Support spatial extension types

This PR changes the handling of extension types. Instead of treating
all custom types (detected by having an alias) as `VARCHAR`, it ignores
type alias and uses underlying logical type.

This allows to work with the following types from the spatial
extension using default JDBC types `java.sql.Struct`, `java.sql.Array`,
and `java.sql.Blob`:

 - `POINT_2D`: as `STRUCT{x: DOUBLE, y: DOUBLE}`
 - `POINT_3D`: as `STRUCT{x: DOUBLE, y: DOUBLE, z: DOUBLE}`
 - `POINT_4D`: as `STRUCT{x: DOUBLE, y: DOUBLE, z: DOUBLE, m: DOUBLE}`
 - `LINESTRING_2D`: as `LIST[STRUCT{x: DOUBLE, y: DOUBLE}]`
 - `POLYGON_2D`: as `LIST[LIST[STRUCT{x: DOUBLE, y: DOUBLE}]]`
 - `BOX_2D`: as `STRUCT{min_x: DOUBLE, max_x: DOUBLE, min_y: DOUBLE, max_y: DOUBLE}`
 - `BOX_2DF`: as `STRUCT{min_x: FLOAT, max_x: FLOAT, min_y: FLOAT, max_y: FLOAT}`
 - `GEOMETRY`: as `BLOB`
 - `WKB_BLOB`: as `BLOB`

Special handling is left only for `JSON` type because it is mapped to
driver-specific `JsonNode` class.

Testing: existing test for extnsion types is adjusted to use
`java.sql.Struct` and `java.sql.Blob`. New test is added to cover all
spatial types in bind parameters and in result set, minor enhancements
are added to tests runner.

Fixes: duckdb#37

Author: staticlibs

CMakeLists.txt

@@ -560,6 +560,7 @@ add_library(duckdb_java SHARED
   src/jni/duckdb_java.cpp
   src/jni/functions.cpp
   src/jni/refs.cpp
+  src/jni/types.cpp
   src/jni/util.cpp
   ${DUCKDB_SRC_FILES})
 

src/jni/duckdb_java.cpp

@@ -14,6 +14,7 @@
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "functions.hpp"
 #include "refs.hpp"
+#include "types.hpp"
 #include "util.hpp"
 
 #include <cstdint>
@@ -396,42 +397,6 @@ void _duckdb_jdbc_free_result(JNIEnv *env, jclass, jobject res_ref_buf) {
 	}
 }
 
