Add fix for incorrect timestamp issue (#1118)

## Description
Fixes #1116 

## Testing
Tested E2E using the following test (also verified that the legacy
driver has the same behavior)


```
  @test
  void example_TimestampMicrosecondPrecisionWithCalendar() throws Exception {
    //create connection first.
    try {
      String tableName = "default.samikshyananosecondtesting";
      Statement stmt = con.createStatement();
      stmt.execute(
          "CREATE TABLE IF NOT EXISTS " + tableName + " (id INT, ts TIMESTAMP) USING DELTA");
      System.out.println("Created test table: " + tableName);

      String insertSql = "INSERT INTO " + tableName + " VALUES (?, ?)";
      PreparedStatement pstmt = con.prepareStatement(insertSql);

      java.sql.Timestamp originalTs = java.sql.Timestamp.valueOf("2025-11-21 23:30:49.185645");
      assertEquals(
          185645000, originalTs.getNanos(), "Original timestamp should have microsecond precision");

      pstmt.setInt(1, 1);
      java.util.Calendar utcCalendar =
          java.util.Calendar.getInstance(java.util.TimeZone.getTimeZone("UTC"));
      pstmt.setTimestamp(2, originalTs, utcCalendar);
      pstmt.executeUpdate();
      System.out.println("Inserted timestamp with microsecond precision: " + originalTs);

      ResultSet rs = stmt.executeQuery("SELECT id, ts FROM " + tableName + " WHERE id = 1");
      if (rs.next()) {
        java.sql.Timestamp retrievedTs = rs.getTimestamp(2);
        System.out.println("Retrieved timestamp: " + retrievedTs);
        System.out.println("Retrieved nanoseconds: " + retrievedTs.getNanos());

        assertEquals(
            185645000,
            retrievedTs.getNanos(),
            "Microsecond precision should be preserved (issue #1116 fix verification)");
        System.out.println("✓ Microsecond precision preserved successfully!");
      }
      rs.close();

      stmt.execute("DROP TABLE IF EXISTS " + tableName);
      System.out.println("Cleaned up test table");

      pstmt.close();
      stmt.close();
    } finally {
      con.close();
      System.out.println("Connection closed");
    }
  }
```
## Additional Notes to the Reviewer
<!-- Share any additional context or insights that may help the reviewer
understand the changes better. This could include challenges faced,
limitations, or compromises made during the development process.
Also, mention any areas of the code that you would like the reviewer to
focus on specifically. -->

Author: samikshya-db

NEXT_CHANGELOG.md

@@ -15,6 +15,7 @@
 - Fix driver crash when using `INTERVAL` types.
 - Fix connection failure in restricted environments when `LogLevel.OFF` is used.
 - Fix U2M by including SDK OAuth HTML callback resources.
+- Fix microsecond precision loss in `PreparedStatement.setTimestamp(int,Timestamp, Calendar)` and address thread-safety issues with global timezone modification.
 
 ---
 *Note: When making changes, please add your change under the appropriate section with a brief description.*

src/main/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatement.java

@@ -441,11 +441,23 @@ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws S
     LOGGER.debug("public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)");
     checkIfClosed();
     if (cal != null) {
-      TimeZone originalTimeZone = TimeZone.getDefault();
-      TimeZone.setDefault(cal.getTimeZone());
-      x = new Timestamp(x.getTime());
-      TimeZone.setDefault(originalTimeZone);
-      setObject(parameterIndex, x, DatabricksTypeUtil.TIMESTAMP);
+      Calendar defaultCalendar = Calendar.getInstance();
+      defaultCalendar.setTimeInMillis(x.getTime());
+
+      Calendar targetCalendar = (Calendar) cal.clone();
+      targetCalendar.set(Calendar.YEAR, defaultCalendar.get(Calendar.YEAR));
+      targetCalendar.set(Calendar.MONTH, defaultCalendar.get(Calendar.MONTH));
+      targetCalendar.set(Calendar.DAY_OF_MONTH, defaultCalendar.get(Calendar.DAY_OF_MONTH));
+      targetCalendar.set(Calendar.HOUR_OF_DAY, defaultCalendar.get(Calendar.HOUR_OF_DAY));
+      targetCalendar.set(Calendar.MINUTE, defaultCalendar.get(Calendar.MINUTE));
+      targetCalendar.set(Calendar.SECOND, defaultCalendar.get(Calendar.SECOND));
+      targetCalendar.set(
+          Calendar.MILLISECOND, 0); // Because we are already handling sub-second precision below
+
+      Timestamp convertedTimestamp = new Timestamp(targetCalendar.getTimeInMillis());
+      convertedTimestamp.setNanos(
+          x.getNanos()); // Note this preserved the microseconds and nanoseconds both
+      setObject(parameterIndex, convertedTimestamp, DatabricksTypeUtil.TIMESTAMP);
     } else {
       setTimestamp(parameterIndex, x);
     }

src/test/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatementTest.java

@@ -31,8 +31,13 @@
 import java.util.Calendar;
 import java.util.HashMap;
 import java.util.Properties;
+import java.util.TimeZone;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -1209,4 +1214,153 @@ public void testRejectsZeroBatchSize() throws Exception {
         exception.getMessage().contains("Invalid value for BatchInsertSize"),
         "Exception should mention invalid BatchInsertSize: " + exception.getMessage());
   }
