duckdb 2.0.0.0 → 2.0.0.1

data/ext/duckdb/scalar_function.c

@@ -18,11 +18,6 @@ static VALUE scalar_function__set_bind(VALUE self);
 static void scalar_function_callback(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);
 static void scalar_function_bind_callback(duckdb_bind_info info);
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
-/*
- * Thread detection functions (available since Ruby 2.3).
- * Used to skip the proxy on Ruby threads.
- */
-extern int ruby_native_thread_p(void);
 static void scalar_function_init_callback(duckdb_init_info info);
 #endif
 
@@ -251,15 +246,8 @@ static VALUE process_rows(VALUE varg) {
      * a GC, and the earlier columns' objects must stay reachable. */
     VALUE args = rb_ary_new_capa((long)arg->col_count);
 
-    /* Allocate arrays to hold input vectors and their types */
-    arg->input_vectors = ALLOC_N(duckdb_vector, arg->col_count);
-    arg->input_types = ALLOC_N(duckdb_logical_type, arg->col_count);
-
     /* Get all input vectors and their types */
-    for (j = 0; j < arg->col_count; j++) {
-        arg->input_vectors[j] = duckdb_data_chunk_get_vector(arg->input, j);
-        arg->input_types[j] = duckdb_vector_get_column_type(arg->input_vectors[j]);
-    }
+    rbduckdb_input_columns_load(arg->input, arg->col_count, &arg->input_vectors, &arg->input_types);
 
     /* Process each row */
     for (i = 0; i < arg->row_count; i++) {
@@ -282,24 +270,10 @@ static VALUE process_rows(VALUE varg) {
 
 static VALUE cleanup_callback(VALUE varg) {
     struct callback_arg *arg = (struct callback_arg *)varg;
-    idx_t j;
 
-    /* Destroy all logical types */
-    if (arg->input_types != NULL) {
-        for (j = 0; j < arg->col_count; j++) {
-            duckdb_destroy_logical_type(&arg->input_types[j]);
-        }
-    }
+    rbduckdb_input_columns_free(arg->input_vectors, arg->input_types, arg->col_count);
     duckdb_destroy_logical_type(&arg->output_type);
 
-    /* Free allocated memory */
-    if (arg->input_types != NULL) {
-        xfree(arg->input_types);
-    }
-    if (arg->input_vectors != NULL) {
-        xfree(arg->input_vectors);
-    }
-
     return Qnil;
 }
 
@@ -307,50 +281,16 @@ static VALUE cleanup_callback(VALUE varg) {
 /*
  * Per-worker init for the execute path (DuckDB >= 1.5.0).
  *
- * DuckDB calls this once on each worker thread that will run the execute
- * callback. We create a per-worker proxy (allocating its Ruby thread under the
- * GVL via the global executor, since this runs on a non-Ruby thread) and store
- * it as per-worker state. The execute callback then dispatches through it
- * instead of the shared global executor, so workers run callbacks concurrently.
- * DuckDB invokes rbduckdb_worker_proxy_destroy when the state is freed.
+ * Runs once on each worker thread that will execute the callback. Creates the
+ * worker's proxy and stores it as per-worker state, so the execute callback
+ * dispatches through it rather than the shared global executor. DuckDB calls
+ * rbduckdb_worker_proxy_destroy when the state is freed.
  */
-struct create_proxy_callback_arg {
-    struct worker_proxy *proxy;
-};
-
-static VALUE create_proxy_callback(VALUE varg) {
-    struct create_proxy_callback_arg *arg = (struct create_proxy_callback_arg *)varg;
-    arg->proxy = rbduckdb_worker_proxy_create();
-    return Qnil;
-}
-
-/*
- * 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, 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;
-
-    rb_protect(create_proxy_callback, (VALUE)user_data, &exception_state);
-    if (exception_state) {
-        rb_set_errinfo(Qnil);
-    }
-}
-
 static void scalar_function_init_callback(duckdb_init_info info) {
-    struct create_proxy_callback_arg arg;
-
-    /* A Ruby calling thread runs the callback inline (Case 1/2); no proxy needed. */
-    if (ruby_native_thread_p()) return;
-
-    arg.proxy = NULL;
-    rbduckdb_function_executor_dispatch(create_proxy_callback_protected, &arg);
+    struct worker_proxy *proxy = rbduckdb_worker_proxy_create_for_current_thread();
 
-    if (arg.proxy != NULL) {
-        duckdb_scalar_function_init_set_state(info, arg.proxy, rbduckdb_worker_proxy_destroy);
+    if (proxy != NULL) {
+        duckdb_scalar_function_init_set_state(info, proxy, rbduckdb_worker_proxy_destroy);
     }
 }
 #endif

data/ext/duckdb/table_function.c

@@ -22,8 +22,6 @@ static void table_function_init_callback(duckdb_init_info info);
 static VALUE table_function_execute(VALUE self);
 static void table_function_execute_callback(duckdb_function_info info, duckdb_data_chunk output);
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
-/* Thread detection (declared in function_executor.c); used to skip the proxy on Ruby threads. */
-extern int ruby_native_thread_p(void);
 static void table_function_local_init_callback(duckdb_init_info info);
 #endif
 
@@ -185,6 +183,27 @@ static VALUE table_function_add_named_parameter(VALUE self, VALUE name, VALUE lo
     return self;
 }
 
+static rubyDuckDBTableFunction *table_function_get_settable_ctx(VALUE self, const char *block_msg) {
+    rubyDuckDBTableFunction *ctx;
+
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eArgError, "%s", block_msg);
+    }
+
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+
+    if (!ctx->table_function) {
+        rb_raise(eDuckDBError, "Table function is destroyed");
+    }
+
+    return ctx;
+}
+
+static VALUE call_proc_with_one_arg(VALUE arg) {
+    VALUE *args = (VALUE *)arg;
+    return rb_funcall(args[0], rb_intern("call"), 1, args[1]);
+}
+
 /*
  * call-seq:
  *   table_function.bind { |bind_info| ... } -> self
@@ -198,17 +217,7 @@ static VALUE table_function_add_named_parameter(VALUE self, VALUE name, VALUE lo
  *   end
  */
 static VALUE table_function_bind(VALUE self) {
-    rubyDuckDBTableFunction *ctx;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
-
-    if (!ctx->table_function) {
-        rb_raise(eDuckDBError, "Table function is destroyed");
-    }
+    rubyDuckDBTableFunction *ctx = table_function_get_settable_ctx(self, "block is required");
 
     RB_OBJ_WRITE(self, &ctx->bind_proc, rb_block_proc());
 
@@ -219,11 +228,6 @@ static VALUE table_function_bind(VALUE self) {
     return self;
 }
 
-static VALUE call_bind_proc(VALUE arg) {
-    VALUE *args = (VALUE *)arg;
-    return rb_funcall(args[0], rb_intern("call"), 1, args[1]);
-}
-
 struct bind_dispatch_arg {
     rubyDuckDBTableFunction *ctx;
     duckdb_bind_info info;
@@ -240,7 +244,7 @@ static void execute_bind_callback_protected(void *user_data) {
     bind_info_ctx->bind_info = darg->info;
 
     VALUE call_args[2] = { darg->ctx->bind_proc, bind_info_obj };
-    rb_protect(call_bind_proc, (VALUE)call_args, &state);
+    rb_protect(call_proc_with_one_arg, (VALUE)call_args, &state);
 
     if (state) {
         VALUE msg = rbduckdb_pending_error_message();
@@ -274,17 +278,7 @@ static void table_function_bind_callback(duckdb_bind_info info) {
  *   end
  */
 static VALUE table_function_init(VALUE self) {
-    rubyDuckDBTableFunction *ctx;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required for init");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
-
-    if (!ctx->table_function) {
-        rb_raise(eDuckDBError, "Table function is destroyed");
-    }
+    rubyDuckDBTableFunction *ctx = table_function_get_settable_ctx(self, "block is required for init");
 
     RB_OBJ_WRITE(self, &ctx->init_proc, rb_block_proc());
     duckdb_table_function_set_init(ctx->table_function, table_function_init_callback);
@@ -294,11 +288,6 @@ static VALUE table_function_init(VALUE self) {
     return self;
 }
 
-static VALUE call_init_proc(VALUE args_val) {
-    VALUE *args = (VALUE *)args_val;
-    return rb_funcall(args[0], rb_intern("call"), 1, args[1]);
-}
-
 struct init_dispatch_arg {
     rubyDuckDBTableFunction *ctx;
     duckdb_init_info info;
@@ -315,7 +304,7 @@ static void execute_init_callback_protected(void *user_data) {
     init_info_ctx->info = darg->info;
 
     VALUE call_args[2] = { darg->ctx->init_proc, init_info_obj };
-    rb_protect(call_init_proc, (VALUE)call_args, &state);
+    rb_protect(call_proc_with_one_arg, (VALUE)call_args, &state);
 
     if (state) {
         VALUE msg = rbduckdb_pending_error_message();
@@ -351,13 +340,7 @@ static void table_function_init_callback(duckdb_init_info info) {
  *   end
  */
 static VALUE table_function_execute(VALUE self) {
-    rubyDuckDBTableFunction *ctx;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required for execute");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+    rubyDuckDBTableFunction *ctx = table_function_get_settable_ctx(self, "block is required for execute");
 
     RB_OBJ_WRITE(self, &ctx->execute_proc, rb_block_proc());
     duckdb_table_function_set_function(ctx->table_function, table_function_execute_callback);
@@ -431,48 +414,16 @@ static void table_function_execute_callback(duckdb_function_info info, duckdb_da
 /*
  * Per-worker init for the execute path (DuckDB >= 1.5.0).
  *
- * DuckDB calls this once on each worker thread that will run the execute
- * callback. We create a per-worker proxy (allocating its Ruby thread under the
- * GVL via the global executor, since this runs on a non-Ruby thread) and store
- * it as thread-local init data. The execute callback then dispatches through it
- * instead of the shared global executor, so workers run callbacks concurrently.
- * DuckDB invokes rbduckdb_worker_proxy_destroy when the local state is freed.
- */
-struct create_proxy_callback_arg {
-    struct worker_proxy *proxy;
-};
-
-static VALUE create_proxy_callback(VALUE varg) {
-    struct create_proxy_callback_arg *arg = (struct create_proxy_callback_arg *)varg;
-    arg->proxy = rbduckdb_worker_proxy_create();
-    return Qnil;
-}
-
-/*
- * 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.
+ * Runs once on each worker thread that will execute the callback. Creates the
+ * worker's proxy and stores it as thread-local init data, so the execute callback
+ * dispatches through it rather than the shared global executor. DuckDB calls
+ * rbduckdb_worker_proxy_destroy when the local state is freed.
  */
-static void create_proxy_callback_protected(void *user_data) {
-    int exception_state;
-
-    rb_protect(create_proxy_callback, (VALUE)user_data, &exception_state);
-    if (exception_state) {
-        rb_set_errinfo(Qnil);
-    }
-}
-
 static void table_function_local_init_callback(duckdb_init_info info) {
-    struct create_proxy_callback_arg arg;
-
-    /* A Ruby calling thread runs the callback inline (Case 1/2); no proxy needed. */
-    if (ruby_native_thread_p()) return;
-
-    arg.proxy = NULL;
-    rbduckdb_function_executor_dispatch(create_proxy_callback_protected, &arg);
+    struct worker_proxy *proxy = rbduckdb_worker_proxy_create_for_current_thread();
 
-    if (arg.proxy != NULL) {
-        duckdb_init_set_init_data(info, arg.proxy, rbduckdb_worker_proxy_destroy);
+    if (proxy != NULL) {
+        duckdb_init_set_init_data(info, proxy, rbduckdb_worker_proxy_destroy);
     }
 }
 #endif

data/ext/duckdb/util.c

@@ -1,5 +1,38 @@
 #include "ruby-duckdb.h"
 
+#define MICROS_PER_DAY 86400000000LL
+
+/*
+ * Mirrors DuckDB's Date::IsValid. duckdb_to_date throws a C++ exception
+ * for dates it rejects, which would abort the process.
+ */
+static int is_valid_date(int32_t year, int32_t month, int32_t day) {
+    static const int32_t days_in_month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    int32_t max_day;
+
+    if (month < 1 || month > 12 || day < 1) {
+        return 0;
+    }
+    if (year < -5877641 || (year == -5877641 && (month < 6 || (month == 6 && day < 25)))) {
+        return 0;
+    }
+    if (year > 5881580 || (year == 5881580 && (month > 7 || (month == 7 && day > 10)))) {
+        return 0;
+    }
+    max_day = days_in_month[month];
+    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
+        max_day = 29;
+    }
+    return day <= max_day;
+}
+
+static duckdb_date to_duckdb_date(duckdb_date_struct dt_struct) {
+    if (!is_valid_date(dt_struct.year, dt_struct.month, dt_struct.day)) {
+        rb_raise(rb_eRangeError, "date out of range: %d-%02d-%02d", dt_struct.year, dt_struct.month, dt_struct.day);
+    }
+    return duckdb_to_date(dt_struct);
+}
+
 duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     duckdb_date_struct dt_struct;
 
@@ -7,7 +40,7 @@ duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE da
     dt_struct.month = NUM2INT(month);
     dt_struct.day = NUM2INT(day);
 
-    return duckdb_to_date(dt_struct);
+    return to_duckdb_date(dt_struct);
 }
 
 duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
@@ -47,6 +80,9 @@ 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) {
     duckdb_timestamp_struct timestamp_st;
+    duckdb_timestamp result;
+    int64_t days;
+    int64_t time_micros;
 
     timestamp_st.date.year = NUM2INT(year);
     timestamp_st.date.month = NUM2INT(month);
@@ -56,7 +92,22 @@ duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month
     timestamp_st.time.sec = NUM2INT(sec);
     timestamp_st.time.micros = NUM2INT(micros);
 
-    return duckdb_to_timestamp(timestamp_st);
+    /* Mirrors DuckDB's Timestamp::TryFromDatetime; duckdb_to_timestamp throws on failure. */
+    days = to_duckdb_date(timestamp_st.date).days;
+    time_micros = duckdb_to_time(timestamp_st.time).micros;
+    if (days > INT64_MAX / MICROS_PER_DAY || days < INT64_MIN / MICROS_PER_DAY) {
+        rb_raise(rb_eRangeError, "timestamp out of range");
+    }
+    result.micros = days * MICROS_PER_DAY;
+    if ((time_micros > 0 && result.micros > INT64_MAX - time_micros) ||
+        (time_micros < 0 && result.micros < INT64_MIN - time_micros)) {
+        rb_raise(rb_eRangeError, "timestamp out of range");
+    }
+    result.micros += time_micros;
+    if (!duckdb_is_finite_timestamp(result)) {
+        rb_raise(rb_eRangeError, "timestamp out of range");
+    }
+    return result;
 }
 
 void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {

data/lib/duckdb/interval.rb

@@ -103,12 +103,10 @@ module DuckDB
 
       def matched_to_i(matched) # :nodoc:
         sign = to_sign(matched)
-        sec = to_sec(matched)
+        year, month, day, hour, min, sec = %i[year month day hour min sec].map { |k| matched[k].to_i }
         usec = to_usec(matched)
         usec *= -1 if sec.negative?
-        value = [
-          to_year(matched), to_month(matched), to_day(matched), to_hour(matched), to_min(matched), sec, usec
-        ]
+        value = [year, month, day, hour, min, sec, usec]
         sign.positive? ? value : value.map { |v| v * sign }
       end
 
@@ -116,30 +114,6 @@ module DuckDB
         matched[:negativ] == '-' ? -1 : 1
       end
 
-      def to_year(matched) # :nodoc:
-        matched[:year].to_i
-      end
-
-      def to_month(matched) # :nodoc:
-        matched[:month].to_i
-      end
-
-      def to_day(matched) # :nodoc:
-        matched[:day].to_i
-      end
-
-      def to_hour(matched) # :nodoc:
-        matched[:hour].to_i
-      end
-
-      def to_min(matched) # :nodoc:
-        matched[:min].to_i
-      end
-
-      def to_sec(matched) # :nodoc:
-        matched[:sec].to_i
-      end
-
       def to_usec(matched) # :nodoc:
         matched[:usec].to_s.ljust(6, '0')[0, 6].to_i
       end

data/lib/duckdb/prepared_statement.rb

@@ -332,6 +332,11 @@ module DuckDB
       decimal = _parse_deciaml(value)
       lower, upper = decimal_to_hugeint(decimal)
       width = _decimal_width(decimal)
+      # _bind_decimal narrows width to uint8, and DuckDB aborts on a mismatched width.
+      unless RANGE_DECIMAL_WIDTH.cover?(width)
+        raise ArgumentError, "value out of range for DECIMAL width (#{RANGE_DECIMAL_WIDTH})"
+      end
+
       _bind_decimal(index, lower, upper, width, decimal.scale)
     end
 

data/lib/duckdb/scalar_function_set.rb

@@ -11,8 +11,7 @@ module DuckDB
     def initialize(name)
       raise TypeError, "#{name.class} is not a String or Symbol" unless name.is_a?(String) || name.is_a?(Symbol)
 
-      @name = name.to_s
-      _initialize(@name)
+      _initialize(name.to_s)
     end
 
     # @param scalar_function [DuckDB::ScalarFunction] the overload to add

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 = '2.0.0.0'
+  VERSION = '2.0.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 2.0.0.0
+  version: 2.0.0.1
 platform: ruby
 authors:
 - Masaki Suketa