private static HollowMapSchema readMapSchemaFrom(DataInputStream is, String schemaName, boolean hasHashKey) throws IOException { String keyType = is.readUTF(); String valueType = is.readUTF(); String hashKeyFields[] = null; if(hasHashKey) { int numFields = VarInt.readVInt(is); hashKeyFields = new String[numFields]; for(int i=0;i<numFields;i++) { hashKeyFields[i] = is.readUTF(); } } return new HollowMapSchema(schemaName, keyType, valueType, hashKeyFields); }
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 protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState( new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); } }
@Override protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); }
@Override public HollowSchema handleSchema(String type) { if("MissingMap".equals(type)) return new HollowMapSchema("MissingMap", "MissingObject", "MissingObject"); if("MissingObject".equals(type)) return new HollowObjectSchema("MissingObject", 0); return null; }
@Override protected void initializeTypeStates() { HollowMapTypeWriteState writeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue")); writeStateEngine.addTypeState(writeState); }
@Test public void testEquals() { { HollowMapSchema s1 = new HollowMapSchema("Test", "TypeA", "TypeB"); HollowMapSchema s2 = new HollowMapSchema("Test", "TypeA", "TypeB"); Assert.assertEquals(s1, s2); } { HollowMapSchema s1 = new HollowMapSchema("Test", "TypeA", "TypeB"); HollowMapSchema s2 = new HollowMapSchema("Test2", "TypeA", "TypeB"); Assert.assertNotEquals(s1, s2); } { HollowMapSchema s1 = new HollowMapSchema("Test", "TypeA", "TypeB"); HollowMapSchema s2 = new HollowMapSchema("Test", "TypeB", "TypeB"); Assert.assertNotEquals(s1, s2); } { HollowMapSchema s1 = new HollowMapSchema("Test", "TypeA", "TypeB"); HollowMapSchema s2 = new HollowMapSchema("Test", "TypeA", "TypeC"); Assert.assertNotEquals(s1, s2); } }
@Override protected void initializeTypeStates() { writeStateEngine.setTargetMaxTypeShardSize(4096); writeStateEngine.addTypeState(new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue"))); }
@Before public void setUp() { schema = new HollowMapSchema("TestMap", "TestKey", "TestValue"); super.setUp(); }
public HollowMapTypeMapper(HollowObjectMapper parentMapper, ParameterizedType type, String declaredName, String[] hashKeyFieldPaths, int numShards, HollowWriteStateEngine stateEngine, boolean useDefaultHashKeys, Set<Type> visited) { this.keyMapper = parentMapper.getTypeMapper(type.getActualTypeArguments()[0], null, null, -1, visited); this.valueMapper = parentMapper.getTypeMapper(type.getActualTypeArguments()[1], null, null, -1, visited); String typeName = declaredName != null ? declaredName : getDefaultTypeName(type); if(hashKeyFieldPaths == null && useDefaultHashKeys && (keyMapper instanceof HollowObjectTypeMapper)) hashKeyFieldPaths = ((HollowObjectTypeMapper)keyMapper).getDefaultElementHashKey(); this.schema = new HollowMapSchema(typeName, keyMapper.getTypeName(), valueMapper.getTypeName(), hashKeyFieldPaths); this.hashCodeFinder = stateEngine.getHashCodeFinder(); HollowMapTypeWriteState typeState = (HollowMapTypeWriteState) parentMapper.getStateEngine().getTypeState(typeName); this.writeState = typeState != null ? typeState : new HollowMapTypeWriteState(schema, numShards); }
@Test public void restoreFailsIfShardConfigurationChanges() throws IOException { roundTripSnapshot(); HollowWriteStateEngine writeStateEngine = new HollowWriteStateEngine(); HollowMapTypeWriteState misconfiguredTypeState = new HollowMapTypeWriteState(new HollowMapSchema("TestMap", "TestKey", "TestValue"), 16); writeStateEngine.addTypeState(misconfiguredTypeState); try { writeStateEngine.restoreFrom(readStateEngine); Assert.fail("Should have thrown IllegalStateException because shard configuration has changed"); } catch(IllegalStateException expected) { } }
public static HollowSchema withoutKeys(HollowSchema schema) { switch(schema.getSchemaType()) { case SET: HollowSetSchema setSchema = (HollowSetSchema)schema; if(setSchema.getHashKey() != null) setSchema = new HollowSetSchema(setSchema.getName(), setSchema.getElementType()); return setSchema; case MAP: HollowMapSchema mapSchema = (HollowMapSchema)schema; if(mapSchema.getHashKey() != null) mapSchema = new HollowMapSchema(mapSchema.getName(), mapSchema.getKeyType(), mapSchema.getValueType()); return mapSchema; default: return schema; } }
@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(); }
@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"); }