duckdb 1.5.0.2 → 1.5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35eae50625fd72c7cb1b870ff496d259c0271453404a0646fd05514b4a3f7338
-  data.tar.gz: e96e82fcbffa7427f63cf8a7af0ba9434b5cb7daefbd9951c3eba4866508d67e
+  metadata.gz: c55213e9e388de53b04f29987c7714975ab5c1a8fa10a40ae378189507dae752
+  data.tar.gz: a96e6256ce85583fd395d936994d2a871727af8f7ba11fadc40a9d9ca79c15fa
 SHA512:
-  metadata.gz: c7fdc287942e832ee9f33fbbf0056add1a7b7fc8db0e633356b7cf73c3d086f1d7a89ac7cf79673d0ecbbecda15ee33d365182c2874a74ac23aaf95270fe90dd
-  data.tar.gz: 7cc3079783a36442e43b7228223e2ded5cb453184e1eb4344788f5b7c1758e2ba665d8a9d087f6239d84dfb16a389f18fe091bd346a439e7e3c32ed9a333a9ce
+  metadata.gz: 67c2d5de633c5999ca07e3deb7c98a091b4eaedb70eacce2d2f7c34b9e8795b012d4415e197d5996ca80eb9c526dc28e86ced8f1d977cc040fcfd8c59a9a3ad2
+  data.tar.gz: 38de479e2069a0b4dd1fa8684b2174d6f42c15375d54269f56983b530e2b7ea43150284b8825879cdceca1fe959f1c05b8043bb1c2202b30456c63eac8dbc6ab

data/.github/workflows/test_on_macos.yml

@@ -21,7 +21,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['3.2.9', '3.3.10', '3.4.9', '4.0.2', 'head']
-        duckdb: ['1.4.4', '1.5.0']
+        duckdb: ['1.4.4', '1.5.1']
 
     steps:
     - uses: actions/checkout@v4
@@ -35,39 +35,36 @@ jobs:
       id: duckdb-cache
       uses: actions/cache@v4
       with:
-        path: duckdb-v${{ matrix.duckdb }}
+        path: libduckdb-osx-universal
         key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
 
-    - name: Build duckdb ${{ matrix.duckdb }}
+    - name: Download duckdb ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
-      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       run: |
-        git clone -b v$DUCKDB_VERSION https://github.com/cwida/duckdb.git duckdb-tmp-v$DUCKDB_VERSION
-        cd duckdb-tmp-v$DUCKDB_VERSION && make && cd ..
-        rm -rf duckdb-v$DUCKDB_VERSION
-        mkdir -p duckdb-v$DUCKDB_VERSION/build/release/src duckdb-v$DUCKDB_VERSION/src
-        cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.dylib duckdb-v$DUCKDB_VERSION/build/release/src
-        cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/libduckdb-osx-universal.zip
+        case "${DUCKDB_VERSION}" in
+          "1.5.1") EXPECTED_SHA256="d9dd723c59f8571202b468f6bf71d4555238544553dd1445e6c9ecb39f54c0f3" ;;
+          "1.4.4") EXPECTED_SHA256="5e6d79f5fb86bbd4f24d59cee3bc38f113d1433761df35337e3c01c62eeafe26" ;;
+          *) echo "No known SHA256 for DuckDB v${DUCKDB_VERSION}"; exit 1 ;;
+        esac
+        echo "${EXPECTED_SHA256}  libduckdb-osx-universal.zip" | shasum -a 256 -c
+        mkdir libduckdb-osx-universal
+        unzip libduckdb-osx-universal.zip -d libduckdb-osx-universal
 
     - name: bundle install with Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         bundle install --jobs 4 --retry 3
 
     - name: Build test with DUCKDB_API_NO_DEPRECATED and Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        env DUCKDB_API_NO_DEPRECATED=1 bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+        env DUCKDB_API_NO_DEPRECATED=1 bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/libduckdb-osx-universal --with-duckdb-lib=${GITHUB_WORKSPACE}/libduckdb-osx-universal
         bundle exec rake clean
 
     - name: Build with Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/libduckdb-osx-universal --with-duckdb-lib=${GITHUB_WORKSPACE}/libduckdb-osx-universal
 
     - name: Setup MySQL
       run: |
