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/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;
 

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

@@ -22,7 +22,6 @@
 import tech.ydb.table.values.proto.ProtoValue;
 
 
-
 /**
  * @author Sergey Polovko
  */
@@ -63,8 +62,8 @@ public long getInt64() {
     }
 
     /** JVM does not support unsigned long, be careful when using this method
-      for numbers greater than Long.MAX_VALUE.For correct work you can use wrappers
-      like {@link com.google.common.primitives.UnsignedLong#fromLongBits(long) UnsignedLong }
+     for numbers greater than Long.MAX_VALUE.For correct work you can use wrappers
+     like {@link com.google.common.primitives.UnsignedLong#fromLongBits(long) UnsignedLong }
      * @return signed long value corresponding to a bit representation of unsigned.*/
     public long getUint64() {
         throw new IllegalStateException("expected Uint64, but was " + getClass().getSimpleName());
@@ -164,6 +163,22 @@ public ZonedDateTime getTzTimestamp() {
         throw new IllegalStateException("expected TzTimestamp, but was " + getClass().getSimpleName());
     }
 
+    public LocalDate getDate32() {
+        throw new IllegalStateException("expected Date32, but was " + getClass().getSimpleName());
+    }
+
+    public LocalDateTime getDatetime64() {
+        throw new IllegalStateException("expected Datetime64, but was " + getClass().getSimpleName());
+    }
+
+    public Instant getTimestamp64() {
+        throw new IllegalStateException("expected Timestamp64, but was " + getClass().getSimpleName());
+    }
+
+    public Duration getInterval64() {
+        throw new IllegalStateException("expected Interval64, but was " + getClass().getSimpleName());
+    }
+
     // -- constructors --
 
     public static PrimitiveValue newBool(boolean value) {
@@ -274,6 +289,19 @@ public static PrimitiveValue newDate(Instant value) {
         return newDate(TimeUnit.SECONDS.toDays(value.getEpochSecond()));
     }
 
+    public static PrimitiveValue newDate32(long daysSinceEpoch) {
+        return new InstantValue(PrimitiveType.Date32, TimeUnit.DAYS.toMicros(daysSinceEpoch));
+    }
+
+    public static PrimitiveValue newDate32(LocalDate value) {
+        return newDate32(value.toEpochDay());
+    }
+
+    public static PrimitiveValue newDate32(Instant value) {
+        return newDate32(TimeUnit.SECONDS.toDays(value.getEpochSecond()));
+    }
+
+
     public static PrimitiveValue newDatetime(long secondsSinceEpoch) {
         if (secondsSinceEpoch < 0) {
             throw new IllegalArgumentException("negative secondsSinceEpoch: " + secondsSinceEpoch);
@@ -289,6 +317,18 @@ public static PrimitiveValue newDatetime(LocalDateTime value) {
         return newDatetime(value.toEpochSecond(ZoneOffset.UTC));
     }
 
+    public static PrimitiveValue newDatetime64(long secondsSinceEpoch) {
+        return new InstantValue(PrimitiveType.Datetime64, TimeUnit.SECONDS.toMicros(secondsSinceEpoch));
+    }
+
+    public static PrimitiveValue newDatetime64(Instant value) {
+        return newDatetime64(value.getEpochSecond());
+    }
+
+    public static PrimitiveValue newDatetime64(LocalDateTime value) {
+        return newDatetime64(value.toEpochSecond(ZoneOffset.UTC));
+    }
+
     public static PrimitiveValue newTimestamp(long microsSinceEpoch) {
         if (microsSinceEpoch < 0) {
             throw new IllegalArgumentException("microsSinceEpoch value is before "
@@ -317,14 +357,32 @@ public static PrimitiveValue newTimestamp(Instant value) {
         return new InstantValue(PrimitiveType.Timestamp, micros);
     }
 
+    public static PrimitiveValue newTimestamp64(long microsSinceEpoch) {
+        return new InstantValue(PrimitiveType.Timestamp, microsSinceEpoch);
+    }
+
+    public static PrimitiveValue newTimestamp64(Instant value) {
+        long micros = TimeUnit.SECONDS.toMicros(value.getEpochSecond()) +
+                TimeUnit.NANOSECONDS.toMicros(value.getNano());
+        return new InstantValue(PrimitiveType.Timestamp, micros);
+    }
+
     public static PrimitiveValue newInterval(long micros) {
-        return new IntervalValue(micros);
+        return new IntervalValue(PrimitiveType.Interval, micros);
     }
 
     public static PrimitiveValue newInterval(Duration value) {
         return newInterval(TimeUnit.NANOSECONDS.toMicros(value.toNanos()));
     }
 
+    public static PrimitiveValue newInterval64(long micros) {
+        return new IntervalValue(PrimitiveType.Interval64, micros);
+    }
+
+    public static PrimitiveValue newInterval64(Duration value) {
+        return newInterval(TimeUnit.NANOSECONDS.toMicros(value.toNanos()));
+    }
+
     public static PrimitiveValue newTzDate(ZonedDateTime dateTime) {
         return new TzDatetime(PrimitiveType.TzDate, dateTime);
     }

table/src/main/java/tech/ydb/table/values/proto/ProtoType.java

@@ -62,6 +62,10 @@ public class ProtoType {
     private static final ValueProtos.Type TZ_TIMESTAMP = primitiveType(PrimitiveTypeId.TZ_TIMESTAMP);
     private static final ValueProtos.Type JSON_DOCUMENT = primitiveType(PrimitiveTypeId.JSON_DOCUMENT);
     private static final ValueProtos.Type DYNUMBER = primitiveType(PrimitiveTypeId.DYNUMBER);
+    private static final ValueProtos.Type DATE32 = primitiveType(PrimitiveTypeId.DATE32);
+    private static final ValueProtos.Type DATETIME64 = primitiveType(PrimitiveTypeId.DATETIME64);
+    private static final ValueProtos.Type TIMESTAMP64 = primitiveType(PrimitiveTypeId.TIMESTAMP64);
+    private static final ValueProtos.Type INTERVAL64 = primitiveType(PrimitiveTypeId.INTERVAL64);
 
     private ProtoType() { }
 
@@ -171,6 +175,22 @@ public static ValueProtos.Type getDyNumber() {
         return DYNUMBER;
     }
 
+    public static ValueProtos.Type getDate32() {
+        return DATE32;
+    }
+
+    public static ValueProtos.Type getDatetime64() {
+        return DATETIME64;
+    }
+
+    public static ValueProtos.Type getTimestamp64() {
+        return TIMESTAMP64;
+    }
+
+    public static ValueProtos.Type getInterval64() {
+        return INTERVAL64;
+    }
+
     public static ValueProtos.Type getDecimal(int precision, int scale) {
         ValueProtos.Type.Builder builder = ValueProtos.Type.newBuilder();
         builder.getDecimalTypeBuilder()