duckdb 1.5.2.0 → 1.5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295ef9eeb24957c23fe7b581094e8961b3c6ce818040246e6b027fd97d462984
-  data.tar.gz: 01e6c633d11f6c25ed15a3326250a4c3c107c8257e0a29b6149ea66bde2c4d46
+  metadata.gz: 4c7c57e0282ec2213b1efb3844445804e5fbbc09e03496f2ba71c1bd24152843
+  data.tar.gz: 9057fa45fafeba0dc2110562f98cd49eecf53ec0f0a48a989756742525c82b4a
 SHA512:
-  metadata.gz: e3472308ea3a5fd362ebe0d2f048451e88b40d35bd14f987f6adc31c050355e340a47897b73ff1c272f409a161950b1ce7dd26c29e63598acfba8695eb4a7249
-  data.tar.gz: b31c79510aab7118f0ef0b60d3704135a6e3920eca7bef4835e866b919ea45c796bad353a06c0c0274fab3baac215be763a63bb1911958350abc0acb9c545939
+  metadata.gz: 78bbd166f587491085267791ffca949f2b310597f802424b7e0525c8c4f35f345c2362b17b33401bee374601d5f52746d10ac21f60ea8344bd3bf08e28d7f4b5
+  data.tar.gz: 6fc88b5e289ef3451691f57cb404c390b9deabbafddf81e8aedd300121276a9df62b0492559f2602eb4aeaa57ed2a83cc98ccfbef3a728771c34a565a022f78a

data/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.2.1 - 2026-04-24
+
+- add `DuckDB::AggregateFunction.create`.
+- add `DuckDB::Appender#clear_columns`.
+- add `DuckDB::Appender#add_column`.
+- add `DuckDB::Appender#clear` to discard all unflushed data from the appender without writing it to the table (requires DuckDB >= 1.5.0).
+- add `DuckDB::Value.create_decimal`.
+- fix gemspec to use `git ls-files`, preventing precompiled x86_64 `.so` from being bundled into the gem and breaking non-x86 platforms.
+
 # 1.5.2.0 - 2026-04-16
 
 - add `DuckDB::DataChunk#reset` to clear a chunk's contents so it can be reused across multiple `Appender#append_data_chunk` calls without reallocation.

data/duckdb.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/duckdb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'duckdb'
+  spec.version       = DuckDB::VERSION
+  spec.authors       = ['Masaki Suketa']
+  spec.email         = ['masaki.suketa@nifty.ne.jp']
+  spec.homepage      = 'https://github.com/suketa/ruby-duckdb'
+  spec.license       = 'MIT'
+
+  spec.summary = 'Ruby bindings for the DuckDB database engine.'
+  spec.description = <<~TEXT
+    This gem provides bindings for DuckDB, which is an in-process SQL database optimized for analytical queries on structured data.
+    It's lightweight, embeddable, and works directly with files like Parquet and CSV, making it popular for data analysis tasks.
+  TEXT
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features|sample|benchmark)/|^\.(?!rdoc_options)|
+                 ^(HACKING|CONTRIBUTION)\.md$|
+                 ^(Dockerfile|docker-compose\.yml|getduckdb\.sh|Gemfile(\.lock)?)$}x)
+    end
+  end
+
+  spec.require_paths = ['lib']
+  spec.extensions = ['ext/duckdb/extconf.rb']
+  spec.required_ruby_version = '>= 3.2.0'
+  spec.add_dependency 'bigdecimal', '>= 3.1.4'
+end

data/ext/duckdb/aggregate_function.c