-static std::string type_to_jduckdb_type(LogicalType logical_type) {
-	switch (logical_type.id()) {
-	case LogicalTypeId::DECIMAL: {
-
-		uint8_t width = 0;
-		uint8_t scale = 0;
-		logical_type.GetDecimalProperties(width, scale);
-		std::string width_scale = std::to_string(width) + std::string(";") + std::to_string(scale);
-
-		auto physical_type = logical_type.InternalType();
-		switch (physical_type) {
-		case PhysicalType::INT16: {
-			string res = std::string("DECIMAL16;") + width_scale;
-			return res;
-		}
-		case PhysicalType::INT32: {
-			string res = std::string("DECIMAL32;") + width_scale;
-			return res;
-		}
-		case PhysicalType::INT64: {
-			string res = std::string("DECIMAL64;") + width_scale;
-			return res;
-		}
-		case PhysicalType::INT128: {
-			string res = std::string("DECIMAL128;") + width_scale;
-			return res;
-		}
-		default:
-			return std::string("no physical type found");
-		}
-	} break;
-	default:
-		return logical_type.ToString();
-	}
-}
-
 static jobject build_meta(JNIEnv *env, size_t column_count, size_t n_param, const duckdb::vector<string> &names,
                           const duckdb::vector<LogicalType> &types, StatementProperties properties) {
 	auto name_array = env->NewObjectArray(column_count, J_String, nullptr);
@@ -515,6 +480,7 @@ jobjectArray _duckdb_jdbc_fetch(JNIEnv *env, jclass, jobject res_ref_buf, jobjec
 
 	return vec_array;
 }
+
 jobject ProcessVector(JNIEnv *env, Connection *conn_ref, Vector &vec, idx_t row_count) {
 	auto type_str = env->NewStringUTF(type_to_jduckdb_type(vec.GetType()).c_str());
 	// construct nullmask
@@ -530,11 +496,7 @@ jobject ProcessVector(JNIEnv *env, Connection *conn_ref, Vector &vec, idx_t row_
 	jobject constlen_data = nullptr;
 	jobjectArray varlen_data = nullptr;
 
-	// this allows us to treat aliased (usually extension) types as strings
-	auto type = vec.GetType();
-	auto type_id = type.HasAlias() ? LogicalTypeId::UNKNOWN : type.id();
-
-	switch (type_id) {
+	switch (vec.GetType().id()) {
 	case LogicalTypeId::BOOLEAN:
 		constlen_data = env->NewDirectByteBuffer(FlatVector::GetData(vec), row_count * sizeof(bool));
 		break;

src/jni/types.cpp

@@ -0,0 +1,45 @@
+#include "types.hpp"
+
+#include <string>
+#include <vector>
+
+std::string type_to_jduckdb_type(duckdb::LogicalType logical_type) {
+	switch (logical_type.id()) {
+	case duckdb::LogicalTypeId::DECIMAL: {
+
+		uint8_t width = 0;
+		uint8_t scale = 0;
+		logical_type.GetDecimalProperties(width, scale);
+		std::string width_scale = std::to_string(width) + std::string(";") + std::to_string(scale);
+
+		auto physical_type = logical_type.InternalType();
+		switch (physical_type) {
+		case duckdb::PhysicalType::INT16: {
+			std::string res = std::string("DECIMAL16;") + width_scale;
+			return res;
+		}
+		case duckdb::PhysicalType::INT32: {
+			std::string res = std::string("DECIMAL32;") + width_scale;
+			return res;
+		}
+		case duckdb::PhysicalType::INT64: {
+			std::string res = std::string("DECIMAL64;") + width_scale;
+			return res;
+		}
+		case duckdb::PhysicalType::INT128: {
+			std::string res = std::string("DECIMAL128;") + width_scale;
+			return res;
+		}
+		default:
+			return std::string("no physical type found");
+		}
+	} break;
+	default:
+		// JSON requires special handling because it is mapped
+		// to JsonNode class
+		if (logical_type.IsJSONType()) {
+			return logical_type.GetAlias();
+		}
+		return duckdb::EnumUtil::ToString(logical_type.id());
+	}
+}

src/jni/types.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "duckdb.hpp"
+
+std::string type_to_jduckdb_type(duckdb::LogicalType logical_type);

src/test/java/org/duckdb/TestDuckDBJDBC.java

@@ -11,14 +11,7 @@
 import static org.duckdb.DuckDBDriver.DUCKDB_USER_AGENT_PROPERTY;
 import static org.duckdb.DuckDBDriver.JDBC_STREAM_RESULTS;
 import static org.duckdb.DuckDBTimestamp.localDateTimeFromTimestamp;
-import static org.duckdb.test.Assertions.assertEquals;
-import static org.duckdb.test.Assertions.assertFalse;
-import static org.duckdb.test.Assertions.assertNotNull;
-import static org.duckdb.test.Assertions.assertNull;
-import static org.duckdb.test.Assertions.assertThrows;
-import static org.duckdb.test.Assertions.assertThrowsMaybe;
-import static org.duckdb.test.Assertions.assertTrue;
-import static org.duckdb.test.Assertions.fail;
+import static org.duckdb.test.Assertions.*;
 import static org.duckdb.test.Runner.runTests;
 
 import java.math.BigDecimal;
@@ -1302,7 +1295,7 @@ public static void test_lots_of_decimals() throws Exception {
         conn.close();
     }
 
-    public static void test_big_data() throws Exception {
+    public static void test_lots_of_big_data() throws Exception {
         Connection conn = DriverManager.getConnection(JDBC_URL);
         Statement stmt = conn.createStatement();
         int rows = 10000;
@@ -4187,21 +4180,6 @@ private static Map<String, Object> structToMap(DuckDBStruct actual) throws SQLEx
         return result;
     }
 
-    private static <T> void assertListsEqual(List<T> actual, List<T> expected) throws Exception {
-        assertListsEqual(actual, expected, "");
-    }
-
-    private static <T> void assertListsEqual(List<T> actual, List<T> expected, String label) throws Exception {
-        assertEquals(actual.size(), expected.size());
-
-        ListIterator<T> itera = actual.listIterator();
-        ListIterator<T> itere = expected.listIterator();
-
-        while (itera.hasNext()) {
-            assertEquals(itera.next(), itere.next(), label);
-        }
-    }
-
     public static void test_cancel() throws Exception {
         ExecutorService service = Executors.newFixedThreadPool(1);
         try (Connection conn = DriverManager.getConnection(JDBC_URL); Statement stmt = conn.createStatement()) {
@@ -4300,7 +4278,7 @@ public static void test_invalid_execute_calls() throws Exception {
         }
     }
 
-    public static void test_race() throws Exception {
+    public static void test_lots_of_races() throws Exception {
         try (Connection connection = DriverManager.getConnection(JDBC_URL)) {
             ExecutorService executorService = Executors.newFixedThreadPool(10);
 
@@ -4799,6 +4777,15 @@ public static void test_typed_connection_properties() throws Exception {
     }
 
     public static void main(String[] args) throws Exception {
-        System.exit(runTests(args, TestDuckDBJDBC.class, TestExtensionTypes.class));
+        String arg1 = args.length > 0 ? args[0] : "";
+        final int statusCode;
+        if (arg1.startsWith("Test")) {
+            Class<?> clazz = Class.forName("org.duckdb." + arg1);
+            statusCode = runTests(new String[0], clazz);
+        } else {
+            // extension installation fails on CI, Spatial test is temporary disabled
+            statusCode = runTests(args, TestDuckDBJDBC.class, TestExtensionTypes.class /*, TestSpatial.class */);
+        }
+        System.exit(statusCode);
     }
 }

src/test/java/org/duckdb/TestExtensionTypes.java

@@ -3,12 +3,7 @@
 import static org.duckdb.TestDuckDBJDBC.JDBC_URL;
 import static org.duckdb.test.Assertions.assertEquals;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.Statement;
-import java.sql.Types;
+import java.sql.*;
 
 public class TestExtensionTypes {
 
@@ -21,8 +16,14 @@ public static void test_extension_type() throws Exception {
             try (ResultSet rs = stmt.executeQuery(
                      "SELECT {\"hello\": 'foo', \"world\": 'bar'}::test_type, '\\xAA'::byte_test_type")) {
                 rs.next();
-                assertEquals(rs.getObject(1), "{'hello': foo, 'world': bar}");
-                assertEquals(rs.getObject(2), "\\xAA");
+                Struct struct = (Struct) rs.getObject(1);
+                Object[] attrs = struct.getAttributes();
+                assertEquals(attrs[0], "foo");
+                assertEquals(attrs[1], "bar");
+                Blob blob = rs.getBlob(2);
+                byte[] bytes = blob.getBytes(1, (int) blob.length());
+                assertEquals(bytes.length, 1);
+                assertEquals(bytes[0] & 0xff, 0xaa);
             }
         }
     }