Added support of raw ranges to ReadTableSettings

alex268 · alex268 · commit 5492d7efc655 · 2025-10-28T14:24:26.000Z
diff --git a/table/src/main/java/tech/ydb/table/impl/BaseSession.java b/table/src/main/java/tech/ydb/table/impl/BaseSession.java
@@ -1266,23 +1266,23 @@ public GrpcReadStream<ReadTablePart> executeReadTable(String tablePath, ReadTabl
                 .setBatchLimitBytes(settings.batchLimitBytes())
                 .setBatchLimitRows(settings.batchLimitRows());
 
-        Value<?> fromKey = settings.getFromKey();
+        ValueProtos.TypedValue fromKey = settings.getFromKeyRaw();
         if (fromKey != null) {
             YdbTable.KeyRange.Builder range = request.getKeyRangeBuilder();
             if (settings.isFromInclusive()) {
-                range.setGreaterOrEqual(ProtoValue.toTypedValue(fromKey));
+                range.setGreaterOrEqual(fromKey);
             } else {
-                range.setGreater(ProtoValue.toTypedValue(fromKey));
+                range.setGreater(fromKey);
             }
         }
 
-        Value<?> toKey = settings.getToKey();
+        ValueProtos.TypedValue toKey = settings.getToKeyRaw();
         if (toKey != null) {
             YdbTable.KeyRange.Builder range = request.getKeyRangeBuilder();
             if (settings.isToInclusive()) {
-                range.setLessOrEqual(ProtoValue.toTypedValue(toKey));
+                range.setLessOrEqual(toKey);
             } else {
-                range.setLess(ProtoValue.toTypedValue(toKey));
+                range.setLess(toKey);
             }
         }
 
diff --git a/table/src/main/java/tech/ydb/table/query/ReadTablePart.java b/table/src/main/java/tech/ydb/table/query/ReadTablePart.java
@@ -28,25 +28,29 @@ public long getTxId() {
     }
 
     private final YdbTable.ReadTableResponse part;
-    private final ResultSetReader resultSetReader;
-    private final VirtualTimestamp timestamp;
+    private ResultSetReader resultSetReader = null;
+    private VirtualTimestamp timestamp = null;
 
     public ReadTablePart(YdbTable.ReadTableResponse part) {
         this.part = part;
-        this.resultSetReader = ProtoValueReaders.forResultSet(part.getResult().getResultSet());
-        CommonProtos.VirtualTimestamp vt = part.getSnapshot();
-        this.timestamp = new VirtualTimestamp(vt.getPlanStep(), vt.getTxId());
     }
 
     public YdbTable.ReadTableResponse getReadTableResponse() {
         return part;
     }
 
     public ResultSetReader getResultSetReader() {
+        if (resultSetReader == null) {
+            resultSetReader = ProtoValueReaders.forResultSet(part.getResult().getResultSet());
+        }
         return resultSetReader;
     }
 
     public VirtualTimestamp getVirtualTimestamp() {
+        if (timestamp == null) {
+            CommonProtos.VirtualTimestamp vt = part.getSnapshot();
+            timestamp = new VirtualTimestamp(vt.getPlanStep(), vt.getTxId());
+        }
         return timestamp;
     }
 }
diff --git a/table/src/main/java/tech/ydb/table/result/impl/ProtoValueReaders.java b/table/src/main/java/tech/ydb/table/result/impl/ProtoValueReaders.java
@@ -40,10 +40,17 @@ public static ResultSetReader forResultSets(Collection<ResultSetReader> resultSe
         return new ProtoResultSetReader(builder.build());
     }
 
+    @Deprecated
     public static ValueReader forType(ValueProtos.Type type) {
         return forTypeImpl(type);
     }
 
