@Override public String getSchemaJSON() { if (!changed && schemaJSON != null) { return schemaJSON; } if (schemaKeys == null) { schema.remove(Schema.FIELD_SCHEMA_KEYS); } else { try { schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys)); } catch (JSONException ex) { throw new RuntimeException(ex); } } schemaJSON = schema.toString(); return schemaJSON; }
/** * This is a helper method to initialize the schema. * * @throws JSONException This exception is thrown if there is an error parsing the JSON which * specified this schema. */ private void initialize() throws JSONException { schema = new JSONObject(schemaJSON); Preconditions.checkState( schema.length() == NUM_KEYS_FIRST_LEVEL, "Expected " + NUM_KEYS_FIRST_LEVEL + " keys in the first level but found " + schema.length()); if (schemaKeys != null) { schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys)); } valueToType = Maps.newHashMap(); JSONArray values = schema.getJSONArray(FIELD_VALUES); Preconditions.checkState(values.length() > 0, "The schema does not specify any values."); for (int index = 0; index < values.length(); index++) { JSONObject value = values.getJSONObject(index); String name = value.getString(FIELD_VALUES_NAME); String typeName = value.getString(FIELD_VALUES_TYPE); Type type = Type.NAME_TO_TYPE.get(typeName); valueToType.put(name, type); Preconditions.checkArgument(type != null, typeName + " is not a valid type."); } valueToType = Collections.unmodifiableMap(valueToType); valuesDescriptor = new FieldsDescriptor(valueToType); try { schema.put(FIELD_SCHEMA_TYPE, SCHEMA_TYPE); schema.put(FIELD_SCHEMA_VERSION, SCHEMA_VERSION); } catch (JSONException e) { throw new RuntimeException(e); } schemaJSON = this.schema.toString(); }
@Override public String getSchemaJSON() { if (!changed && schemaJSON != null) { // If there are no changes, return the pre computed JSON return schemaJSON; } if (changedSchemaKeys) { // If the schema keys change, recompute the schema keys portion of the JSON changedSchemaKeys = false; if (schemaKeys == null) { schema.remove(Schema.FIELD_SCHEMA_KEYS); } else { try { schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys)); } catch (JSONException ex) { throw new RuntimeException(ex); } } } if (changedFromTo) { // If the from to times have changed then recompute the time portion of the schema. changedFromTo = false; Preconditions.checkState( !(from == null ^ to == null), "Either both from and to should be set or both should be not set."); if (from != null) { Preconditions.checkState( to >= from, "to {} must be greater than or equal to from {}.", to, from); } if (from == null) { time.remove(FIELD_TIME_FROM); time.remove(FIELD_TIME_TO); } else { try { time.put(FIELD_TIME_FROM, from); time.put(FIELD_TIME_TO, to); } catch (JSONException ex) { throw new RuntimeException(ex); } } } if (this.areEnumsUpdated) { // If the enums have been updated, recompute the key portion of the schema. for (int keyIndex = 0; keyIndex < keys.length(); keyIndex++) { JSONObject keyData; String name; try { keyData = keys.getJSONObject(keyIndex); name = keyData.getString(DimensionalConfigurationSchema.FIELD_KEYS_NAME); } catch (JSONException ex) { throw new RuntimeException(ex); } List<Object> enumVals = currentEnumVals.get(name); if (enumVals == null || enumVals.isEmpty()) { keyData.remove(DimensionalConfigurationSchema.FIELD_KEYS_ENUMVALUES); continue; } JSONArray newEnumValues = new JSONArray(); for (Object enumVal : enumVals) { newEnumValues.put(enumVal); } try { keyData.put(DimensionalConfigurationSchema.FIELD_KEYS_ENUMVALUES, newEnumValues); } catch (JSONException ex) { throw new RuntimeException(ex); } } this.areEnumsUpdated = false; } // Rebuild the schema JSON string. schemaJSON = schema.toString(); return schemaJSON; }
/** * Initializes the schema JSON and schema metadata. * * @throws JSONException This exception is thrown when there is an exception building the schema * for the AppData dimensions schema. */ private void initialize() throws JSONException { schema = new JSONObject(); if (schemaKeys != null) { schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys)); } schema.put(SnapshotSchema.FIELD_SCHEMA_TYPE, DimensionalSchema.SCHEMA_TYPE); schema.put(SnapshotSchema.FIELD_SCHEMA_VERSION, DimensionalSchema.SCHEMA_VERSION); if (!configurationSchema.getTags().isEmpty()) { schema.put(FIELD_TAGS, new JSONArray(configurationSchema.getTags())); } // time time = new JSONObject(); schema.put(FIELD_TIME, time); JSONArray bucketsArray = new JSONArray(configurationSchema.getBucketsString()); time.put(FIELD_TIME_BUCKETS, bucketsArray); time.put(FIELD_SLIDING_AGGREGATE_SUPPORTED, true); // keys keys = new JSONArray(configurationSchema.getKeysString()); for (int keyIndex = 0; keyIndex < keys.length(); keyIndex++) { JSONObject keyJo = keys.getJSONObject(keyIndex); String keyName = keyJo.getString(DimensionalConfigurationSchema.FIELD_KEYS_NAME); List<String> tags = configurationSchema.getKeyToTags().get(keyName); if (!tags.isEmpty()) { keyJo.put(FIELD_TAGS, new JSONArray(tags)); } } schema.put(DimensionalConfigurationSchema.FIELD_KEYS, keys); // values JSONArray values = new JSONArray(); schema.put(SnapshotSchema.FIELD_VALUES, values); FieldsDescriptor inputValuesDescriptor = configurationSchema.getInputValuesDescriptor(); Map<String, Map<String, Type>> allValueToAggregator = configurationSchema.getSchemaAllValueToAggregatorToType(); for (Map.Entry<String, Map<String, Type>> entry : allValueToAggregator.entrySet()) { String valueName = entry.getKey(); for (Map.Entry<String, Type> entryAggType : entry.getValue().entrySet()) { String aggregatorName = entryAggType.getKey(); Type outputValueType = entryAggType.getValue(); JSONObject value = new JSONObject(); String combinedName = valueName + DimensionalConfigurationSchema.ADDITIONAL_VALUE_SEPERATOR + aggregatorName; value.put(SnapshotSchema.FIELD_VALUES_NAME, combinedName); value.put(SnapshotSchema.FIELD_VALUES_TYPE, outputValueType.getName()); List<String> tags = configurationSchema.getValueToTags().get(valueName); if (!tags.isEmpty()) { value.put(FIELD_TAGS, new JSONArray(tags)); } values.put(value); } } JSONArray dimensions = new JSONArray(); for (int combinationID = 0; combinationID < configurationSchema.getDimensionsDescriptorIDToKeys().size(); combinationID++) { Fields fields = configurationSchema.getDimensionsDescriptorIDToKeys().get(combinationID); Map<String, Set<String>> fieldToAggregatorAdditionalValues = configurationSchema .getDimensionsDescriptorIDToFieldToAggregatorAdditionalValues() .get(combinationID); JSONObject combination = new JSONObject(); JSONArray combinationArray = new JSONArray(); for (String field : fields.getFields()) { combinationArray.put(field); } combination.put( DimensionalConfigurationSchema.FIELD_DIMENSIONS_COMBINATIONS, combinationArray); if (!fieldToAggregatorAdditionalValues.isEmpty()) { JSONArray additionalValueArray = new JSONArray(); for (Map.Entry<String, Set<String>> entry : fieldToAggregatorAdditionalValues.entrySet()) { String valueName = entry.getKey(); for (String aggregatorName : entry.getValue()) { JSONObject additionalValueObject = new JSONObject(); String combinedName = valueName + DimensionalConfigurationSchema.ADDITIONAL_VALUE_SEPERATOR + aggregatorName; Type inputValueType = inputValuesDescriptor.getType(valueName); if (!configurationSchema.getAggregatorRegistry().isAggregator(aggregatorName)) { if (aggregatorName == null) { LOG.error("{} is not a valid aggregator.", aggregatorName); } } Type outputValueType; if (configurationSchema .getAggregatorRegistry() .isIncrementalAggregator(aggregatorName)) { IncrementalAggregator aggregator = configurationSchema .getAggregatorRegistry() .getNameToIncrementalAggregator() .get(aggregatorName); outputValueType = aggregator.getOutputType(inputValueType); } else { outputValueType = configurationSchema .getAggregatorRegistry() .getNameToOTFAggregators() .get(aggregatorName) .getOutputType(); } additionalValueObject.put( DimensionalConfigurationSchema.FIELD_VALUES_NAME, combinedName); additionalValueObject.put( DimensionalConfigurationSchema.FIELD_VALUES_TYPE, outputValueType.getName()); additionalValueArray.put(additionalValueObject); } } combination.put( DimensionalConfigurationSchema.FIELD_DIMENSIONS_ADDITIONAL_VALUES, additionalValueArray); } dimensions.put(combination); } schema.put(DimensionalConfigurationSchema.FIELD_DIMENSIONS, dimensions); this.schemaJSON = this.schema.toString(); }