duckdb 1.5.4.0 → 1.5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9c37c59f2e64ac10b72765250ec674ef40e82d83a7499a6c9e1117ee8e9e9d0
-  data.tar.gz: e9510873a0de444b35bb7c3de2d26f8d9a9ebcd01466a95383fa16d38d277e97
+  metadata.gz: 534e22d8df0424b7551b9ca68678d4da9f2e7a8055272dabe7c31d9f63c7b5b4
+  data.tar.gz: 5a1a9289dd5b20de755dd2c5c17242a353fe695ff27e47e5c862bc62004d1875
 SHA512:
-  metadata.gz: 2ab204dc5d6034b846d3267ca78fd4d47f75f000e3d6c97e5673ca9791618c84e7130230cd1ad7634858ff25fd5cc5952bac500263ef228225767a730684749c
-  data.tar.gz: f55e20a3dc6a97aea0606dca4b047746da44941c4f84145a48c45248d150fd58ef800ca617adc7921ae6418ac0f8275bf29e24405f3cdbf2e917377029b8641f
+  metadata.gz: 5afc359f5b6f5c972a34f0662e0f94360d91a12fd6a3db3e116f54eea486436c2855e0ee8f1949d8aff42c7b171e2efbeded84989b5bf335b57c7b9e7d5ee497
+  data.tar.gz: 7f5d628c60766814253cf9971b90f3fc1911d63d376cbce414dcff92f8e550dbccc676832435349b925c26449aa18d2dff394bd0e33d300ee1e57cc8ff8f5f5f

