feat: supported date32, datetime64, timestamp64, interval64

Author: KirillKurdyukov

bom/pom.xml

@@ -15,7 +15,7 @@
 
     <properties>
         <ydb-auth-api.version>1.0.0</ydb-auth-api.version>
-        <ydb-proto-api.version>1.6.4</ydb-proto-api.version>
+        <ydb-proto-api.version>1.7.0</ydb-proto-api.version>
         <yc-auth.version>2.2.0</yc-auth.version>
     </properties>
 

query/pom.xml

@@ -46,6 +46,8 @@
                     <environmentVariables>
                         <YDB_DOCKER_IMAGE>cr.yandex/yc/yandex-docker-local-ydb:trunk</YDB_DOCKER_IMAGE>
                         <TESTCONTAINERS_REUSE_ENABLE>true</TESTCONTAINERS_REUSE_ENABLE>
+                        <YDB_ENDPOINT>grpc://localhost:2136</YDB_ENDPOINT>
+                        <YDB_DATABASE>/local</YDB_DATABASE>
                     </environmentVariables>
                 </configuration>
             </plugin>

query/src/test/java/tech/ydb/query/ValueReadTest.java

@@ -0,0 +1,91 @@
+package tech.ydb.query;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+import org.junit.Assert;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+import tech.ydb.common.transaction.TxMode;
+import tech.ydb.query.tools.QueryReader;
+import tech.ydb.query.tools.SessionRetryContext;
+import tech.ydb.table.query.Params;
+import tech.ydb.table.result.ResultSetReader;
+import tech.ydb.table.values.PrimitiveValue;
+import tech.ydb.test.junit4.GrpcTransportRule;
+
+/**
+ * @author Kirill Kurdyukov
+ */
+public class ValueReadTest {
+
+    @ClassRule
+    public final static GrpcTransportRule ydbTransport = new GrpcTransportRule();
+
+    private final SessionRetryContext CTX = SessionRetryContext.create(QueryClient.newClient(ydbTransport).build()).build();
+
+//    @Test TODO
+    public void date32datetime64timestamp64interval64() {
+        date32datetime64timestamp64interval64Assert(
+                LocalDate.of(988, 2, 6),
+                LocalDateTime.of(988, 2, 7, 12, 30, 0),
+                Instant.parse("0998-06-02T12:30:00.678901Z"),
+                Duration.parse("-PT2S")
+        );
+
+//        date32datetime64timestamp64interval64Assert(
+//                LocalDate.MIN,
+//                LocalDateTime.MIN,
+//                Instant.MIN,
+//                Duration.ZERO
+//        );
+
+
+        QueryReader reader = CTX.supplyResult(
+                s -> QueryReader.readFrom(s.createQuery("SELECT " +
+                        "        Date32('998-06-02') AS c1,\n" +
+                        "        Datetime64('0998-06-02T12:30:00Z') AS c2,\n" +
+                        "        Timestamp64('0998-06-02T12:30:00.678901Z') AS c3,\n" +
+                        "        Interval64('-PT2S') AS c4;", TxMode.NONE))
+        ).join().getValue();
+
+        ResultSetReader resultSetReader = reader.getResultSet(0);
+
+        Assert.assertTrue(resultSetReader.next());
+        Assert.assertEquals(LocalDate.parse("0998-06-02"), resultSetReader.getColumn(0).getDate32());
+        Assert.assertEquals(LocalDateTime.parse("0998-06-02T12:30:00"), resultSetReader.getColumn(1).getDatetime64());
+        Assert.assertEquals(Instant.parse("0998-06-02T12:30:00.678901Z"), resultSetReader.getColumn(2).getTimestamp64());
+        Assert.assertEquals(Duration.parse("-PT2S"), resultSetReader.getColumn(3).getInterval64());
+    }
+
+    private void date32datetime64timestamp64interval64Assert(LocalDate date32, LocalDateTime datetime64,
+                                                             Instant timestamp64, Duration interval64) {
+        QueryReader reader = CTX.supplyResult(
+                s -> QueryReader.readFrom(s.createQuery("" +
+                                "DECLARE $date32 AS Date32;\n" +
+                                "DECLARE $datetime64 AS Datetime64;\n" +
+                                "DECLARE $timestamp64 AS Timestamp64;\n" +
+                                "DECLARE $interval64 AS Instant64;\n" +
+                                "SELECT $date32, $datetime64, $timestamp64, $interval64;",
+                        TxMode.SERIALIZABLE_RW,
+                        Params.of(
+                                "$date32", PrimitiveValue.newDate32(date32),
+                                "$datetime64", PrimitiveValue.newDatetime64(datetime64),
+                                "$timestamp64", PrimitiveValue.newTimestamp64(timestamp64),
+                                "$interval64", PrimitiveValue.newInterval64(interval64)
+                        )
+                ))
+        ).join().getValue();
+
+        ResultSetReader resultSetReader = reader.getResultSet(0);
+
+        Assert.assertTrue(resultSetReader.next());
+        Assert.assertEquals(date32, resultSetReader.getColumn(0).getDate32());
+        Assert.assertEquals(datetime64, resultSetReader.getColumn(1).getDatetime64());
+        Assert.assertEquals(timestamp64, resultSetReader.getColumn(2).getTimestamp64());
+        Assert.assertEquals(interval64, resultSetReader.getColumn(3).getInterval64());
+    }
+}