@@ -79,12 +76,23 @@ jobs:
         mysql -u root -e "GRANT ALL PRIVILEGES ON test_db.* TO 'test_user'@'127.0.0.1';"
         mysql -u root -e "FLUSH PRIVILEGES;"
 
+    - name: confirm duckdb library version
+      env:
+        EXPECTED_DUCKDB_VERSION: ${{ matrix.duckdb }}
+        DYLD_LIBRARY_PATH: ${{ github.workspace }}/libduckdb-osx-universal
+      run: |
+        ruby -Ilib -rduckdb -e '
+          actual = DuckDB::LIBRARY_VERSION
+          expected = ENV.fetch("EXPECTED_DUCKDB_VERSION")
+          abort("Expected DuckDB #{expected}, got #{actual}") if actual != expected
+          puts "duckdb library #{actual}"
+        '
+
     - name: test with Ruby ${{ matrix.ruby }}
       env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
         MYSQL_TEST: 1
+        DYLD_LIBRARY_PATH: ${{ github.workspace }}/libduckdb-osx-universal
       run: |
-        export DYLD_LIBRARY_PATH=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src:${DYLD_LIBRARY_PATH}
         env RUBYOPT=-W:deprecated rake test
 
   post-test:

data/.github/workflows/test_on_ubuntu.yml

@@ -21,7 +21,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['3.2.9', '3.3.10', '3.4.9', '4.0.2', 'head']
-        duckdb: ['1.4.4', '1.5.0']
+        duckdb: ['1.4.4', '1.5.1']
 
     services:
       mysql:
@@ -47,43 +47,55 @@ jobs:
       id: duckdb-cache
       uses: actions/cache@v4
       with:
-        path: duckdb-v${{ matrix.duckdb }}
+        path: libduckdb-linux-amd64
         key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
 
-    - name: Build duckdb ${{ matrix.duckdb }}
+    - name: Download duckdb ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
-      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       run: |
-        git clone -b v$DUCKDB_VERSION https://github.com/cwida/duckdb.git duckdb-tmp-v$DUCKDB_VERSION
-        cd duckdb-tmp-v$DUCKDB_VERSION && make && cd ..
-        rm -rf duckdb-v$DUCKDB_VERSION
-        mkdir -p duckdb-v$DUCKDB_VERSION/build/release/src duckdb-v$DUCKDB_VERSION/src
-        cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.so duckdb-v$DUCKDB_VERSION/build/release/src
-        cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/libduckdb-linux-amd64.zip
+        case "${DUCKDB_VERSION}" in
+          "1.5.1") EXPECTED_SHA256="21aec66a60eae1696270ba715a481ab066a88d99a62718d0577579ac1a7a4834" ;;
+          "1.4.4") EXPECTED_SHA256="09cc288295964d897b47665d1898e16e8ef176cae9ea615797fc136eae15bd5d" ;;
+          *) echo "No known SHA256 for DuckDB v${DUCKDB_VERSION}"; exit 1 ;;
+        esac
+        echo "${EXPECTED_SHA256}  libduckdb-linux-amd64.zip" | sha256sum -c
+        mkdir libduckdb-linux-amd64
+        unzip libduckdb-linux-amd64.zip -d libduckdb-linux-amd64
+
+    - name: setup libduckdb.so
+      run: |
+        sudo cp libduckdb-linux-amd64/libduckdb.so /usr/local/lib/
+        sudo ldconfig
 
     - name: bundle install with Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         bundle install --jobs 4 --retry 3
 
     - name: Build test with DUCKDB_API_NO_DEPRECATED and Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        env DUCKDB_API_NO_DEPRECATED=1 bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+        env DUCKDB_API_NO_DEPRECATED=1 bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/libduckdb-linux-amd64 --with-duckdb-lib=${GITHUB_WORKSPACE}/libduckdb-linux-amd64
         bundle exec rake clean
 
     - name: Build with Ruby ${{ matrix.ruby }}
