private static HollowSetSchema readSetSchemaFrom(DataInputStream is, String schemaName, boolean hasHashKey) throws IOException { String elementType = 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 HollowSetSchema(schemaName, elementType, hashKeyFields); }
private static HollowSetSchema parseSetSchema(String typeName, StreamTokenizer tokenizer) throws IOException { int tok = tokenizer.nextToken(); if(tokenizer.ttype != '<') throw new IOException("Invalid Syntax: Expected '<' after 'Set' 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(); String hashKeyPaths[] = parseHashKey(tokenizer); if(tokenizer.ttype != ';') throw new IOException("Invalid Syntax: Expected semicolon after Set schema declaration: " + typeName); return new HollowSetSchema(typeName, elementType, hashKeyPaths); }
@Override public HollowSchema handleSchema(String type) { if("MissingSet".equals(type)) return new HollowSetSchema("MissingSet", "MissingObject"); if("MissingObject".equals(type)) return new HollowObjectSchema("MissingObject", 0); return null; }
@Override protected void initializeTypeStates() { HollowSetTypeWriteState writeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowSetTypeWriteState writeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject")); writeStateEngine.addTypeState(writeState); } }
@Override protected void initializeTypeStates() { HollowSetTypeWriteState writeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Test public void testEquals() { { HollowSetSchema s1 = new HollowSetSchema("Test", "TypeA"); HollowSetSchema s2 = new HollowSetSchema("Test", "TypeA"); Assert.assertEquals(s1, s2); } { HollowSetSchema s1 = new HollowSetSchema("Test", "TypeA"); HollowSetSchema s2 = new HollowSetSchema("Test2", "TypeA"); Assert.assertNotEquals(s1, s2); } { HollowSetSchema s1 = new HollowSetSchema("Test", "TypeA"); HollowSetSchema s2 = new HollowSetSchema("Test", "TypeB"); Assert.assertNotEquals(s1, s2); } }
@Override protected void initializeTypeStates() { HollowSetTypeWriteState writeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { HollowSetTypeWriteState writeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject")); writeStateEngine.addTypeState(writeState); }
@Override protected void initializeTypeStates() { writeStateEngine.setTargetMaxTypeShardSize(4096); writeStateEngine.addTypeState(new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject"))); }
@Before public void setUp() { schema = new HollowSetSchema("TestSet", "TestObject"); super.setUp(); }
public HollowSetTypeMapper(HollowObjectMapper parentMapper, ParameterizedType type, String declaredName, String[] hashKeyFieldPaths, int numShards, HollowWriteStateEngine stateEngine, boolean useDefaultHashKeys, Set<Type> visited) { this.elementMapper = parentMapper.getTypeMapper(type.getActualTypeArguments()[0], null, null, -1, visited); String typeName = declaredName != null ? declaredName : getDefaultTypeName(type); if(hashKeyFieldPaths == null && useDefaultHashKeys && (elementMapper instanceof HollowObjectTypeMapper)) hashKeyFieldPaths = ((HollowObjectTypeMapper)elementMapper).getDefaultElementHashKey(); this.schema = new HollowSetSchema(typeName, elementMapper.getTypeName(), hashKeyFieldPaths); this.hashCodeFinder = stateEngine.getHashCodeFinder(); HollowSetTypeWriteState existingTypeState = (HollowSetTypeWriteState) parentMapper.getStateEngine().getTypeState(typeName); this.writeState = existingTypeState != null ? existingTypeState : new HollowSetTypeWriteState(schema, numShards); }
@Test public void restoreFailsIfShardConfigurationChanges() throws IOException { roundTripSnapshot(); HollowWriteStateEngine writeStateEngine = new HollowWriteStateEngine(); HollowSetTypeWriteState misconfiguredTypeState = new HollowSetTypeWriteState(new HollowSetSchema("TestSet", "TestObject"), 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() { aSchema = new HollowObjectSchema("A", 2, new PrimaryKey("A", "a1")); aSchema.addField("a1", FieldType.INT); aSchema.addField("a2", FieldType.REFERENCE, "B"); bSchema = new HollowSetSchema("B", "C"); cSchema = new HollowObjectSchema("C", 1); cSchema.addField("c1", FieldType.STRING); hashCodeFinder = new DefaultHashCodeFinder("C"); shard1 = createStateEngine(); shard2 = createStateEngine(); shard3 = createStateEngine(); }
@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"); }