private static HollowListSchema readListSchemaFrom(DataInputStream is, String schemaName) throws IOException { String elementType = is.readUTF(); return new HollowListSchema(schemaName, elementType); }
private static HollowListSchema parseListSchema(String typeName, StreamTokenizer tokenizer) throws IOException { int tok = tokenizer.nextToken(); if(tokenizer.ttype != '<') throw new IOException("Invalid Syntax: Expected '<' after 'List' for type " + typeName); tok = tokenizer.nextToken(); if(tok != StreamTokenizer.TT_WORD) { log.warning("Invalid Syntax: Expected element type declaration: " + typeName); } String elementType = tokenizer.sval; tok = tokenizer.nextToken(); if(tokenizer.ttype != '>') throw new IOException("Invalid Syntax: Expected '>' element type declaration: " + typeName); tok = tokenizer.nextToken(); if(tokenizer.ttype != ';') throw new IOException("Invalid Syntax: Expected semicolon after List schema declaration: " + typeName); return new HollowListSchema(typeName, elementType); }
public HollowSchema toHollowSchema() { switch(type) { case LIST: return new HollowListSchema(schemaName, subType); case MAP: return new HollowMapSchema(schemaName, "MapKey", subType); case OBJECT: HollowObjectSchema schema = new HollowObjectSchema(schemaName, fields.size()); for(Map.Entry<String, HollowDiscoveredField> entry : fields.entrySet()) { if(entry.getValue().fieldType == FieldType.STRING) { schema.addField(entry.getKey(), FieldType.REFERENCE, "String"); } else { schema.addField(entry.getKey(), entry.getValue().fieldType, entry.getValue().referencedType); } } return schema; } throw new IllegalStateException("HollowDiscoveredSchema type must be one of LIST,MAP,OBJECT. Was " + type); } }
@Override public HollowSchema handleSchema(String type) { if("MissingList".equals(type)) return new HollowListSchema("MissingList", "MissingObject"); if("MissingObject".equals(type)) return new HollowObjectSchema("MissingObject", 0); return null; }
@Override protected void initializeTypeStates() { HollowListTypeWriteState writeState = new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowListTypeWriteState writeState = new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowListTypeWriteState writeState = new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { writeStateEngine.setTargetMaxTypeShardSize(4096); writeStateEngine.addTypeState(new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject"))); }
public HollowListTypeMapper(HollowObjectMapper parentMapper, ParameterizedType type, String declaredName, int numShards, boolean ignoreListOrdering, Set<Type> visited) { this.elementMapper = parentMapper.getTypeMapper(type.getActualTypeArguments()[0], null, null, -1, visited); String typeName = declaredName != null ? declaredName : getDefaultTypeName(type); this.schema = new HollowListSchema(typeName, elementMapper.getTypeName()); this.ignoreListOrdering = ignoreListOrdering; HollowListTypeWriteState existingTypeState = (HollowListTypeWriteState)parentMapper.getStateEngine().getTypeState(typeName); this.writeState = existingTypeState != null ? existingTypeState : new HollowListTypeWriteState(schema, numShards); }
@Before public void setUp() { schema = new HollowListSchema("TestList", "TestObject"); super.setUp(); }
@Test public void restoreFailsIfShardConfigurationChanges() throws IOException { roundTripSnapshot(); HollowWriteStateEngine writeStateEngine = new HollowWriteStateEngine(); HollowListTypeWriteState misconfiguredTypeState = new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject"), 16); writeStateEngine.addTypeState(misconfiguredTypeState); try { writeStateEngine.restoreFrom(readStateEngine); Assert.fail("Should have thrown IllegalStateException because shard configuration has changed"); } catch(IllegalStateException expected) { } }
@Override protected void initializeTypeStates() { writeStateEngine.addTypeState(new HollowObjectTypeWriteState(new HollowObjectSchema("TestObject", 0))); writeStateEngine.addTypeState(new HollowListTypeWriteState(new HollowListSchema("TestList", "TestObject"))); writeStateEngine.addTypeState(new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject"))); writeStateEngine.addTypeState(new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestObject", "TestObject"))); }
@Before public void setUp() { objSchema = new HollowObjectSchema("TestObject", 5); objSchema.addField("field1", FieldType.STRING); objSchema.addField("field2", FieldType.INT); objSchema.addField("field3", FieldType.STRING); objSchema.addField("field4", FieldType.DOUBLE); objSchema.addField("field5", FieldType.FLOAT); listSchema = new HollowListSchema("TestList", "TestElement"); setSchema = new HollowSetSchema("TestSet", "TestElement"); mapSchema = new HollowMapSchema("TestMap", "TestElement", "TestElement"); elementSchema = new HollowObjectSchema("TestElement", 1); elementSchema.addField("field", FieldType.INT); super.setUp(); }
private void populateStateEngineTypes() { for(NFTypeSerializer<?> serializer : getOrderedSerializers()) { if(serializer instanceof ListSerializer) { ListSerializer<?> listSerializer = (ListSerializer<?>)serializer; TypedFieldDefinition elementFieldDef = (TypedFieldDefinition)listSerializer.getFastBlobSchema().getFieldDefinition(0); HollowListSchema listSchema = new HollowListSchema(serializer.getName(), elementFieldDef.getSubType()); HollowTypeWriteState writeState = new HollowListTypeWriteState(listSchema); stateEngine.addTypeState(writeState); } else if(serializer instanceof SetSerializer) { SetSerializer<?> setSerializer = (SetSerializer<?>)serializer; TypedFieldDefinition elementFieldDef = (TypedFieldDefinition)setSerializer.getFastBlobSchema().getFieldDefinition(0); HollowSetSchema setSchema = new HollowSetSchema(serializer.getName(), elementFieldDef.getSubType()); HollowTypeWriteState writeState = new HollowSetTypeWriteState(setSchema); stateEngine.addTypeState(writeState); } else if(serializer instanceof MapSerializer) { MapSerializer<?, ?> mapSerializer = (MapSerializer<?, ?>)serializer; MapFieldDefinition fieldDef = (MapFieldDefinition)mapSerializer.getFastBlobSchema().getFieldDefinition(0); HollowMapSchema mapSchema = new HollowMapSchema(serializer.getName(), fieldDef.getKeyType(), fieldDef.getValueType()); HollowTypeWriteState writeState = new HollowMapTypeWriteState(mapSchema); stateEngine.addTypeState(writeState); } else { HollowObjectSchema objectSchema = getHollowObjectSchema(serializer.getFastBlobSchema()); HollowTypeWriteState writeState = new HollowObjectTypeWriteState(objectSchema); stateEngine.addTypeState(writeState); } } }
@Before public void setUp() { aSchema = new HollowObjectSchema("A", 3); aSchema.addField("a", FieldType.INT); aSchema.addField("b", FieldType.REFERENCE, "B"); aSchema.addField("c", FieldType.REFERENCE, "C"); bSchema = new HollowListSchema("B", "D"); cSchema = new HollowMapSchema("C", "E", "F"); dSchema = new HollowObjectSchema("D", 2); dSchema.addField("d1", FieldType.STRING); dSchema.addField("d2", FieldType.BOOLEAN); eSchema = new HollowObjectSchema("E", 1); eSchema.addField("e", FieldType.STRING); fSchema = new HollowSetSchema("F", "G"); gSchema = new HollowObjectSchema("G", 1); gSchema.addField("g", FieldType.FLOAT); super.setUp(); }
private void setUp() { typeASchema = new HollowObjectSchema("TypeA", 3); typeASchema.addField("a1", FieldType.STRING); typeASchema.addField("a2", FieldType.REFERENCE, "TypeB"); typeASchema.addField("a3", FieldType.REFERENCE, "MapOfTypeCToTypeD"); typeBSchema = new HollowObjectSchema("TypeB", 3); typeBSchema.addField("b1", FieldType.INT); typeBSchema.addField("b2", FieldType.REFERENCE, "ListOfTypeC"); typeBSchema.addField("b3", FieldType.REFERENCE, "SetOfTypeD"); typeCSchema = new HollowObjectSchema("TypeC", 2); typeCSchema.addField("c1", FieldType.LONG); typeCSchema.addField("c2", FieldType.BOOLEAN); typeDSchema = new HollowObjectSchema("TypeD", 3); typeDSchema.addField("d1", FieldType.FLOAT); typeDSchema.addField("d2", FieldType.DOUBLE); typeDSchema.addField("d3", FieldType.BYTES); listOfTypeCSchema = new HollowListSchema("ListOfTypeC", "TypeC"); setOfTypeDSchema = new HollowSetSchema("SetOfTypeD", "TypeD"); mapOfTypeCToTypeDSchema = new HollowMapSchema("MapOfTypeCToTypeD", "TypeC", "TypeD"); }
@Before public void setUp() { typeASchema = new HollowObjectSchema("TypeA", 3); typeASchema.addField("a1", FieldType.STRING); typeASchema.addField("a2", FieldType.REFERENCE, "TypeB"); typeASchema.addField("a3", FieldType.REFERENCE, "MapOfTypeCToTypeD"); typeBSchema = new HollowObjectSchema("TypeB", 3); typeBSchema.addField("b1", FieldType.INT); typeBSchema.addField("b2", FieldType.REFERENCE, "ListOfTypeC"); typeBSchema.addField("b3", FieldType.REFERENCE, "SetOfTypeD"); typeCSchema = new HollowObjectSchema("TypeC", 2); typeCSchema.addField("c1", FieldType.LONG); typeCSchema.addField("c2", FieldType.BOOLEAN); typeDSchema = new HollowObjectSchema("TypeD", 3, "d1", "d2"); typeDSchema.addField("d1", FieldType.FLOAT); typeDSchema.addField("d2", FieldType.DOUBLE); typeDSchema.addField("d3", FieldType.BYTES); listOfTypeCSchema = new HollowListSchema("ListOfTypeC", "TypeC"); setOfTypeDSchema = new HollowSetSchema("SetOfTypeD", "TypeD"); mapOfTypeCToTypeDSchema = new HollowMapSchema("MapOfTypeCToTypeD", "TypeC", "TypeD"); }
String listElementType = ((TypedFieldDefinition)def).getSubType(); hollowSchema.addField(schema.getFieldName(i), FieldType.REFERENCE, listTypeName); HollowListSchema listSchema = new HollowListSchema(listTypeName, listElementType); HollowTypeWriteState listWriteState = new HollowListTypeWriteState(listSchema); stateEngine.addTypeState(listWriteState);
typeBSchema.addField("longVal", FieldType.LONG); listOfTypeCSchema = new HollowListSchema("ListOfTypeC", "TypeC"); setOfTypeCSchema = new HollowSetSchema("SetOfTypeC", "TypeC"); mapOfTypeCSchema = new HollowMapSchema("MapOfTypeC", "TypeC", "TypeC");