duckdb 1.5.5.0 → 1.5.6.0

data/ext/duckdb/table_description.c

@@ -19,7 +19,7 @@ static VALUE table_description__column_has_default(VALUE self, VALUE idx);
 static const rb_data_type_t table_description_data_type = {
     "DuckDB/TableDescription",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/table_function.c

@@ -30,14 +30,14 @@ static void table_function_local_init_callback(duckdb_init_info info);
 static const rb_data_type_t table_function_data_type = {
     "DuckDB/TableFunction",
     {mark, deallocate, memsize, compact},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void mark(void *ctx) {
     rubyDuckDBTableFunction *p = (rubyDuckDBTableFunction *)ctx;
-    rb_gc_mark(p->bind_proc);
-    rb_gc_mark(p->init_proc);
-    rb_gc_mark(p->execute_proc);
+    rb_gc_mark_movable(p->bind_proc);
+    rb_gc_mark_movable(p->init_proc);
+    rb_gc_mark_movable(p->execute_proc);
 }
 
 static void deallocate(void *ctx) {
@@ -210,7 +210,7 @@ static VALUE table_function_bind(VALUE self) {
         rb_raise(eDuckDBError, "Table function is destroyed");
     }
 
-    ctx->bind_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &ctx->bind_proc, rb_block_proc());
 
     duckdb_table_function_set_bind(ctx->table_function, table_function_bind_callback);
 
@@ -243,10 +243,9 @@ static void execute_bind_callback_protected(void *user_data) {
     rb_protect(call_bind_proc, (VALUE)call_args, &state);
 
     if (state) {
-        VALUE err = rb_errinfo();
-        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        VALUE msg = rbduckdb_pending_error_message();
         duckdb_bind_set_error(darg->info, StringValueCStr(msg));
-        rb_set_errinfo(Qnil);
+        RB_GC_GUARD(msg);
     }
 }
 
@@ -287,7 +286,7 @@ static VALUE table_function_init(VALUE self) {
         rb_raise(eDuckDBError, "Table function is destroyed");
     }
 
-    ctx->init_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &ctx->init_proc, rb_block_proc());
     duckdb_table_function_set_init(ctx->table_function, table_function_init_callback);
 
     rbduckdb_function_executor_ensure_started();
@@ -319,10 +318,9 @@ static void execute_init_callback_protected(void *user_data) {
     rb_protect(call_init_proc, (VALUE)call_args, &state);
 
     if (state) {
-        VALUE err = rb_errinfo();
-        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        VALUE msg = rbduckdb_pending_error_message();
         duckdb_init_set_error(darg->info, StringValueCStr(msg));
-        rb_set_errinfo(Qnil);
+        RB_GC_GUARD(msg);
     }
 }
 
@@ -361,7 +359,7 @@ static VALUE table_function_execute(VALUE self) {
 
     TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
 
-    ctx->execute_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &ctx->execute_proc, rb_block_proc());
     duckdb_table_function_set_function(ctx->table_function, table_function_execute_callback);
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
     /* Per-worker proxy threads for the execute path (DuckDB >= 1.5.0). */
@@ -404,10 +402,9 @@ static void execute_execute_callback_protected(void *user_data) {
     rb_protect(call_execute_proc, (VALUE)call_args, &state);
 
     if (state) {
-        VALUE err = rb_errinfo();
-        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        VALUE msg = rbduckdb_pending_error_message();
         duckdb_function_set_error(darg->info, StringValueCStr(msg));
-        rb_set_errinfo(Qnil);
+        RB_GC_GUARD(msg);
     }
 }
 
@@ -452,11 +449,9 @@ static VALUE create_proxy_callback(VALUE varg) {
 }
 
 /*
- * rbduckdb_worker_proxy_create may raise (NoMemError, Thread.new failure),
- * and the executor runs callbacks unprotected — a raise would longjmp past
- * its done-signaling and block the waiting DuckDB worker forever. Swallow
- * the exception instead: the proxy stays NULL, local_init sets no state, and
- * the execute callback falls back to the global executor.
+ * rbduckdb_worker_proxy_create may raise (NoMemError, Thread.new failure).
+ * Swallow it: the proxy stays NULL, local_init sets no state, and the execute
+ * callback falls back to the global executor.
  */
 static void create_proxy_callback_protected(void *user_data) {
     int exception_state;

data/ext/duckdb/table_function_bind_info.c

@@ -10,12 +10,13 @@ static VALUE table_function_bind_info_get_parameter(VALUE self, VALUE index);
 static VALUE table_function_bind_info_get_named_parameter(VALUE self, VALUE name);
 static VALUE table_function_bind_info__add_result_column(VALUE self, VALUE column_name, VALUE logical_type);
 static VALUE table_function_bind_info_set_cardinality(VALUE self, VALUE cardinality, VALUE is_exact);
+static VALUE table_function_bind_info_set_bind_data(VALUE self, VALUE data);
 static VALUE table_function_bind_info_set_error(VALUE self, VALUE error);
 
 static const rb_data_type_t bind_info_data_type = {
     "DuckDB/TableFunctionBindInfo",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {
@@ -167,6 +168,32 @@ static VALUE table_function_bind_info_set_cardinality(VALUE self, VALUE cardinal
     return self;
 }
 
+/*
+ * call-seq:
+ *   bind_info.bind_data = data
+ *
+ * Stores an arbitrary Ruby object as the table function's bind data. The same
+ * object can be retrieved during init and execution, and is kept alive until
+ * DuckDB frees the bind data.
+ *
+ *   bind_info.bind_data = { rows: 100 }
+ */
+static VALUE table_function_bind_info_set_bind_data(VALUE self, VALUE data) {
+    rubyDuckDBBindInfo *ctx;
+    void *handle;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    if (ctx->bind_data_handle != NULL) {
+        rbduckdb_function_data_release(ctx->bind_data_handle);
+    }
+    handle = rbduckdb_function_data_register(data);
+    ctx->bind_data_handle = handle;
+    duckdb_bind_set_bind_data(ctx->bind_info, handle, rbduckdb_function_data_destroy);
+
+    return self;
+}
+
 /*
  * call-seq:
  *   bind_info.set_error(error_message) -> self
@@ -198,6 +225,7 @@ void rbduckdb_init_table_function_bind_info(void) {
     rb_define_method(cDuckDBTableFunctionBindInfo, "get_parameter", table_function_bind_info_get_parameter, 1);
     rb_define_method(cDuckDBTableFunctionBindInfo, "get_named_parameter", table_function_bind_info_get_named_parameter, 1);
     rb_define_method(cDuckDBTableFunctionBindInfo, "set_cardinality", table_function_bind_info_set_cardinality, 2);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "bind_data=", table_function_bind_info_set_bind_data, 1);
     rb_define_method(cDuckDBTableFunctionBindInfo, "set_error", table_function_bind_info_set_error, 1);
 
     rb_define_private_method(cDuckDBTableFunctionBindInfo, "_add_result_column", table_function_bind_info__add_result_column, 2);

data/ext/duckdb/table_function_bind_info.h

@@ -3,6 +3,7 @@
 
 struct _rubyDuckDBBindInfo {
     duckdb_bind_info bind_info;
+    void *bind_data_handle;
 };
 
 typedef struct _rubyDuckDBBindInfo rubyDuckDBBindInfo;

data/ext/duckdb/table_function_function_info.c

@@ -5,12 +5,13 @@ VALUE cDuckDBTableFunctionFunctionInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
+static VALUE table_function_function_info_bind_data(VALUE self);
 static VALUE table_function_function_info_set_error(VALUE self, VALUE error);
 
 static const rb_data_type_t function_info_data_type = {
     "DuckDB/TableFunctionFunctionInfo",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {
@@ -33,6 +34,26 @@ rubyDuckDBFunctionInfo *rbduckdb_get_struct_function_info(VALUE obj) {
     return ctx;
 }
 
+/*
+ * call-seq:
+ *   function_info.bind_data -> object or nil
+ *
+ * Returns the object stored during the bind phase with
+ * DuckDB::TableFunction::BindInfo#bind_data=, or nil if none was set.
+ *
+ *   data = function_info.bind_data
+ */
+static VALUE table_function_function_info_bind_data(VALUE self) {
+    rubyDuckDBFunctionInfo *ctx;
+    void *bind_data;
+
+    TypedData_Get_Struct(self, rubyDuckDBFunctionInfo, &function_info_data_type, ctx);
+
+    bind_data = duckdb_function_get_bind_data(ctx->info);
+
+    return rbduckdb_function_data_lookup(bind_data);
+}
+
 /*
  * call-seq:
  *   function_info.set_error(error_message) -> self
@@ -61,5 +82,6 @@ void rbduckdb_init_table_function_function_info(void) {
     cDuckDBTableFunctionFunctionInfo = rb_define_class_under(cDuckDBTableFunction, "FunctionInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunctionFunctionInfo, allocate);
 
+    rb_define_method(cDuckDBTableFunctionFunctionInfo, "bind_data", table_function_function_info_bind_data, 0);
     rb_define_method(cDuckDBTableFunctionFunctionInfo, "set_error", table_function_function_info_set_error, 1);
 }

data/ext/duckdb/table_function_init_info.c

@@ -9,11 +9,12 @@ static VALUE table_function_init_info_set_error(VALUE self, VALUE error);
 static VALUE table_function_init_info_set_max_threads(VALUE self, VALUE max_threads);
 static VALUE table_function_init_info_column_count(VALUE self);
 static VALUE table_function_init_info_column_index(VALUE self, VALUE index);
+static VALUE table_function_init_info_bind_data(VALUE self);
 
 static const rb_data_type_t init_info_data_type = {
     "DuckDB/TableFunctionInitInfo",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {
@@ -115,6 +116,23 @@ static VALUE table_function_init_info_column_index(VALUE self, VALUE index) {
     return ULL2NUM(duckdb_init_get_column_index(ctx->info, NUM2ULL(index)));
 }
 
+/*
+ * call-seq:
+ *   init_info.bind_data -> object or nil
+ *
+ * Returns the object stored during the bind phase with
+ * DuckDB::TableFunction::BindInfo#bind_data=, or nil if none was set.
+ *
+ *   data = init_info.bind_data
+ */
+static VALUE table_function_init_info_bind_data(VALUE self) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    return rbduckdb_function_data_lookup(duckdb_init_get_bind_data(ctx->info));
+}
+
 void rbduckdb_init_table_function_init_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
@@ -127,4 +145,5 @@ void rbduckdb_init_table_function_init_info(void) {
     rb_define_method(cDuckDBTableFunctionInitInfo, "max_threads=", table_function_init_info_set_max_threads, 1);
     rb_define_method(cDuckDBTableFunctionInitInfo, "column_count", table_function_init_info_column_count, 0);
     rb_define_method(cDuckDBTableFunctionInitInfo, "column_index", table_function_init_info_column_index, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "bind_data", table_function_init_info_bind_data, 0);
 }

data/ext/duckdb/value.c

@@ -53,7 +53,7 @@ static VALUE value_to_ruby(VALUE self);
 static const rb_data_type_t value_data_type = {
     "DuckDB/Value",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void * ctx) {
@@ -332,7 +332,7 @@ static idx_t marshal_values(VALUE ary, duckdb_value **out, volatile VALUE *guard
     idx_t i;
 
     for (i = 0; i < n; i++) {
-        buf[i] = rbduckdb_get_struct_value(RARRAY_AREF(ary, i))->value;
+        buf[i] = rbduckdb_get_struct_value(rb_ary_entry(ary, (long)i))->value;
     }
     *out = buf;
     return n;

data/ext/duckdb/vector.c

@@ -15,7 +15,7 @@ static VALUE vector_set_validity(VALUE self, VALUE index, VALUE valid);
 static const rb_data_type_t vector_data_type = {
     "DuckDB/Vector",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/lib/duckdb/appender.rb

@@ -759,7 +759,7 @@ module DuckDB
     #   appender.append(1)
     #   appender.append('Alice')
     #   appender.end_row
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength
     def append(value)
       case value
       when NilClass
@@ -782,7 +782,6 @@ module DuckDB
         raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
       end
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     # append a row.
     #

data/lib/duckdb/converter/int_to_sym.rb

@@ -32,6 +32,9 @@ module DuckDB
         attach
         detach
         multi
+        copy_database
+        update_extensions
+        merge_into
       ].freeze
 
       HASH_TYPES = {

data/lib/duckdb/converter.rb

@@ -44,14 +44,13 @@ module DuckDB
       Date.new(year, month, day)
     end
 
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     def _to_time(year, month, day, hour, minute, second, microsecond)
       Time.public_send(
         default_timezone_utc? ? :utc : :local,
         year, month, day, hour, minute, second, microsecond
       )
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def _to_time_from_duckdb_time(hour, minute, second, microsecond)
       return Time.utc(1970, 1, 1, hour, minute, second, microsecond) if default_timezone_utc?

data/lib/duckdb/data_chunk.rb

@@ -44,7 +44,7 @@ module DuckDB
     # @example Set NULL value
     #   output.set_value(0, 1, nil)
     #
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
     def set_value(col_idx, row_idx, value)
       vector = cached_vector(col_idx)
       type_id = cached_type_id(col_idx, vector)
@@ -94,7 +94,6 @@ module DuckDB
 
       value
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     #
     # Resets the data chunk so it can be reused for another batch of rows.

data/lib/duckdb/prepared_statement.rb

@@ -379,7 +379,7 @@ module DuckDB
 
     private
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength
     def bind_with_index(index, value)
       case value
       when NilClass
@@ -402,7 +402,6 @@ module DuckDB
         raise(DuckDB::Error, "not supported type `#{value}` (#{value.class})")
       end
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     def bind_integer_value(index, value)
       if RANGE_INT64.cover?(value)

data/lib/duckdb/table_function/function_info.rb

@@ -14,10 +14,9 @@ module DuckDB
     #     func_info.set_error('Something went wrong')
     #   end
     #
-    # rubocop:disable Lint/EmptyClass
+    # rubocop:disable-next Lint/EmptyClass
     class FunctionInfo
       # All methods are defined in C extension (ext/duckdb/table_function_function_info.c)
     end
-    # rubocop:enable Lint/EmptyClass
   end
 end

data/lib/duckdb/table_function/init_info.rb

@@ -15,10 +15,9 @@ module DuckDB
     #     init_info.set_error('Initialization failed')
     #   end
     #
-    # rubocop:disable Lint/EmptyClass
+    # rubocop:disable-next Lint/EmptyClass
     class InitInfo
       # All methods are defined in C extension (ext/duckdb/table_function_init_info.c)
     end
-    # rubocop:enable Lint/EmptyClass
   end
 end

data/lib/duckdb/table_function.rb

@@ -75,7 +75,7 @@ module DuckDB
       #     3  # Return row count
       #   end
       #
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def create(name:, columns:, parameters: nil, &)
         raise ArgumentError, 'name is required' unless name
         raise ArgumentError, 'columns are required' unless columns
@@ -116,7 +116,6 @@ module DuckDB
 
         tf
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # Registers a table adapter for a Ruby class.
       #

data/lib/duckdb/vector.rb

@@ -12,9 +12,8 @@ module DuckDB
   #   vector.assign_string_element(0, 'hello')
   #   vector.assign_string_element(1, 'world')
   #
-  # rubocop:disable Lint/EmptyClass
+  # rubocop:disable-next Lint/EmptyClass
   class Vector
     # All methods are defined in C extension (ext/duckdb/vector.c)
   end
-  # rubocop:enable Lint/EmptyClass
 end

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.5.5.0'
+  VERSION = '1.5.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.5.5.0
+  version: 1.5.6.0
 platform: ruby
 authors:
 - Masaki Suketa
@@ -176,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby bindings for the DuckDB database engine.
 test_files: []