SNOW-1950032 Fix Gregorian dates handling in BindUploader and handling of TIME as wall clock time (#2164)

Author: sfc-gh-rkowalski

src/main/java/net/snowflake/client/core/JsonSqlOutput.java

@@ -198,7 +198,13 @@ public void writeDate(Date value) throws SQLException {
   public void writeTime(Time x) throws SQLException {
     withNextValue(
         ((json, fieldName, maybeColumn) -> {
-          long nanosSinceMidnight = SfTimestampUtil.getTimeInNanoseconds(x);
+          long nanosSinceMidnight;
+          if (session.getTreatTimeAsWallClockTime()) {
+            nanosSinceMidnight = x.toLocalTime().toNanoOfDay();
+          } else {
+            nanosSinceMidnight = SfTimestampUtil.getTimeInNanoseconds(x);
+          }
+
           String result =
               ResultUtil.getSFTimeAsString(
                   SFTime.fromNanoseconds(nanosSinceMidnight),

src/main/java/net/snowflake/client/core/SFBaseSession.java

@@ -151,6 +151,9 @@ public abstract class SFBaseSession {
 
   private boolean clearBatchOnlyAfterSuccessfulExecution = false;
 
+  /** Treat java.sql.Time as wall clock time without converting it to UTC */
+  private boolean treatTimeAsWallClockTime = false;
+
   protected SFBaseSession(SFConnectionHandler sfConnectionHandler) {
     this.sfConnectionHandler = sfConnectionHandler;
   }
@@ -1362,4 +1365,12 @@ void setClearBatchOnlyAfterSuccessfulExecution(boolean value) {
   public boolean getClearBatchOnlyAfterSuccessfulExecution() {
     return this.clearBatchOnlyAfterSuccessfulExecution;
   }
+
+  public boolean getTreatTimeAsWallClockTime() {
+    return treatTimeAsWallClockTime;
+  }
+
+  public void setTreatTimeAsWallClockTime(boolean treatTimeAsWallClockTime) {
+    this.treatTimeAsWallClockTime = treatTimeAsWallClockTime;
+  }
 }

src/main/java/net/snowflake/client/core/SFSession.java

@@ -569,6 +569,12 @@ public void addSFSessionProperty(String propertyName, Object propertyValue) thro
           }
           break;
 
+        case CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME:
+          if (propertyValue != null) {
+            setTreatTimeAsWallClockTime(getBooleanValue(propertyValue));
+          }
+          break;
+
         default:
           break;
       }

src/main/java/net/snowflake/client/core/SFSessionProperty.java

@@ -129,7 +129,10 @@ public enum SFSessionProperty {
   IMPLICIT_SERVER_SIDE_QUERY_TIMEOUT("IMPLICIT_SERVER_SIDE_QUERY_TIMEOUT", false, Boolean.class),
 
   CLEAR_BATCH_ONLY_AFTER_SUCCESSFUL_EXECUTION(
-      "CLEAR_BATCH_ONLY_AFTER_SUCCESSFUL_EXECUTION", false, Boolean.class);
+      "CLEAR_BATCH_ONLY_AFTER_SUCCESSFUL_EXECUTION", false, Boolean.class),
+
+  CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME(
+      "CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME", false, Boolean.class);
 
   // property key in string
   private String propertyKey;

src/main/java/net/snowflake/client/core/bind/BindUploader.java

@@ -13,8 +13,10 @@
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.time.Instant;
+import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
@@ -54,7 +56,7 @@ public class BindUploader implements Closeable {
 
   private final DateFormat utcTimestampFormat;
   private final DateFormat localTimestampFormat;
-  private final DateFormat dateFormat;
+  private final DateTimeFormatter dateFormat;
   private final SimpleDateFormat timeFormat;
   private final String createStageSQL;
 
@@ -96,8 +98,7 @@ private BindUploader(SFBaseSession session, String stageDir) {
     this.utcTimestampFormat.setCalendar(utcCalendar);
     this.localTimestampFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.");
     this.localTimestampFormat.setCalendar(localCalendar);
-    this.dateFormat = new SimpleDateFormat("yyyy-MM-dd");
-    this.dateFormat.setCalendar(utcCalendar);
+    this.dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd");
     this.timeFormat = new SimpleDateFormat("HH:mm:ss.");
     this.timeFormat.setCalendar(utcCalendar);
   }
@@ -106,7 +107,10 @@ private synchronized String synchronizedDateFormat(String o) {
     if (o == null) {
       return null;
     }
-    return dateFormat.format(new java.sql.Date(Long.parseLong(o)));
+    long millis = Long.parseLong(o);
+    Instant instant = Instant.ofEpochMilli(millis);
+    LocalDate localDate = instant.atZone(ZoneOffset.UTC).toLocalDate();
+    return localDate.format(this.dateFormat);
   }
 
   private synchronized String synchronizedTimeFormat(String o) {

src/main/java/net/snowflake/client/jdbc/SnowflakePreparedStatementV1.java

@@ -382,13 +382,17 @@ public void setTime(int parameterIndex, Time x) throws SQLException {
     if (x == null) {
       setNull(parameterIndex, Types.TIME);
     } else {
-      // Convert to nanoseconds since midnight using the input time mod 24 hours.
-      long nanosSinceMidnight = SfTimestampUtil.getTimeInNanoseconds(x);
+      String value;
+      if (connection.getSFBaseSession().getTreatTimeAsWallClockTime()) {
+        value = String.valueOf(x.toLocalTime().toNanoOfDay());
+      } else {
+        value = String.valueOf(SfTimestampUtil.getTimeInNanoseconds(x));
+      }
 
       ParameterBindingDTO binding =
           new ParameterBindingDTO(
               SnowflakeUtil.javaTypeToSFTypeString(Types.TIME, connection.getSFBaseSession()),
-              String.valueOf(nanosSinceMidnight));
+              value);
 
       parameterBindings.put(String.valueOf(parameterIndex), binding);
     }

src/test/java/net/snowflake/client/jdbc/BindingDataLatestIT.java

@@ -11,14 +11,19 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Time;
 import java.sql.Timestamp;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.util.Arrays;
 import java.util.Calendar;
+import java.util.List;
+import java.util.Properties;
 import java.util.TimeZone;
 import net.snowflake.client.AbstractDriverIT;
 import net.snowflake.client.annotations.DontRunOnGithubActions;
 import net.snowflake.client.category.TestTags;
+import net.snowflake.client.util.SFPair;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 
@@ -35,6 +40,34 @@ public class BindingDataLatestIT extends AbstractDriverIT {
   TimeZone australiaTz = TimeZone.getTimeZone("Australia/Sydney");
   Calendar tokyo = Calendar.getInstance(tokyoTz);
 
+  List<Time> times =
+      Arrays.asList(
+          Time.valueOf("00:00:00"),
+          Time.valueOf("11:59:59"),
+          Time.valueOf("12:00:00"),
+          Time.valueOf("12:34:56"),
+          Time.valueOf("13:01:01"),
+          Time.valueOf("15:30:00"),
+          Time.valueOf("23:59:59"));
+
+  List<SFPair<String, Date>> gregorianJulianDates =
+      Arrays.asList(
+          SFPair.of("0001-01-01", Date.valueOf("0001-01-01")),
+          SFPair.of("0100-03-01", Date.valueOf("0100-03-01")),
+          SFPair.of("0400-02-29", Date.valueOf("0400-02-29")),
+          SFPair.of("0400-03-01", Date.valueOf("0400-03-01")),
+          SFPair.of("1400-03-01", Date.valueOf("1400-03-01")),
+          SFPair.of("1582-10-15", Date.valueOf("1582-10-15")),
+          SFPair.of("1900-02-28", Date.valueOf("1900-02-28")),
+          SFPair.of("1900-03-01", Date.valueOf("1900-03-01")),
+          SFPair.of("1969-12-31", Date.valueOf("1969-12-31")),
+          SFPair.of("1970-01-01", Date.valueOf("1970-01-01")),
+          SFPair.of("2000-02-28", Date.valueOf("2000-02-28")),
+          SFPair.of("2000-02-29", Date.valueOf("2000-02-29")),
+          SFPair.of("2000-03-01", Date.valueOf("2000-03-01")),
+          SFPair.of("2023-10-26", Date.valueOf("2023-10-26")),
+          SFPair.of("2024-02-29", Date.valueOf("2024-02-29")));
+
   @Test
   public void testBindTimestampTZ() throws SQLException {
     try (Connection connection = getConnection();
@@ -340,6 +373,196 @@ public void testTimestampLtzBindingNoLongerBreaksOtherDatetimeBindings() throws
     }
   }
 
+  @Test
+  public void testGregorianJulianConversions() throws SQLException {
+    try (Connection connection = getConnection();
+        Statement statement = connection.createStatement()) {
+      statement.execute("create or replace table stageinsertdates(ind int, d1 date)");
+
+      try (PreparedStatement prepStatement =
+          connection.prepareStatement("insert into stageinsertdates values (?,?)")) {
+        for (int i = 0; i < gregorianJulianDates.size(); i++) {
+          prepStatement.setInt(1, i);
+          prepStatement.setDate(2, gregorianJulianDates.get(i).right);
+          prepStatement.addBatch();
+        }
+
+        prepStatement.executeBatch();
+        prepStatement.getConnection().commit();
+      }
+
+      try (ResultSet rs1 = statement.executeQuery("select * from stageinsertdates order by ind")) {
+        for (int i = 0; i < gregorianJulianDates.size(); i++) {
+          assertTrue(rs1.next());
+          assertEquals(i, rs1.getInt(1));
+          assertEquals(gregorianJulianDates.get(i).left, rs1.getDate(2).toLocalDate().toString());
+        }
+      }
+    }
+  }
+
+  /**
+   * This test cannot run on the GitHub testing because of the "ALTER SESSION SET
+   * CLIENT_STAGE_ARRAY_BINDING_THRESHOLD" This command should be executed with the system admin.
+   *
+   * @throws SQLException
+   */
+  @Test
+  @DontRunOnGithubActions
+  public void testGregorianJulianConversionsWithStageBindings() throws SQLException {
+    try (Connection connection = getConnection();
+        Statement statement = connection.createStatement()) {
+      statement.execute("create or replace table stageinsertdates(ind int, d1 date)");
+      statement.execute("alter session set CLIENT_STAGE_ARRAY_BINDING_THRESHOLD = 1");
+
+      try (PreparedStatement prepStatement =
+          connection.prepareStatement("insert into stageinsertdates values (?,?)")) {
+        for (int i = 0; i < gregorianJulianDates.size(); i++) {
+          prepStatement.setInt(1, i);
+          prepStatement.setDate(2, gregorianJulianDates.get(i).right);
+          prepStatement.addBatch();
+        }
+
+        prepStatement.executeBatch();
+        prepStatement.getConnection().commit();
+      }
+
+      try (ResultSet rs1 = statement.executeQuery("select * from stageinsertdates order by ind")) {
+        for (int i = 0; i < gregorianJulianDates.size(); i++) {
+          assertTrue(rs1.next());
+          assertEquals(i, rs1.getInt(1));
+          assertEquals(gregorianJulianDates.get(i).left, rs1.getDate(2).toLocalDate().toString());
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testInsertTimeColumnAsWallClockTimeRegardlessOfTimezone() throws SQLException {
+    TimeZone.setDefault(TimeZone.getTimeZone("Pacific/Honolulu"));
+
+    Properties props = new Properties();
+    props.put("CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME", true);
+    try (Connection connection = getConnection(DONT_INJECT_SOCKET_TIMEOUT, props, false, false);
+        Statement statement = connection.createStatement()) {
+      statement.execute("create or replace table test_wall_clock_time(ind int, t1 time)");
+      statement.execute("alter session set TIMEZONE='America/Los_Angeles';");
+
+      try (PreparedStatement prepStatement =
+          connection.prepareStatement("insert into test_wall_clock_time values (?,?)")) {
+        for (int i = 0; i < times.size(); i++) {
+          prepStatement.setInt(1, i);
+          prepStatement.setTime(2, times.get(i));
+          prepStatement.addBatch();
+        }
+
+        prepStatement.executeBatch();
+        prepStatement.getConnection().commit();
+      }
+
+      try (ResultSet rs =
+          statement.executeQuery("select * from test_wall_clock_time order by ind")) {
+        for (int i = 0; i < times.size(); i++) {
+          assertTrue(rs.next());
+          assertEquals(i, rs.getInt(1));
+          assertEquals(times.get(i).toLocalTime(), rs.getTime(2).toLocalTime());
+          // check if inserted time is wall clock time
+          assertEquals(times.get(i).toString(), rs.getString(2));
+        }
+      }
+    } finally {
+      TimeZone.setDefault(origTz);
+    }
+  }
+
+  /**
+   * This test cannot run on the GitHub testing because of the "ALTER SESSION SET
+   * CLIENT_STAGE_ARRAY_BINDING_THRESHOLD" This command should be executed with the system admin.
+   *
+   * @throws SQLException
+   */
+  @Test
+  @DontRunOnGithubActions
+  public void testInsertTimeColumnAsWallClockTimeRegardlessOfTimezoneWithStageBinding()
+      throws SQLException {
+    TimeZone.setDefault(TimeZone.getTimeZone("Pacific/Honolulu"));
+
+    Properties props = new Properties();
+    props.put("CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME", true);
+    try (Connection connection = getConnection(DONT_INJECT_SOCKET_TIMEOUT, props, false, false);
+        Statement statement = connection.createStatement()) {
+      statement.execute("create or replace table test_wall_clock_time(ind int, t1 time)");
+      statement.execute("alter session set TIMEZONE='America/Los_Angeles';");
+      statement.execute("alter session set CLIENT_STAGE_ARRAY_BINDING_THRESHOLD = 1");
+
+      try (PreparedStatement prepStatement =
+          connection.prepareStatement("insert into test_wall_clock_time values (?,?)")) {
+        for (int i = 0; i < times.size(); i++) {
+          prepStatement.setInt(1, i);
+          prepStatement.setTime(2, times.get(i));
+          prepStatement.addBatch();
+        }
+
+        prepStatement.executeBatch();
+        prepStatement.getConnection().commit();
+      }
+
+      try (ResultSet rs =
+          statement.executeQuery("select * from test_wall_clock_time order by ind")) {
+        for (int i = 0; i < times.size(); i++) {
+          assertTrue(rs.next());
+          assertEquals(i, rs.getInt(1));
+          assertEquals(times.get(i).toLocalTime(), rs.getTime(2).toLocalTime());
+          // check if inserted time is wall clock time
+          assertEquals(times.get(i).toString(), rs.getString(2));
+        }
+      }
+    } finally {
+      TimeZone.setDefault(origTz);
+    }
+  }
+
+  /***
+   * Verifies that without enabling CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME time column gets shifted to UTC on insert
+   *
+   * @throws SQLException
+   */
+  @Test
+  public void testInsertTimeColumnNotAsWallClockTimeAsUtc() throws SQLException {
+    TimeZone.setDefault(TimeZone.getTimeZone("Pacific/Honolulu"));
+
+    Properties props = new Properties();
+    props.put("CLIENT_TREAT_TIME_AS_WALL_CLOCK_TIME", false);
+    try (Connection connection = getConnection(DONT_INJECT_SOCKET_TIMEOUT, props, false, false);
+        Statement statement = connection.createStatement()) {
+      statement.execute("create or replace table test_wall_clock_time(ind int, t1 time)");
+      statement.execute("alter session set TIMEZONE='America/Los_Angeles';");
+
+      String localTimeValue = "00:00:00";
+      String utcTimeValue = "10:00:00"; // 00:00 in Pacific/Honolulu is 10:00 UTC
+      Time localTime = Time.valueOf(localTimeValue);
+
+      try (PreparedStatement prepStatement =
+          connection.prepareStatement("insert into test_wall_clock_time values (?,?)")) {
+        prepStatement.setInt(1, 0);
+        prepStatement.setTime(2, localTime);
+        prepStatement.addBatch();
+        prepStatement.executeBatch();
+        prepStatement.getConnection().commit();
+      }
+
+      try (ResultSet rs =
+          statement.executeQuery("select * from test_wall_clock_time order by ind")) {
+        assertTrue(rs.next());
+        assertEquals(0, rs.getInt(1));
+        // check if time gets shifted to UTC time on insert
+        assertEquals(utcTimeValue, rs.getString(2));
+      }
+    } finally {
+      TimeZone.setDefault(origTz);
+    }
+  }
+
   public void executePsStatementForTimestampTest(
       Connection connection, String tableName, Timestamp timestamp) throws SQLException {
     try (PreparedStatement prepStatement =