/** * This is a helper method extracts and validates the information contained in the schema stub for * this schema. * * @param schemaStub The schema stub to extract information from and validate. * @throws JSONException This exception is thrown if there is an error processing the provided * JSON schemaStub. */ private void setSchemaStub(String schemaStub) throws JSONException { JSONObject jo = new JSONObject(schemaStub); SchemaUtils.checkValidKeysEx(jo, VALID_KEYS); JSONObject tempTime = jo.getJSONObject(FIELD_TIME); SchemaUtils.checkValidKeys(jo, VALID_TIME_KEYS); this.from = tempTime.getLong(FIELD_TIME_FROM); this.to = tempTime.getLong(FIELD_TIME_TO); }
@Override public void checkSchema(ResourceSchema schema) throws IOException { SchemaUtils.claim( schema, 0, DataType.INTEGER, DataType.CHARARRAY, DataType.UNKNOWN); // the part name (usually will be int, but generally accept any type) ResourceSchema.ResourceFieldSchema bag = SchemaUtils.claim(schema, 1, DataType.BAG); // the bag ResourceSchema.ResourceFieldSchema tuple = SchemaUtils.claim(bag, 0, DataType.TUPLE); // the tuple of (id, vector) SchemaUtils.claim(tuple, 0, DataType.INTEGER); // the id tuple = SchemaUtils.claim(tuple, 1, DataType.TUPLE); // the vector Env.setProperty( GroupedVectorStore.class, "vector.type", VectorUtils.typeOfVector(tuple.getSchema())); }
public Element exec(Element params, ServiceContext context) throws Exception { GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME); SchemaManager scm = gc.getBean(SchemaManager.class); String schema = Util.getParam(params, Params.SCHEMA); String urlStr, uuid, fname; uuid = ""; URL url = null; // -- try the file name argument then the url then the uuid of a metadata // -- record to which a schema is attached fname = Util.getParam(params, Params.FNAME, ""); if ("".equals(fname)) { urlStr = Util.getParam(params, Params.URL, ""); if ("".equals(urlStr)) { uuid = Util.getParam(params, Params.UUID, ""); if ("".equals(uuid)) { throw new IllegalArgumentException("One of fname, url or uuid must be supplied"); } } else { try { url = new URL(urlStr); } catch (MalformedURLException mu) { throw new OperationAbortedEx("URL " + urlStr + " is malformed: " + mu.getMessage()); } } } // -- test if schema to be updated exists, if not then chuck a fit and exit if (!scm.existsSchema(schema)) { throw new OperationAbortedEx("Schema doesn't exist"); } SchemaUtils su = new SchemaUtils(); return su.updateSchema(context, schema, fname, url, uuid, scm); }
@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(); }
public SampleXmlUtil(boolean soapEnc) { _soapEnc = soapEnc; excludedTypes.addAll(SchemaUtils.getExcludedTypes()); }
private String normalize(final ByteSequence value) { return SchemaUtils.normalizeStringAttributeValue(value, TRIM, CASE_FOLD).toString(); }