public FieldType getFieldType(String fieldName) { int fieldPosition = getPosition(fieldName); if(fieldPosition == -1) return null; return getFieldType(fieldPosition); }
@Override protected void setUpChildren() { children = new HollowIndexerTraversalNode[super.children.size()]; childOrdinalFieldPositions = new int[children.length]; int idx = 0; for(Map.Entry<String, HollowIndexerTraversalNode> entry : super.children.entrySet()) { childOrdinalFieldPositions[idx] = dataAccess().getSchema().getPosition(entry.getKey()); children[idx] = entry.getValue(); idx++; } }
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[] 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; }
public void setBoolean(String fieldName, boolean value) { int fieldIndex = getSchema().getPosition(fieldName); validateFieldType(fieldIndex, fieldName, FieldType.BOOLEAN); ByteDataBuffer buf = getFieldBuffer(fieldIndex); buf.write(value ? (byte) 1 : (byte) 0); }
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)); } } }
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); } }
@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(); }
private Set<String> getMovieNames(Set<Integer> ordinals, String type, String field) { Set<String> movieNames = new HashSet<>(); HollowObjectTypeReadState movieReadState = (HollowObjectTypeReadState) readStateEngine.getTypeState(type); HollowObjectTypeReadState nameReadState = (HollowObjectTypeReadState) readStateEngine.getTypeState("String"); int nameField = movieReadState.getSchema().getPosition(field); int valueField = nameReadState.getSchema().getPosition("value"); for (int ordinal : ordinals) { int nameOrdinal = movieReadState.readOrdinal(ordinal, nameField); movieNames.add(nameReadState.readString(nameOrdinal, valueField)); } return movieNames; }
public void setInt(String fieldName, int value) { if(value == Integer.MIN_VALUE) { setNull(fieldName); } else { int fieldIndex = getSchema().getPosition(fieldName); validateFieldType(fieldIndex, fieldName, FieldType.INT); ByteDataBuffer buf = getFieldBuffer(fieldIndex); // zig zag encoding VarInt.writeVInt(buf, ZigZag.encodeInt(value)); } }
public void setLong(String fieldName, long value) { if(value == Long.MIN_VALUE) { setNull(fieldName); } else { int fieldIndex = getSchema().getPosition(fieldName); validateFieldType(fieldIndex, fieldName, FieldType.LONG); ByteDataBuffer buf = getFieldBuffer(fieldIndex); // zig zag encoding VarInt.writeVLong(buf, ZigZag.encodeLong(value)); } }
private boolean recordFieldMatchesKey(HollowObjectTypeReadState typeState, int ordinal, HollowObjectTypeReadState keyTypeState, int keyOrdinal, int keyFieldPosition, String[] keyFieldParts, int keyFieldPartPosition) { int schemaPosition = typeState.getSchema().getPosition(keyFieldParts[keyFieldPartPosition]); if(keyFieldPartPosition < keyFieldParts.length - 1) { HollowObjectTypeReadState nextPartTypeState = (HollowObjectTypeReadState) typeState.getSchema().getReferencedTypeState(schemaPosition); int nextOrdinal = typeState.readOrdinal(ordinal, schemaPosition); return recordFieldMatchesKey(nextPartTypeState, nextOrdinal, keyTypeState, keyOrdinal, keyFieldPosition, keyFieldParts, keyFieldPartPosition + 1); } else { return HollowReadFieldUtils.fieldsAreEqual(typeState, ordinal, schemaPosition, keyTypeState, keyOrdinal, keyFieldPosition); } }
@Override public long getLong(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleLong(getSchema().getName(), ordinal, fieldName); return dataAccess.readLong(ordinal, fieldIndex); }
@Override public boolean isStringFieldEqual(int ordinal, String fieldName, String testValue) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) { return missingDataHandler().handleStringEquals(getSchema().getName(), ordinal, fieldName, testValue); } return dataAccess.isStringFieldEqual(ordinal, fieldIndex, testValue); }
@Override public int getOrdinal(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleReferencedOrdinal(getSchema().getName(), ordinal, fieldName); return dataAccess.readOrdinal(ordinal, fieldIndex); }
@Override public int getInt(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleInt(getSchema().getName(), ordinal, fieldName); return dataAccess.readInt(ordinal, fieldIndex); }
@Override public float getFloat(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleFloat(getSchema().getName(), ordinal, fieldName); return dataAccess.readFloat(ordinal, fieldIndex); }
@Override public String getString(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleString(getSchema().getName(), ordinal, fieldName); return dataAccess.readString(ordinal, fieldIndex); }
@Override public boolean shouldIndex(int ordinal) { HollowObjectTypeDataAccess objectTypeDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("Movie"); int yearReleasedFieldPosition = objectTypeDataAccess.getSchema().getPosition("releaseYear"); int yearReleased = objectTypeDataAccess.readInt(ordinal, yearReleasedFieldPosition); if (yearReleased == 2009) return true; return false; } };
private String roundTripReferenceStringValue(String value) throws IOException { HollowObjectMapper mapper = new HollowObjectMapper(writeStateEngine); mapper.add(new TypeA(value, 1, null, null)); roundTripSnapshot(); HollowObjectTypeDataAccess typeDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("TypeA"); int stringFieldIndex = typeDataAccess.getSchema().getPosition("a1"); int stringValueOrdinal = typeDataAccess.readOrdinal(0, stringFieldIndex); HollowObjectTypeDataAccess stringDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("String"); int stringValueField = stringDataAccess.getSchema().getPosition("value"); return stringDataAccess.readString(stringValueOrdinal, stringValueField); }