feat: struct, list, and map parameter support

[Mause]

No description provided.

[rayokota]

@Mause , any idea on when this will be released?

[Mause]

@Mause , any idea on when this will be released?

It will be included in the next DuckDB release

https://duckdb.org/docs/dev/release_calendar

[StephenFlavin]

Hi @Mause,

I was excited to see support for Connection#createArrayOf was added so I decided to build locally to try it out and I came across one issue and a question on performance.

Issue:

connection.createArrayOf("timestamp", new Instant[] {Instant.now()} )

produces an error

...
Caused by: java.sql.SQLException: Invalid Input Error: Unsupported parameter type
	at org.duckdb.DuckDBNative.duckdb_jdbc_execute(Native Method)
	at org.duckdb.DuckDBPreparedStatement.execute(DuckDBPreparedStatement.java:142)
	at org.duckdb.DuckDBPreparedStatement.executeQuery(DuckDBPreparedStatement.java:174)
Caused by: java.sql.SQLException: Invalid Input Error: Unsupported parameter type

Not sure if this is intentional for now or an oversight

Performance Question:

Before I saw that this had been implemented I passed arrays as literals from java then casting the parameter to the array type in the sql, it seems passing the array literal is many times faster than using Connection#createArrayOf, I tried similar on postgres in the past and the speed improvement using Connection#createArrayOf was significant.
Quick test code (using spring)

    public static void main(String[] args) throws SQLException {
        var jdbcClient = JdbcClient.create(new SingleConnectionDataSource("jdbc:duckdb:", true));

        jdbcClient.sql("create table foo(i int)")
                        .update();

        String arrayLiteral = IntStream.range(0, 10000).mapToObj(String::valueOf).collect(Collectors.joining(",", "[", "]"));

        System.out.println("ArrayLiteral");

        for (int i = 0; i < 100; i++) {
            final var now2 = Instant.now();
            jdbcClient.sql("insert into foo select unnest(:arr::int[])")
                    .param("arr", arrayLiteral)
                    .update();
            final var duration = Duration.between(now2, Instant.now());
            System.out.println(duration.toNanos() / 1000000d);
        }

        jdbcClient.sql("truncate table foo")
                .update();

        System.out.println("`Connection#createArrayOf`");

        final var elements = IntStream.range(0, 10000).boxed().toArray();

        try (final var connection = new SingleConnectionDataSource("jdbc:duckdb:", true).getConnection()) {
            for (int i = 0; i < 100; i++) {
                final var now = Instant.now();
                jdbcClient.sql("insert into foo select unnest(:arr::int[])")
                        .param("arr", connection.createArrayOf("int4", elements))
                        .update();
                final var duration = Duration.between(now, Instant.now());
                System.out.println(duration.toNanos() / 1000000d);
            }
        }
    }

output on M1 mac showing 1.3ms for array literal vs 6.4ms for Connection#createArrayOf, is this expected as a first implementation or do you think something is a rye?

unfortunately, I've not got the time to dig into potential performance improvements on the java side and I don't know c++ so can't help there 😓