Result set Timestamp handling improvements

DuckDB supports both `TIMESTAMP WITHOUT TIME ZONE` and
`TIMESTAMP WITH TIME ZONE`. When gettting Java `Timestamp` from a
result set, user can optionally request desired time zone by specifying
a `Calendar` instance.

Thus we are getting the following invariants:

1. `TIMESTAMP WITH TIME ZONE`, no `Calendar`: returns
`Timestamp` in a system-default (JVM) time zone that represents the
same moment in time as the DB's `TIMESTAMP WITH TIME ZONE`. For example
with a system-default time zone being `EET` (`UTC+2`) the timestamp with
`12:00` time and `CET` (`UTC+1`) DB time zone will be returned with
`13:00` time (in `EET`).

2. `TIMESTAMP WITH TIME ZONE`, user-specified Calendar: the same logic
is used as in point `1.`, just the time-zone from the user-specified
Calendar is used instead of the system-default time zone.

3. `TIMESTAMP WITHOUT TIME ZONE`, no `Calendar`: returns the timestamp
that has the same numeric values of all components as the DB's
`TIMESTAMP WITHOUT TIME ZONE`. For example the timestamp with `12:00`
time will be returned with the same `12:00` time in any system-defaut
time zone.

4. `TIMESTAMP WITHOUT TIME ZONE`, user-specified `Calendar`: this case
is tricky because user is requesting to adjust the timestamp for the
specified timezone, but DB's timestamp does not denote any time zone
that can be used as a starting point for adjustment. In this case we
are using the same logic as Postgres' JDBC driver:

https://github.com/pgjdbc/pgjdbc/blob/d86d7ce19030230f14e573b8095f04721d1d8e35/pgjdbc/src/main/java/org/postgresql/jdbc/TimestampUtils.java#L1606

So we assume that the incoming time stamp belongs to the
system-default time zone. Then we calculating the offset between the
system-default and the user-requested time zones that is effective at
the moment of time defined by our timestamp in a system-default time
zone. Note, that such offset can be different depending on the time of
year due to DST. And then shifting the timestamp by this offset - this
can seen as a "reverse" shift comparing to points `1.` and `2.`. For
example, with a system-default time zone being `EET` (`UTC+2`) and
user-requested time zone being `CET` (`UTC+1`), the timestamp with time
`12:00` will be shifted by the difference between `EET` and `CET` and
returned as `13:00` (in `CET`).

Additionally the logic added for getting date-only and time-only values
from the `TIMESTAMP_*` fields is added. It is done by getting the Java
`Timestamp` first (using the invariants described above) and then
getting date-only or time-only part of this timestamp.

Testing: existing tests adjusted to match the new time zone handling
logic; new test is added for getting `Date` and `Time` from `TIMESTAMP`.

Fixes: duckdb#146

Author: staticlibs

src/main/java/org/duckdb/DuckDBResultSet.java

@@ -31,11 +31,7 @@
 import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 import java.time.OffsetTime;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
