public int addField(String fieldName, FieldType fieldType, String referencedType, HollowTypeReadState referencedTypeState) { if(fieldType == FieldType.REFERENCE && referencedType == null) throw new RuntimeException("When adding a REFERENCE field to a schema, the referenced type must be provided. Check type: " + getName() + " field: " + fieldName); fieldNames[size] = fieldName; fieldTypes[size] = fieldType; referencedTypes[size] = referencedType; nameFieldIndexLookup.put(fieldName, Integer.valueOf(size)); size++; return size - 1; }
public HollowPOJOClassGenerator(HollowDataset dataset, HollowObjectSchema schema, String packageName, String classNameSuffix, boolean memoizeOrdinal) { this.dataset = dataset; this.schema = schema; this.packageName = packageName; this.classNameSuffix = classNameSuffix; this.className = buildClassName(schema.getName(), classNameSuffix); this.importClasses = new HashSet<Class<?>>(); this.memoizeOrdinal = memoizeOrdinal; }
private void appendTypeAPIAccessor(StringBuilder classBuilder) { String typeAPIClassname = typeAPIClassname(schema.getName()); classBuilder.append(" public " + typeAPIClassname + " typeApi() {\n"); classBuilder.append(" return delegate().getTypeAPI();\n"); classBuilder.append(" }\n\n"); }
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(); }
public HollowDataAccessorGenerator(String packageName, String apiclassName, HollowObjectSchema schema, HollowDataset dataset, CodeGeneratorConfig config) { super(packageName, SUB_PACKAGE_NAME, dataset, config); this.className = getClassName(schema); this.apiclassName = apiclassName; this.type = hollowImplClassname(schema.getName()); this.schema = schema; }
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; }
@Override public boolean isNull(int ordinal, String fieldName) { try { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleIsNull(getSchema().getName(), ordinal, fieldName); return dataAccess.isNull(ordinal, fieldIndex); } catch(Exception ex) { throw new RuntimeException(String.format("Unable to handle ordinal=%s, fieldName=%s", ordinal, fieldName), ex); } }
@Override public boolean getBoolean(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); Boolean bool = (fieldIndex != -1) ? dataAccess.readBoolean(ordinal, fieldIndex) : missingDataHandler().handleBoolean(getSchema().getName(), ordinal, fieldName); return bool == null ? false : bool.booleanValue(); }
@Override public double getDouble(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleDouble(getSchema().getName(), ordinal, fieldName); return dataAccess.readDouble(ordinal, fieldIndex); }
@Override public byte[] getBytes(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) { return missingDataHandler().handleBytes(getSchema().getName(), ordinal, fieldName); } return dataAccess.readBytes(ordinal, fieldIndex); }
@Override public boolean isNull(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).isNull(ordinal, fieldIndex); return removedRecords().isNull(getMappedOrdinal(ordinal), fieldIndex); }
@Override public int readOrdinal(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readOrdinal(ordinal, fieldIndex); return removedRecords().readOrdinal(getMappedOrdinal(ordinal), fieldIndex); }
@Override public String readString(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readString(ordinal, fieldIndex); return removedRecords().readString(getMappedOrdinal(ordinal), fieldIndex); }
@Override public boolean isStringFieldEqual(int ordinal, int fieldIndex, String testValue) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).isStringFieldEqual(ordinal, fieldIndex, testValue); return removedRecords().isStringFieldEqual(getMappedOrdinal(ordinal), fieldIndex, testValue); }
@Override public float readFloat(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readFloat(ordinal, fieldIndex); return removedRecords().readFloat(getMappedOrdinal(ordinal), fieldIndex); }
@Override public Boolean readBoolean(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readBoolean(ordinal, fieldIndex); return removedRecords().readBoolean(getMappedOrdinal(ordinal), fieldIndex); }
@Override public byte[] readBytes(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readBytes(ordinal, fieldIndex); return removedRecords().readBytes(getMappedOrdinal(ordinal), fieldIndex); }
private void addRecord(HollowObjectSchema schema, String fnPrefix, int ... vals) { String bType = schema.getName(); if (writeStateEngine.getTypeState(bType) == null) { writeStateEngine.addTypeState(new HollowObjectTypeWriteState(schema)); } HollowObjectWriteRecord rec = new HollowObjectWriteRecord(schema); for (int i = 0; i < vals.length; i++) { String fn = fnPrefix + (i + 1); rec.setInt(fn, vals[i]); } writeStateEngine.add(bType, rec); }
private void addTestObject(String f1, int f2, String f3, double f4, float f5) { HollowObjectWriteRecord rec = new HollowObjectWriteRecord(objSchema); rec.setString("field1", f1); rec.setInt("field2", f2); rec.setString("field3", f3); rec.setDouble("field4", f4); rec.setFloat("field5", f5); writeStateEngine.add(objSchema.getName(), rec); }