/** * Returns a field name that is same for use as a java variable. */ private String getFieldName(int index) { return substituteInvalidChars(schema.getFieldName(index)); }
private void mapAllPaths(HollowObjectSchema schema) { for(int i=0;i<schema.numFields();i++) { if(!mappedFieldPaths.containsKey(schema.getFieldName(i))) { HollowObjectWriteRecord rec = getWriteRecord(schema); mappedFieldPaths.put(schema.getFieldName(i), new ObjectMappedFieldPath(rec, schema.getFieldName(i), schema.getName(), schema.getFieldName(i), i, populator.getFieldProcessor(schema.getName(), schema.getFieldName(i)))); } } }
private String generateByteArrayFieldAccessor(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(objectSchema.getFieldName(fieldNum)); builder.append(" public byte[] get" + uppercase(fieldName) + "(int ordinal) {\n"); builder.append(" if(fieldIndex[" + fieldNum +"] == -1)\n"); builder.append(" return missingDataHandler().handleBytes(\"").append(objectSchema.getName()).append("\", ordinal, \"").append(fieldName).append("\");\n"); builder.append(" boxedFieldAccessSampler.recordFieldAccess(fieldIndex[" + fieldNum + "]);\n"); builder.append(" return getTypeDataAccess().readBytes(ordinal, fieldIndex[" + fieldNum + "]);\n"); builder.append(" }\n\n"); return builder.toString(); }
private String generateByteArrayFieldAccessor(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(schema.getFieldName(fieldNum)); builder.append(" public byte[] ").append(getterPrefix).append("get" + uppercase(fieldName) + "() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "(ordinal);\n"); builder.append(" }"); return builder.toString(); }
private String generateFloatFieldAccessor(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(schema.getFieldName(fieldNum)); builder.append(" public float ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "(ordinal);\n"); builder.append(" }\n\n"); if(!restrictApiToFieldType) { builder.append(" public Float ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("Boxed() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "Boxed(ordinal);\n"); builder.append(" }"); } return builder.toString(); }
private String generateDoubleFieldAccessor(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(schema.getFieldName(fieldNum)); builder.append(" public double ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "(ordinal);\n"); builder.append(" }\n\n"); if(!restrictApiToFieldType) { builder.append(" public Double ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("Boxed() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "Boxed(ordinal);\n"); builder.append(" }"); } return builder.toString(); }
private String generateLongFieldAccessor(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(schema.getFieldName(fieldNum)); builder.append(" public long ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "(ordinal);\n"); builder.append(" }\n\n"); if(!restrictApiToFieldType) { builder.append(" public Long ").append(getterPrefix).append("get").append(uppercase(fieldName)).append("Boxed() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "Boxed(ordinal);\n"); builder.append(" }"); } return builder.toString(); }
private String generateStringFieldAccessors(int fieldNum) { StringBuilder builder = new StringBuilder(); String fieldName = substituteInvalidChars(schema.getFieldName(fieldNum)); builder.append(" public String ").append(getterPrefix).append("get" + uppercase(fieldName) + "() {\n"); builder.append(" return delegate().get" + uppercase(fieldName) + "(ordinal);\n"); builder.append(" }\n\n"); builder.append(" public boolean ").append(getterPrefix).append("is" + uppercase(fieldName) + "Equal(String testValue) {\n"); builder.append(" return delegate().is" + uppercase(fieldName) + "Equal(ordinal, testValue);\n"); builder.append(" }"); return builder.toString(); }
public HollowObjectSampler(HollowObjectSchema schema, HollowSamplingDirector director) { this.typeName = schema.getName(); this.sampleCounts = new long[schema.numFields()]; HollowSamplingDirector[] samplingDirectors = new HollowSamplingDirector[schema.numFields()]; Arrays.fill(samplingDirectors, director); String fieldNames[] = new String[schema.numFields()]; for(int i=0;i<fieldNames.length;i++) { fieldNames[i] = schema.getFieldName(i); } this.fieldNames = fieldNames; this.samplingDirectors = samplingDirectors; }
private int[] createFieldMapping(HollowObjectSchema unionSchema, HollowObjectSchema individualSchema) { int mapping[] = new int[unionSchema.numFields()]; for(int i=0;i<unionSchema.numFields();i++) { String fieldName = unionSchema.getFieldName(i); mapping[i] = individualSchema.getPosition(fieldName); } return mapping; }
private long writeBitsPerField(HollowObjectSchema unfilteredSchema, int bitsPerField[], HollowObjectSchema filteredSchema, DataOutputStream os) throws IOException { long bitsPerRecord = 0; for(int i=0;i<unfilteredSchema.numFields();i++) { if(filteredSchema.getPosition(unfilteredSchema.getFieldName(i)) != -1) { VarInt.writeVInt(os, bitsPerField[i]); bitsPerRecord += bitsPerField[i]; } } return bitsPerRecord; }
private int[] buildCommonSchemaFieldMapping(HollowObjectTypeReadState state) { int[] commonFieldMapping = new int[commonSchema.numFields()]; for(int i=0;i<commonFieldMapping.length;i++) { String fieldName = commonSchema.getFieldName(i); commonFieldMapping[i] = state.getSchema().getPosition(fieldName); } return commonFieldMapping; }
public HollowDiffFieldCountingNode(HollowDiff diff, HollowTypeDiff topLevelTypeDiff, HollowDiffNodeIdentifier nodeId, HollowObjectTypeReadState fromState, HollowObjectTypeReadState toState, HollowObjectSchema unionSchema, int unionFieldIndex) { super(diff, topLevelTypeDiff, nodeId); this.fromState = fromState; this.toState = toState; String fieldName = unionSchema.getFieldName(unionFieldIndex); this.fromFieldIndex = fromState == null ? -1 : fromState.getSchema().getPosition(fieldName); this.toFieldIndex = toState == null ? -1 : toState.getSchema().getPosition(fieldName); this.fieldDiff = new HollowFieldDiff(nodeId); this.hashedOrdinals = new int[16]; this.ordinalHashCodes = new int[16]; this.ordinalHashCounts = new int[16]; this.hashSizeBeforeGrow = 11; Arrays.fill(hashedOrdinals, -1); }
@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 HollowObjectCopier(HollowObjectTypeReadState readTypeState, HollowObjectSchema destinationSchema, OrdinalRemapper ordinalRemapper) { super(readTypeState, new HollowObjectWriteRecord(destinationSchema), ordinalRemapper, false); fieldIndexMapping = new int[destinationSchema.numFields()]; for(int i=0;i<fieldIndexMapping.length;i++) { String fieldName = destinationSchema.getFieldName(i); fieldIndexMapping[i] = readState().getSchema().getPosition(fieldName); } }
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 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; }
@Test public void filterSchema() { HollowObjectSchema s1 = new HollowObjectSchema("Test", 2, "F2"); s1.addField("F1", FieldType.INT); s1.addField("F2", FieldType.LONG); Assert.assertEquals(2, s1.numFields()); HollowFilterConfig filter = new HollowFilterConfig(); filter.addField("Test", "F2"); HollowObjectSchema s2 = s1.filterSchema(filter); Assert.assertEquals(1, s2.numFields()); Assert.assertEquals("F2", s2.getFieldName(0)); Assert.assertEquals(s1.getPrimaryKey(), s2.getPrimaryKey()); }