duckdb 1.5.5.1 → 1.5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caab56325522ea94df9e9cdc12c54b20f2335c2a8d93df0d1fce965643e78cf0
-  data.tar.gz: a572bfa7d8f4ff0dfac85c34ace463b272446e1de7f3fad6bd790de055f25787
+  metadata.gz: cd491bbe1e80d7e2f20455e768b0331c91cbd015e570ccc023497c74217f86a0
+  data.tar.gz: b3c9d5bd5b38a7f72fa7d8c00be7bd20d61505c234efc702cd365b040dcce0dd
 SHA512:
-  metadata.gz: c150cfd69f78f5106596211b5d09432ef60678942c9fdfca4a634eff25052ec3704381ab85bbf9ae9e82dc5b177f1e226c25b95afa33e57a225e9bf4c284efad
-  data.tar.gz: 163925f3b77e0bf445b23d37a0e3e45d0aab4d981c58b73d196af7157964c8e33f20147a8d062a13d68becd71f57a4e5906fc9d1fbbbd716c1b8319aedb7ce58
+  metadata.gz: acc1eb730e31250b6d8cc281923dd332b2141a4fb2ced34821126928b0c94757a6b1c5f49e29c39c01e899b196e4fe857ea529d62bd8fd88015c2dad806fbb8f
+  data.tar.gz: a18fc12e5e6252c32129d8ab005f75b29834711fc5790e009a8dc45fabcb9c9c9e88f1c16213a16bf346da906087ec9f57dea7e6162e51554d622a20575cdf55

