diff --git a/jdbc/pom.xml b/jdbc/pom.xml
index f8a64fa..b9c89e3 100644
--- a/jdbc/pom.xml
+++ b/jdbc/pom.xml
@@ -73,6 +73,7 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <configuration>
+                    <argLine>@{argLine} -Duser.timezone=GMT-04</argLine>
                     <environmentVariables>
                         <TESTCONTAINERS_REUSE_ENABLE>true</TESTCONTAINERS_REUSE_ENABLE>
                         <YDB_DOCKER_IMAGE>cr.yandex/yc/yandex-docker-local-ydb:trunk</YDB_DOCKER_IMAGE>
@@ -80,7 +81,6 @@
                     <systemPropertyVariables>
                         <java.util.logging.config.file>src/test/resources/logging.properties</java.util.logging.config.file>
                     </systemPropertyVariables>
-
                     <!--
                     Enable support of test's custom display names
                     https://maven.apache.org/surefire/maven-surefire-plugin/examples/junit-platform.html#surefire-extensions-and-reports-configuration-for-displayname
diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementImplTest.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementImplTest.java
index 25fa48f..b1a9df3 100644
--- a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementImplTest.java
+++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementImplTest.java
@@ -96,11 +96,6 @@ private String upsertSql(String column, String type) {
                 .replaceAll("#tableName", TEST_TABLE_NAME);
     }
 