table/src/main/java/tech/ydb/table/result/PrimitiveReader.java

@@ -46,6 +46,14 @@ public interface PrimitiveReader {
 
     Duration getInterval();
 
+    LocalDate getDate32();
+
+    LocalDateTime getDatetime64();
+
+    Instant getTimestamp64();
+
+    Duration getInterval64();
+
     ZonedDateTime getTzDate();
 
     ZonedDateTime getTzDatetime();

table/src/main/java/tech/ydb/table/result/impl/AbstractValueReader.java

@@ -116,6 +116,24 @@ public Duration getInterval() {
         throw error("getInterval");
     }
 
+    @Override
+    public LocalDate getDate32() {
+        throw error("getDate32");
+    }
+
+    public LocalDateTime getDatetime64() {
+        throw error("getDatetime64");
+    }
+
+    @Override
+    public Instant getTimestamp64() {
+        throw error("getTimestamp64");
+    }
+
+    public Duration getInterval64() {
+        throw error("getInterval64");
+    }
+
     @Override
     public ZonedDateTime getTzDate() {
         throw error("getTzDate");

table/src/main/java/tech/ydb/table/result/impl/ProtoPrimitiveValueReader.java

@@ -139,6 +139,30 @@ public Duration getInterval() {
         return ProtoValue.toInterval(value);
     }
 
+    @Override
+    public LocalDate getDate32() {
+        checkPrimitive(PrimitiveTypeId.DATE32);
+        return ProtoValue.toDate32(value);
+    }
+
+    @Override
+    public LocalDateTime getDatetime64() {
+        checkPrimitive(PrimitiveTypeId.DATETIME64);
+        return ProtoValue.toDatetime64(value);
+    }
+
+    @Override
+    public Instant getTimestamp64() {
+        checkPrimitive(PrimitiveTypeId.TIMESTAMP64);
+        return ProtoValue.toTimestamp64(value);
+    }
+
+    @Override
+    public Duration getInterval64() {
+        checkPrimitive(PrimitiveTypeId.INTERVAL64);
+        return ProtoValue.toInterval64(value);
+    }
+
     @Override
     public ZonedDateTime getTzDate() {
         checkPrimitive(PrimitiveTypeId.TZ_DATE);

table/src/main/java/tech/ydb/table/values/PrimitiveType.java

@@ -58,12 +58,20 @@ public enum PrimitiveType implements Type {
     /** JSON in an indexed binary representation. Doesn't support matching, can't be used in the primary key */
     JsonDocument(ProtoType.getJsonDocument()),
     /** A binary representation of a real number with an accuracy of up to 38 digits.
-      * Acceptable values: positive numbers from 1×10-130 up to 1×10126–1,
-      * negative numbers from -1×10126–1 to -1×10-130, and 0.
-      * Compatible with the Number type in AWS DynamoDB.
-      * It's not recommended for ydb-native applications.
-      */
-    DyNumber(ProtoType.getDyNumber());
+     * Acceptable values: positive numbers from 1×10-130 up to 1×10126–1,
+     * negative numbers from -1×10126–1 to -1×10-130, and 0.
+     * Compatible with the Number type in AWS DynamoDB.
+     * It's not recommended for ydb-native applications.
+     */
+    DyNumber(ProtoType.getDyNumber()),
+
+    Date32(ProtoType.getDate32()),
+
+    Datetime64(ProtoType.getDatetime64()),
+
+    Timestamp64(ProtoType.getTimestamp64()),
+
+    Interval64(ProtoType.getInterval64());
 
     private final ValueProtos.Type pbType;