/** * This method trims doc (1st arg) according to projected (2nd arg), which may have been modified * by projection. This method works in-place, meaning that the doc may be mutated. */ private static void trim(DataMap doc, DataMap projected) { DataMap toAddDoc = new DataMap(); Set<String> fields = doc.keySet(); List<String> toRemoveDoc = new ArrayList<String>(fields.size()); for (String f : fields) { Object v = doc.get(f); if (f.equals(PatchConstants.DELETE_COMMAND)) { DataList deletedFields = (DataList) v; DataList filteredDeleteFields = new DataList(); for (Object patchDeleteField : deletedFields) { if (projected.containsKey(patchDeleteField)) { filteredDeleteFields.add(patchDeleteField); } } toRemoveDoc.add(f); if (!filteredDeleteFields.isEmpty()) { toAddDoc.put(PatchConstants.DELETE_COMMAND, filteredDeleteFields); } } else if (f.equals(PatchConstants.SET_COMMAND)) { DataMap setFields = (DataMap) v; Set<String> setFieldNames = setFields.keySet(); List<String> toRemove = new LinkedList<String>(); DataMap filteredSetFields = new DataMap(); for (String setFieldName : setFieldNames) { if (projected.containsKey(setFieldName)) { filteredSetFields.put(setFieldName, projected.get(setFieldName)); } toRemove.add(setFieldName); } for (String fieldToRemove : toRemove) { setFields.remove(fieldToRemove); if (filteredSetFields.containsKey(fieldToRemove)) { setFields.put(fieldToRemove, filteredSetFields.get(fieldToRemove)); } } if (setFields.isEmpty()) { toRemoveDoc.add(f); } } else if (v instanceof DataMap) { if (projected.containsKey(f)) { trim((DataMap) v, (DataMap) projected.get(f)); } else { toRemoveDoc.add(f); } } } // apply changes to doc for (String f : toRemoveDoc) { doc.remove(f); } for (String f : toAddDoc.keySet()) { doc.put(f, toAddDoc.get(f)); } }
/** * Converts a String -> Object based representation of query params into a {@link DataMap} * * @param queryParams * @param queryParamClasses * @param version * @return */ public static DataMap convertToDataMap( Map<String, Object> queryParams, Map<String, Class<?>> queryParamClasses, ProtocolVersion version) { DataMap result = new DataMap(queryParams.size()); for (Map.Entry<String, Object> entry : queryParams.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); if (RestConstants.PROJECTION_PARAMETERS.contains(key)) { @SuppressWarnings("unchecked") List<PathSpec> pathSpecs = (List<PathSpec>) value; result.put(key, MaskCreator.createPositiveMask(pathSpecs).getDataMap()); } else { result.put(key, paramToDataObject(value, queryParamClasses.get(key), version)); } } result.makeReadOnly(); return result; }
/** * This method 'exposes' changes conveyed in the patch's meta commands to the main document. * Contents of $set commands are moved to the node which contains $set command. Names of removed * fields from $delete commands are moved to the nod which contains $delete command. The effect is * that patch will resemble structurally document which it is supposed to modify. This allows * application of projection to such patch to discover which changes relate to fields specified by * that projection. Examples: $delete: ['x', 'y', 'z'] => x: true, y: true, z: true $set: {x: 10, * y: {z: 'yeey'}, t: [10]} => x: 10, y: {z: 'yeey'}, t: [10] * * <p>This method works in-place, meaning that the doc may be mutated. */ private static void expose(DataMap doc) { Set<String> fields = doc.keySet(); DataMap toAdd = new DataMap(); for (String f : fields) { Object v = doc.get(f); if (f.equals(PatchConstants.DELETE_COMMAND)) { for (Object removedFields : (DataList) v) { toAdd.put((String) removedFields, true); } } else if (f.equals(PatchConstants.SET_COMMAND)) { toAdd.putAll((DataMap) v); } else if (v instanceof DataMap) { expose((DataMap) v); } } doc.putAll(toAdd); }
private Object translate(Object value, DataSchema dataSchema, Schema avroSchema) { AvroOverride avroOverride = getAvroOverride(dataSchema); if (avroOverride != null) { return avroOverride .getCustomDataTranslator() .avroGenericToData(this, value, avroSchema, dataSchema); } DataSchema dereferencedDataSchema = dataSchema.getDereferencedDataSchema(); DataSchema.Type type = dereferencedDataSchema.getType(); Object result; switch (type) { case NULL: if (value != null) { appendMessage("value must be null for null schema"); result = BAD_RESULT; break; } result = Data.NULL; break; case BOOLEAN: result = ((Boolean) value).booleanValue(); break; case INT: result = ((Number) value).intValue(); break; case LONG: result = ((Number) value).longValue(); break; case FLOAT: result = ((Number) value).floatValue(); break; case DOUBLE: result = ((Number) value).doubleValue(); break; case STRING: result = value.toString(); break; case BYTES: ByteBuffer byteBuffer = (ByteBuffer) value; ByteString byteString = ByteString.copy(byteBuffer); byteBuffer.rewind(); result = byteString; break; case ENUM: String enumValue = value.toString(); EnumDataSchema enumDataSchema = (EnumDataSchema) dereferencedDataSchema; if (enumDataSchema.getSymbols().contains(enumValue) == false) { appendMessage( "enum value %1$s not one of %2$s", enumValue, enumDataSchema.getSymbols()); result = BAD_RESULT; break; } result = enumValue; break; case FIXED: GenericFixed fixed = (GenericFixed) value; byte[] fixedBytes = fixed.bytes(); FixedDataSchema fixedDataSchema = (FixedDataSchema) dereferencedDataSchema; if (fixedDataSchema.getSize() != fixedBytes.length) { appendMessage( "GenericFixed size %1$d != FixedDataSchema size %2$d", fixedBytes.length, fixedDataSchema.getSize()); result = BAD_RESULT; break; } byteString = ByteString.copy(fixedBytes); result = byteString; break; case MAP: @SuppressWarnings("unchecked") Map<?, Object> map = (Map<?, Object>) value; DataSchema valueDataSchema = ((MapDataSchema) dereferencedDataSchema).getValues(); Schema valueAvroSchema = avroSchema.getValueType(); DataMap dataMap = new DataMap(map.size()); for (Map.Entry<?, Object> entry : map.entrySet()) { String key = entry.getKey().toString(); _path.addLast(key); Object entryValue = translate(entry.getValue(), valueDataSchema, valueAvroSchema); _path.removeLast(); dataMap.put(key, entryValue); } result = dataMap; break; case ARRAY: GenericArray<?> list = (GenericArray<?>) value; DataSchema elementDataSchema = ((ArrayDataSchema) dereferencedDataSchema).getItems(); Schema elementAvroSchema = avroSchema.getElementType(); DataList dataList = new DataList(list.size()); for (int i = 0; i < list.size(); i++) { _path.addLast(i); Object entryValue = translate(list.get(i), elementDataSchema, elementAvroSchema); _path.removeLast(); dataList.add(entryValue); } result = dataList; break; case RECORD: GenericRecord record = (GenericRecord) value; RecordDataSchema recordDataSchema = (RecordDataSchema) dereferencedDataSchema; dataMap = new DataMap(avroSchema.getFields().size()); for (RecordDataSchema.Field field : recordDataSchema.getFields()) { String fieldName = field.getName(); Object fieldValue = record.get(fieldName); // fieldValue could be null if the Avro schema does not contain the named field or // the field is present with a null value. In either case we do not add a value // to the translated DataMap. We do not consider optional/required/default here // either (i.e. it is not an error if a required field is missing); the user can // later call ValidateDataAgainstSchema with various // settings for RequiredMode to obtain the desired behaviour. if (fieldValue == null) { continue; } boolean isOptional = field.getOptional(); DataSchema fieldDataSchema = field.getType(); Schema fieldAvroSchema = avroSchema.getField(fieldName).schema(); if (isOptional && (fieldDataSchema.getDereferencedType() != DataSchema.Type.UNION)) { // Avro schema should be union with 2 types: null and the field's type. Map.Entry<String, Schema> fieldAvroEntry = findUnionMember(fieldDataSchema, fieldAvroSchema); if (fieldAvroEntry == null) { continue; } fieldAvroSchema = fieldAvroEntry.getValue(); } _path.addLast(fieldName); dataMap.put(fieldName, translate(fieldValue, fieldDataSchema, fieldAvroSchema)); _path.removeLast(); } result = dataMap; break; case UNION: UnionDataSchema unionDataSchema = (UnionDataSchema) dereferencedDataSchema; Map.Entry<DataSchema, Schema> memberSchemas = findUnionMemberSchema(value, unionDataSchema, avroSchema); if (memberSchemas == null) { result = BAD_RESULT; break; } if (value == null) { // schema must be "null" schema result = Data.NULL; } else { DataSchema memberDataSchema = memberSchemas.getKey(); Schema memberAvroSchema = memberSchemas.getValue(); String key = memberDataSchema.getUnionMemberKey(); dataMap = new DataMap(1); _path.addLast(key); dataMap.put(key, translate(value, memberDataSchema, memberAvroSchema)); _path.removeLast(); result = dataMap; } break; default: appendMessage("schema type unknown %1$s", dereferencedDataSchema.getType()); result = BAD_RESULT; break; } return result; }
static { ENTITY_BODY.put("testFieldName", "testValue"); ENTITY_BODY.put("testInteger", 1); }