-    private YdbPreparedStatement prepareUpsert(YdbPrepareMode mode,String column, String type)
-            throws SQLException {
-        return jdbc.connection().unwrap(YdbConnection.class).prepareStatement(upsertSql(column, type), mode);
-    }
-
     private PreparedStatement prepareSimpleSelect(String column) throws SQLException {
         String sql = SIMPLE_SELECT_SQL
                 .replaceAll("#column", column)
diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementTest.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementTest.java
index 0d99f6b..efc192a 100644
--- a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementTest.java
+++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbPreparedStatementTest.java
@@ -5,18 +5,19 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Time;
 import java.sql.Timestamp;
 import java.sql.Types;
 import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.time.Month;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.temporal.ChronoField;
 import java.time.temporal.ChronoUnit;
-import java.util.TimeZone;
 
 import org.junit.Assert;
 import org.junit.jupiter.api.AfterAll;
@@ -52,12 +53,6 @@ public class YdbPreparedStatementTest {
      */
     private static final Instant TEST_TS = Instant.ofEpochSecond(1583288311l, 123456789);
 
-    @BeforeAll
-    public static void setupTimeZone() throws SQLException {
-        // Set non UTC timezone to test different cases
-        TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.ofOffset("GMT", ZoneOffset.ofHours(-4))));
-    }
-
     @BeforeAll
     public static void createTable() throws SQLException {
         try (Statement statement = jdbc.connection().createStatement();) {
@@ -341,6 +336,257 @@ public void batchUpsertAllTest(SqlQueries.JdbcQuery query) throws SQLException {
         }
     };
 
+    @ParameterizedTest(name = "with {0}")
+    @EnumSource(SqlQueries.JdbcQuery.class)
+    public void int32Test(SqlQueries.JdbcQuery query) throws SQLException {
+        String upsert = TEST_TABLE.upsertOne(query, "c_Int32", "Int32");
+        boolean castingSupported = query != SqlQueries.JdbcQuery.IN_MEMORY;
+        int ydbSqlType = YdbConst.SQL_KIND_PRIMITIVE + PrimitiveType.Int32.ordinal();
+
+        try (PreparedStatement ps = jdbc.connection().prepareStatement(upsert)) {
+            ps.setInt(1, 1);
+            ps.setByte(2, (byte) -120);
+            ps.execute();
+
+            ps.setInt(1, 2);
+            ps.setShort(2, (short) 1234);
+            ps.execute();
+
+            ps.setInt(1, 3);
+            ps.setInt(2, 1234567);
+            ps.execute();
+
+            ps.setInt(1, 4);
+            ps.setTime(2, Time.valueOf(LocalTime.of(11, 23, 59))); // will be stored as 11 * 3600 + 23 * 60 + 59
+            ps.execute();
+
+            ps.setInt(1, 5);
+            ps.setTime(2, new Time(TEST_TS.toEpochMilli())); // will be stored local time of timestamp
+            ps.execute();
+
+            if (castingSupported) {
+                ps.setInt(1, 6);
+                ps.setBoolean(2, true);
+                ps.execute();
+
+                ps.setInt(1, 7);
+                ps.setDate(2, Date.valueOf(LocalDate.of(2020, Month.MARCH, 3))); // will be store as day of epoch
+                ps.execute();
+
+                ps.setInt(1, 8);
+                ps.setDate(2, new Date(TEST_TS.toEpochMilli())); // will be store as day of the year
+                ps.execute();
+
+                ps.setInt(1, 9);
+                ps.setTimestamp(2, new Timestamp(TEST_TS.toEpochMilli()));
+                ps.execute();
+            } else {
+                ps.setInt(1, 6);
+                ps.setObject(2, Boolean.TRUE, ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 7);
+                ps.setObject(2, Date.valueOf(LocalDate.of(2020, Month.MARCH, 3)), ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 8);
+                ps.setObject(2, new Date(TEST_TS.toEpochMilli()), ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 9);
+                ps.setObject(2, new Timestamp(TEST_TS.toEpochMilli()), ydbSqlType);
+                ps.execute();
+            }
+        }
+
+        try (Statement statement = jdbc.connection().createStatement()) {
+            try (ResultSet rs = statement.executeQuery(TEST_TABLE.selectColumn("c_Int32"))) {
+                assertNextInt32(rs, 1, -120);
+                assertNextInt32(rs, 2, 1234);
+                assertNextInt32(rs, 3, 1234567);
+                assertNextInt32(rs, 4, 11 * 3600 + 23 * 60 + 59);
+                assertNextInt32(rs, 5, TEST_TS.atZone(ZoneId.systemDefault()).toLocalTime().toSecondOfDay());
+
+                assertNextInt32(rs, 6, 1);
+                assertNextInt32(rs, 7, (int) LocalDate.of(2020, Month.MARCH, 3).toEpochDay());
+                assertNextInt32(rs, 8, (int) TEST_TS.atZone(ZoneId.systemDefault()).toLocalDate().toEpochDay());
+                assertNextInt32(rs, 9, (int) TEST_TS.toEpochMilli());
+
+                Assert.assertFalse(rs.next());
+            }
+        }
+    };
+
+    private void assertNextInt32(ResultSet rs, int key, Integer value) throws SQLException {
+        Assert.assertTrue(rs.next());
+        Assert.assertEquals(key, rs.getInt("key"));
+
+        Object obj = rs.getObject("c_Int32");
+        Assert.assertTrue(obj instanceof Integer);
+        Assert.assertEquals(value, obj);
+
+        if (value.byteValue() == value.intValue()) {
+            Assert.assertEquals(value.intValue(), rs.getByte("c_Int32"));
+        } else {
+            String msg = String.format("Cannot cast [Int32] with value [%s] to [byte]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getByte("c_Int32"));
+        }
+
+        if (value.shortValue() == value.intValue()) {
+            Assert.assertEquals(value.intValue(), rs.getShort("c_Int32"));
+        } else {
+            String msg = String.format("Cannot cast [Int32] with value [%s] to [short]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getShort("c_Int32"));
+        }
+
+        Assert.assertEquals(value.intValue(), rs.getInt("c_Int32"));
+        Assert.assertEquals(value.longValue(), rs.getLong("c_Int32"));
+
+        if (value >= 0 && value < 24 * 3600) {
+            Assert.assertEquals(Time.valueOf(LocalTime.ofSecondOfDay(value)), rs.getTime("c_Int32"));
+        } else {
+            String msg = String.format("Cannot cast [Int32] with value [%s] to [class java.sql.Time]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getTime("c_Int32"));
+        }
+
+        Assert.assertEquals(Date.valueOf(LocalDate.ofEpochDay(value)), rs.getDate("c_Int32"));
+        Assert.assertEquals(new Timestamp(value), rs.getTimestamp("c_Int32"));
+    }
+
+    @ParameterizedTest(name = "with {0}")
+    @EnumSource(SqlQueries.JdbcQuery.class)
+    public void int64Test(SqlQueries.JdbcQuery query) throws SQLException {
+        String upsert = TEST_TABLE.upsertOne(query, "c_Int64", "Int64");
+        boolean castingSupported = query != SqlQueries.JdbcQuery.IN_MEMORY;
+        int ydbSqlType = YdbConst.SQL_KIND_PRIMITIVE + PrimitiveType.Int64.ordinal();
+
+        try (PreparedStatement ps = jdbc.connection().prepareStatement(upsert)) {
+            ps.setInt(1, 1);
+            ps.setByte(2, (byte) -120);
+            ps.execute();
+
+            ps.setInt(1, 2);
+            ps.setShort(2, (short) 1234);
+            ps.execute();
+
+            ps.setInt(1, 3);
+            ps.setInt(2, 1234567);
+            ps.execute();
+
+            ps.setInt(1, 4);
+            ps.setLong(2, 54211234567l);
+            ps.execute();
+
+            ps.setInt(1, 5);
+            ps.setTime(2, Time.valueOf(LocalTime.of(11, 23, 59))); // will be stored as 11 * 3600 + 23 * 60 + 59
+            ps.execute();
+
+            ps.setInt(1, 6);
+            ps.setTime(2, new Time(TEST_TS.toEpochMilli())); // will be stored local time of timestamp
+            ps.execute();
+
+            if (castingSupported) {
+                ps.setInt(1, 7);
+                ps.setBoolean(2, true);
+                ps.execute();
+
+                ps.setInt(1, 8);
+                ps.setDate(2, Date.valueOf(LocalDate.of(2020, Month.MARCH, 3))); // will be store as day of epoch
+                ps.execute();
+
+                ps.setInt(1, 9);
+                ps.setDate(2, new Date(TEST_TS.toEpochMilli())); // will be store as day of the year
+                ps.execute();
+
+                ps.setInt(1, 10);
+                ps.setTimestamp(2, new Timestamp(TEST_TS.toEpochMilli()));
+                ps.execute();
+            } else {
+                ps.setInt(1, 7);
+                ps.setObject(2, Boolean.TRUE, ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 8);
+                ps.setObject(2, Date.valueOf(LocalDate.of(2020, Month.MARCH, 3)), ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 9);
+                ps.setObject(2, new Date(TEST_TS.toEpochMilli()), ydbSqlType);
+                ps.execute();
+
+                ps.setInt(1, 10);
+                ps.setObject(2, new Timestamp(TEST_TS.toEpochMilli()), ydbSqlType);
+                ps.execute();
+            }
+        }
+
+        try (Statement statement = jdbc.connection().createStatement()) {
+            try (ResultSet rs = statement.executeQuery(TEST_TABLE.selectColumn("c_Int64"))) {
+                assertNextInt64(rs, 1, -120l);
+                assertNextInt64(rs, 2, 1234l);
+                assertNextInt64(rs, 3, 1234567l);
+                assertNextInt64(rs, 4, 54211234567l);
+                assertNextInt64(rs, 5, 11 * 3600l + 23 * 60 + 59);
+                assertNextInt64(rs, 6, Long.valueOf(TEST_TS.atZone(ZoneId.systemDefault()).toLocalTime().toSecondOfDay()));
+
+                assertNextInt64(rs, 7, 1l);
+                assertNextInt64(rs, 8, LocalDate.of(2020, Month.MARCH, 3).toEpochDay());
+                assertNextInt64(rs, 9, TEST_TS.atZone(ZoneId.systemDefault()).toLocalDate().toEpochDay());
+                assertNextInt64(rs, 10, TEST_TS.toEpochMilli());
+
+                Assert.assertFalse(rs.next());
+            }
+        }
+    };
+
+    private void assertNextInt64(ResultSet rs, int key, Long value) throws SQLException {
+        Assert.assertTrue(rs.next());
+        Assert.assertEquals(key, rs.getInt("key"));
+
+        Object obj = rs.getObject("c_Int64");
+        Assert.assertTrue(obj instanceof Long);
+        Assert.assertEquals(value, obj);
+
+        if (value.byteValue() == value.intValue()) {
+            Assert.assertEquals(value.intValue(), rs.getByte("c_Int64"));
+        } else {
+            String msg = String.format("Cannot cast [Int64] with value [%s] to [byte]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getByte("c_Int64"));
+        }
+
+        if (value.shortValue() == value.intValue()) {
+            Assert.assertEquals(value.intValue(), rs.getShort("c_Int64"));
+        } else {
+            String msg = String.format("Cannot cast [Int64] with value [%s] to [short]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getShort("c_Int64"));
+        }
+
+        if (value.intValue() == value.longValue()) {
+            Assert.assertEquals(value.intValue(), rs.getInt("c_Int64"));
+        } else {
+            String msg = String.format("Cannot cast [Int64] with value [%s] to [int]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getInt("c_Int64"));
+        }
+
+        Assert.assertEquals(value.longValue(), rs.getLong("c_Int64"));
+
+        if (value >= 0 && value < 24 * 3600) {
+            Assert.assertEquals(Time.valueOf(LocalTime.ofSecondOfDay(value)), rs.getTime("c_Int64"));
+        } else {
+            String msg = String.format("Cannot cast [Int64] with value [%s] to [class java.sql.Time]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getTime("c_Int64"));
+        }
+
+        if (ChronoField.EPOCH_DAY.range().isValidValue(value)) {
+            Assert.assertEquals(Date.valueOf(LocalDate.ofEpochDay(value)), rs.getDate("c_Int64"));
+        } else {
+            String msg = String.format("Cannot cast [Int64] with value [%s] to [class java.sql.Date]", value);
+            ExceptionAssert.sqlException(msg, () -> rs.getDate("c_Int64"));
+        }
+
+        Assert.assertEquals(new Timestamp(value), rs.getTimestamp("c_Int64"));
+    }
+
     @ParameterizedTest(name = "with {0}")
     @EnumSource(SqlQueries.JdbcQuery.class)
     public void timestampTest(SqlQueries.JdbcQuery query) throws SQLException {
diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbResultSetImplTest.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbResultSetImplTest.java
index e88a419..092d42a 100644
--- a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbResultSetImplTest.java
+++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbResultSetImplTest.java
@@ -20,6 +20,7 @@
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.time.Month;
 import java.time.ZoneOffset;
 import java.util.Collections;
@@ -1453,10 +1454,16 @@ public void getDate() throws SQLException {
         ResultSetChecker<Date> checker = check(resultSet, ResultSet::getDate, ResultSet::getDate);
 
         checker.nextRow()
-                // 2000000000001 unix millis = May 18, 2033 3:33:20.001 UTC
-                .value(6,  "c_Int64",     Date.valueOf(LocalDate.of(2033, Month.MAY, 18)))
-                // 2000000000002 unix millis = May 18, 2033 3:33:20.002 UTC
-                .value(10, "c_Uint64",    Date.valueOf(LocalDate.of(2033, Month.MAY, 18)))
+                .value(3, "c_Int8", Date.valueOf(LocalDate.ofEpochDay(101)))
+                .value(4, "c_Int16", Date.valueOf(LocalDate.ofEpochDay(20001)))
+                .value(5, "c_Int32", Date.valueOf(LocalDate.ofEpochDay(2000000001)))
+                .exceptionValue(6, "c_Int64",
+                        "Cannot cast [Int64] with value [2000000000001] to [class java.sql.Date]")
+                .value(7, "c_Uint8", Date.valueOf(LocalDate.ofEpochDay(100)))
+                .value(8, "c_Uint16", Date.valueOf(LocalDate.ofEpochDay(20002)))
+                .value(9, "c_Uint32", Date.valueOf(LocalDate.ofEpochDay(2000000002)))
+                .exceptionValue(10, "c_Uint64",
+                        "Cannot cast [Uint64] with value [2000000000002] to [class java.sql.Date]")
                 // 3111 unix days = Sunday, July 9, 1978 0:00:00 UTC
                 .value(18, "c_Date",      Date.valueOf(LocalDate.of(1978, Month.JULY, 9)))
                 // 311111156 unix seconds = Sat Nov 10 1979 19:45:56 UTC
@@ -1465,11 +1472,16 @@ public void getDate() throws SQLException {
                 .value(20, "c_Timestamp", new Date(311111223342l / 1000));
 
         checker.nextRow()
-                // -2000000000001 unix millis = Thursday, August 16, 1906 20:26:39.999 UTC
-                .value(6,  "c_Int64",     Date.valueOf(LocalDate.of(1906, Month.AUGUST, 16)))
-                // 4000000000002 unix millis = Tuesday, October 2, 2096 7:06:40.002 UTC
-                .value(10, "c_Uint64",    Date.valueOf(LocalDate.of(2096, Month.OCTOBER, 2)))
-                // 3112 unix days = Mon Jul 10 1978 00:00:00 UTC
+                .value(3, "c_Int8", Date.valueOf(LocalDate.ofEpochDay(-101)))
+                .value(4, "c_Int16", Date.valueOf(LocalDate.ofEpochDay(-20001)))
+                .value(5, "c_Int32", Date.valueOf(LocalDate.ofEpochDay(-2000000001)))
+                .exceptionValue(6, "c_Int64",
+                        "Cannot cast [Int64] with value [-2000000000001] to [class java.sql.Date]")
+                .value(7, "c_Uint8", Date.valueOf(LocalDate.ofEpochDay(200)))
+                .value(8, "c_Uint16", Date.valueOf(LocalDate.ofEpochDay(40002)))
+                .value(9, "c_Uint32", Date.valueOf(LocalDate.ofEpochDay(4000000002l)))
+                .exceptionValue(10, "c_Uint64",
+                        "Cannot cast [Uint64] with value [4000000000002] to [class java.sql.Date]")
                 .value(18, "c_Date",      Date.valueOf(LocalDate.of(1978, Month.JULY, 10)))
                 // 211211100 unix seconds = Fri Sep 10 1976 13:45:00 UTC
                 .value(19, "c_Datetime",  Date.valueOf(LocalDate.of(1976, Month.SEPTEMBER, 10)))
@@ -1477,74 +1489,119 @@ public void getDate() throws SQLException {
                 .value(20, "c_Timestamp", new Date(111111223342l / 1000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
-                .value(10, "c_Uint64",    Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(3, "c_Int8", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(4, "c_Int16", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(5, "c_Int32", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(6, "c_Int64", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(7, "c_Uint8", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(8, "c_Uint16", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(9, "c_Uint32", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(10, "c_Uint64", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
                 .value(18, "c_Date",      Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
                 .value(19, "c_Datetime",  Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
                 .value(20, "c_Timestamp", new Date(1 / 1000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
-                .value(10, "c_Uint64",    Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
+                .value(3, "c_Int8", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(4, "c_Int16", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(5, "c_Int32", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(6, "c_Int64", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(7, "c_Uint8", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(8, "c_Uint16", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(9, "c_Uint32", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
+                .value(10, "c_Uint64", Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
                 .value(18, "c_Date",      Date.valueOf(LocalDate.of(1970, Month.JANUARY, 2)))
                 .value(19, "c_Datetime",  Date.valueOf(LocalDate.of(1970, Month.JANUARY, 1)))
                 .value(20, "c_Timestamp", new Date(0));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     null)
-                .value(10, "c_Uint64",    null)
-                .value(18, "c_Date",      null)
-                .value(19, "c_Datetime",  null)
+                .value(3, "c_Int8", null)
+                .value(4, "c_Int16", null)
+                .value(5, "c_Int32", null)
+                .value(6, "c_Int64", null)
+                .value(7, "c_Uint8", null)
+                .value(8, "c_Uint16", null)
+                .value(9, "c_Uint32", null)
+                .value(10, "c_Uint64", null)
+                .value(18, "c_Date", null)
+                .value(19, "c_Datetime", null)
                 .value(20, "c_Timestamp", null);
 
         checker.assertNoRows();
     }
 
-    private Time timeUTC(long seconds, int nanos) {
-        return Time.valueOf(LocalDateTime.ofEpochSecond(seconds, nanos, ZoneOffset.UTC).toLocalTime());
-    }
-
-    private Time timeDefault(long seconds, int nanos) {
-        return new Time(Instant.ofEpochSecond(seconds, nanos).toEpochMilli());
-    }
-
     @Test
     public void getTime() throws SQLException {
         ResultSetChecker<Time> checker = check(resultSet, ResultSet::getTime, ResultSet::getTime);
 
         checker.nextRow()
-                .value(6,  "c_Int64",     timeUTC(2000000000, 1000000))
-                .value(10, "c_Uint64",    timeUTC(2000000000, 2000000))
-                .value(18, "c_Date",      timeUTC(3111 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timeUTC(311111156, 0))
-                .value(20, "c_Timestamp", timeDefault(311111, 223342000));
-
-        checker.nextRow()
-                .value(6,  "c_Int64",     timeUTC(-2000000001, 999000000))
-                .value(10, "c_Uint64",    timeUTC(4000000000l, 2000000))
-                .value(18, "c_Date",      timeUTC(3112 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timeUTC(211211100, 0))
-                .value(20, "c_Timestamp", timeDefault(111111, 223342000));
-
-        checker.nextRow()
-                .value(6,  "c_Int64",     timeUTC(0, 0))
-                .value(10, "c_Uint64",    timeUTC(0, 0))
-                .value(18, "c_Date",      timeUTC(0, 0))
-                .value(19, "c_Datetime",  timeUTC(0, 0))
-                .value(20, "c_Timestamp", timeDefault(0, 0));
-
-        checker.nextRow()
-                .value(6,  "c_Int64",     timeUTC(0, 1000000))
-                .value(10, "c_Uint64",    timeUTC(0, 1000000))
-                .value(18, "c_Date",      timeUTC(1 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timeUTC(1, 0))
-                .value(20, "c_Timestamp", timeDefault(0, 1000));
+                .value(3, "c_Int8", Time.valueOf(LocalTime.ofSecondOfDay(101)))
+                .value(4, "c_Int16", Time.valueOf(LocalTime.ofSecondOfDay(20001)))
+                .exceptionValue(5, "c_Int32", "Cannot cast [Int32] with value [2000000001] to [class java.sql.Time]")
+                .exceptionValue(6, "c_Int64", "Cannot cast [Int64] with value [2000000000001] to [class java.sql.Time]")
+                .value(7, "c_Uint8", Time.valueOf(LocalTime.ofSecondOfDay(100)))
+                .value(8, "c_Uint16", Time.valueOf(LocalTime.ofSecondOfDay(20002)))
+                .exceptionValue(9, "c_Uint32", "Cannot cast [Uint32] with value [2000000002] to [class java.sql.Time]")
+                .exceptionValue(10, "c_Uint64", "Cannot cast [Uint64] with value [2000000000002] to [class java.sql.Time]")
+                // Any value of Date doesn't have a time
+                .value(18, "c_Date", Time.valueOf(LocalTime.MIN))
+                // 311111156 unix seconds = Sat Nov 10 1979 19:45:56 UTC
+                .value(19, "c_Datetime", Time.valueOf(LocalTime.of(19, 45, 56)))
+                // 311111223342 unix microseconds = Sun Jan 04 1970 10:25:11 in UTC-04
+                .value(20, "c_Timestamp", new Time(311111223342l / 1000));
+
+        checker.nextRow()
+                .exceptionValue(3, "c_Int8", "Cannot cast [Int8] with value [-101] to [class java.sql.Time]")
+                .exceptionValue(4, "c_Int16", "Cannot cast [Int16] with value [-20001] to [class java.sql.Time]")
+                .exceptionValue(5, "c_Int32", "Cannot cast [Int32] with value [-2000000001] to [class java.sql.Time]")
+                .exceptionValue(6, "c_Int64", "Cannot cast [Int64] with value [-2000000000001] to [class java.sql.Time]")
+                .value(7, "c_Uint8", Time.valueOf(LocalTime.ofSecondOfDay(200)))
+                .value(8, "c_Uint16", Time.valueOf(LocalTime.ofSecondOfDay(40002)))
+                .exceptionValue(9, "c_Uint32", "Cannot cast [Uint32] with value [4000000002] to [class java.sql.Time]")
+                .exceptionValue(10, "c_Uint64", "Cannot cast [Uint64] with value [4000000000002] to [class java.sql.Time]")
+                .value(18, "c_Date", Time.valueOf(LocalTime.MIN))
+                // 211211100 unix seconds = Fri Sep 10 1976 13:45:00 UTC
+                .value(19, "c_Datetime", Time.valueOf(LocalTime.of(13, 45, 00)))
+                // 111111223342 unix microseconds = Fri Jan 02 1970 06:51:51 in UTC-04
+                .value(20, "c_Timestamp", new Time(111111223342l / 1000));
+
+        checker.nextRow()
+                .value(3, "c_Int8", Time.valueOf(LocalTime.MIN))
+                .value(4, "c_Int16", Time.valueOf(LocalTime.MIN))
+                .value(5, "c_Int32", Time.valueOf(LocalTime.MIN))
+                .value(6, "c_Int64", Time.valueOf(LocalTime.MIN))
+                .value(7, "c_Uint8", Time.valueOf(LocalTime.MIN))
+                .value(8, "c_Uint16", Time.valueOf(LocalTime.MIN))
+                .value(9, "c_Uint32", Time.valueOf(LocalTime.MIN))
+                .value(10, "c_Uint64", Time.valueOf(LocalTime.MIN))
+                .value(18, "c_Date", Time.valueOf(LocalTime.MIN))
+                .value(19, "c_Datetime",  Time.valueOf(LocalTime.MIN))
+                .value(20, "c_Timestamp", new Time(0));
+
+        checker.nextRow()
+                .value(3, "c_Int8", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(4, "c_Int16", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(5, "c_Int32", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(6, "c_Int64", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(7, "c_Uint8", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(8, "c_Uint16", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(9, "c_Uint32", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(10, "c_Uint64", Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(18, "c_Date", Time.valueOf(LocalTime.MIN))
+                .value(19, "c_Datetime",  Time.valueOf(LocalTime.ofSecondOfDay(1)))
+                .value(20, "c_Timestamp", new Time(1 / 1000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     null)
-                .value(10, "c_Uint64",    null)
-                .value(18, "c_Date",      null)
-                .value(19, "c_Datetime",  null)
+                .value(3, "c_Int8", null)
+                .value(4, "c_Int16", null)
+                .value(5, "c_Int32", null)
+                .value(6, "c_Int64", null)
+                .value(7, "c_Uint8", null)
+                .value(8, "c_Uint16", null)
+                .value(9, "c_Uint32", null)
+                .value(10, "c_Uint64", null)
+                .value(18, "c_Date", null)
+                .value(19, "c_Datetime", null)
                 .value(20, "c_Timestamp", null);
 
         checker.assertNoRows();
@@ -1563,38 +1620,68 @@ public void getTimestamp() throws SQLException {
         ResultSetChecker<Timestamp> checker = check(resultSet, ResultSet::getTimestamp, ResultSet::getTimestamp);
 
         checker.nextRow()
-                .value(6,  "c_Int64",     timestampUTC(2000000000, 1000000))
-                .value(10, "c_Uint64",    timestampUTC(2000000000, 2000000))
-                .value(18, "c_Date",      timestampUTC(3111 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timestampUTC(311111156, 0))
+                .value(3, "c_Int8", new Timestamp(101))
+                .value(4, "c_Int16", new Timestamp(20001))
+                .value(5, "c_Int32", new Timestamp(2000000001))
+                .value(6, "c_Int64", new Timestamp(2000000000001l))
+                .value(7, "c_Uint8", new Timestamp(100))
+                .value(8, "c_Uint16", new Timestamp(20002))
+                .value(9, "c_Uint32", new Timestamp(2000000002))
+                .value(10, "c_Uint64", new Timestamp(2000000000002l))
+                .value(18, "c_Date", timestampUTC(3111 * 24 * 60 * 60, 0))
+                .value(19, "c_Datetime", timestampUTC(311111156, 0))
                 .value(20, "c_Timestamp", timestampDefault(311111, 223342000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     timestampUTC(-2000000001, 999000000))
-                .value(10, "c_Uint64",    timestampUTC(4000000000l, 2000000))
-                .value(18, "c_Date",      timestampUTC(3112 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timestampUTC(211211100, 0))
+                .value(3, "c_Int8", new Timestamp(-101))
+                .value(4, "c_Int16", new Timestamp(-20001))
+                .value(5, "c_Int32", new Timestamp(-2000000001))
+                .value(6, "c_Int64", new Timestamp(-2000000000001l))
+                .value(7, "c_Uint8", new Timestamp(200))
+                .value(8, "c_Uint16", new Timestamp(40002))
+                .value(9, "c_Uint32", new Timestamp(4000000002l))
+                .value(10, "c_Uint64", new Timestamp(4000000000002l))
+                .value(18, "c_Date", timestampUTC(3112 * 24 * 60 * 60, 0))
+                .value(19, "c_Datetime", timestampUTC(211211100, 0))
                 .value(20, "c_Timestamp", timestampDefault(111111, 223342000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     timestampUTC(0, 0))
-                .value(10, "c_Uint64",    timestampUTC(0, 0))
-                .value(18, "c_Date",      timestampUTC(0, 0))
-                .value(19, "c_Datetime",  timestampUTC(0, 0))
+                .value(3, "c_Int8", new Timestamp(0))
+                .value(4, "c_Int16", new Timestamp(0))
+                .value(5, "c_Int32", new Timestamp(0))
+                .value(6, "c_Int64", new Timestamp(0))
+                .value(7, "c_Uint8", new Timestamp(0))
+                .value(8, "c_Uint16", new Timestamp(0))
+                .value(9, "c_Uint32", new Timestamp(0))
+                .value(10, "c_Uint64", new Timestamp(0))
+                .value(18, "c_Date", timestampUTC(0, 0))
+                .value(19, "c_Datetime", timestampUTC(0, 0))
                 .value(20, "c_Timestamp", timestampDefault(0, 0));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     timestampUTC(0, 1000000))
-                .value(10, "c_Uint64",    timestampUTC(0, 1000000))
-                .value(18, "c_Date",      timestampUTC(1 * 24 * 60 * 60, 0))
-                .value(19, "c_Datetime",  timestampUTC(1, 0))
+                .value(3, "c_Int8", new Timestamp(1))
+                .value(4, "c_Int16", new Timestamp(1))
+                .value(5, "c_Int32", new Timestamp(1))
+                .value(6, "c_Int64", new Timestamp(1))
+                .value(7, "c_Uint8", new Timestamp(1))
+                .value(8, "c_Uint16", new Timestamp(1))
+                .value(9, "c_Uint32", new Timestamp(1))
+                .value(10, "c_Uint64", new Timestamp(1))
+                .value(18, "c_Date", timestampUTC(1 * 24 * 60 * 60, 0))
+                .value(19, "c_Datetime", timestampUTC(1, 0))
                 .value(20, "c_Timestamp", timestampDefault(0, 1000));
 
         checker.nextRow()
-                .value(6,  "c_Int64",     null)
-                .value(10, "c_Uint64",    null)
-                .value(18, "c_Date",      null)
-                .value(19, "c_Datetime",  null)
+                .value(3, "c_Int8", null)
+                .value(4, "c_Int16", null)
+                .value(5, "c_Int32", null)
+                .value(6, "c_Int64", null)
+                .value(7, "c_Uint8", null)
+                .value(8, "c_Uint16", null)
+                .value(9, "c_Uint32", null)
+                .value(10, "c_Uint64", null)
+                .value(18, "c_Date", null)
+                .value(19, "c_Datetime", null)
                 .value(20, "c_Timestamp", null);
 
         checker.assertNoRows();