Change DataInKeySpacePath to contain a KeySpacePath instead of ResolvedKeySpacePath (#3716)

It was unnecessary to have the ResolvedKeySpacePath, and we want to be
able to import into a different cluster, where the resolved values are
different from the exported data.
This means that DataInKeySpacePath has a few more fields, but makes it
more versatile going forward.
This also changes `exportAllData` to use `mapPipelined` to resolve the
path, so that `DataInKeySpacePath` does not contain a future.

This is in support of #3573

Author: ScottDugas

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

@@ -24,11 +24,10 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.RecordCoreArgumentException;
 import com.apple.foundationdb.record.logging.LogMessageKeys;
-import com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext;
-import com.apple.foundationdb.tuple.ByteArrayUtil2;
+import com.apple.foundationdb.tuple.Tuple;
 
 import javax.annotation.Nonnull;
-import java.util.concurrent.CompletableFuture;
+import javax.annotation.Nullable;
 
 /**
  * Class representing a {@link KeyValue} pair within in {@link KeySpacePath}.
@@ -37,24 +36,35 @@
 public class DataInKeySpacePath {
 
     @Nonnull
-    private final CompletableFuture<ResolvedKeySpacePath> resolvedPath;
+    private final KeySpacePath path;
+    @Nullable
+    private final Tuple remainder;
     @Nonnull
     private final byte[] value;
 
-    public DataInKeySpacePath(KeySpacePath path, KeyValue rawKeyValue, FDBRecordContext context) {
-        this.resolvedPath = path.toResolvedPathAsync(context, rawKeyValue.getKey());
-        this.value = rawKeyValue.getValue();
-        if (this.value == null) {
+    public DataInKeySpacePath(@Nonnull final KeySpacePath path, @Nullable final Tuple remainder,
+                              @Nullable final byte[] value) {
+        this.path = path;
+        this.remainder = remainder;
+        if (value == null) {
             throw new RecordCoreArgumentException("Value cannot be null")
-                    .addLogInfo(LogMessageKeys.KEY, ByteArrayUtil2.loggable(rawKeyValue.getKey()));
+                    .addLogInfo(LogMessageKeys.KEY, path);
         }
-    }
-
-    public CompletableFuture<ResolvedKeySpacePath> getResolvedPath() {
-        return resolvedPath;
+        this.value = value;
     }
 
     public byte[] getValue() {
         return this.value;
     }
+
+    @Nonnull
+    public KeySpacePath getPath() {
+        return path;
+    }
+
+    @Nullable
+    public Tuple getRemainder() {
+        return remainder;
+    }
+
 }

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

@@ -189,8 +189,6 @@ public KeySpacePath path(@Nonnull String name, @Nullable Object value) {
      * <p>
      *     If entries remained in the tuple beyond the leaf directory, then {@link ResolvedKeySpacePath#getRemainder()} can be
      *     used to fetch the remaining portion.
-     *     See also {@link KeySpacePath#toResolvedPathAsync(FDBRecordContext, byte[])} if you need to resolve and you
-     *     know that it is part of a given path.
      * </p>
      * @param context context used, if needed, for any database operations
      * @param key the tuple to be decoded

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

@@ -157,25 +157,6 @@ default Tuple toTuple(@Nonnull FDBRecordContext context) {
     @Nonnull
     CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull FDBRecordContext context);
 
-    /**
-     * Given a tuple from an FDB key, attempts to determine what sub-path through this directory the tuple
-     * represents, returning a <code>ResolvedKeySpacePath</code> representing the leaf-most directory in the path.
-     * <p>
-     *     If entries remained in the tuple beyond the leaf directory, then {@link ResolvedKeySpacePath#getRemainder()}
-     *     can be used to fetch the remaining portion.
-     *     See also {@link KeySpace#resolveFromKeyAsync(FDBRecordContext, Tuple)} if you need to resolve from the root.
-     * </p>
-     * @param context  context used, if needed, for any database operations
-     * @param key a raw key from the database
-     * @return the {@link ResolvedKeySpacePath} corresponding to that key, with a potential remainder.
-     * @throws com.apple.foundationdb.record.RecordCoreArgumentException if the key provided is not part of this path
-     */
-    @API(API.Status.EXPERIMENTAL)
-    @Nonnull
-    default CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull FDBRecordContext context, byte[] key) {
-        throw new UnsupportedOperationException("toResolvedPathAsync is not supported");
-    }
-
     /**
      * Resolves the path into a {@link ResolvedKeySpacePath}, a form the retains all of the information about
      * the path itself along with the value to which each path entry is resolved.

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

@@ -34,6 +34,7 @@
 import com.apple.foundationdb.tuple.ByteArrayUtil;
 import com.apple.foundationdb.tuple.Tuple;
 import com.apple.foundationdb.tuple.TupleHelpers;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Lists;
 
 import javax.annotation.Nonnull;
@@ -181,8 +182,8 @@ public CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull FDBR
     }
 
     @Nonnull
-    @Override
-    public CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull final FDBRecordContext context, final byte[] key) {
+    @VisibleForTesting
+    CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull final FDBRecordContext context, final byte[] key) {
         final Tuple keyTuple = Tuple.fromBytes(key);
         return toResolvedPathAsync(context).thenCompose(resolvedPath -> {
             // Now use the resolved path to find the child for the key
@@ -308,7 +309,11 @@ public RecordCursor<DataInKeySpacePath> exportAllData(@Nonnull FDBRecordContext
                         .setScanProperties(scanProperties)
                         .build()),
                 context.getExecutor())
-                .map(keyValue -> new DataInKeySpacePath(this, keyValue, context));
+                .mapPipelined(keyValue ->
+                    toResolvedPathAsync(context, keyValue.getKey())
+                            .thenApply(resolvedKey ->
+                                    new DataInKeySpacePath(resolvedKey.toPath(), resolvedKey.getRemainder(), keyValue.getValue())),
+                    1);
     }
 
     /**

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

@@ -175,12 +175,6 @@ public CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull FDBR
         return inner.toResolvedPathAsync(context);
     }
 
-    @Nonnull
-    @Override
-    public CompletableFuture<ResolvedKeySpacePath> toResolvedPathAsync(@Nonnull final FDBRecordContext context, final byte[] key) {
-        return inner.toResolvedPathAsync(context, key);
-    }
-
     @Override
     public boolean equals(Object obj) {
         return inner.equals(obj);