add withPartitionedOrdinalMap into blob header and forcing restore to fail, if producer and dataset don't have the same partition setting;

Author: azeng-netflix

hollow/src/main/java/com/netflix/hollow/api/producer/AbstractHollowProducer.java

@@ -327,6 +327,22 @@ private HollowProducer.ReadState restore(
                 readState = ReadStateHelper.newReadState(client.getCurrentVersionId(), client.getStateEngine());
                 readStates = ReadStateHelper.restored(readState);
 
+                String datasetTag = readStates.current().getStateEngine()
+                        .getHeaderTag(HollowStateEngine.HEADER_TAG_PARTITIONED_ORDINAL_MAP);
+                boolean datasetPartitionedOrdinalMap = Boolean.parseBoolean(datasetTag); // null → false
+                if (partitionedOrdinalMap && !datasetPartitionedOrdinalMap) {
+                    throw new IllegalStateException(
+                            "trying to restore a HollowProducer with partitionedOrdinalMap enabled to a dataset " +
+                            "that is produced with this feature disabled. In order to enable partitionedOrdinalMap " +
+                            "feature, please start a new delta chain.");
+                }
+                if (!partitionedOrdinalMap && datasetPartitionedOrdinalMap) {
+                    throw new IllegalStateException(
+                            "trying to restore a HollowProducer with partitionedOrdinalMap disabled to a dataset " +
+                            "that is produced with this feature enabled. In order to disable partitionedOrdinalMap " +
+                            "feature, please start a new delta chain.");
+                }
+
                 // Need to restore data to new ObjectMapper since can't restore to non empty Write State Engine
                 Collection<HollowSchema> schemas = objectMapper.getStateEngine().getSchemas();
                 HollowWriteStateEngine writeEngine = hashCodeFinder == null
@@ -591,6 +607,7 @@ private void updateHeaderTags(HollowWriteStateEngine writeEngine, long toVersion
         }
         long deltaChainVersionCounter = prevDeltaChainVersionCounter + 1;
         writeEngine.addHeaderTag(HEADER_TAG_DELTA_CHAIN_VERSION_COUNTER, String.valueOf(deltaChainVersionCounter));
+        writeEngine.addHeaderTag(HollowStateEngine.HEADER_TAG_PARTITIONED_ORDINAL_MAP, Boolean.toString(partitionedOrdinalMap));
     }
 
     void populate(

hollow/src/main/java/com/netflix/hollow/core/HollowStateEngine.java

@@ -80,6 +80,11 @@ public interface HollowStateEngine extends HollowDataset {
      */
     String HEADER_TAG_DELTA_CHAIN_VERSION_COUNTER = "hollow.delta.chain.version.counter";
 
+    /**
+     * A header tag indicating whether the producer used partitioned ordinal maps.
+     */
+    String HEADER_TAG_PARTITIONED_ORDINAL_MAP = "hollow.partitioned.ordinal.map";
+
     @Override
     List<HollowSchema> getSchemas();
 

hollow/src/test/java/com/netflix/hollow/api/producer/HollowProducerTest.java

@@ -511,6 +511,93 @@ private void restoreAndAssert(HollowProducer producer, long version, int size, i
         System.out.println("Asserted Correctness of version:" + version + "\n\n");
     }
 
+    @Test(expected = IllegalStateException.class)
+    public void testRestorePartitionedOrdinalMapMismatch_producerEnabledDatasetDisabled() {
+        InMemoryBlobStore blobStore = new InMemoryBlobStore();
+        HollowInMemoryBlobStager blobStager = new HollowInMemoryBlobStager();
+
+        // Produce dataset with partitionedOrdinalMap disabled (default)
+        HollowProducer producer1 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .build();
+        producer1.initializeDataModel(TestPojoV1.class);
+        long version = producer1.runCycle(ws -> ws.add(new TestPojoV1(1, 1)));
+
+        // Restore with partitionedOrdinalMap enabled → should fail
+        HollowProducer producer2 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .withPartitionedOrdinalMap(true)
+                .build();
+        producer2.initializeDataModel(TestPojoV1.class);
+        producer2.restore(version, blobStore);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testRestorePartitionedOrdinalMapMismatch_producerDisabledDatasetEnabled() {
+        InMemoryBlobStore blobStore = new InMemoryBlobStore();
+        HollowInMemoryBlobStager blobStager = new HollowInMemoryBlobStager();
+
+        // Produce dataset with partitionedOrdinalMap enabled
+        HollowProducer producer1 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .withPartitionedOrdinalMap(true)
+                .build();
+        producer1.initializeDataModel(TestPojoV1.class);
+        long version = producer1.runCycle(ws -> ws.add(new TestPojoV1(1, 1)));
+
+        // Restore with partitionedOrdinalMap disabled → should fail
+        HollowProducer producer2 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .build();
+        producer2.initializeDataModel(TestPojoV1.class);
+        producer2.restore(version, blobStore);
+    }
+
+    @Test
+    public void testRestorePartitionedOrdinalMapMatch_bothEnabled() {
+        InMemoryBlobStore blobStore = new InMemoryBlobStore();
+        HollowInMemoryBlobStager blobStager = new HollowInMemoryBlobStager();
+
+        // Produce dataset with partitionedOrdinalMap enabled
+        HollowProducer producer1 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .withPartitionedOrdinalMap(true)
+                .build();
+        producer1.initializeDataModel(TestPojoV1.class);
+        long version = producer1.runCycle(ws -> ws.add(new TestPojoV1(1, 1)));
+
+        // Restore with partitionedOrdinalMap enabled → should not throw IllegalStateException
+        // from our validation check (partitioned ordinal map mismatch)
+        HollowProducer producer2 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .withPartitionedOrdinalMap(true)
+                .build();
+        producer2.initializeDataModel(TestPojoV1.class);
+        producer2.restore(version, blobStore);
+    }
+
+    @Test
+    public void testRestorePartitionedOrdinalMapMatch_bothDisabled() {
+        InMemoryBlobStore blobStore = new InMemoryBlobStore();
+        HollowInMemoryBlobStager blobStager = new HollowInMemoryBlobStager();
+
+        // Produce dataset with partitionedOrdinalMap disabled (default)
+        HollowProducer producer1 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .build();
+        producer1.initializeDataModel(TestPojoV1.class);
+        long version = producer1.runCycle(ws -> ws.add(new TestPojoV1(1, 1)));
+
+        // Restore with partitionedOrdinalMap disabled → should succeed
+        HollowProducer producer2 = HollowProducer.withPublisher(blobStore)
+                .withBlobStager(blobStager)
+                .build();
+        producer2.initializeDataModel(TestPojoV1.class);
+        HollowProducer.ReadState readState = producer2.restore(version, blobStore);
+        Assert.assertNotNull(readState);
+        assertEquals(version, readState.getVersion());
+    }
+
     @Test
     public void testReshardingAllTypes() {
         HollowInMemoryBlobStager blobStager = new HollowInMemoryBlobStager();