Respond to DataInKeySpacePath not having Resolved on main (after rebase)

Author: ScottDugas

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/foundationdb/keyspace/KeySpacePath.java

@@ -417,7 +417,8 @@ default RecordCursor<DataInKeySpacePath> exportAllData(@Nonnull FDBRecordContext
      * or one of the sub-directories, if not the future will complete exceptionally with
      * {@link RecordCoreIllegalImportDataException}.
      * If there is any data already existing under this path, the new data will overwrite if the keys are the same.
-     * This will use the logical value in the {@link DataInKeySpacePath#getResolvedPath()} to determine the key, rather
+     * This will use the logical values in the {@link DataInKeySpacePath#getPath()} and
+     * {@link DataInKeySpacePath#getRemainder()} to determine the key, rather
      * than the raw key, meaning that this will work even if the data was exported from a different cluster.
      * @param context the transaction context in which to save the data
      * @param dataToImport the data to be saved to the database

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/foundationdb/keyspace/KeySpacePathImpl.java

@@ -322,33 +322,32 @@ public CompletableFuture<Void> importData(@Nonnull FDBRecordContext context,
                                               @Nonnull Iterable<DataInKeySpacePath> dataToImport) {
         return toTupleAsync(context).thenCompose(targetTuple -> {
             List<CompletableFuture<Void>> importFutures = new ArrayList<>();
-            
+
             for (DataInKeySpacePath dataItem : dataToImport) {
-                CompletableFuture<Void> importFuture = dataItem.getResolvedPath().thenCompose(resolvedPath -> {
+                CompletableFuture<Void> importFuture = dataItem.getPath().toTupleAsync(context).thenCompose(itemPathTuple -> {
                     // Validate that this data belongs under this path
-                    Tuple itemTuple = resolvedPath.toTuple();
-                    if (!TupleHelpers.isPrefix(targetTuple, itemTuple)) {
+                    if (!TupleHelpers.isPrefix(targetTuple, itemPathTuple)) {
                         throw new RecordCoreIllegalImportDataException(
                                 "Data item path does not belong under target path",
-                                "target", targetTuple, "item", itemTuple);
+                                "target", targetTuple, "item", itemPathTuple);
                     }
-                    
-                    // Reconstruct the key using logical values from the resolved path
-                    Tuple keyTuple = itemTuple;
-                    if (resolvedPath.getRemainder() != null) {
-                        keyTuple = keyTuple.addAll(resolvedPath.getRemainder());
+
+                    // Reconstruct the key using the path and remainder
+                    Tuple keyTuple = itemPathTuple;
+                    if (dataItem.getRemainder() != null) {
+                        keyTuple = keyTuple.addAll(dataItem.getRemainder());
                     }
-                    
+
                     // Store the data
                     byte[] keyBytes = keyTuple.pack();
                     byte[] valueBytes = dataItem.getValue();
                     context.ensureActive().set(keyBytes, valueBytes);
-                    
+
                     return AsyncUtil.DONE;
                 });
                 importFutures.add(importFuture);
             }
-            
+
             return AsyncUtil.whenAll(importFutures);
         });
     }

fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/keyspace/KeySpacePathDataExportTest.java

@@ -635,7 +635,7 @@ private static List<DataInKeySpacePath> exportAllData(final KeySpacePath pathToE
         final List<DataInKeySpacePath> reversed = pathToExport.exportAllData(context, null, ScanProperties.REVERSE_SCAN)
                 .asList().join();
         Collections.reverse(reversed);
-        assertDataInKeySpacePathEquals(asSingleExport, reversed);
+        assertDataInKeySpacePathEquals(context, asSingleExport, reversed);
 
         // Assert continuations work correctly
         final ScanProperties scanProperties = ScanProperties.FORWARD_SCAN.with(props -> props.setReturnedRowLimit(1));
@@ -655,11 +655,12 @@ private static List<DataInKeySpacePath> exportAllData(final KeySpacePath pathToE
             }
         }
 
-        assertDataInKeySpacePathEquals(asSingleExport, asContinuations);
+        assertDataInKeySpacePathEquals(context, asSingleExport, asContinuations);
         return asSingleExport;
     }
 
-    private static void assertDataInKeySpacePathEquals(final List<DataInKeySpacePath> expectedList,
+    private static void assertDataInKeySpacePathEquals(final FDBRecordContext context,
+                                                       final List<DataInKeySpacePath> expectedList,
                                                        final List<DataInKeySpacePath> actualList) {
         assertThat(actualList).zipSatisfy(expectedList,
                 (actual, other) -> {

fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/keyspace/KeySpacePathImportDataTest.java

@@ -20,7 +20,6 @@
 
 package com.apple.foundationdb.record.provider.foundationdb.keyspace;
 
-import com.apple.foundationdb.KeyValue;
 import com.apple.foundationdb.Transaction;
 import com.apple.foundationdb.record.ScanProperties;
 import com.apple.foundationdb.record.provider.foundationdb.FDBDatabase;
@@ -178,11 +177,8 @@ void importOverwriteExistingData() {
 
         // Create import data with same key but different value
         List<DataInKeySpacePath> importData = new ArrayList<>();
-        try (FDBRecordContext context = database.openContext()) {
-            byte[] key = dataPath.toSubspace(context).pack(Tuple.from("record"));
-            KeyValue kv = new KeyValue(key, Tuple.from("new_value").pack());
-            importData.add(new DataInKeySpacePath(root.path("root"), kv, context));
-        }
+        importData.add(new DataInKeySpacePath(dataPath,
+                Tuple.from("record"), Tuple.from("new_value").pack()));
 
         // Verify we can re-import the data multiple times
         importData(database, root.path("root"), importData);
@@ -349,19 +345,15 @@ void importDataWithDuplicateKeys() {
 
 
         KeySpacePath dataPath = root.path("root").add("data", 1L);
-        try (FDBRecordContext context = database.openContext()) {
-            byte[] key = dataPath.toSubspace(context).pack(Tuple.from("item"));
-            
-            // Create multiple DataInKeySpacePath objects with same key but different values
-            List<DataInKeySpacePath> duplicateData = Arrays.asList(
-                    new DataInKeySpacePath(root.path("root"), 
-                            new KeyValue(key, Tuple.from("first_value").pack()), context),
-                    new DataInKeySpacePath(root.path("root"), 
-                            new KeyValue(key, Tuple.from("second_value").pack()), context),
-                    new DataInKeySpacePath(root.path("root"), 
-                            new KeyValue(key, Tuple.from("final_value").pack()), context)
-            );
 
+        // Create multiple DataInKeySpacePath objects with same key but different values
+        List<DataInKeySpacePath> duplicateData = Arrays.asList(
+                new DataInKeySpacePath(dataPath, Tuple.from("item"), Tuple.from("first_value").pack()),
+                new DataInKeySpacePath(dataPath, Tuple.from("item"), Tuple.from("second_value").pack()),
+                new DataInKeySpacePath(dataPath, Tuple.from("item"), Tuple.from("final_value").pack())
+        );
+
+        try (FDBRecordContext context = database.openContext()) {
             root.path("root").importData(context, duplicateData).join();
             context.commit();
         }