+    public static ValueReader forTypedValue(ValueProtos.TypedValue tv) {
+        AbstractValueReader vr = forTypeImpl(tv.getType());
+        vr.setProtoValue(tv.getValue());
+        return vr;
+    }
+
     static AbstractValueReader forTypeImpl(ValueProtos.Type type) {
         switch (type.getTypeCase()) {
             case TYPE_ID:
diff --git a/table/src/main/java/tech/ydb/table/settings/ReadTableSettings.java b/table/src/main/java/tech/ydb/table/settings/ReadTableSettings.java
@@ -11,8 +11,11 @@
 
 import tech.ydb.core.grpc.GrpcFlowControl;
 import tech.ydb.core.settings.BaseRequestSettings;
+import tech.ydb.proto.ValueProtos;
+import tech.ydb.table.result.impl.ProtoValueReaders;
 import tech.ydb.table.values.PrimitiveValue;
 import tech.ydb.table.values.TupleValue;
+import tech.ydb.table.values.proto.ProtoValue;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
@@ -24,9 +27,9 @@
 public class ReadTableSettings extends BaseRequestSettings {
 
     private final boolean ordered;
-    private final TupleValue fromKey;
+    private final ValueProtos.TypedValue fromKey;
     private final boolean fromInclusive;
-    private final TupleValue toKey;
+    private final ValueProtos.TypedValue toKey;
     private final boolean toInclusive;
     private final int rowLimit;
     private final ImmutableList<String> columns;
@@ -58,6 +61,11 @@ public boolean isOrdered() {
 
     @Nullable
     public TupleValue getFromKey() {
+        return fromKey == null ? null : ProtoValueReaders.forTypedValue(fromKey).getValue().asTuple();
+    }
+
+    @Nullable
+    public ValueProtos.TypedValue getFromKeyRaw() {
         return fromKey;
     }
 
@@ -67,6 +75,11 @@ public boolean isFromInclusive() {
 
     @Nullable
     public TupleValue getToKey() {
+        return toKey == null ? null : ProtoValueReaders.forTypedValue(toKey).getValue().asTuple();
+    }
+
+    @Nullable
+    public ValueProtos.TypedValue getToKeyRaw() {
         return toKey;
     }
 
@@ -99,9 +112,9 @@ public GrpcFlowControl getGrpcFlowControl() {
      */
     public static final class Builder extends BaseBuilder<Builder> {
         private boolean ordered = false;
-        private TupleValue fromKey = null;
+        private ValueProtos.TypedValue fromKey = null;
         private boolean fromInclusive = false;
-        private TupleValue toKey = null;
+        private ValueProtos.TypedValue toKey = null;
         private boolean toInclusive = false;
         private int rowLimit = 0;
         private List<String> columns = Collections.emptyList();
@@ -115,12 +128,24 @@ public Builder orderedRead(boolean ordered) {
         }
 
         public Builder fromKey(TupleValue value, boolean inclusive) {
+            this.fromKey = ProtoValue.toTypedValue(value);
+            this.fromInclusive = inclusive;
+            return this;
+        }
+
+        public Builder fromKey(ValueProtos.TypedValue value, boolean inclusive) {
             this.fromKey = value;
             this.fromInclusive = inclusive;
             return this;
         }
 
         public Builder toKey(TupleValue value, boolean inclusive) {
+            this.toKey = ProtoValue.toTypedValue(value);
+            this.toInclusive = inclusive;
+            return this;
+        }
+
+        public Builder toKey(ValueProtos.TypedValue value, boolean inclusive) {
             this.toKey = value;
             this.toInclusive = inclusive;
             return this;
diff --git a/table/src/main/java/tech/ydb/table/values/Value.java b/table/src/main/java/tech/ydb/table/values/Value.java
@@ -44,6 +44,10 @@ default StructValue asStruct() {
         return (StructValue) this;
     }
 
+    default TupleValue asTuple() {
+        return (TupleValue) this;
+    }
+
     default VariantValue asVariant() {
         return (VariantValue) this;
     }
diff --git a/table/src/test/java/tech/ydb/table/integration/ReadTableTest.java b/table/src/test/java/tech/ydb/table/integration/ReadTableTest.java
@@ -38,6 +38,8 @@
 import tech.ydb.table.values.PrimitiveValue;
 import tech.ydb.table.values.StructType;
 import tech.ydb.table.values.StructValue;
+import tech.ydb.table.values.TupleValue;
+import tech.ydb.table.values.proto.ProtoValue;
 import tech.ydb.test.junit4.GrpcTransportRule;
 
 /**
@@ -143,6 +145,13 @@ public void limitedReadTableTest() {
         AtomicLong rewsRead = new AtomicLong(0);
 
         ReadTableSettings rts = ReadTableSettings.newBuilder().column("id").batchLimitRows(100).build();
+        Assert.assertNull(rts.getFromKey());
+        Assert.assertNull(rts.getToKey());
+        Assert.assertNull(rts.getFromKeyRaw());
+        Assert.assertNull(rts.getToKeyRaw());
+        Assert.assertEquals(0, rts.batchLimitBytes());
+        Assert.assertEquals(100, rts.batchLimitRows());
+
         retryCtx.supplyStatus(session -> {
             rewsRead.set(0);
             return session.executeReadTable(tablePath, rts).start(part -> {
@@ -159,10 +168,20 @@ public void partialReadTableTest() {
         String tablePath = tablePath(TEST_TABLE);
         AtomicLong rowsRead = new AtomicLong(0);
 
+        PrimitiveValue from = PrimitiveValue.newInt64(1);
+        PrimitiveValue to = PrimitiveValue.newInt64(TEST_TABLE_SIZE);
         ReadTableSettings rts = ReadTableSettings.newBuilder().column("id")
-                .fromKeyExclusive(PrimitiveValue.newInt64(1))
-                .toKeyExclusive(PrimitiveValue.newInt64(TEST_TABLE_SIZE))
+                .fromKeyExclusive(from) // always coverted to optional type
+                .toKeyExclusive(to)
                 .build();
+
+        Assert.assertEquals(TupleValue.of(from.makeOptional()), rts.getFromKey());
+        Assert.assertEquals(TupleValue.of(to.makeOptional()), rts.getToKey());
+        Assert.assertEquals(ProtoValue.toTypedValue(TupleValue.of(from.makeOptional())), rts.getFromKeyRaw());
+        Assert.assertEquals(ProtoValue.toTypedValue(TupleValue.of(to.makeOptional())), rts.getToKeyRaw());
+        Assert.assertEquals(0, rts.batchLimitBytes());
+        Assert.assertEquals(0, rts.batchLimitRows());
+
         retryCtx.supplyStatus(session -> {
             rowsRead.set(0);
             return session.executeReadTable(tablePath, rts).start(part -> {

Original file line number	Diff line number	Diff line change
`@@ -28,25 +28,29 @@ public long getTxId() {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`private final YdbTable.ReadTableResponse part;`
`31`		`- private final ResultSetReader resultSetReader;`
`32`		`- private final VirtualTimestamp timestamp;`
	`31`	`+ private ResultSetReader resultSetReader = null;`
	`32`	`+ private VirtualTimestamp timestamp = null;`
`33`	`33`
`34`	`34`	`public ReadTablePart(YdbTable.ReadTableResponse part) {`
`35`	`35`	`this.part = part;`
`36`		`- this.resultSetReader = ProtoValueReaders.forResultSet(part.getResult().getResultSet());`
`37`		`- CommonProtos.VirtualTimestamp vt = part.getSnapshot();`
`38`		`- this.timestamp = new VirtualTimestamp(vt.getPlanStep(), vt.getTxId());`
`39`	`36`	`}`
`40`	`37`
`41`	`38`	`public YdbTable.ReadTableResponse getReadTableResponse() {`
`42`	`39`	`return part;`
`43`	`40`	`}`
`44`	`41`
`45`	`42`	`public ResultSetReader getResultSetReader() {`
	`43`	`+ if (resultSetReader == null) {`
	`44`	`+ resultSetReader = ProtoValueReaders.forResultSet(part.getResult().getResultSet());`
	`45`	`+ }`
`46`	`46`	`return resultSetReader;`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public VirtualTimestamp getVirtualTimestamp() {`
	`50`	`+ if (timestamp == null) {`
	`51`	`+ CommonProtos.VirtualTimestamp vt = part.getSnapshot();`
	`52`	`+ timestamp = new VirtualTimestamp(vt.getPlanStep(), vt.getTxId());`
	`53`	`+ }`
`50`	`54`	`return timestamp;`
`51`	`55`	`}`
`52`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,10 @@ default StructValue asStruct() {`
`44`	`44`	`return (StructValue) this;`
`45`	`45`	`}`
`46`	`46`
	`47`	`+ default TupleValue asTuple() {`
	`48`	`+ return (TupleValue) this;`
	`49`	`+ }`
	`50`	`+`
`47`	`51`	`default VariantValue asVariant() {`
`48`	`52`	`return (VariantValue) this;`
`49`	`53`	`}`