pending prepared を使うと httpfs + parquet の呼び出しが失敗する例

main.c

#include <stdio.h>
#include <duckdb.h>

int main(int argc, char **argv)
{
#if 1
    const char query[] = "SELECT avg(c_acctbal) FROM 'https://shell.duckdb.org/data/tpch/0_01/parquet/customer.parquet'";
#else
    const char query[] = "SELECT avg(c_acctbal) FROM 'customer.parquet'";
#endif

    duckdb_database db;
    duckdb_connection con;
    duckdb_state state;

    if (duckdb_open(NULL, &db) == DuckDBError) {
        printf("duckdb_open failed\n");
        return 1;
    }
    if (duckdb_connect(db, &con) == DuckDBError) {
        printf("duckdb_connect failed\n");
        return 1;
    }

    // run queries...

    state = duckdb_query(con, "INSTALL httpfs", NULL);
    if (state == DuckDBError) {
        printf("failed: INSTALL httpfs\n");
        return 1;
    }
    state = duckdb_query(con, "LOAD httpfs", NULL);
    if (state == DuckDBError) {
        printf("failed: LOAD httpfs\n");
        return 1;
    }

    duckdb_result result;

    duckdb_prepared_statement prepared;
    duckdb_pending_result pending;
    state = duckdb_prepare(con, query, &prepared); 
    if (state == DuckDBError) {
        printf("faield to prepare\n");
        return 1;
    }
    if (duckdb_pending_prepared(prepared, &pending) == DuckDBError) {
        printf("failed to pending prepared\n");
        return 1;
    }
    duckdb_pending_state pending_state;
    do {
        pending_state = duckdb_pending_execute_task(pending);
    } while (pending_state == DUCKDB_PENDING_RESULT_NOT_READY);
    if (pending_state == DUCKDB_PENDING_ERROR) {
         printf("pending error: %s\n", duckdb_pending_error(pending));
         return 1;
    }
    duckdb_execute_pending(pending, &result);
    duckdb_destroy_pending(&pending);
    duckdb_destroy_prepare(&prepared);

#if 0
    state = duckdb_query(con, query, &result);
    if (state == DuckDBError) {
        printf("duckdb_query failed: %s\n", duckdb_result_error(&result));
    }
#endif

    while (true) {
        duckdb_data_chunk chunk = duckdb_fetch_chunk(result);
        if (!chunk) {
            break;
        }
        printf("column#0: name=%s type=%d\n",
                duckdb_column_name(&result, 0),
                duckdb_column_type(&result, 0));
        idx_t row_count = duckdb_data_chunk_get_size(chunk);
        duckdb_vector col0 = duckdb_data_chunk_get_vector(chunk, 0);
        double *col0_data = (double *)duckdb_vector_get_data(col0);
        uint64_t *col0_validity = duckdb_vector_get_validity(col0);
        printf("row_count=%d\n", row_count);

        for (idx_t row = 0; row < row_count; row++) {
            if (duckdb_validity_row_is_valid(col0_validity, row)) {
                printf("%e", col0_data[row]);
            } else {
                printf("NULL");
            }
            printf("\n");
        }
        duckdb_destroy_data_chunk(&chunk);
    }

    // cleanup
    duckdb_destroy_result(&result);
    duckdb_disconnect(&con);
    duckdb_close(&db);
    return 0;
}

Makefile

DUCKDB_DIR=../duckdb-go-bindings/lib/windows-amd64
#DUCKDB_DIR=../duckdb-go-bindings/lib/linux-amd64
#DUCKDB_DIR=../duckdb-go-bindings/lib/darwin-arm64

CFLAGS=-I${DUCKDB_DIR} -DDUCKDB_STATIC_BUILD
LDLIBS= \
	-lduckdb_static \
	-lautocomplete_extension \
	-lcore_functions_extension \
	-licu_extension \
	-ljson_extension \
	-lparquet_extension \
	-ltpcds_extension \
	-ltpch_extension \
	-lduckdb_fastpforlib \
	-lduckdb_fmt \
	-lduckdb_fsst \
	-lduckdb_hyperloglog \
	-lduckdb_mbedtls \
	-lduckdb_miniz \
	-lduckdb_pg_query \
	-lduckdb_re2 \
	-lduckdb_skiplistlib \
	-lduckdb_utf8proc \
	-lduckdb_yyjson \
	-lduckdb_zstd \
	-lws2_32 \
	-lwsock32 \
	-lrstrtmgr \
	-lstdc++ \
	-lm \
	--static \
	-L${DUCKDB_DIR}

main: main.c

clean:
	rm -f *.o
	rm -f main