+
+  @Test
+  public void testSetTimestampWithCalendarPreservesMicroseconds() throws Exception {
+    // Test that microsecond precision is preserved when using setTimestamp with Calendar
+    IDatabricksConnectionContext connectionContext =
+        DatabricksConnectionContext.parse(JDBC_URL_WITH_MANY_PARAMETERS, new Properties());
+    DatabricksConnection connection = new DatabricksConnection(connectionContext, client);
+
+    String sql = "UPDATE test_table SET ts = ? WHERE id = ?";
+    DatabricksPreparedStatement statement = new DatabricksPreparedStatement(connection, sql);
+
+    // Create a timestamp with microsecond precision (185.645 milliseconds = 185645000 nanoseconds)
+    Timestamp originalTs = Timestamp.valueOf("2025-11-21 23:30:49.185645");
+    assertEquals(
+        185645000, originalTs.getNanos(), "Original timestamp should have microsecond precision");
+
+    // Set timestamp with a Calendar (UTC timezone)
+    Calendar calendar = Calendar.getInstance(java.util.TimeZone.getTimeZone("UTC"));
+    statement.setTimestamp(1, originalTs, calendar);
+    statement.setInt(2, 123);
+
+    // Capture the SQL that gets executed
+    ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
+    when(client.executeStatement(
+            sqlCaptor.capture(),
+            eq(new Warehouse(WAREHOUSE_ID)),
+            any(HashMap.class),
+            eq(StatementType.UPDATE),
+            any(IDatabricksSession.class),
+            eq(statement)))
+        .thenReturn(resultSet);
+
+    statement.executeUpdate();
+
+    // Calculate expected timestamp after timezone conversion
+    Calendar defaultCal = Calendar.getInstance();
+    defaultCal.setTimeInMillis(originalTs.getTime());
+
+    Calendar expectedCal = (Calendar) calendar.clone();
+    expectedCal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR));
+    expectedCal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH));
+    expectedCal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH));
+    expectedCal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY));
+    expectedCal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE));
+    expectedCal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND));
+    expectedCal.set(Calendar.MILLISECOND, 0);
+
+    Timestamp expectedTs = new Timestamp(expectedCal.getTimeInMillis());
+    expectedTs.setNanos(originalTs.getNanos());
+
+    // Verify the executed SQL contains the expected timestamp
+    String executedSql = sqlCaptor.getValue();
+
+    // Verify full timestamp with microsecond precision is preserved
+    assertTrue(
+        executedSql.contains(expectedTs.toString()),
+        "Executed SQL should match expected timestamp: expected="
+            + expectedTs.toString()
+            + ", actual="
+            + executedSql);
+
+    // Verify microsecond precision is preserved (6 decimal places, not truncated to 3)
+    assertTrue(
+        executedSql.matches(".*\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{6}.*"),
+        "Executed SQL should have microsecond precision (6 decimal places): " + executedSql);
+
+    // Verify nanosecond value is exactly preserved
+    assertEquals(
+        185645000,
+        expectedTs.getNanos(),
+        "Nanosecond precision should be preserved in converted timestamp");
+  }
+
+  static Stream<Arguments> dstTestCases() {
+    return Stream.of(
+        Arguments.of("Spring Forward (Non-existent time)", "2024-03-10 02:30:00.185645"),
+        Arguments.of("Fall Back (Ambiguous time)", "2024-11-03 01:30:00.185645"));
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("dstTestCases")
+  public void testSetTimestampWithCalendarDSTTransitions(String testName, String timestampLiteral)
+      throws Exception {
+
+    IDatabricksConnectionContext connectionContext =
+        DatabricksConnectionContext.parse(JDBC_URL_WITH_MANY_PARAMETERS, new Properties());
+
+    DatabricksConnection connection = new DatabricksConnection(connectionContext, client);
+
+    String sql = "UPDATE test_table SET ts = ? WHERE id = ?";
+    DatabricksPreparedStatement statement = new DatabricksPreparedStatement(connection, sql);
+
+    // Create timestamp (either Spring forward gap or Fall back overlap)
+    Timestamp originalTs = Timestamp.valueOf(timestampLiteral);
+
+    assertEquals(
+        185645000, originalTs.getNanos(), "Original timestamp must preserve microsecond precision");
+
+    // Use New York calendar (DST-enabled)
+    Calendar nyCalendar = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));
+
+    statement.setTimestamp(1, originalTs, nyCalendar);
+    statement.setInt(2, 123);
+
+    // Build expected timestamp by reinterpreting fields in target TZ
+    Calendar defaultCal = Calendar.getInstance();
+    defaultCal.setTimeInMillis(originalTs.getTime());
+
+    Calendar expectedCal = (Calendar) nyCalendar.clone();
+    expectedCal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR));
+    expectedCal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH));
+    expectedCal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH));
+    expectedCal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY));
+    expectedCal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE));
+    expectedCal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND));
+    expectedCal.set(Calendar.MILLISECOND, 0);
+
+    // Lenient mode resolves both gap and ambiguity
+    Timestamp expectedTs = new Timestamp(expectedCal.getTimeInMillis());
+    expectedTs.setNanos(originalTs.getNanos());
+
+    // Capture executed SQL
+    ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
+    when(client.executeStatement(
+            sqlCaptor.capture(),
+            eq(new Warehouse(WAREHOUSE_ID)),
+            any(HashMap.class),
+            eq(StatementType.UPDATE),
+            any(IDatabricksSession.class),
+            eq(statement)))
+        .thenReturn(resultSet);
+
+    statement.executeUpdate();
+
+    String executedSql = sqlCaptor.getValue();
+
+    // Validation
+    assertTrue(
+        executedSql.contains(expectedTs.toString()),
+        "DST behavior incorrect for "
+            + testName
+            + ": expected="
+            + expectedTs
+            + ", actual="
+            + executedSql);
+
+    assertEquals(
+        185645000, expectedTs.getNanos(), "Nanosecond precision must be preserved for " + testName);
+  }
 }