improved resultset target type lookup

chernser · chernser · commit 1b0d729f77ea · 2026-06-02T13:33:29.000-07:00
diff --git a/jdbc-v2/src/main/java/com/clickhouse/jdbc/ResultSetImpl.java b/jdbc-v2/src/main/java/com/clickhouse/jdbc/ResultSetImpl.java
@@ -5,10 +5,12 @@
 import com.clickhouse.client.api.metadata.TableSchema;
 import com.clickhouse.client.api.query.QueryResponse;
 import com.clickhouse.data.ClickHouseColumn;
+import com.clickhouse.data.ClickHouseDataType;
 import com.clickhouse.jdbc.internal.ExceptionUtils;
 import com.clickhouse.jdbc.internal.FeatureManager;
 import com.clickhouse.jdbc.internal.JdbcUtils;
 import com.clickhouse.jdbc.metadata.ResultSetMetaDataImpl;
+import com.google.common.collect.ImmutableMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -34,13 +36,8 @@
 import java.sql.Statement;
 import java.sql.Time;
 import java.sql.Timestamp;
-import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.util.Calendar;
 import java.util.Collections;
@@ -72,19 +69,30 @@ public class ResultSetImpl implements ResultSet, JdbcV2Wrapper {
     private final int maxRows;
 
     private Consumer<Exception> onDataTransferException;
+    private final Map<String, ColumnTypeBinding> columnTypeBindings;
 
     public ResultSetImpl(StatementImpl parentStatement, QueryResponse response, ClickHouseBinaryFormatReader reader,
                          Consumer<Exception> onDataTransferException) throws SQLException {
+        this(parentStatement, response, reader, onDataTransferException, JdbcUtils.DATA_TYPE_CLASS_MAP);
+    }
+
+    public ResultSetImpl(StatementImpl parentStatement, QueryResponse response, ClickHouseBinaryFormatReader reader,
+                         Consumer<Exception> onDataTransferException,
+                         Map<ClickHouseDataType, Class<?>> defaultTypeMap) throws SQLException {
         this.parentStatement = parentStatement;
         this.response = response;
         this.reader = reader;
         this.featureManager = new FeatureManager(parentStatement.getConnection().getJdbcConfig());
         TableSchema tableMetadata = reader.getSchema();
 
+        final Map<ClickHouseDataType, Class<?>> resolvedDefaultTypeMap =
+                defaultTypeMap != null ? defaultTypeMap : JdbcUtils.DATA_TYPE_CLASS_MAP;
+        this.columnTypeBindings = buildColumnTypeBindings(tableMetadata, resolvedDefaultTypeMap);
+
         // Result set contains columns from one database (there is a special table engine 'Merge' to do cross DB queries)
         this.metaData = new ResultSetMetaDataImpl(tableMetadata
                 .getColumns(), response.getSettings().getDatabase(), "", tableMetadata.getTableName(),
-                JdbcUtils.DATA_TYPE_CLASS_MAP);
+                resolvedDefaultTypeMap);
         this.closed = false;
         this.wasNull = false;
         this.defaultCalendar = parentStatement.getConnection().defaultCalendar;
@@ -96,6 +104,41 @@ public ResultSetImpl(StatementImpl parentStatement, QueryResponse response, Clic
         this.onDataTransferException = onDataTransferException;
     }
 
+    private static Map<String, ColumnTypeBinding> buildColumnTypeBindings(TableSchema schema,
+                                                                          Map<ClickHouseDataType, Class<?>> typeMap) {
+        ImmutableMap.Builder<String, ColumnTypeBinding> bindings = ImmutableMap.builder();
+
+        for (ClickHouseColumn column : schema.getColumns()) {
+            ClickHouseDataType dataType = column.getDataType();
+            bindings.put(column.getColumnName(), new ColumnTypeBinding(typeMap.get(dataType),
+                    JdbcUtils.convertToSqlType(dataType)));
+        }
+        return bindings.buildKeepingLast();
+    }
+
+    /**
+     * Immutable pair of pre-resolved values for a single column: the Java class to materialize when
+     * no typeMap is supplied, and the JDBC {@link SQLType} that corresponds to the column's ClickHouse
+     * data type (used as a secondary key when looking up a user-provided typeMap).
+     */
+    private static final class ColumnTypeBinding {
+        private final Class<?> aClass;
+        private final SQLType jdbcType;
+
+        ColumnTypeBinding(Class<?> aClass, SQLType jdbcType) {
+            this.aClass = aClass;
+            this.jdbcType = jdbcType;
+        }
+
+        public Class<?> getAClass() {
+            return aClass;
+        }
+
+        public SQLType getJdbcType() {
+            return jdbcType;
+        }
+    }
+
     private void checkClosed() throws SQLException {
         if (closed) {
             throw new SQLException("ResultSet is closed.", ExceptionUtils.SQL_STATE_CONNECTION_EXCEPTION);
@@ -1497,22 +1540,7 @@ public <T> T getObjectImpl(String columnLabel, Class<?> type, Map<String, Class<
                 wasNull = false;
 
                 if (type == null) {
-                    switch (column.getDataType()) {
-                        case Point:
-                        case Ring:
-                        case LineString:
-                        case Polygon:
-                        case MultiPolygon:
-                        case MultiLineString:
-                        case Geometry:
-                            break; // read as is
-                        default:
-                            if (typeMap == null || typeMap.isEmpty()) {
-                                type = JdbcUtils.convertToJavaClass(column.getDataType());
-                            } else {
-                                type = typeMap.get(JdbcUtils.convertToSqlType(column.getDataType()).getName());
-                            }
-                    }
+                    type = resolveTargetType(columnLabel, column, typeMap);
                 } else {
                     ///  shortcut
                     if (type == Timestamp.class) {
@@ -1539,6 +1567,32 @@ public <T> T getObjectImpl(String columnLabel, Class<?> type, Map<String, Class<
         }
     }
 
+    private Class<?> resolveTargetType(String columnLabel, ClickHouseColumn column, Map<String, Class<?>> typeMap) {
+        switch (column.getDataType()) {
+            case Point:
+            case Ring:
+            case LineString:
+            case Polygon:
+            case MultiPolygon:
+            case MultiLineString:
+            case Geometry:
+                return null; // read as is
+            default:
+                break;
+        }
+
+        ColumnTypeBinding binding = columnTypeBindings.get(columnLabel);
+        if (typeMap == null || typeMap.isEmpty()) {
+            return binding.getAClass();
+        }
+
+        Class<?> resolved = typeMap.get(column.getDataType().name());
+        if (resolved == null) {
+            resolved = typeMap.get(binding.getJdbcType().getName());
+        }
+        return resolved;
+    }
+
     @Override
     public void updateObject(int columnIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
         updateObject(columnIndexToName(columnIndex), x, targetSqlType, scaleOrLength);
diff --git a/jdbc-v2/src/test/java/com/clickhouse/jdbc/ResultSetImplTest.java b/jdbc-v2/src/test/java/com/clickhouse/jdbc/ResultSetImplTest.java
@@ -25,6 +25,10 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.sql.Types;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Properties;
 
 import static org.testng.Assert.assertEquals;
@@ -481,4 +485,77 @@ public void testGetResultSetFromArrayTimestamp() throws Exception {
             }
         }
     }
+
+    @Test(groups = {"integration"})
+    public void testGetObjectWithSqlTypeNameMap() throws SQLException {
+        try (Connection conn = getJdbcConnection(); Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT 1::Int32 AS i, toDateTime('2024-12-01 12:34:56') AS ts, " +
+                     "toDate('2024-12-01') AS d")) {
+            assertTrue(rs.next());
+
+            Map<String, Class<?>> sqlTypeMap = new HashMap<>();
+            sqlTypeMap.put(JDBCType.INTEGER.getName(), Long.class);
+            sqlTypeMap.put(JDBCType.TIMESTAMP.getName(), LocalDateTime.class);
+            sqlTypeMap.put(JDBCType.DATE.getName(), LocalDate.class);
+
+            assertEquals(rs.getObject("i", sqlTypeMap), 1L);
+            assertEquals(rs.getObject("ts", sqlTypeMap), LocalDateTime.of(2024, 12, 1, 12, 34, 56));
+            assertEquals(rs.getObject("d", sqlTypeMap), LocalDate.of(2024, 12, 1));
+        }
+    }
+
+    @Test(groups = {"integration"})
+    public void testGetObjectWithClickHouseTypeNameMap() throws SQLException {
+        // typeMap keyed by ClickHouseDataType name (e.g. "Int32"): the V1-style direct lookup
+        // that ResultSetImpl#getObjectImpl now supports in addition to JDBC SQLType names.
+        try (Connection conn = getJdbcConnection(); Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT 1::Int32 AS i, 1::UInt64 AS u, " +
+                     "toDateTime('2024-12-01 12:34:56') AS ts")) {
+            assertTrue(rs.next());
+
+            Map<String, Class<?>> chTypeMap = new HashMap<>();
+            chTypeMap.put("Int32", Long.class);
+            chTypeMap.put("UInt64", String.class);
+            chTypeMap.put("DateTime", LocalDateTime.class);
+
+            assertEquals(rs.getObject("i", chTypeMap), 1L);
+            assertEquals(rs.getObject("u", chTypeMap), "1");
+            assertEquals(rs.getObject("ts", chTypeMap), LocalDateTime.of(2024, 12, 1, 12, 34, 56));
+        }
+    }
+
+    @Test(groups = {"integration"})
+    public void testGetObjectWithMixedTypeNameMap() throws SQLException {
+        // Single typeMap mixing ClickHouseDataType names and SQLType names: CH-name lookup is tried
+        // first, then SQLType-name lookup, so the user can address columns by either convention.
+        try (Connection conn = getJdbcConnection(); Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT 1::Int32 AS i, 'abc'::String AS s")) {
+            assertTrue(rs.next());
+
+            Map<String, Class<?>> mixed = new HashMap<>();
+            mixed.put("Int32", Long.class);
+            mixed.put(JDBCType.VARCHAR.getName(), String.class);
+
+            assertEquals(rs.getObject("i", mixed), 1L);
+            assertEquals(rs.getObject("s", mixed), "abc");
+        }
+    }
+
+    @Test(groups = {"integration"})
+    public void testGetObjectWithTypeMapMissingEntry() throws SQLException {
+        // typeMap that does not contain an entry for the column type: ResultSetImpl#getObjectImpl
+        // falls back to "read as is" (no conversion) as documented by JDBC.
+        try (Connection conn = getJdbcConnection(); Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT 1::Int32 AS i, 'abc'::String AS s")) {
+            assertTrue(rs.next());
+
+            Map<String, Class<?>> partial = new HashMap<>();
+            partial.put("Int32", Long.class);
+
+            assertEquals(rs.getObject("i", partial), 1L);
+            // String column has no entry: value comes back as the reader's native representation
+            // and is not coerced into the default Java class.
+            Assert.assertNotNull(rs.getObject("s", partial));
+        }
+    }
 }
