ObjectFieldSegment( HollowObjectSchema enclosingSchema, String name, String typeName, int index) { super(enclosingSchema, name, typeName); this.index = index; this.type = enclosingSchema.getFieldType(index); }
private boolean fieldNeedsInlineAnnotation(int i) { return schema.getFieldType(i) == FieldType.STRING; }
public void completeCalculations() { for(int i=0;i<totalSizeOfVarLengthField.length;i++) { if(schema.getFieldType(i) == FieldType.STRING || schema.getFieldType(i) == FieldType.BYTES) { maxBitsForField[i] = bitsRequiredForRepresentation(totalSizeOfVarLengthField[i]) + 1; // one extra bit for null. } } for(int i=0;i<maxBitsForField.length;i++) { bitOffsetForField[i] = numBitsPerRecord; numBitsPerRecord += maxBitsForField[i]; } }
public FieldType getFieldType(String fieldName) { int fieldPosition = getPosition(fieldName); if(fieldPosition == -1) return null; return getFieldType(fieldPosition); }
private void validateFieldType(int fieldIndex, String fieldName, FieldType attemptedFieldType) { if(getSchema().getFieldType(fieldIndex) != attemptedFieldType) { throw new IllegalArgumentException("Attempting to serialize " + attemptedFieldType + " in field " + fieldName + ". Carefully check your schema for type " + getSchema().getName() + "."); } } }
/** * Add an individual field from an OBJECT schema, plus recursively add any directly or transitively referenced types. * This field will be either excluded or included, depending on whether this is an exclude or include filter, respectively. * * @param type The OBJECT type from the data model * @param objectField The field in the specified type to either include or exclude. * @param schemas A map of typeName to schema including all schemas for this data model. */ public void addFieldRecursive(String type, String objectField, Map<String, HollowSchema> schemas) { addField(type, objectField); HollowObjectSchema schema = (HollowObjectSchema)schemas.get(type); if(schema.getFieldType(objectField) == FieldType.REFERENCE) { addTypeRecursive(schema.getReferencedType(objectField), schemas); } }
private void writeField(ByteDataBuffer buf, int fieldIndex) { if (isNonNull[fieldIndex]) { if (getSchema().getFieldType(fieldIndex).isVariableLength()) VarInt.writeVInt(buf, (int)fieldData[fieldIndex].length()); fieldData[fieldIndex].copyTo(buf); } else { writeNull(buf, schema.getFieldType(fieldIndex)); } }
private boolean fieldNeedsTypeNameAnnotation(int i) { if (schema.getFieldType(i) == FieldType.REFERENCE) { HollowSchema referencedSchema = dataset.getSchema(schema.getReferencedType(i)); return !referencedSchema.getName().equals(expectedCollectionClassName(referencedSchema)); } return false; }
private void addNullRecord(int ordinal, long recordBitOffset, FixedLengthElementArray fixedLengthLongArray, ByteDataBuffer varLengthByteArrays[]) { for(int fieldIndex=0; fieldIndex < getSchema().numFields(); fieldIndex++) { if(getSchema().getFieldType(fieldIndex) == FieldType.STRING || getSchema().getFieldType(fieldIndex) == FieldType.BYTES) { long fieldBitOffset = recordBitOffset + fieldStats.getFieldBitOffset(fieldIndex); int bitsPerElement = fieldStats.getMaxBitsForField(fieldIndex); long currentPointer = varLengthByteArrays[fieldIndex] == null ? 0 : varLengthByteArrays[fieldIndex].length(); fixedLengthLongArray.setElementValue(fieldBitOffset, bitsPerElement, currentPointer); } } }
private String getKeyFieldType(String fieldPath) { try { HollowObjectSchema keySchema = (HollowObjectSchema)dataset.getSchema(schema.getKeyType()); String fieldPathElements[] = fieldPath.split("\\."); int idx = 0; while(idx < fieldPathElements.length-1) { keySchema = (HollowObjectSchema)dataset.getSchema(keySchema.getReferencedType(fieldPathElements[idx])); idx++; } FieldType fieldType = keySchema.getFieldType(keySchema.getPosition(fieldPathElements[idx])); return HollowCodeGenerationUtils.getJavaBoxedType(fieldType); } catch(Throwable th) { } throw new IllegalArgumentException("Field path '" + fieldPath + "' specified incorrectly for type: " + schema.getName()); }
public SchemaDisplayField(String fieldPath, HollowObjectSchema parentSchema, int fieldNumber) { this.fieldPath = fieldPath; this.fieldName = parentSchema.getFieldName(fieldNumber); this.fieldType = parentSchema.getFieldType(fieldNumber); this.isSearchable = isSearchable(parentSchema, fieldNumber); this.referencedType = fieldType == FieldType.REFERENCE ? new SchemaDisplay(parentSchema.getReferencedTypeState(fieldNumber).getSchema(), fieldPath) : null; }
public void writeDataTo(ByteDataBuffer buf, HollowObjectSchema translate) { for(int i=0; i < translate.numFields(); i++) { int fieldIndex = schema.getPosition(translate.getFieldName(i)); if(fieldIndex != -1) { writeField(buf, fieldIndex); } else { writeNull(buf, translate.getFieldType(i)); } } }
private void traverseObject(HollowObjectTypeReadState typeState, int ordinal) { HollowObjectSchema schema = typeState.getSchema(); for(int i=0;i<schema.numFields();i++) { if(schema.getFieldType(i) == FieldType.REFERENCE) { HollowTypeReadState refTypeState = schema.getReferencedTypeState(i); int refOrdinal = typeState.readOrdinal(ordinal, i); extractHollowRecord(refTypeState, refOrdinal); } } }
public void setNull(String fieldName) { int fieldIndex = getSchema().getPosition(fieldName); ByteDataBuffer fieldBuffer = getFieldBuffer(fieldIndex); FieldType fieldType = getSchema().getFieldType(fieldIndex); writeNull(fieldBuffer, fieldType); }
private int copyObjectRecord(HollowObjectSchema recordSchema, HollowObjectSchema engineSchema, int currentRecordPointer, int currentRecordOrdinal) { HollowObjectWriteRecord rec = engineSchema != null ? (HollowObjectWriteRecord)getWriteRecord(engineSchema) : null; for(int i=0;i<recordSchema.numFields();i++) { String fieldName = recordSchema.getFieldName(i); FieldType fieldType = recordSchema.getFieldType(i); boolean fieldExistsInEngine = engineSchema != null && engineSchema.getPosition(fieldName) != -1; currentRecordPointer = copyObjectField(fieldExistsInEngine ? rec : null, fieldName, fieldType, currentRecordPointer); } if(engineSchema != null) { int stateEngineOrdinal = stateEngine.add(engineSchema.getName(), rec); ordinalMapping.put(currentRecordOrdinal, stateEngineOrdinal); } return currentRecordPointer; }
private void addSchemaField(HollowObjectSchema schema, HollowObjectSchema keySchema, String keyField, String[] keyFieldParts, int keyFieldPartPosition) { int schemaPosition = schema.getPosition(keyFieldParts[keyFieldPartPosition]); if(keyFieldPartPosition < keyFieldParts.length - 1) { HollowObjectSchema nextPartSchema = (HollowObjectSchema) schema.getReferencedTypeState(schemaPosition).getSchema(); addSchemaField(nextPartSchema, keySchema, keyField, keyFieldParts, keyFieldPartPosition + 1); } else { keySchema.addField(keyField, schema.getFieldType(schemaPosition), schema.getReferencedType(schemaPosition)); } }
private boolean isSearchable(HollowObjectSchema schema, int fieldNumber) { if(schema.getFieldType(fieldNumber) == FieldType.REFERENCE) { if(schema.getReferencedTypeState(fieldNumber).getSchema().getSchemaType() != SchemaType.OBJECT) return false; HollowObjectSchema refObjSchema = (HollowObjectSchema)schema.getReferencedTypeState(fieldNumber).getSchema(); if(refObjSchema.numFields() != 1) return false; return isSearchable(refObjSchema, 0); } return true; }
@Override public int findVarLengthFieldHashCode(int ordinal, int fieldIndex) { HollowObjectSchema schema = getSchema(); if(schema.getFieldType(fieldIndex) == FieldType.STRING) { return HashCodes.hashCode(missingDataHandler().handleString(typeName, ordinal, schema.getFieldName(fieldIndex))); } else { return HashCodes.hashCode(missingDataHandler().handleBytes(typeName, ordinal, schema.getFieldName(fieldIndex))); } }
public boolean recordsAreEqual(int ordinal) { for(int i=0;i<commonSchema.numFields();i++) { int fromFieldPos = fromObjectState.getSchema().getPosition(commonSchema.getFieldName(i)); int toFieldPos = toObjectState.getSchema().getPosition(commonSchema.getFieldName(i)); if(commonSchema.getFieldType(i) == FieldType.REFERENCE) { if(fromObjectState.readOrdinal(ordinal, fromFieldPos) != toObjectState.readOrdinal(ordinal, toFieldPos)) return false; } else if(!HollowReadFieldUtils.fieldsAreEqual(fromObjectState, ordinal, fromFieldPos, toObjectState, ordinal, toFieldPos)) { return false; } } return true; } };
public HollowObjectSchema filterSchema(HollowFilterConfig config) { ObjectFilterConfig typeConfig = config.getObjectTypeConfig(getName()); int includedFields = 0; for(int i=0;i<numFields();i++) { if(typeConfig.includesField(getFieldName(i))) includedFields++; } HollowObjectSchema filteredSchema = new HollowObjectSchema(getName(), includedFields, primaryKey); for(int i=0;i<numFields();i++) { if(typeConfig.includesField(getFieldName(i))) filteredSchema.addField(getFieldName(i), getFieldType(i), getReferencedType(i)); } return filteredSchema; }