private EqualityCondition objectRecordEquality(HollowTypeReadState fromState, HollowTypeReadState toState) { final HollowObjectTypeReadState fromObjectState = (HollowObjectTypeReadState)fromState; final HollowObjectTypeReadState toObjectState = (HollowObjectTypeReadState)toState; final HollowObjectSchema commonSchema = fromObjectState.getSchema().findCommonSchema(toObjectState.getSchema()); return new EqualityCondition() { public boolean recordsAreEqual(int ordinal) { for(int i=0;i<commonSchema.numFields();i++) { int fromFieldPos = fromObjectState.getSchema().getPosition(commonSchema.getFieldName(i)); int toFieldPos = toObjectState.getSchema().getPosition(commonSchema.getFieldName(i)); if(commonSchema.getFieldType(i) == FieldType.REFERENCE) { if(fromObjectState.readOrdinal(ordinal, fromFieldPos) != toObjectState.readOrdinal(ordinal, toFieldPos)) return false; } else if(!HollowReadFieldUtils.fieldsAreEqual(fromObjectState, ordinal, fromFieldPos, toObjectState, ordinal, toFieldPos)) { return false; } } return true; } }; }
private Set<HollowSchema> getCommonSchemas(HollowReadStateEngine from, HollowReadStateEngine to) { Set<HollowSchema> schemas = new HashSet<HollowSchema>(); for(HollowSchema fromSchema : from.getSchemas()) { HollowSchema toSchema = to.getTypeState(fromSchema.getName()).getSchema(); if(toSchema != null) { if(fromSchema.getSchemaType() == SchemaType.OBJECT) { HollowObjectSchema commonSchema = ((HollowObjectSchema)fromSchema).findCommonSchema((HollowObjectSchema)toSchema); schemas.add(commonSchema); } else { schemas.add(toSchema); } } } return schemas; }
throw new IllegalArgumentException("HollowObjectTypeReadState can only calculate checksum with a HollowObjectSchema: " + schema.getName()); HollowObjectSchema commonSchema = schema.findCommonSchema((HollowObjectSchema)withSchema);
protected void restoreFrom(HollowTypeReadState readState) { if(previousCyclePopulated.cardinality() != 0 || currentCyclePopulated.cardinality() != 0) throw new IllegalStateException("Attempting to restore into a non-empty state (type " + schema.getName() + ")"); PopulatedOrdinalListener listener = readState.getListener(PopulatedOrdinalListener.class); BitSet populatedOrdinals = listener.getPopulatedOrdinals(); restoredReadState = readState; restoredMap = new ByteArrayOrdinalMap(); if(schema instanceof HollowObjectSchema) restoredSchema = ((HollowObjectSchema)schema).findCommonSchema((HollowObjectSchema)readState.getSchema()); else restoredSchema = readState.getSchema(); HollowRecordCopier copier = HollowRecordCopier.createCopier(restoredReadState, restoredSchema); int ordinal = populatedOrdinals.nextSetBit(0); while(ordinal != -1) { previousCyclePopulated.set(ordinal); restoreOrdinal(ordinal, copier, restoredMap, IGNORED_HASHES); ordinal = populatedOrdinals.nextSetBit(ordinal + 1); } ordinalMap.reservePreviouslyPopulatedOrdinals(populatedOrdinals); }
@Test public void findCommonSchema_incompatible() { try { HollowObjectSchema s1 = new HollowObjectSchema("Test", 2, "F1"); s1.addField("F1", FieldType.INT); HollowObjectSchema s2 = new HollowObjectSchema("Test", 2, "F1"); s2.addField("F1", FieldType.STRING); s1.findCommonSchema(s2); Assert.fail("Expected IncompatibleSchemaException"); } catch (IncompatibleSchemaException e) { Assert.assertEquals("Test", e.getTypeName()); Assert.assertEquals("F1", e.getFieldName()); } }
public DiffEqualityObjectMapper(DiffEqualityMapping mapping, HollowObjectTypeReadState fromState, HollowObjectTypeReadState toState, boolean oneToOne) { super(fromState, toState, oneToOne); this.commonSchema = fromState.getSchema().findCommonSchema(toState.getSchema()); this.commonReferenceFieldEqualOrdinalMaps = new DiffEqualOrdinalMap[commonSchema.numFields()]; for(int i=0;i<commonReferenceFieldEqualOrdinalMaps.length;i++) { if(commonSchema.getFieldType(i) == FieldType.REFERENCE) this.commonReferenceFieldEqualOrdinalMaps[i] = mapping.getEqualOrdinalMap(commonSchema.getReferencedType(i)); } this.fromSchemaCommonFieldMapping = buildCommonSchemaFieldMapping(fromState); this.toSchemaCommonFieldMapping = buildCommonSchemaFieldMapping(toState); boolean requiresTraversalForMissingFields = fromState().getSchema().numFields() != commonSchema.numFields() || toState().getSchema().numFields() != commonSchema.numFields(); for(int i=0;i<commonSchema.numFields();i++) { if(commonSchema.getFieldType(i) == FieldType.REFERENCE && mapping.requiresMissingFieldTraversal(commonSchema.getReferencedType(i))) { requiresTraversalForMissingFields = true; break; } } this.requiresTraversalForMissingFields = requiresTraversalForMissingFields; }
@Test public void findsCommonSchemas() { HollowObjectSchema s1 = new HollowObjectSchema("Test", 2, "F2"); s1.addField("F1", FieldType.INT); s1.addField("F2", FieldType.LONG); HollowObjectSchema s2 = new HollowObjectSchema("Test", 2, "F2"); s2.addField("F2", FieldType.LONG); s2.addField("F3", FieldType.STRING); HollowObjectSchema commonSchema = s1.findCommonSchema(s2); Assert.assertEquals(1, commonSchema.numFields()); Assert.assertEquals("F2", commonSchema.getFieldName(0)); Assert.assertEquals(FieldType.LONG, commonSchema.getFieldType(0)); Assert.assertEquals(s1.getPrimaryKey(), s2.getPrimaryKey()); Assert.assertEquals(s1.getPrimaryKey(), commonSchema.getPrimaryKey()); { HollowObjectSchema s3 = new HollowObjectSchema("Test", 2, "F3"); s3.addField("F2", FieldType.LONG); s3.addField("F3", FieldType.STRING); HollowObjectSchema c3 = s1.findCommonSchema(s3); Assert.assertNotEquals(s1.getPrimaryKey(), s3.getPrimaryKey()); Assert.assertNotEquals(s1.getPrimaryKey(), c3.getPrimaryKey()); Assert.assertNull(c3.getPrimaryKey()); } }