data/CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.6.0 - 2026-10-11
+- bump up DuckDB 1.5.6 on CI.
+
 # 1.5.5.1 - 2026-08-29
 - fix `DuckDB::Database#close` deadlocking when DuckDB tears down a pipeline that still owes a UDF callback, as a failed aggregate window query does on DuckDB 1.4.x. `duckdb_close` joins DuckDB's worker threads, and a worker running a callback waits for the executor thread, which waits for the GVL the closing thread was holding. The GVL is now released for the duration of `duckdb_close`.
 - fix a segfault when an aggregate UDF was used as a window function over a constant frame, such as `OVER ()` or `OVER (PARTITION BY x)` (issue #1446). DuckDB's `CAPIAggregateUpdate` does not flatten the state vector the way its combine and finalize counterparts do, so it hands the update callback a single state while reporting the partition's full row count; reading one state per row then ran off the end of the allocation. Such a chunk is now recognised and every row aggregated into the one state DuckDB supplied.

data/ext/duckdb/aggregate_function.c

@@ -9,7 +9,7 @@ VALUE cDuckDBAggregateFunction;
  * VALUE returned from the user's init_proc and later passed to
  * finalize_proc.
  *
- * Protected from GC via rb_gc_register_mark_object on init.
+ * Protected from GC via rb_global_variable on init.
  */
 static VALUE g_aggregate_state_registry;
 
@@ -37,7 +37,7 @@ static unsigned long long g_next_state_id = 0;
  * reach state_id is the crash; membership here is the only test that does not.
  * See issue #1446.
  *
- * Protected from GC via rb_gc_register_mark_object on init.
+ * Protected from GC via rb_global_variable on init.
  */
 static VALUE g_aggregate_state_addresses;
 
@@ -69,7 +69,7 @@ static VALUE aggregate_function__set_special_handling(VALUE self);
 static const rb_data_type_t aggregate_function_data_type = {
     "DuckDB/AggregateFunction",
     {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) {
@@ -895,7 +895,7 @@ static VALUE aggregate_function__set_init(VALUE self) {
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    p->init_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->init_proc, rb_block_proc());
 
     maybe_set_functions(p);
 
@@ -911,7 +911,7 @@ static VALUE aggregate_function__set_update(VALUE self) {
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    p->update_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->update_proc, rb_block_proc());
 
     maybe_set_functions(p);
 
@@ -927,7 +927,7 @@ static VALUE aggregate_function__set_combine(VALUE self) {
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    p->combine_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->combine_proc, rb_block_proc());
 
     maybe_set_functions(p);
 
@@ -943,7 +943,7 @@ static VALUE aggregate_function__set_finalize(VALUE self) {
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    p->finalize_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->finalize_proc, rb_block_proc());
 
     maybe_set_functions(p);
 
@@ -983,8 +983,8 @@ void rbduckdb_init_aggregate_function(void) {
     rb_define_singleton_method(cDuckDBAggregateFunction, "_state_registry_size",
                                aggregate_function_s__state_registry_size, 0);
 
+    rb_global_variable(&g_aggregate_state_registry);
     g_aggregate_state_registry = rb_hash_new();
-    rb_gc_register_mark_object(g_aggregate_state_registry);
+    rb_global_variable(&g_aggregate_state_addresses);
     g_aggregate_state_addresses = rb_hash_new();
-    rb_gc_register_mark_object(g_aggregate_state_addresses);
 }

data/ext/duckdb/aggregate_function_set.c

@@ -13,12 +13,12 @@ static VALUE aggregate_function_set__add(VALUE self, VALUE aggregate_function);
 static const rb_data_type_t aggregate_function_set_data_type = {
     "DuckDB/AggregateFunctionSet",
     {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) {
     rubyDuckDBAggregateFunctionSet *p = (rubyDuckDBAggregateFunctionSet *)ctx;
-    rb_gc_mark(p->functions);
+    rb_gc_mark_movable(p->functions);
 }
 
 static void deallocate(void *ctx) {
@@ -35,8 +35,7 @@ static void compact(void *ctx) {
 static VALUE allocate(VALUE klass) {
     rubyDuckDBAggregateFunctionSet *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBAggregateFunctionSet));
     VALUE obj = TypedData_Wrap_Struct(klass, &aggregate_function_set_data_type, ctx);
-    ctx->functions = rb_ary_new();
-    RB_GC_GUARD(ctx->functions);
+    RB_OBJ_WRITE(obj, &ctx->functions, rb_ary_new());
     return obj;
 }
 

data/ext/duckdb/appender.c

@@ -50,10 +50,20 @@ static VALUE appender__clear_columns(VALUE self);
 static VALUE appender__close(VALUE self);
 static VALUE state_to_rbool(duckdb_state state);
 
+/*
+ * Keeps RUBY_TYPED_FREE_IMMEDIATELY although duckdb_appender_destroy flushes
+ * buffered rows (blocking I/O): when an unclosed appender is collected in the
+ * same GC as its connection, freeing it during sweep runs before the deferred
+ * Connection/Database free, so its rows still reach the table. Deferring it too
+ * would let the connection close first and lose rows. (The appender holds no
+ * reference to its connection, so if the connection is collected in an earlier
+ * GC the flush is lost anyway.) Freeing in sweep cannot shut the database down:
+ * DuckDB's BaseAppender holds only a weak_ptr<ClientContext>.
+ */
 static const rb_data_type_t appender_data_type = {
     "DuckDB/Appender",
     {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/arrow_array_stream.c

@@ -13,7 +13,7 @@ typedef struct {
  * the Ruby DuckDB::ArrowArrayStream object is gone, so this context is
  * freed only by the stream release callback, and it holds a reference on
  * the result struct (rbduckdb_result_ref) until then. The release callback
- * must not call any Ruby API: it can run during GC sweep (via deallocate
+ * must not call any Ruby API: it can run during GC finalization (via deallocate
  * of an unconsumed stream) or from a non-Ruby thread.
  */
 typedef struct {
@@ -34,10 +34,14 @@ static int stream_get_next(struct ArrowArrayStream *stream, struct ArrowArray *o
 static const char *stream_get_last_error(struct ArrowArrayStream *stream);
 static void stream_release(struct ArrowArrayStream *stream);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: releasing the stream may destroy a streaming result (see result.c).
+ */
 static const rb_data_type_t arrow_array_stream_data_type = {
     "DuckDB/ArrowArrayStream",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/arrow_import.c

@@ -26,7 +26,7 @@ static VALUE connection__arrow_release(VALUE self, VALUE address);
 static const rb_data_type_t arrow_converted_schema_data_type = {
     "DuckDB/ArrowConvertedSchema",
     {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/client_context.c

@@ -10,7 +10,7 @@ static VALUE 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
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/column.c

@@ -12,7 +12,7 @@ static VALUE column_name(VALUE oDuckDBColumn);
 static const rb_data_type_t column_data_type = {
     "DuckDB/Column",
     {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/column.h

@@ -2,7 +2,6 @@
 #define RUBY_DUCKDB_COLUMN_H
 
 struct _rubyDuckDBColumn {
-    VALUE result;
     idx_t col;
 };
 

data/ext/duckdb/config.c

@@ -13,7 +13,7 @@ static VALUE config_set_config(VALUE self, VALUE key, VALUE value);
 static const rb_data_type_t config_data_type = {
     "DuckDB/Config",
     {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/connection.c

@@ -4,6 +4,7 @@ VALUE cDuckDBConnection;
 
 static void deallocate(void *ctx);
 static void mark(void *ctx);
+static void compact(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE connection_disconnect(VALUE self);
@@ -19,10 +20,15 @@ static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggre
 static VALUE connection__register_table_function(VALUE self, VALUE table_function);
 static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualified);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: duckdb_disconnect rolls back an open transaction and may drop the
+ * last reference to the database (checkpoint on shutdown).
+ */
 static const rb_data_type_t connection_data_type = {
     "DuckDB/Connection",
-    {mark, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {
@@ -34,7 +40,12 @@ static void deallocate(void *ctx) {
 
 static void mark(void *ctx) {
     rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
-    rb_gc_mark(p->database);
+    rb_gc_mark_movable(p->database);
+}
+
+static void compact(void *ctx) {
+    rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
+    p->database = rb_gc_location(p->database);
 }
 
 static VALUE allocate(VALUE klass) {
@@ -77,7 +88,7 @@ VALUE rbduckdb_create_connection(VALUE oDuckDBDatabase) {
     if (duckdb_connect(ctxdb->db, &(ctxcon->con)) == DuckDBError) {
         rb_raise(eDuckDBError, "connection error");
     }
-    ctxcon->database = oDuckDBDatabase;
+    RB_OBJ_WRITE(obj, &ctxcon->database, oDuckDBDatabase);
 
     return obj;
 }
@@ -93,7 +104,7 @@ static VALUE connection_disconnect(VALUE self) {
      * reachable from other connections. They are released with the database.
      * This connection no longer needs the database, so stop retaining it.
      */
-    ctx->database = Qnil;
+    RB_OBJ_WRITE(self, &ctx->database, Qnil);
 
     return self;
 }
@@ -162,7 +173,7 @@ static VALUE connection__connect(VALUE self, VALUE oDuckDBDatabase) {
     if (duckdb_connect(ctxdb->db, &(ctx->con)) == DuckDBError) {
         rb_raise(eDuckDBError, "connection error");
     }
-    ctx->database = oDuckDBDatabase;
+    RB_OBJ_WRITE(self, &ctx->database, oDuckDBDatabase);
 
     return self;
 }

data/ext/duckdb/data_chunk.c

@@ -16,7 +16,7 @@ static VALUE data_chunk__reset(VALUE self);
 static const rb_data_type_t data_chunk_data_type = {
     "DuckDB/DataChunk",
     {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/database.c

@@ -5,6 +5,7 @@ VALUE cDuckDBDatabase;
 static void close_database(rubyDuckDB *p);
 static void deallocate(void * ctx);
 static void mark(void *ctx);
+static void compact(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static duckdb_config create_config_with_ruby_api(void);
@@ -12,10 +13,14 @@ static VALUE database__initialize(VALUE self, VALUE file, VALUE config);
 static VALUE database__connect(VALUE self);
 static VALUE database_close(VALUE self);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: duckdb_close may checkpoint to disk and joins worker threads.
+ */
 static const rb_data_type_t database_data_type = {
     "DuckDB/Database",
-    {mark, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void close_database(rubyDuckDB *p) {
@@ -31,7 +36,7 @@ static void close_database(rubyDuckDB *p) {
  * for us, and we wait for the worker.
  *
  * The GC free function calls close_database directly and cannot do this;
- * releasing the GVL mid-sweep is not allowed. A database reaching close via
+ * a free function must not release the GVL. A database reaching close via
  * the GC with callbacks still pending would deadlock the same way.
  */
 static void *close_database_without_gvl(void *ctx) {
@@ -49,9 +54,17 @@ static void deallocate(void * ctx) {
 static void mark(void *ctx) {
     rubyDuckDB *p = (rubyDuckDB *)ctx;
 
-    rb_gc_mark(p->registered_functions);
-    rb_gc_mark(p->cached_path);
-    rb_gc_mark(p->cache_wrappers);
+    rb_gc_mark_movable(p->registered_functions);
+    rb_gc_mark_movable(p->cached_path);
+    rb_gc_mark_movable(p->cache_wrappers);
+}
+
+static void compact(void *ctx) {
+    rubyDuckDB *p = (rubyDuckDB *)ctx;
+
+    p->registered_functions = rb_gc_location(p->registered_functions);
+    p->cached_path = rb_gc_location(p->cached_path);
+    p->cache_wrappers = rb_gc_location(p->cache_wrappers);
 }
 
 static size_t memsize(const void *p) {
@@ -61,11 +74,9 @@ static size_t memsize(const void *p) {
 static VALUE allocate(VALUE klass) {
     rubyDuckDB *ctx = xcalloc((size_t)1, sizeof(rubyDuckDB));
     VALUE obj = TypedData_Wrap_Struct(klass, &database_data_type, ctx);
-    VALUE registered_functions = rb_ary_new();
-    ctx->registered_functions = registered_functions;
     ctx->cached_path = Qnil;
     ctx->cache_wrappers = Qnil;
-    RB_GC_GUARD(registered_functions);
+    RB_OBJ_WRITE(obj, &ctx->registered_functions, rb_ary_new());
     return obj;
 }
 
@@ -89,8 +100,8 @@ void rbduckdb_database_set_cache_entry(VALUE database, VALUE path, VALUE wrapper
     rubyDuckDB *ctx;
 
     TypedData_Get_Struct(database, rubyDuckDB, &database_data_type, ctx);
-    ctx->cached_path = rb_str_new_frozen(path);
-    ctx->cache_wrappers = wrappers;
+    RB_OBJ_WRITE(database, &ctx->cached_path, rb_str_new_frozen(path));
+    RB_OBJ_WRITE(database, &ctx->cache_wrappers, wrappers);
 }
 
 rubyDuckDB *rbduckdb_get_struct_database(VALUE obj) {
@@ -181,8 +192,8 @@ static VALUE database_close(VALUE self) {
      */
     if (!NIL_P(ctx->cache_wrappers)) {
         rb_funcall(ctx->cache_wrappers, rb_intern("delete"), 1, self);
-        ctx->cache_wrappers = Qnil;
-        ctx->cached_path = Qnil;
+        RB_OBJ_WRITE(self, &ctx->cache_wrappers, Qnil);
+        RB_OBJ_WRITE(self, &ctx->cached_path, Qnil);
     }
     rb_thread_call_without_gvl(close_database_without_gvl, ctx, NULL, NULL);
     return self;

data/ext/duckdb/expression.c

@@ -11,7 +11,7 @@ static VALUE expression__fold(VALUE self, VALUE client_context);
 static const rb_data_type_t expression_data_type = {
     "DuckDB/Expression",
     {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/extracted_statements.c

@@ -9,7 +9,7 @@ static size_t memsize(const void *p);
 static const rb_data_type_t extract_statements_data_type = {
     "DuckDB/ExtractedStatements",
     {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/instance_cache.c

@@ -4,6 +4,7 @@ VALUE cDuckDBInstanceCache;
 
 static void deallocate(void * ctx);
 static void mark(void *ctx);
+static void compact(void *ctx);
 static VALUE allocate(VALUE klass);
 static VALUE memoizable_path(VALUE vpath);
 static VALUE find_cached_wrapper(rubyDuckDBInstanceCache *ctx, VALUE vpath);
@@ -14,8 +15,8 @@ static VALUE instance_cache_destroy(VALUE self);
 
 static const rb_data_type_t instance_cache_data_type = {
     "DuckDB/InstanceCache",
-    {mark, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void * ctx) {
@@ -30,7 +31,13 @@ static void deallocate(void * ctx) {
 static void mark(void *ctx) {
     rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
 
-    rb_gc_mark(p->wrappers);
+    rb_gc_mark_movable(p->wrappers);
+}
+
+static void compact(void *ctx) {
+    rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
+
+    p->wrappers = rb_gc_location(p->wrappers);
 }
 
 static size_t memsize(const void *p) {
@@ -87,9 +94,10 @@ static VALUE instance_cache_initialize(VALUE self) {
         rb_raise(eDuckDBError, "Failed to create instance cache");
     }
 
-    ctx->wrappers = rb_funcall(rb_const_get(rb_const_get(rb_cObject, rb_intern("ObjectSpace")),
-                                            rb_intern("WeakMap")),
-                               rb_intern("new"), 0);
+    RB_OBJ_WRITE(self, &ctx->wrappers,
+                 rb_funcall(rb_const_get(rb_const_get(rb_cObject, rb_intern("ObjectSpace")),
+                                         rb_intern("WeakMap")),
+                            rb_intern("new"), 0));
 
     return self;
 }

data/ext/duckdb/logical_type.c

@@ -35,7 +35,7 @@ static VALUE logical_type_initialize(VALUE self, VALUE type_id_arg);
 static const rb_data_type_t logical_type_data_type = {
     "DuckDB/LogicalType",
     {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/pending_result.c

@@ -12,10 +12,15 @@ static VALUE pending_result_execution_finished_p(VALUE self);
 static VALUE pending_result__state(VALUE self);
 static VALUE pending_result__execute_check_state(VALUE self);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: the pending result holds a ClientContext reference; dropping the last
+ * one rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t pending_result_data_type = {
     "DuckDB/PendingResult",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/prepared_statement.c

@@ -47,10 +47,15 @@ static VALUE prepared_statement__bind_uuid(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale);
 static VALUE prepared_statement__bind_value(VALUE self, VALUE vidx, VALUE val);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: the statement holds a ClientContext reference; dropping the last one
+ * rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t prepared_statement_data_type = {
     "DuckDB/PreparedStatement",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void destroy_prepared_statement(rubyDuckDBPreparedStatement *p) {

data/ext/duckdb/result.c

@@ -48,10 +48,15 @@ static VALUE vector_timestamp_tz(void* vector_data, idx_t row_idx);
 static VALUE vector_uuid(void* vector_data, idx_t row_idx);
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: a streaming result holds a ClientContext reference; dropping the last
+ * one rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t result_data_type = {
     "DuckDB/Result",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/result.h

@@ -6,7 +6,7 @@
  * object holds one reference, and each exported Arrow stream holds another,
  * so the duckdb_result stays valid for consumers that outlive the Ruby
  * objects. rbduckdb_result_unref() must not call any Ruby API: it runs from
- * GC sweep (deallocate) and from Arrow stream release callbacks.
+ * GC finalization (deallocate) and from Arrow stream release callbacks.
  */
 struct _rubyDuckDBResult {
     duckdb_result result;

data/ext/duckdb/scalar_function.c

@@ -79,13 +79,13 @@ static void execute_callback_protected(void *user_data) {
 static const rb_data_type_t scalar_function_data_type = {
     "DuckDB/ScalarFunction",
     {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) {
     rubyDuckDBScalarFunction *p = (rubyDuckDBScalarFunction *)ctx;
-    rb_gc_mark(p->function_proc);
-    rb_gc_mark(p->bind_proc);
+    rb_gc_mark_movable(p->function_proc);
+    rb_gc_mark_movable(p->bind_proc);
 }
 
 static void deallocate(void * ctx) {
@@ -371,7 +371,7 @@ static VALUE scalar_function_set_function(VALUE self) {
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
 
-    p->function_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->function_proc, rb_block_proc());
 
     duckdb_scalar_function_set_extra_info(p->scalar_function, p, NULL);
     duckdb_scalar_function_set_function(p->scalar_function, scalar_function_callback);
@@ -398,7 +398,7 @@ static VALUE scalar_function__set_bind(VALUE self) {
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
 
-    p->bind_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->bind_proc, rb_block_proc());
 
     duckdb_scalar_function_set_extra_info(p->scalar_function, p, NULL);
     duckdb_scalar_function_set_bind(p->scalar_function, scalar_function_bind_callback);

data/ext/duckdb/scalar_function_bind_info.c

@@ -13,7 +13,7 @@ static VALUE scalar_function_bind_info_client_context(VALUE self);
 static const rb_data_type_t scalar_function_bind_info_data_type = {
     "DuckDB/ScalarFunction/BindInfo",
     {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/scalar_function_set.c

@@ -13,12 +13,12 @@ static VALUE scalar_function_set__add(VALUE self, VALUE scalar_function);
 static const rb_data_type_t scalar_function_set_data_type = {
     "DuckDB/ScalarFunctionSet",
     {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) {
     rubyDuckDBScalarFunctionSet *p = (rubyDuckDBScalarFunctionSet *)ctx;
-    rb_gc_mark(p->functions);
+    rb_gc_mark_movable(p->functions);
 }
 
 static void deallocate(void *ctx) {
@@ -35,8 +35,7 @@ static void compact(void *ctx) {
 static VALUE allocate(VALUE klass) {
     rubyDuckDBScalarFunctionSet *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBScalarFunctionSet));
     VALUE obj = TypedData_Wrap_Struct(klass, &scalar_function_set_data_type, ctx);
-    ctx->functions = rb_ary_new();
-    RB_GC_GUARD(ctx->functions);
+    RB_OBJ_WRITE(obj, &ctx->functions, rb_ary_new());
     return obj;
 }
 

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);
 
@@ -286,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();
@@ -359,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). */

data/ext/duckdb/table_function_bind_info.c

@@ -16,7 +16,7 @@ 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) {

data/ext/duckdb/table_function_function_info.c

@@ -11,7 +11,7 @@ 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) {

data/ext/duckdb/table_function_init_info.c

@@ -14,7 +14,7 @@ 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) {

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/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.1'
+  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.1
+  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: []