+      run: |
+        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/libduckdb-linux-amd64 --with-duckdb-lib=${GITHUB_WORKSPACE}/libduckdb-linux-amd64
+
+    - name: confirm duckdb library version
       env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
+        EXPECTED_DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+        ruby -Ilib -rduckdb -e '
+          actual = DuckDB::LIBRARY_VERSION
+          expected = ENV.fetch("EXPECTED_DUCKDB_VERSION")
+          abort("Expected DuckDB #{expected}, got #{actual}") if actual != expected
+          puts "duckdb library #{actual}"
+        '
 
     - name: test with Ruby ${{ matrix.ruby }}
       env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
         MYSQL_TEST: 1
       run: |
         env RUBYOPT=-W:deprecated rake test

data/.github/workflows/test_on_windows.yml

@@ -17,11 +17,11 @@ concurrency:
 jobs:
   test:
     runs-on: windows-latest
-    timeout-minutes: 15
+    timeout-minutes: 8
     strategy:
       matrix:
         ruby: ['3.2.9', '3.3.10', '3.4.8', '4.0.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['1.4.4', '1.5.0']
+        duckdb: ['1.4.4', '1.5.1']
 
     steps:
     - uses: actions/checkout@v4
@@ -31,29 +31,35 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v4
+      with:
+        path: libduckdb-windows-amd64
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
+
     - name: download duckdb binary for windows 64bit
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         curl -OL https://github.com/duckdb/duckdb/releases/download/v${env:DUCKDB_VERSION}/libduckdb-windows-amd64.zip
-
-    - name: extract zip file
-      run: |
-        unzip libduckdb-windows-amd64.zip
+        mkdir libduckdb-windows-amd64
+        unzip libduckdb-windows-amd64.zip -d libduckdb-windows-amd64
 
     - name: setup duckdb.dll
       run: |
-        cp duckdb.dll C:/Windows/System32/
+        cp libduckdb-windows-amd64/duckdb.dll C:/Windows/System32/
 
     - name: Build with Rake with Ruby ${{ matrix.ruby }}
       run: |
         bundle install
-        bundle exec rake build -- --with-duckdb-include=../../../.. --with-duckdb-lib=../../../..
+        bundle exec rake build -- --with-duckdb-include=../../../../libduckdb-windows-amd64 --with-duckdb-lib=../../../../libduckdb-windows-amd64
 
     - name: rake test
       uses: nick-fields/retry@v3
       with:
-        timeout_minutes: 3
+        timeout_minutes: 1
         max_attempts: 3
         command: bundle exec rake test TESTOPTS="--verbose"
 

data/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.1.0 - 2026-03-29
+
+- add `DuckDB::ScalarFunction#varargs_type=` to register a scalar function that accepts a variable number of arguments of a given type (wraps `duckdb_scalar_function_set_varargs`).
+- `DuckDB::ScalarFunction.create` accepts `varargs_type:` keyword argument (mutually exclusive with `parameter_type:`/`parameter_types:`).
+- add `DuckDB::ScalarFunction#set_special_handling` to make the block receive `nil` for NULL inputs instead of DuckDB short-circuiting (wraps `duckdb_scalar_function_set_special_handling`).
+- `DuckDB::ScalarFunction.create` accepts `null_handling: true` keyword to enable special NULL handling.
+- add `34 => :any` to `Converter::IntToSym::HASH_TYPES` and `:any` to `ScalarFunction::SUPPORTED_TYPES` so `DuckDB::LogicalType::ANY` can be used with `varargs_type=`.
+- add `DuckDB::ScalarFunction#set_bind` to register a bind callback (wraps `duckdb_scalar_function_set_bind`). The block receives a `DuckDB::ScalarFunction::BindInfo` object at query planning time (once, before per-row execution).
+- add `DuckDB::ScalarFunction::BindInfo#argument_count` to return the number of arguments passed to the scalar function (wraps `duckdb_scalar_function_bind_get_argument_count`).
+- add `DuckDB::ScalarFunction::BindInfo#set_error(message)` to report an error early at planning time (wraps `duckdb_scalar_function_bind_set_error`).
+- add `DuckDB::ScalarFunction::BindInfo#get_argument(index)` to return the expression at the given argument index as a `DuckDB::Expression` object (wraps `duckdb_scalar_function_bind_get_argument`). Raises `ArgumentError` for out-of-range index.
+- add `DuckDB::Expression#foldable?` to check whether an expression can be folded to a constant at query planning time (wraps `duckdb_expression_is_foldable`). Returns `true` for literals and constant arithmetic, `false` for column references and non-deterministic functions.
+- add `DuckDB::LogicalType.create_map` to create a map logical type.
+- bump duckdb to 1.5.1 on CI
+- add `DuckDB::ScalarFunction::BindInfo#client_context` to return the client context of the bind phase as a `DuckDB::ClientContext` object (wraps `duckdb_scalar_function_get_client_context`).
+- add `DuckDB::ClientContext#connection_id` to return the connection id of the client context (wraps `duckdb_client_context_get_connection_id`).
+- add `DuckDB::Expression#fold(client_context)` to fold a constant expression to a native Ruby value at query planning time (wraps `duckdb_expression_fold`). Returns Integer, Float, String, true/false, or nil. Raises `DuckDB::Error` if the expression is not foldable.
+
+## Breaking changes
+- rename `DuckDB::BindInfo` to `DuckDB::TableFunction::BindInfo`. `DuckDB::BindInfo` still works but emits a deprecation warning.
+- rename `DuckDB::InitInfo` to `DuckDB::TableFunction::InitInfo`. `DuckDB::InitInfo` still works but emits a deprecation warning.
+- rename `DuckDB::FunctionInfo` to `DuckDB::TableFunction::FunctionInfo`. `DuckDB::FunctionInfo` still works but emits a deprecation warning.
+
 # 1.5.0.2 - 2026-03-22
 
 - add `DuckDB.vector_size` to return the DuckDB vector size (number of rows processed per vectorized operation).

data/Dockerfile

@@ -1,7 +1,7 @@
 ARG RUBY_VERSION=4.0.1
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=1.5.0
+ARG DUCKDB_VERSION=1.5.1
 ARG VALGRIND_VERSION=3.21.0
 
 RUN apt-get update -qq && \

data/Gemfile.lock

@@ -1,46 +1,37 @@
 PATH
   remote: .
   specs:
-    duckdb (1.5.0.2)
+    duckdb (1.5.1.0)
       bigdecimal (>= 3.1.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.9)
-      public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.3)
-    bigdecimal (4.0.1)
+    bigdecimal (4.1.0)
     csv (3.3.5)
     drb (2.2.3)