@@ -32,15 +32,15 @@ static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static void compact(void *);
-static VALUE duckdb_aggregate_function_initialize(VALUE self);
-static VALUE rbduckdb_aggregate_function_set_name(VALUE self, VALUE name);
-static VALUE rbduckdb_aggregate_function__set_return_type(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_aggregate_function_add_parameter(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_aggregate_function_set_init(VALUE self);
-static VALUE rbduckdb_aggregate_function_set_update(VALUE self);
-static VALUE rbduckdb_aggregate_function_set_combine(VALUE self);
-static VALUE rbduckdb_aggregate_function_set_finalize(VALUE self);
-static VALUE rbduckdb_aggregate_function__set_special_handling(VALUE self);
+static VALUE aggregate_function_initialize(VALUE self);
+static VALUE aggregate_function_set_name(VALUE self, VALUE name);
+static VALUE aggregate_function__set_return_type(VALUE self, VALUE logical_type);
+static VALUE aggregate_function__add_parameter(VALUE self, VALUE logical_type);
+static VALUE aggregate_function__set_init(VALUE self);
+static VALUE aggregate_function__set_update(VALUE self);
+static VALUE aggregate_function__set_combine(VALUE self);
+static VALUE aggregate_function__set_finalize(VALUE self);
+static VALUE aggregate_function__set_special_handling(VALUE self);
 
 static const rb_data_type_t aggregate_function_data_type = {
     "DuckDB/AggregateFunction",
@@ -87,13 +87,13 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBAggregateFunction);
 }
 
-rubyDuckDBAggregateFunction *get_struct_aggregate_function(VALUE obj) {
+rubyDuckDBAggregateFunction *rbduckdb_get_struct_aggregate_function(VALUE obj) {
     rubyDuckDBAggregateFunction *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBAggregateFunction, &aggregate_function_data_type, ctx);
     return ctx;
 }
 
-static VALUE duckdb_aggregate_function_initialize(VALUE self) {
+static VALUE aggregate_function_initialize(VALUE self) {
     rubyDuckDBAggregateFunction *p;
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
     p->aggregate_function = duckdb_create_aggregate_function();
@@ -105,7 +105,7 @@ static VALUE duckdb_aggregate_function_initialize(VALUE self) {
     return self;
 }
 
-static VALUE rbduckdb_aggregate_function_set_name(VALUE self, VALUE name) {
+static VALUE aggregate_function_set_name(VALUE self, VALUE name) {
     rubyDuckDBAggregateFunction *p;
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
 
@@ -115,24 +115,24 @@ static VALUE rbduckdb_aggregate_function_set_name(VALUE self, VALUE name) {
     return self;
 }
 
-static VALUE rbduckdb_aggregate_function__set_return_type(VALUE self, VALUE logical_type) {
+static VALUE aggregate_function__set_return_type(VALUE self, VALUE logical_type) {
     rubyDuckDBAggregateFunction *p;
     rubyDuckDBLogicalType *lt;
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    lt = get_struct_logical_type(logical_type);
+    lt = rbduckdb_get_struct_logical_type(logical_type);
 
     duckdb_aggregate_function_set_return_type(p->aggregate_function, lt->logical_type);
 
     return self;
 }
 
-static VALUE rbduckdb_aggregate_function_add_parameter(VALUE self, VALUE logical_type) {
+static VALUE aggregate_function__add_parameter(VALUE self, VALUE logical_type) {
     rubyDuckDBAggregateFunction *p;
     rubyDuckDBLogicalType *lt;
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    lt = get_struct_logical_type(logical_type);
+    lt = rbduckdb_get_struct_logical_type(logical_type);
 
     duckdb_aggregate_function_add_parameter(p->aggregate_function, lt->logical_type);
 
@@ -237,15 +237,6 @@ static void state_init_callback(duckdb_function_info info, duckdb_aggregate_stat
     rbduckdb_function_executor_dispatch(execute_init_callback_protected, &arg);
 }
 
-/* No-op update: used when no update_proc has been supplied. */
-static void noop_update_callback(duckdb_function_info info,
-                                 duckdb_data_chunk input,
-                                 duckdb_aggregate_state *states) {
-    (void)info;
-    (void)input;
-    (void)states;
-}
-
 /* update callback dispatch argument */
 struct update_callback_arg {
     rubyDuckDBAggregateFunction *ctx;
@@ -387,7 +378,14 @@ static void update_callback(duckdb_function_info info,
     struct update_callback_arg arg;
 
     ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
-    if (ctx == NULL || ctx->update_proc == Qnil) {
+    if (ctx == NULL) {
+        return;
+    }
+    if (ctx->update_proc == Qnil) {
+        /* Reached only if _set_init was called directly (bypassing the Ruby
+         * wrapper) without setting an update proc. Raise rather than silently
+         * leaving state unchanged. */
+        duckdb_aggregate_function_set_error(info, "update callback invoked with no update proc set");
         return;
     }
 
@@ -404,56 +402,6 @@ static void update_callback(duckdb_function_info info,
     rbduckdb_function_executor_dispatch(execute_update_callback_protected, &arg);
 }
 
-/* No-op combine: Phase 1.0 does not dispatch combine to Ruby. */
-static void noop_combine_callback(duckdb_function_info info,
-                                  duckdb_aggregate_state *source,
-                                  duckdb_aggregate_state *target,
-                                  idx_t count) {
-    (void)info;
-    (void)source;
-    (void)target;
-    (void)count;
-}
-
-/*
- * Fallback combine used when update_proc is supplied but the user did not
- * register a combine_proc via set_combine.
- *
- * DuckDB invokes combine even for single-partition aggregates: after update
- * has accumulated values into a source state, DuckDB freshly initialises a
- * target state and calls combine to merge source into target before finalize.
- *
- * Without a user-provided combine_proc we cannot perform an arbitrary merge,
- * so this minimal implementation overwrites target->ruby_state with the
- * source value. This is correct for the common single-group/single-thread
- * path; parallel execution requires the user to supply a combine_proc via
- * set_combine, in which case combine_callback is wired instead of this
- * fallback.
- */
-static void default_combine_callback(duckdb_function_info info,
-                                     duckdb_aggregate_state *source,
-                                     duckdb_aggregate_state *target,
-                                     idx_t count) {
-    ruby_aggregate_state **src = (ruby_aggregate_state **)source;
-    ruby_aggregate_state **tgt = (ruby_aggregate_state **)target;
-    idx_t i;
-    (void)info;
-
-    for (i = 0; i < count; i++) {
-        tgt[i]->ruby_state = src[i]->ruby_state;
-        /*
-         * Do NOT call any Ruby API here.  This callback is invoked by a
-         * DuckDB worker thread that does not hold the GVL; any rb_* call
-         * from this context is unsafe and causes a SIGSEGV on Windows.
-         *
-         * The copied VALUE is already GC-protected via the source state's
-         * existing registry entry — which shares the same state_id (because
-         * DuckDB memcpy'd the buffer).  The destructor callback will clean
-         * up that entry when DuckDB frees the source state.
-         */
-    }
-}
-
 /* combine_callback dispatch argument */
 struct combine_callback_arg {
     rubyDuckDBAggregateFunction *ctx;
@@ -515,7 +463,13 @@ static void combine_callback(duckdb_function_info info,
     struct combine_callback_arg arg;
 
     ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
-    if (ctx == NULL || ctx->combine_proc == Qnil) {
+    if (ctx == NULL) {
+        return;
+    }
+    if (ctx->combine_proc == Qnil) {
+        /* Reached only if _set_init was called directly (bypassing the Ruby
+         * wrapper) without setting a combine proc. Raise rather than SIGSEGV. */
+        duckdb_aggregate_function_set_error(info, "combine callback invoked with no combine proc set");
         return;
     }
 
@@ -616,7 +570,13 @@ static void finalize_callback(duckdb_function_info info,
     struct finalize_callback_arg arg;
 
     ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
-    if (ctx == NULL || ctx->finalize_proc == Qnil) {
+    if (ctx == NULL) {
+        return;
+    }
+    if (ctx->finalize_proc == Qnil) {
+        /* Reached only if _set_init was called directly (bypassing the Ruby
+         * wrapper) without setting a finalize proc. Raise rather than SIGSEGV. */
+        duckdb_aggregate_function_set_error(info, "finalize callback invoked with no finalize proc set");
         return;
     }
 
@@ -667,10 +627,12 @@ static void destroy_callback(duckdb_aggregate_state *states, idx_t count) {
 
 /*
  * Wire up all 5 DuckDB aggregate callbacks on the underlying aggregate_function.
- * Called once both init_proc and finalize_proc have been supplied.
+ * Called once init_proc has been supplied.  combine_proc and finalize_proc are
+ * guaranteed non-nil by the Ruby wrapper (set_init injects defaults for all
+ * three before calling _set_init).
  */
 static void maybe_set_functions(rubyDuckDBAggregateFunction *p) {
-    if (p->init_proc == Qnil || p->finalize_proc == Qnil) {
+    if (p->init_proc == Qnil) {
         return;
     }
     duckdb_aggregate_function_set_extra_info(p->aggregate_function, p, NULL);
@@ -678,9 +640,8 @@ static void maybe_set_functions(rubyDuckDBAggregateFunction *p) {
         p->aggregate_function,
         state_size_callback,
         state_init_callback,
-        (p->update_proc != Qnil) ? update_callback : noop_update_callback,
-        (p->combine_proc != Qnil) ? combine_callback :
-            ((p->update_proc != Qnil) ? default_combine_callback : noop_combine_callback),
+        update_callback,
+        combine_callback,
         finalize_callback);
     duckdb_aggregate_function_set_destructor(p->aggregate_function, destroy_callback);
 
@@ -690,7 +651,7 @@ static void maybe_set_functions(rubyDuckDBAggregateFunction *p) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_aggregate_function_set_init(VALUE self) {
+static VALUE aggregate_function__set_init(VALUE self) {
     rubyDuckDBAggregateFunction *p;
 
     if (!rb_block_given_p()) {
@@ -706,7 +667,7 @@ static VALUE rbduckdb_aggregate_function_set_init(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_aggregate_function_set_update(VALUE self) {
+static VALUE aggregate_function__set_update(VALUE self) {
     rubyDuckDBAggregateFunction *p;
 
     if (!rb_block_given_p()) {
@@ -722,7 +683,7 @@ static VALUE rbduckdb_aggregate_function_set_update(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_aggregate_function_set_combine(VALUE self) {
+static VALUE aggregate_function__set_combine(VALUE self) {
     rubyDuckDBAggregateFunction *p;
 
     if (!rb_block_given_p()) {
@@ -738,7 +699,7 @@ static VALUE rbduckdb_aggregate_function_set_combine(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_aggregate_function_set_finalize(VALUE self) {
+static VALUE aggregate_function__set_finalize(VALUE self) {
     rubyDuckDBAggregateFunction *p;
 
     if (!rb_block_given_p()) {
@@ -754,7 +715,7 @@ static VALUE rbduckdb_aggregate_function_set_finalize(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_aggregate_function__set_special_handling(VALUE self) {
+static VALUE aggregate_function__set_special_handling(VALUE self) {
     rubyDuckDBAggregateFunction *p;
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
     p->special_handling = true;
@@ -763,28 +724,28 @@ static VALUE rbduckdb_aggregate_function__set_special_handling(VALUE self) {
 }
 
 /* Returns the number of Ruby states currently tracked in the registry. */
-static VALUE aggregate_function_state_registry_size(VALUE klass) {
+static VALUE aggregate_function_s__state_registry_size(VALUE klass) {
     (void)klass;
     return LONG2NUM((long)RHASH_SIZE(g_aggregate_state_registry));
 }
 
-void rbduckdb_init_duckdb_aggregate_function(void) {
+void rbduckdb_init_aggregate_function(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBAggregateFunction = rb_define_class_under(mDuckDB, "AggregateFunction", rb_cObject);
     rb_define_alloc_func(cDuckDBAggregateFunction, allocate);
-    rb_define_method(cDuckDBAggregateFunction, "initialize", duckdb_aggregate_function_initialize, 0);
-    rb_define_method(cDuckDBAggregateFunction, "name=", rbduckdb_aggregate_function_set_name, 1);
-    rb_define_private_method(cDuckDBAggregateFunction, "_set_return_type", rbduckdb_aggregate_function__set_return_type, 1);
-    rb_define_private_method(cDuckDBAggregateFunction, "_add_parameter", rbduckdb_aggregate_function_add_parameter, 1);
-    rb_define_method(cDuckDBAggregateFunction, "set_init", rbduckdb_aggregate_function_set_init, 0);
-    rb_define_method(cDuckDBAggregateFunction, "set_update", rbduckdb_aggregate_function_set_update, 0);
-    rb_define_method(cDuckDBAggregateFunction, "set_combine", rbduckdb_aggregate_function_set_combine, 0);
-    rb_define_method(cDuckDBAggregateFunction, "set_finalize", rbduckdb_aggregate_function_set_finalize, 0);
-    rb_define_private_method(cDuckDBAggregateFunction, "_set_special_handling", rbduckdb_aggregate_function__set_special_handling, 0);
+    rb_define_method(cDuckDBAggregateFunction, "initialize", aggregate_function_initialize, 0);
+    rb_define_method(cDuckDBAggregateFunction, "name=", aggregate_function_set_name, 1);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_return_type", aggregate_function__set_return_type, 1);
+    rb_define_private_method(cDuckDBAggregateFunction, "_add_parameter", aggregate_function__add_parameter, 1);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_init", aggregate_function__set_init, 0);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_update", aggregate_function__set_update, 0);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_combine", aggregate_function__set_combine, 0);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_finalize", aggregate_function__set_finalize, 0);
+    rb_define_private_method(cDuckDBAggregateFunction, "_set_special_handling", aggregate_function__set_special_handling, 0);
     rb_define_singleton_method(cDuckDBAggregateFunction, "_state_registry_size",
-                               aggregate_function_state_registry_size, 0);
+                               aggregate_function_s__state_registry_size, 0);
 
     g_aggregate_state_registry = rb_hash_new();
     rb_gc_register_mark_object(g_aggregate_state_registry);

data/ext/duckdb/aggregate_function.h

@@ -12,7 +12,7 @@ struct _rubyDuckDBAggregateFunction {
 
 typedef struct _rubyDuckDBAggregateFunction rubyDuckDBAggregateFunction;
 
-void rbduckdb_init_duckdb_aggregate_function(void);
-rubyDuckDBAggregateFunction *get_struct_aggregate_function(VALUE obj);
+void rbduckdb_init_aggregate_function(void);
+rubyDuckDBAggregateFunction *rbduckdb_get_struct_aggregate_function(VALUE obj);
 
 #endif