+import java.util.*;
 
 public class DuckDBResultSet implements ResultSet {
     private final DuckDBPreparedStatement stmt;
@@ -372,7 +368,7 @@ public Date getDate(int columnIndex) throws SQLException {
     }
 
     public Time getTime(int columnIndex) throws SQLException {
-        return check_and_null(columnIndex) ? null : current_chunk[columnIndex - 1].getTime(chunk_idx - 1);
+        return getTime(columnIndex, null);
     }
 
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
@@ -911,7 +907,10 @@ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
     }
 
     public Time getTime(int columnIndex, Calendar cal) throws SQLException {
-        return getTime(columnIndex);
+        if (check_and_null(columnIndex)) {
+            return null;
+        }
+        return current_chunk[columnIndex - 1].getTime(chunk_idx - 1, cal);
     }
 
     public Time getTime(String columnLabel, Calendar cal) throws SQLException {

src/main/java/org/duckdb/DuckDBTimestamp.java

@@ -1,15 +1,10 @@
 package org.duckdb;
 
 import java.sql.Date;
+import java.sql.SQLException;
 import java.sql.Time;
 import java.sql.Timestamp;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.time.OffsetDateTime;
-import java.time.OffsetTime;
-import java.time.ZoneOffset;
+import java.time.*;
 import java.time.temporal.ChronoUnit;
 
 public class DuckDBTimestamp {
@@ -38,18 +33,47 @@ public DuckDBTimestamp(Timestamp sqlTimestamp) {
     final static LocalDateTime RefLocalDateTime;
     protected long timeMicros;
 
-    public static Timestamp toSqlTimestamp(long timeMicros) {
-        return Timestamp.valueOf(
-            LocalDateTime.ofEpochSecond(micros2seconds(timeMicros), nanosPartMicros(timeMicros), ZoneOffset.UTC));
+    private static Instant createInstant(long value, ChronoUnit unit) throws SQLException {
+        switch (unit) {
+        case SECONDS:
+            return Instant.ofEpochSecond(value);
+        case MILLIS:
+            return Instant.ofEpochMilli(value);
+        case MICROS: {
+            long epochSecond = value / 1_000_000;
+            int nanoAdjustment = nanosPartMicros(value);
+            return Instant.ofEpochSecond(epochSecond, nanoAdjustment);
+        }
+        case NANOS: {
+            long epochSecond = value / 1_000_000_000;
+            long nanoAdjustment = nanosPartNanos(value);
+            return Instant.ofEpochSecond(epochSecond, nanoAdjustment);
+        }
+        default:
+            throw new SQLException("Unsupported unit type: [" + unit + "]");
+        }
     }
 
-    public static Timestamp toSqlTimestampNanos(long timeNanos) {
-        return Timestamp.valueOf(
-            LocalDateTime.ofEpochSecond(nanos2seconds(timeNanos), nanosPartNanos(timeNanos), ZoneOffset.UTC));
+    public static LocalDateTime localDateTimeFromTimestampWithTimezone(long value, ChronoUnit unit,
+                                                                       ZoneId zoneIdNullable) throws SQLException {
+        Instant instant = createInstant(value, unit);
+        ZoneId zoneId = zoneIdNullable != null ? zoneIdNullable : ZoneId.systemDefault();
+        return LocalDateTime.ofInstant(instant, zoneId);
     }
 
-    public static LocalDateTime toLocalDateTime(long timeMicros) {
-        return LocalDateTime.ofEpochSecond(micros2seconds(timeMicros), nanosPartMicros(timeMicros), ZoneOffset.UTC);
+    public static LocalDateTime localDateTimeFromTimestamp(long value, ChronoUnit unit, ZoneId zoneIdNullable)
+        throws SQLException {
+        Instant instant = createInstant(value, unit);
+        LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
+        if (null == zoneIdNullable) {
+            return ldt;
+        }
+        ZoneId zoneIdDefault = ZoneId.systemDefault();
+        LocalDateTime ldtDefault = LocalDateTime.ofInstant(instant, zoneIdDefault);
+        LocalDateTime ldtZoned = LocalDateTime.ofInstant(instant, zoneIdNullable);
+        Duration duration = Duration.between(ldtZoned, ldtDefault);
+        LocalDateTime ldtAdjusted = ldt.plus(duration);
+        return ldtAdjusted;
     }
 
     public static OffsetTime toOffsetTime(long timeBits) {
@@ -78,26 +102,6 @@ private static LocalTime toLocalTime(long timeMicros) {
         return LocalTime.ofNanoOfDay(timeMicros * 1000);
     }
 
-    public static OffsetDateTime toOffsetDateTime(long timeMicros) {
-        return OffsetDateTime.of(toLocalDateTime(timeMicros), ZoneOffset.UTC);
-    }
-
-    public static Timestamp fromSecondInstant(long seconds) {
-        return fromMilliInstant(seconds * 1_000);
-    }
-
-    public static Timestamp fromMilliInstant(long millis) {
-        return new Timestamp(millis);
-    }
-
-    public static Timestamp fromMicroInstant(long micros) {
-        return Timestamp.from(Instant.ofEpochSecond(micros / 1_000_000, nanosPartMicros(micros)));
-    }
-
-    public static Timestamp fromNanoInstant(long nanos) {
-        return Timestamp.from(Instant.ofEpochSecond(nanos / 1_000_000_000, nanosPartNanos(nanos)));
-    }
-
     public static long localDateTime2Micros(LocalDateTime localDateTime) {
         return DuckDBTimestamp.RefLocalDateTime.until(localDateTime, ChronoUnit.MICROS);
     }
@@ -130,7 +134,7 @@ public LocalDateTime toLocalDateTime() {
     }
 
     public OffsetDateTime toOffsetDateTime() {
-        return OffsetDateTime.of(toLocalDateTime(this.timeMicros), ZoneOffset.UTC);
+        return OffsetDateTime.of(toLocalDateTime(), ZoneOffset.UTC);
     }
 
     public static long getMicroseconds(Timestamp sqlTimestamp) {