-    json (2.19.2)
-    json-schema (6.2.0)
-      addressable (~> 2.8)
-      bigdecimal (>= 3.1, < 5)
+    json (2.19.3)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
-    mcp (0.9.0)
-      json-schema (>= 4.1)
     minitest (6.0.2)
       drb (~> 2.0)
       prism (~> 1.5)
     parallel (1.27.0)
-    parser (3.3.10.2)
+    parser (3.3.11.1)
       ast (~> 2.4.1)
       racc
     prism (1.9.0)
-    public_suffix (7.0.5)
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.1)
     rake-compiler (1.3.1)
       rake
     regexp_parser (2.11.3)
-    rubocop (1.85.1)
+    rubocop (1.86.0)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
-      mcp (~> 0.6)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)

data/README.md

@@ -14,11 +14,9 @@ This gem `duckdb` is Ruby client for the [DuckDB](https://www.duckdb.org) databa
 You must have [DuckDB](https://www.duckdb.org) engine installed in order to use this gem.
 
 ## Pre-requisite setup (Linux):
-1. Head over to the [DuckDB](https://duckdb.org/) webpage.
+1. Download the latest [C++ package release for DuckDB](https://duckdb.org/install/?platform=linux&environment=c).
 
-2. Download the latest C++ package release for DuckDB.
-
-3. Move the files to their respective location:
+2. Move the files to their respective location:
     - Extract the `duckdb.h` and `duckdb.hpp` file to `/usr/local/include`.
     - Extract the `libduckdb.so` file to `/usr/local/lib`.
 
@@ -28,7 +26,7 @@ You must have [DuckDB](https://www.duckdb.org) engine installed in order to use
     sudo mv libduckdb/libduckdb.so /usr/local/lib
     ```
 
-4. To create the necessary link, run `ldconfig` as root:
+3. To create the necessary link, run `ldconfig` as root:
 
     ```sh
     sudo ldconfig /usr/local/lib # adding a --verbose flag is optional - but this will let you know if the libduckdb.so library has been linked

data/ext/duckdb/client_context.c

@@ -0,0 +1,70 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBClientContext;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE rbduckdb_client_context_connection_id(VALUE self);
+
+static const rb_data_type_t client_context_data_type = {
+    "DuckDB/ClientContext",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBClientContext *p = (rubyDuckDBClientContext *)ctx;
+
+    if (p->client_context) {
+        duckdb_destroy_client_context(&(p->client_context));
+    }
+
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBClientContext *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBClientContext));
+    return TypedData_Wrap_Struct(klass, &client_context_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBClientContext);
+}
+
+VALUE rbduckdb_client_context_new(duckdb_client_context client_context) {
+    rubyDuckDBClientContext *ctx;
+    VALUE obj = allocate(cDuckDBClientContext);
+
+    TypedData_Get_Struct(obj, rubyDuckDBClientContext, &client_context_data_type, ctx);
+    ctx->client_context = client_context;
+
+    return obj;
+}
+
+rubyDuckDBClientContext *get_struct_client_context(VALUE obj) {
+    rubyDuckDBClientContext *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBClientContext, &client_context_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * call-seq:
+ *   client_context.connection_id -> Integer
+ *
+ * Returns the connection id of the client context.
+ */
+static VALUE rbduckdb_client_context_connection_id(VALUE self) {
+    rubyDuckDBClientContext *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBClientContext, &client_context_data_type, ctx);
+    return ULL2NUM(duckdb_client_context_get_connection_id(ctx->client_context));
+}
+
+void rbduckdb_init_duckdb_client_context(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBClientContext = rb_define_class_under(mDuckDB, "ClientContext", rb_cObject);
+    rb_define_alloc_func(cDuckDBClientContext, allocate);
+    rb_define_method(cDuckDBClientContext, "connection_id", rbduckdb_client_context_connection_id, 0);
+}

data/ext/duckdb/client_context.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_DUCKDB_CLIENT_CONTEXT_H
+#define RUBY_DUCKDB_CLIENT_CONTEXT_H
+
+struct _rubyDuckDBClientContext {
+    duckdb_client_context client_context;
+};
+
+typedef struct _rubyDuckDBClientContext rubyDuckDBClientContext;
+
+void rbduckdb_init_duckdb_client_context(void);
+VALUE rbduckdb_client_context_new(duckdb_client_context client_context);
+rubyDuckDBClientContext *get_struct_client_context(VALUE obj);
+
+#endif

data/ext/duckdb/converter.h

@@ -1,6 +1,35 @@
 #ifndef RUBY_DUCKDB_CONVERTER_H
 #define RUBY_DUCKDB_CONVERTER_H
 
+extern ID id__to_date;
+extern ID id__to_time;
+extern ID id__to_time_from_duckdb_time;
+extern ID id__to_interval_from_vector;
+extern ID id__to_hugeint_from_vector;
+extern ID id__to_decimal_from_hugeint;
+extern ID id__to_uuid_from_vector;
+extern ID id__to_time_from_duckdb_timestamp_s;
+extern ID id__to_time_from_duckdb_timestamp_ms;
+extern ID id__to_time_from_duckdb_timestamp_ns;
+extern ID id__to_time_from_duckdb_time_tz;
+extern ID id__to_time_from_duckdb_timestamp_tz;
+extern ID id__to_infinity;
+
+VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts);
+VALUE rbduckdb_timestamp_ms_to_ruby(duckdb_timestamp_ms ts);
+VALUE rbduckdb_timestamp_ns_to_ruby(duckdb_timestamp_ns ts);
+VALUE rbduckdb_time_tz_to_ruby(duckdb_time_tz tz);
+VALUE rbduckdb_timestamp_tz_to_ruby(duckdb_timestamp ts);
+VALUE rbduckdb_time_to_ruby(duckdb_time t);
+VALUE rbduckdb_date_to_ruby(duckdb_date date);
+VALUE rbduckdb_timestamp_to_ruby(duckdb_timestamp ts);
+
+VALUE infinite_date_value(duckdb_date date);
+VALUE infinite_timestamp_value(duckdb_timestamp timestamp);
+VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s);
+VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms);
+VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns);
+
 void rbduckdb_init_duckdb_converter(void);
 
 #endif

