<p>
Represents the settings of a global secondary index for a global table that will be modified.
</p>

@param globalTableGlobalSecondaryIndexSettingsUpdate
Represents the settings of a global secondary index for a global table that will be modified.
339625
public void setGlobalTableGlobalSecondaryIndexSettingsUpdate(
            java.util.Collection<GlobalTableGlobalSecondaryIndexSettingsUpdate> globalTableGlobalSecondaryIndexSettingsUpdate) {
        if (globalTableGlobalSecondaryIndexSettingsUpdate == null) {
            this.globalTableGlobalSecondaryIndexSettingsUpdate = null;
            return;
        }

        this.globalTableGlobalSecondaryIndexSettingsUpdate = new java.util.ArrayList<GlobalTableGlobalSecondaryIndexSettingsUpdate>(
                globalTableGlobalSecondaryIndexSettingsUpdate);
    }
577137
public static void updateUsageAnnotations(Database db,
                                              Statement stmt,
                                              AbstractPlanNode topPlan,
                                              AbstractPlanNode bottomPlan)
    {
        Map<String, StmtTargetTableScan> tablesRead = new TreeMap<>();
        Collection<String> indexes = new TreeSet<>();
        if (topPlan != null) {
            topPlan.getTablesAndIndexes(tablesRead, indexes);
        }
        if (bottomPlan != null) {
            bottomPlan.getTablesAndIndexes(tablesRead, indexes);
        }

        String updated = "";
        if ( ! stmt.getReadonly()) {
            updated = topPlan.getUpdatedTable();
            if (updated == null) {
                updated = bottomPlan.getUpdatedTable();
            }
            assert(updated.length() > 0);
        }

        Set<String> readTableNames = tablesRead.keySet();
        stmt.setTablesread(StringUtils.join(readTableNames, ","));
        stmt.setTablesupdated(updated);

        Set<String> tableDotIndexNames = new TreeSet<>();

        for (Table table : db.getTables()) {
            if (readTableNames.contains(table.getTypeName())) {
                readTableNames.remove(table.getTypeName());
                for (String indexName : indexes) {
                    Index index = table.getIndexes().get(indexName);
                    if (index != null) {
                        tableDotIndexNames.add(table.getTypeName() + "." + index.getTypeName());
                    }
                }
            }
        }

        String indexString = StringUtils.join(tableDotIndexNames, ",");
        stmt.setIndexesused(indexString);

        assert(tablesRead.size() == 0);
    }
1143396
private void createIndexes(Table t) {
        for (String indexName : t.getIndexHoldersByName().keySet()) {
            if (!indexName.startsWith("PRIMARY")) {
                createIndex(t, t.getIndexHolderByName(indexName));
            }
        }
    }
258302
private void setCompileTimeGlobalsInternal(
      ImmutableMap<String, PrimitiveData> compileTimeGlobalsMap) {
    Preconditions.checkState(compileTimeGlobals == null, "Compile-time globals already set.");
    compileTimeGlobals = compileTimeGlobalsMap;
  }
106904
func (s *CreateTableInput) SetGlobalSecondaryIndexes(v []*GlobalSecondaryIndex) *CreateTableInput {
	s.GlobalSecondaryIndexes = v
	return s
}
574188
@Deprecated
	public static void updateSettings(Client client, String root, String index) throws Exception {
		String settings = IndexSettingsReader.readUpdateSettings(root, index);
		updateIndexWithSettingsInElasticsearch(client, index, settings);
	}
720944
public void usage(GlobalMetadata global)
    {
        StringBuilder stringBuilder = new StringBuilder();
        usage(global, stringBuilder);
        System.out.println(stringBuilder.toString());
    }
1054100
def global_start_index(self, value):
        """"""
        if not isinstance(value, int) and value is not None:
            raise TypeError('global_start_index attribute must be of int '
                            'type.')
        self._global_start_index = value
380751
public void setGlobalVariable(String name, GlobalVariable variable) {

		assert (name != null);

		if (variable != null) {
			globalVariables.put(name, variable);
		} else {
			globalVariables.remove(name);
		}
	}
53390
public function setGlobalValues($iCCN, $iCrapIndex, $iNPath, $iLLOC)
    {
        //Global total
        $this->appendTotalCCN((int)$iCCN * $iLLOC);
        $this->appendToTotalCrapIndex((int)$iCrapIndex * $iLLOC);
        $this->appendToTotalNPath((int)$iNPath * $iLLOC);
        $this->appendToTotalLLOC($iLLOC);

        // Global Max
        $this->updateMaxCCN($iCCN);
        $this->updateMaxCrapIndex($iCrapIndex);
        $this->updateMaxNPath($iNPath);
        $this->updateMaxLLOC($iLLOC);
    }