data/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.5.0 - 2026-07-27
+
+- bump up DuckDB 1.5.5 on CI.
+- support TIME_NS columns in `DuckDB::ScalarFunction` and `DuckDB::AggregateFunction`: TIME_NS can now be used as parameter and return type (with `DuckDB::LogicalType::TIME_NS`). Requires DuckDB >= 1.5.0 for full TIME_NS support in the C API.
+- bump Ruby to 3.4.10 on CI.
+- add `DuckDB::Connection#table_names(sql, qualified: false)` returning the table names referenced by a SQL query without executing it (binds `duckdb_get_table_names`). With `qualified: true`, names are returned as written in the query (including schema/catalog prefixes and aliases). Result order is unspecified.
+- add `DuckDB::Value.create_list(child_type, values)` and `DuckDB::Value.create_array(child_type, values)` to create LIST/ARRAY values from an element type (a Symbol like `:integer` or a `DuckDB::LogicalType`) and an Array of `DuckDB::Value` elements. The created values can be bound to prepared statements with `#bind_value`.
+- add `DuckDB::Value#list_size` and `DuckDB::Value#list_child(index)` to read LIST value elements as `DuckDB::Value`.
+- add `DuckDB::Value#to_ruby` converting a `DuckDB::Value` to a Ruby object. LIST/ARRAY values are converted to Ruby Arrays recursively; NULL becomes `nil`.
+- add `DuckDB::Value.create_struct(struct_type, values)` to create STRUCT values from a field spec (a Hash like `{ a: :integer, b: :varchar }` or a STRUCT `DuckDB::LogicalType`) and an Array of `DuckDB::Value` field values (positional, matching field order).
+- add `DuckDB::Value#struct_child(index)` to read STRUCT fields as `DuckDB::Value`. `DuckDB::Value#to_ruby` converts STRUCT values to a Hash with Symbol keys recursively.
+- add `DuckDB::Value.create_map(map_type, entries)` to create MAP values from a type spec (a one-pair Hash like `{ varchar: :integer }` or a MAP `DuckDB::LogicalType`) and a Hash of `DuckDB::Value` keys to `DuckDB::Value` values.
+- add `DuckDB::Value#map_size`, `#map_key(index)` and `#map_value(index)` to read MAP entries as `DuckDB::Value`. `DuckDB::Value#to_ruby` converts MAP values to a Hash recursively (keys keep their natural Ruby type).
+- add `DuckDB::PreparedStatement#column_count`, `#column_name(col_index)`, `#column_type(col_index)` and `#column_logical_type(col_index)` to get the result-set column metadata of a prepared statement without executing it (column index is 0-based). Useful for PG-style statement caching where column types must be known before execution.
+- add `DuckDB::Error#error_type` returning the DuckDB error category as a Symbol (e.g. `:constraint`, `:catalog`, `:parser`), or `nil` for errors not originating from a query result. Helps the ActiveRecord adapter map failures to `RecordNotUnique` / `NotNullViolation` etc. without parsing error messages.
+- add `DuckDB::PreparedStatement#param_logical_type(param_index)` returning the `DuckDB::LogicalType` of a bind parameter (1-based index), giving richer type information than `#param_type` (e.g. decimal width/scale, nested types).
+- add `DuckDB::Value.create_date(value)` to create DATE values from a Date, a Time, or a parseable String (same lenient input as `Appender#append_date`).
+- add `DuckDB::Value.create_time(value)` to create TIME values (microsecond precision) from a Time or a parseable String.
+- add `DuckDB::Value.create_time_ns(value)` to create TIME_NS values (nanosecond precision) from a Time or a parseable String. TIME_NS values are now converted to Ruby Time with full nanosecond precision (previously truncated to microseconds).
+- add `DuckDB::Value.create_time_tz(value)` to create TIMETZ values from a Time (the UTC offset is taken from the Time) or a parseable String with offset.
+- add `DuckDB::Value.create_timestamp(value)` to create TIMESTAMP values (microsecond precision) from a Time, a Date, or a parseable String (same lenient input as `Appender#append_timestamp`).
+- add `DuckDB::Value.create_timestamp_s(value)` to create TIMESTAMP_S values (second precision; sub-second input is truncated).
+- add `DuckDB::Value.create_timestamp_ms(value)` to create TIMESTAMP_MS values (millisecond precision).
+- add `DuckDB::Value.create_timestamp_ns(value)` to create TIMESTAMP_NS values (nanosecond precision). TIMESTAMP_NS values (including query results) are now converted to Ruby Time with full nanosecond precision (previously truncated to microseconds).
+- add `DuckDB::Value.create_timestamp_tz(value)` to create TIMESTAMP WITH TIME ZONE values; the instant is stored correctly regardless of the input UTC offset.
+- add `DuckDB::Value.create_interval(value)` to create INTERVAL values from a `DuckDB::Interval`.
+- add `DuckDB::Value.create_enum(enum_type, member)` to create ENUM values from an Array of member names (or an ENUM `DuckDB::LogicalType`) and a member name or 0-based index.
+- `DuckDB::Value#to_ruby` converts ENUM values to the member String.
+- add `DuckDB::Value.create_union(union_type, tag, value)` to create UNION values from a member spec Hash like `{ num: :integer, str: :varchar }` (or a UNION `DuckDB::LogicalType`), a member tag, and a `DuckDB::Value`. `DuckDB::Value#to_ruby` converts UNION values to the member value.
+- add `DuckDB::Value.create_bit(value)` to create BIT values from a String of '0'/'1' characters.
+- `DuckDB::Value#to_ruby` converts BIT values to a String of '0'/'1' characters.
+- add `DuckDB::Value.create_bignum(value)` to create BIGNUM (arbitrary-precision integer) values from a Ruby Integer.
+- `DuckDB::Value#to_ruby` converts BIGNUM values to a Ruby Integer.
+- `DuckDB::Value#to_ruby` converts BLOB values to a BINARY-encoded String.
+- `DuckDB::Value#to_ruby` converts DECIMAL values to a BigDecimal.
+
 # 1.5.4.0 - 2026-06-20
 - bump up DuckDB 1.5.4 and 1.4.5 on CI.
 - add experimental `DuckDB::Result#arrow_c_stream` returning `DuckDB::ArrowArrayStream` to export a query result as an Arrow C stream (Arrow C Data Interface). The stream can be consumed directly by ruby-polars (`Polars::DataFrame.new(result)`) and red-arrow (`Arrow::RecordBatchReader.import(stream.to_i)`).

data/CLAUDE.md

@@ -0,0 +1,4 @@
+## Orchestration workflow
+You (Fable) are the orchestrator. Plan, decompose, synthesize.
+Reasoning-heavy phases → deep-reasoner
+Mechanical work → fast-worker

data/duckdb.gemspec

@@ -32,6 +32,6 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ['lib']
   spec.extensions = ['ext/duckdb/extconf.rb']