data/ext/duckdb/conveter.c

@@ -2,6 +2,168 @@
 
 VALUE mDuckDBConverter;
 
+ID id__to_date;
+ID id__to_time;
+ID id__to_time_from_duckdb_time;
+ID id__to_interval_from_vector;
+ID id__to_hugeint_from_vector;
+ID id__to_decimal_from_hugeint;
+ID id__to_uuid_from_vector;
+ID id__to_time_from_duckdb_timestamp_s;
+ID id__to_time_from_duckdb_timestamp_ms;
+ID id__to_time_from_duckdb_timestamp_ns;
+ID id__to_time_from_duckdb_time_tz;
+ID id__to_time_from_duckdb_timestamp_tz;
+ID id__to_infinity;
+
+VALUE infinite_date_value(duckdb_date date) {
+    if (duckdb_is_finite_date(date) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          INT2NUM(date.days)
+                         );
+    }
+    return Qnil;
+}
+
+VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
+    if (duckdb_is_finite_timestamp(timestamp) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp.micros)
+                         );
+    }
+    return Qnil;
+}
+
+VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s) {
+    if (duckdb_is_finite_timestamp_s(timestamp_s) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp_s.seconds)
+                         );
+    }
+    return Qnil;
+}
+
+VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms) {
+    if (duckdb_is_finite_timestamp_ms(timestamp_ms) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp_ms.millis)
+                         );
+    }
+    return Qnil;
+}
+
+VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
+    if (duckdb_is_finite_timestamp_ns(timestamp_ns) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp_ns.nanos)
+                         );
+    }
+    return Qnil;
+}
+
+VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts) {
+    VALUE obj = infinite_timestamp_s_value(ts);
+    if (obj != Qnil) {
+        return obj;
+    }
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_s, 1,
+                      LL2NUM(ts.seconds)
+                      );
+}
+
+VALUE rbduckdb_timestamp_ms_to_ruby(duckdb_timestamp_ms ts) {
+    VALUE obj = infinite_timestamp_ms_value(ts);
+    if (obj != Qnil) {
+        return obj;
+    }
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ms, 1,
+                      LL2NUM(ts.millis)
+                      );
+}
+
+VALUE rbduckdb_timestamp_ns_to_ruby(duckdb_timestamp_ns ts) {
+    VALUE obj = infinite_timestamp_ns_value(ts);
+    if (obj != Qnil) {
+        return obj;
+    }
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ns, 1,
+                      LL2NUM(ts.nanos)
+                      );
+}
+
+VALUE rbduckdb_time_tz_to_ruby(duckdb_time_tz tz) {
+    duckdb_time_tz_struct data = duckdb_from_time_tz(tz);
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_time_tz, 5,
+                      INT2FIX(data.time.hour),
+                      INT2FIX(data.time.min),
+                      INT2FIX(data.time.sec),
+                      INT2NUM(data.time.micros),
+                      INT2NUM(data.offset)
+                      );
+}
+
+VALUE rbduckdb_timestamp_tz_to_ruby(duckdb_timestamp ts) {
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_tz, 1,
+                      LL2NUM(ts.micros)
+                      );
+}
+
+VALUE rbduckdb_time_to_ruby(duckdb_time t) {
+    duckdb_time_struct data = duckdb_from_time(t);
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_time, 4,
+                      INT2FIX(data.hour),
+                      INT2FIX(data.min),
+                      INT2FIX(data.sec),
+                      INT2NUM(data.micros)
+                      );
+}
+
+VALUE rbduckdb_date_to_ruby(duckdb_date date) {
+    VALUE obj = infinite_date_value(date);
+
+    if (obj == Qnil) {
+        duckdb_date_struct date_st = duckdb_from_date(date);
+        obj = rb_funcall(mDuckDBConverter, id__to_date, 3,
+                         INT2FIX(date_st.year),
+                         INT2FIX(date_st.month),
+                         INT2FIX(date_st.day)
+                         );
+    }
+    return obj;
+}
+
+VALUE rbduckdb_timestamp_to_ruby(duckdb_timestamp ts) {
+    VALUE obj = infinite_timestamp_value(ts);
+
+    if (obj == Qnil) {
+        duckdb_timestamp_struct data_st = duckdb_from_timestamp(ts);
+        obj = rb_funcall(mDuckDBConverter, id__to_time, 7,
+                         INT2FIX(data_st.date.year),
+                         INT2FIX(data_st.date.month),
+                         INT2FIX(data_st.date.day),
+                         INT2FIX(data_st.time.hour),
+                         INT2FIX(data_st.time.min),
+                         INT2FIX(data_st.time.sec),
+                         INT2NUM(data_st.time.micros)
+                         );
+    }
+    return obj;
+}
+
 void rbduckdb_init_duckdb_converter(void) {
     mDuckDBConverter = rb_define_module_under(mDuckDB, "Converter");
+
+    id__to_date = rb_intern("_to_date");
+    id__to_time = rb_intern("_to_time");
+    id__to_time_from_duckdb_time = rb_intern("_to_time_from_duckdb_time");
+    id__to_interval_from_vector = rb_intern("_to_interval_from_vector");
+    id__to_hugeint_from_vector = rb_intern("_to_hugeint_from_vector");
+    id__to_decimal_from_hugeint = rb_intern("_to_decimal_from_hugeint");
+    id__to_uuid_from_vector = rb_intern("_to_uuid_from_vector");
+    id__to_time_from_duckdb_timestamp_s = rb_intern("_to_time_from_duckdb_timestamp_s");
+    id__to_time_from_duckdb_timestamp_ms = rb_intern("_to_time_from_duckdb_timestamp_ms");
+    id__to_time_from_duckdb_timestamp_ns = rb_intern("_to_time_from_duckdb_timestamp_ns");
+    id__to_time_from_duckdb_time_tz = rb_intern("_to_time_from_duckdb_time_tz");
+    id__to_time_from_duckdb_timestamp_tz = rb_intern("_to_time_from_duckdb_timestamp_tz");
+    id__to_infinity = rb_intern("_to_infinity");
 }

data/ext/duckdb/duckdb.c

@@ -57,11 +57,14 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_instance_cache();
     rbduckdb_init_duckdb_value_impl();
     rbduckdb_init_duckdb_scalar_function();
-    rbduckdb_init_duckdb_bind_info();
-    rbduckdb_init_duckdb_init_info();
-    rbduckdb_init_duckdb_function_info();
+    rbduckdb_init_duckdb_expression();
+    rbduckdb_init_duckdb_client_context();
+    rbduckdb_init_duckdb_scalar_function_bind_info();
     rbduckdb_init_duckdb_vector();
     rbduckdb_init_duckdb_data_chunk();
     rbduckdb_init_memory_helper();
     rbduckdb_init_duckdb_table_function();
+    rbduckdb_init_duckdb_table_function_bind_info();
+    rbduckdb_init_duckdb_table_function_init_info();
+    rbduckdb_init_duckdb_table_function_function_info();
 }