686204
public GlobalSecondaryIndex globalSecondaryIndex(final String indexName) {
        if (!globalSecondaryIndexes.containsKey(indexName)) {
            return null;
        }
        final GlobalSecondaryIndex gsi = globalSecondaryIndexes.get(indexName);
        final GlobalSecondaryIndex copy = new GlobalSecondaryIndex().withIndexName(gsi.getIndexName());
        copy.withProjection(new Projection().withProjectionType(gsi.getProjection().getProjectionType()));
        for (final KeySchemaElement key : gsi.getKeySchema()) {
            copy.withKeySchema(new KeySchemaElement(key.getAttributeName(), key.getKeyType()));
        }
        return copy;
    }
676088
public static void initGlobals()
    {
        if (gDateFormat == null)
        {   // NOTE: You MUST synchronize before using any of these
            // For dates and times, synchronize on the gCalendar
            gCalendar = Calendar.getInstance();

            gDateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
            gTimeFormat = DateFormat.getTimeInstance(DateFormat.SHORT);
            gLongTimeFormat = DateFormat.getTimeInstance(DateFormat.MEDIUM);
            gDateTimeFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.SHORT);
            gLongDateTimeFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
            gDateShortFormat = DateFormat.getDateInstance(DateFormat.SHORT);
            gDateShortTimeFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
            gGMTDateTimeFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);

            gDateSqlFormat = gDateShortFormat;  // By default use these formats - Change if different
            gTimeSqlFormat = gTimeFormat;
            gDateTimeSqlFormat = gDateShortTimeFormat;
            // For all of these, synchronize on the object you are using
            gIntegerFormat = NumberFormat.getInstance();
            gIntegerFormat.setParseIntegerOnly(true);

            gCurrencyFormat = NumberFormat.getCurrencyInstance();
            
            gNumberFormat = NumberFormat.getInstance();
            gNumberFormat.setParseIntegerOnly(false);
            gNumberFormat.setMinimumFractionDigits(2);
            gNumberFormat.setMaximumFractionDigits(2);
            if (gNumberFormat instanceof DecimalFormat)
            {
                gchDot = ((DecimalFormat)gNumberFormat).getDecimalFormatSymbols().getDecimalSeparator();
                gchMinus = ((DecimalFormat)gNumberFormat).getDecimalFormatSymbols().getMinusSign();
            }

            gPercentFormat = NumberFormat.getPercentInstance();
        }
    }
1068089
public E setGlobal(E value)
  {
    E oldValue = _globalValue;

    _globalValue = value;

    ClassLoader systemLoader = getSystemClassLoader();

    if (systemLoader instanceof EnvironmentClassLoader)
      ((EnvironmentClassLoader) systemLoader).setAttribute(_varName, value);
    else
      _globalValue = value;

    return oldValue;
  }
1264869
private void writeFFGlobalSettings(Database db, XmlStreamWriter writer)
            throws Exception {
        writer.writeStartElement("RDF:Description");

        writer.writeAttribute("RDF:about", RDFDatabaseReader.FF_GLOBAL_SETTINGS_URI);

        for (String key : db.getGlobalSettings().keySet()) {
            writer.writeAttribute(key, db.getGlobalSettings().get(key));
        }

        writer.writeEndElement();
    }
397782
public synchronized void loadGlobalProperties(Map<String, Object> map) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "loadGlobalProperties");

        // clear before reloading.
        globalConfigProperties.clear();

        for (Entry<String, Object> prop : map.entrySet()) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Setting global property: " + prop.getKey() + "=" + prop.getValue());
            }
            globalConfigProperties.setProperty(prop.getKey(), (String) prop.getValue());
        }

        // Check for dynamic outbound and default config conflicts
        String outboundDefaultAlias = getGlobalProperty(LibertyConstants.SSLPROP_OUTBOUND_DEFAULT_ALIAS);
        if (outboundDefaultAlias != null && isTransportSecurityEnabled())
            outboundSSL.checkDefaultConflict();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "loadGlobalProperties");
    }
576929
@Deprecated
	private static void updateIndexWithSettingsInElasticsearch(Client client, String index, String settings) throws Exception {
		logger.trace("updateIndex([{}])", index);

		assert client != null;
		assert index != null;

		if (settings != null) {
			logger.trace("Found update settings for index [{}]: [{}]", index, settings);
			logger.debug("updating settings for index [{}]", index);
			client.admin().indices().prepareUpdateSettings(index).setSettings(settings, XContentType.JSON).get();
		}

		logger.trace("/updateIndex([{}])", index);
	}
1315677
private void initializeSecondaryIndexer() {
    SecondaryIndex secondaryIndexAnnotation = field.getAnnotation(SecondaryIndex.class);
    if (secondaryIndexAnnotation == null) {
      return;
    }
    String indexName = secondaryIndexAnnotation.name();
    if (indexName == null || indexName.trim().length() == 0) {
      indexName = DEFAULT_SECONDARY_INDEX_PREFIX + mappedName;
    }
    this.secondaryIndexName = indexName;
    try {
      secondaryIndexer = IndexerFactory.getInstance().getIndexer(field);
    } catch (Exception exp) {
      String pattern = "No suitable Indexer found or error occurred while creating the indexer "
          + "for field %s in class %s";
      String message = String.format(pattern, field.getName(), field.getDeclaringClass().getName());
      throw new EntityManagerException(message, exp);
    }

  }