-  spec.required_ruby_version = '>= 3.2.0'
+  spec.required_ruby_version = '>= 3.3.0'
   spec.add_dependency 'bigdecimal', '>= 3.1.4'
 end

data/ext/duckdb/connection.c

@@ -17,6 +17,7 @@ static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_f
 static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate_function);
 static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set);
 static VALUE connection__register_table_function(VALUE self, VALUE table_function);
+static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualified);
 
 static const rb_data_type_t connection_data_type = {
     "DuckDB/Connection",
@@ -198,11 +199,31 @@ static VALUE connection__query_sql(VALUE self, VALUE str) {
     RB_GC_GUARD(str);
 
     if (args.retval == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
+        rbduckdb_raise_result_error(&(ctxr->result));
     }
     return result;
 }
 
+/* :nodoc: */
+static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualified) {
+    rubyDuckDBConnection *ctx;
+    duckdb_value table_names;
+
+    ctx = rbduckdb_get_struct_connection(self);
+
+    if (!(ctx->con)) {
+        rb_raise(eDuckDBError, "Database connection closed");
+    }
+
+    table_names = duckdb_get_table_names(ctx->con, StringValueCStr(query), RTEST(qualified));
+
+    if (!table_names) {
+        rb_raise(eDuckDBError, "Failed to get table names from query");
+    }
+
+    return rbduckdb_value_new(table_names);
+}
+
 /* :nodoc: */
 static VALUE connection__register_logical_type(VALUE self, VALUE logical_type) {
     rubyDuckDBConnection *ctxcon;
@@ -346,4 +367,5 @@ void rbduckdb_init_connection(void) {
     rb_define_private_method(cDuckDBConnection, "_register_table_function", connection__register_table_function, 1);
     rb_define_private_method(cDuckDBConnection, "_connect", connection__connect, 1);
     rb_define_private_method(cDuckDBConnection, "_query_sql", connection__query_sql, 1);
+    rb_define_private_method(cDuckDBConnection, "_get_table_names", connection__get_table_names, 2);
 }

data/ext/duckdb/error.c

@@ -2,6 +2,18 @@
 
 VALUE eDuckDBError;
 
+/* Raises DuckDB::Error from a failed result. C only reads the message and error
+ * type id off the result (the result is destroyed before Ruby sees it) and passes
+ * them to DuckDB::Error.new(message, error_type_id). */
+void rbduckdb_raise_result_error(duckdb_result *result) {
+    const char *msg = duckdb_result_error(result);
+    if (!msg) {
+        msg = "DuckDB error";
+    }
+    VALUE exc = rb_funcall(eDuckDBError, rb_intern("new"), 2, rb_str_new_cstr(msg), INT2FIX(duckdb_result_error_type(result)));
+    rb_exc_raise(exc);
+}
+
 void rbduckdb_init_error(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");

data/ext/duckdb/error.h

@@ -2,5 +2,6 @@
 #define RUBY_DUCKDB_ERROR_H
 
 void rbduckdb_init_error(void);
+NORETURN(void rbduckdb_raise_result_error(duckdb_result *result));
 
 #endif

data/ext/duckdb/function_vector.c

@@ -137,6 +137,20 @@ void rbduckdb_vector_set_value_at(duckdb_vector vector, duckdb_logical_type elem
             ((duckdb_time *)vector_data)[index] = time;
             break;
         }
+        case DUCKDB_TYPE_TIME_NS: {
+            if (!rb_obj_is_kind_of(value, rb_cTime)) {
+                rb_raise(rb_eTypeError, "Expected Time object for TIME_NS");
+            }
+
+            VALUE hour = rb_funcall(value, rb_intern("hour"), 0);
+            VALUE min = rb_funcall(value, rb_intern("min"), 0);
+            VALUE sec = rb_funcall(value, rb_intern("sec"), 0);
+            VALUE nsec = rb_funcall(value, rb_intern("nsec"), 0);
+
+            duckdb_time_ns time_ns = rbduckdb_to_duckdb_time_ns_from_value(hour, min, sec, nsec);
+            ((duckdb_time_ns *)vector_data)[index] = time_ns;
+            break;
+        }
         case DUCKDB_TYPE_TIME_TZ: {
             if (!rb_obj_is_kind_of(value, rb_cTime)) {
                 rb_raise(rb_eTypeError, "Expected Time object for TIME_TZ");

data/ext/duckdb/prepared_statement.c

@@ -14,6 +14,7 @@ static idx_t check_index(VALUE vidx);
 
 static VALUE prepared_statement_bind_parameter_index(VALUE self, VALUE name);
 static VALUE prepared_statement_parameter_name(VALUE self, VALUE vidx);
+static VALUE prepared_statement_param_logical_type(VALUE self, VALUE vidx);
 static VALUE prepared_statement_clear_bindings(VALUE self);
 static VALUE prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
@@ -27,6 +28,10 @@ static VALUE prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob);
 static VALUE prepared_statement_bind_null(VALUE self, VALUE vidx);
 static VALUE prepared_statement__statement_type(VALUE self);
 static VALUE prepared_statement__param_type(VALUE self, VALUE vidx);
+static VALUE prepared_statement_column_count(VALUE self);
+static VALUE prepared_statement_column_name(VALUE self, VALUE vidx);
+static VALUE prepared_statement__column_type(VALUE self, VALUE vidx);
+static VALUE prepared_statement_column_logical_type(VALUE self, VALUE vidx);
 static VALUE prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val);
@@ -129,7 +134,6 @@ static VALUE prepared_statement_execute(VALUE self) {
     rubyDuckDBResult *ctxr;
     const char *error;
     VALUE result = rbduckdb_create_result();
-    VALUE msg;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = rbduckdb_get_struct_result(result);
@@ -146,11 +150,10 @@ static VALUE prepared_statement_execute(VALUE self) {
     if (state == DuckDBError) {
         error = duckdb_prepare_error(args.prepared_statement);
         if (error == NULL) {
-            error = duckdb_result_error(args.out_result);
+            /* error originates from the result, which carries an error type */
+            rbduckdb_raise_result_error(args.out_result);
         }
-        msg = rb_str_new2(error ? error : "Failed to execute prepared statement.");
-
-        rb_raise(eDuckDBError, "%s", StringValuePtr(msg));
+        rb_raise(eDuckDBError, "%s", error);
     }
 
     return result;
@@ -206,6 +209,28 @@ static VALUE prepared_statement_parameter_name(VALUE self, VALUE vidx) {
     return vname;
 }
 
+/*
+ *  call-seq:
+ *    prepared_statement.param_logical_type(param_index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the parameter at the given (1-based) index.
+ *  This provides richer type information than #param_type, e.g. decimal
+ *  width/scale, nested types.
+ */
+static VALUE prepared_statement_param_logical_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_logical_type logical_type;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    logical_type = duckdb_param_logical_type(ctx->prepared_statement, idx);
+    if (logical_type == NULL) {
+        rb_raise(eDuckDBError, "fail to get logical type of the parameter at %llu. parameter index is out of range.", (unsigned long long)idx);
+    }
+    return rbduckdb_create_logical_type(logical_type);
+}
+
 /*
  *  call-seq:
  *    prepared_statement.clear_bindings -> DuckDB::PreparedStatement
@@ -360,6 +385,91 @@ static VALUE prepared_statement__statement_type(VALUE self) {
     return INT2FIX(duckdb_prepared_statement_type(ctx->prepared_statement));
 }
 
+/*
+ *  call-seq:
+ *    prepared_statement.column_count -> Integer
+ *
+ *  Returns the number of columns in the result set of the prepared statement
+ *  without executing it.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1 AS a, 2 AS b')
+ *    stmt.column_count # => 2
+ */
+static VALUE prepared_statement_column_count(VALUE self) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return ULL2NUM(duckdb_prepared_statement_column_count(ctx->prepared_statement));
+}
+
+/*
+ *  call-seq:
+ *    prepared_statement.column_name(col_index) -> String
+ *
+ *  Returns the name of the column at the specified index (0-based) of the
+ *  result set of the prepared statement without executing it.
+ *  Raises DuckDB::Error if the column index is out of range.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1 AS a, 2 AS b')
+ *    stmt.column_name(1) # => 'b'
+ */
+static VALUE prepared_statement_column_name(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    VALUE vname;
+    const char *name;
+    idx_t idx = NUM2ULL(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    name = duckdb_prepared_statement_column_name(ctx->prepared_statement, idx);
+    if (name == NULL) {
+        rb_raise(eDuckDBError, "fail to get column name at %llu. column index is out of range.", (unsigned long long)idx);
+    }
+    vname = rb_str_new2(name);
+    duckdb_free((void *)name);
+    return vname;
+}
+
+/* :nodoc: */
+static VALUE prepared_statement__column_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return INT2FIX(duckdb_prepared_statement_column_type(ctx->prepared_statement, NUM2ULL(vidx)));
+}
+
+/*
+ *  call-seq:
+ *    prepared_statement.column_logical_type(col_index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the column at the specified index (0-based) of
+ *  the result set of the prepared statement without executing it.
+ *  Raises DuckDB::Error if the column index is out of range.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1.5::DECIMAL(9, 4) AS a')
+ *    stmt.column_logical_type(0).type # => :decimal
+ */
+static VALUE prepared_statement_column_logical_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_logical_type logical_type;
+    idx_t idx = NUM2ULL(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    logical_type = duckdb_prepared_statement_column_logical_type(ctx->prepared_statement, idx);
+    if (logical_type == NULL) {
+        rb_raise(eDuckDBError, "fail to get column logical type at %llu. column index is out of range.", (unsigned long long)idx);
+    }
+    return rbduckdb_create_logical_type(logical_type);
+}
+
 /* :nodoc: */
 static VALUE prepared_statement__param_type(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
@@ -613,7 +723,11 @@ void rbduckdb_init_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "nparams", prepared_statement_nparams, 0);
     rb_define_method(cDuckDBPreparedStatement, "bind_parameter_index", prepared_statement_bind_parameter_index, 1);
     rb_define_method(cDuckDBPreparedStatement, "parameter_name", prepared_statement_parameter_name, 1);
+    rb_define_method(cDuckDBPreparedStatement, "param_logical_type", prepared_statement_param_logical_type, 1);
     rb_define_method(cDuckDBPreparedStatement, "clear_bindings", prepared_statement_clear_bindings, 0);
+    rb_define_method(cDuckDBPreparedStatement, "column_count", prepared_statement_column_count, 0);
+    rb_define_method(cDuckDBPreparedStatement, "column_name", prepared_statement_column_name, 1);
+    rb_define_method(cDuckDBPreparedStatement, "column_logical_type", prepared_statement_column_logical_type, 1);
     rb_define_method(cDuckDBPreparedStatement, "bind_bool", prepared_statement_bind_bool, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int8", prepared_statement_bind_int8, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int16", prepared_statement_bind_int16, 2);
@@ -630,6 +744,7 @@ void rbduckdb_init_prepared_statement(void) {
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint64", prepared_statement__bind_uint64, 2);
     rb_define_private_method(cDuckDBPreparedStatement, "_statement_type", prepared_statement__statement_type, 0);
     rb_define_private_method(cDuckDBPreparedStatement, "_param_type", prepared_statement__param_type, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_column_type", prepared_statement__column_type, 1);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", prepared_statement__bind_date, 4);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_time", prepared_statement__bind_time, 5);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", prepared_statement__bind_timestamp, 8);

data/ext/duckdb/util.c

@@ -21,6 +21,14 @@ duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec,
     return duckdb_to_time(time_st);
 }
 
+duckdb_time_ns rbduckdb_to_duckdb_time_ns_from_value(VALUE hour, VALUE min, VALUE sec, VALUE nanos) {
+    duckdb_time_ns time_ns;
+
+    time_ns.nanos = ((NUM2LL(hour) * 60 + NUM2LL(min)) * 60 + NUM2LL(sec)) * 1000000000LL + NUM2LL(nanos);
+
+    return time_ns;
+}
+
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj) {
     if (!rb_obj_is_kind_of(time_obj, rb_cTime)) {
         rb_raise(rb_eTypeError, "Expected Time object");

data/ext/duckdb/util.h

@@ -3,6 +3,7 @@
 
 duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
 duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_time_ns rbduckdb_to_duckdb_time_ns_from_value(VALUE hour, VALUE min, VALUE sec, VALUE nanos);
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj);
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);