duckdb 1.5.6.1 → 2.0.0.1

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/table_function_bind_info.c

@@ -76,18 +76,13 @@ static VALUE table_function_bind_info_get_parameter(VALUE self, VALUE index) {
     rubyDuckDBBindInfo *ctx;
     idx_t idx;
     duckdb_value param_value;
-    VALUE result;
 
     TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
 
     idx = NUM2ULL(index);
     param_value = duckdb_bind_get_parameter(ctx->bind_info, idx);
 
-    result = rbduckdb_duckdb_value_to_ruby(param_value);
-
-    duckdb_destroy_value(&param_value);
-
-    return result;
+    return rbduckdb_duckdb_value_to_ruby_and_destroy(param_value);
 }
 
 /*
@@ -102,7 +97,6 @@ static VALUE table_function_bind_info_get_named_parameter(VALUE self, VALUE name
     rubyDuckDBBindInfo *ctx;
     const char *param_name;
     duckdb_value param_value;
-    VALUE result;
 
     TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
 
@@ -114,11 +108,7 @@ static VALUE table_function_bind_info_get_named_parameter(VALUE self, VALUE name
         return Qnil;
     }
 
-    result = rbduckdb_duckdb_value_to_ruby(param_value);
-
-    duckdb_destroy_value(&param_value);
-
-    return result;
+    return rbduckdb_duckdb_value_to_ruby_and_destroy(param_value);
 }
 
 /*

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/ext/duckdb/value.c

@@ -1,5 +1,10 @@
 #include "ruby-duckdb.h"
 
+struct vector_ref_arg {
+    duckdb_vector vec;
+    duckdb_logical_type logical_type;
+};
+
 VALUE cDuckDBValue;
 
 static void deallocate(void *);
@@ -37,6 +42,10 @@ static VALUE value_s__create_bit(VALUE klass, VALUE data);
 static VALUE value_s__create_bignum(VALUE klass, VALUE data, VALUE is_negative);
 static VALUE value_s_create_null(VALUE klass);
 static VALUE to_ruby_via_vector(duckdb_logical_type logical_type, duckdb_value val);
+static VALUE convert_referenced_value(VALUE varg);
+static VALUE destroy_referencing_vector(VALUE varg);
+static VALUE convert_owned_value(VALUE varg);
+static VALUE destroy_owned_value(VALUE varg);
 static idx_t marshal_values(VALUE ary, duckdb_value **out, volatile VALUE *guard);
 static VALUE value_s__create_list(VALUE klass, VALUE ltype, VALUE values);
 static VALUE value_s__create_array(VALUE klass, VALUE ltype, VALUE values);
@@ -557,19 +566,43 @@ rubyDuckDBValue *rbduckdb_get_struct_value(VALUE obj) {
  * the C API has no direct duckdb_get_* accessors for.
  */
 static VALUE to_ruby_via_vector(duckdb_logical_type logical_type, duckdb_value val) {
-    duckdb_vector vec = duckdb_create_vector(logical_type, 1);
-    VALUE result;
+    struct vector_ref_arg arg;
 
-    duckdb_vector_reference_value(vec, val);
-    result = rbduckdb_vector_value_at(vec, logical_type, 0);
-    duckdb_destroy_vector(&vec);
-    return result;
+    arg.vec = duckdb_create_vector(logical_type, 1);
+    arg.logical_type = logical_type;
+    duckdb_vector_reference_value(arg.vec, val);
+    return rb_ensure(convert_referenced_value, (VALUE)&arg, destroy_referencing_vector, (VALUE)&arg);
+}
+
+static VALUE convert_referenced_value(VALUE varg) {
+    struct vector_ref_arg *arg = (struct vector_ref_arg *)varg;
+
+    return rbduckdb_vector_value_at(arg->vec, arg->logical_type, 0);
+}
+
+static VALUE destroy_referencing_vector(VALUE varg) {
+    struct vector_ref_arg *arg = (struct vector_ref_arg *)varg;
+
+    duckdb_destroy_vector(&(arg->vec));
+    return Qnil;
+}
+
+static VALUE convert_owned_value(VALUE varg) {
+    return rbduckdb_duckdb_value_to_ruby(*(duckdb_value *)varg);
+}
+
+static VALUE destroy_owned_value(VALUE varg) {
+    duckdb_destroy_value((duckdb_value *)varg);
+    return Qnil;
+}
+
+VALUE rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_value val) {
+    return rb_ensure(convert_owned_value, (VALUE)&val, destroy_owned_value, (VALUE)&val);
 }
 
 VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
     duckdb_logical_type logical_type;
     duckdb_type type_id;
-    duckdb_value child_value;
     VALUE result;
     VALUE elem;
     VALUE key;
@@ -676,9 +709,7 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
             size = duckdb_get_list_size(val);
             result = rb_ary_new_capa(size);
             for (i = 0; i < size; i++) {
-                child_value = duckdb_get_list_child(val, i);
-                elem = rbduckdb_duckdb_value_to_ruby(child_value);
-                duckdb_destroy_value(&child_value);
+                elem = rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_get_list_child(val, i));
                 rb_ary_push(result, elem);
             }
             break;
@@ -687,23 +718,18 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
             result = rb_hash_new();
             for (i = 0; i < size; i++) {
                 str = duckdb_struct_type_child_name(logical_type, i);
-                child_value = duckdb_get_struct_child(val, i);
-                elem = rbduckdb_duckdb_value_to_ruby(child_value);
-                duckdb_destroy_value(&child_value);
-                rb_hash_aset(result, ID2SYM(rb_intern(str)), elem);
+                key = ID2SYM(rb_intern(str));
                 duckdb_free(str);
+                elem = rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_get_struct_child(val, i));
+                rb_hash_aset(result, key, elem);
             }
             break;
         case DUCKDB_TYPE_MAP:
             size = duckdb_get_map_size(val);
             result = rb_hash_new();
             for (i = 0; i < size; i++) {
-                child_value = duckdb_get_map_key(val, i);
-                key = rbduckdb_duckdb_value_to_ruby(child_value);
-                duckdb_destroy_value(&child_value);
-                child_value = duckdb_get_map_value(val, i);
-                elem = rbduckdb_duckdb_value_to_ruby(child_value);
-                duckdb_destroy_value(&child_value);
+                key = rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_get_map_key(val, i));
+                elem = rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_get_map_value(val, i));
                 rb_hash_aset(result, key, elem);
             }
             break;

data/ext/duckdb/value.h

@@ -10,6 +10,7 @@ typedef struct _rubyDuckDBValue rubyDuckDBValue;
 void rbduckdb_init_value(void);
 VALUE rbduckdb_value_new(duckdb_value value);
 VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val);
+VALUE rbduckdb_duckdb_value_to_ruby_and_destroy(duckdb_value val);
 rubyDuckDBValue *rbduckdb_get_struct_value(VALUE obj);
 
 #endif

data/lib/duckdb/appender.rb

@@ -7,10 +7,9 @@ require_relative 'converter'
 module DuckDB
   # The DuckDB::Appender encapsulates DuckDB Appender.
   #
-  # The +table+ argument (2nd positional argument) supports dot-notation and quoting:
-  #
-  # - <tt>'schema.table'</tt> — interpreted as schema-qualified (deprecated; use +schema:+ instead)
-  # - <tt>'"schema.table"'</tt> or <tt>"'schema.table'"</tt> — treated as a literal table name containing a dot
+  # The +table+ argument (2nd positional argument) is used as a literal table name,
+  # even if it contains a dot. Use the +schema:+ and +catalog:+ keywords to qualify the table.
+  # Surrounding double or single quotes (<tt>'"a.b"'</tt> or <tt>"'a.b'"</tt>) are stripped.
   #
   #   require 'duckdb'
   #   db = DuckDB::Database.open
@@ -26,13 +25,10 @@ module DuckDB
       alias from_query create_query
     end
 
-    def initialize(con, table_or_schema, table = nil, schema: nil, catalog: nil)
-      if table
-        warn_deprecated_3arg
-        _initialize(con, table_or_schema, table)
-      else
-        initialize_with_parsed_table(con, table_or_schema, schema: schema, catalog: catalog)
-      end
+    def initialize(con, table, schema: nil, catalog: nil)
+      raise DuckDB::Error, '2nd argument must be table name.' if table.nil?
+
+      initialize_with_parsed_table(con, table, schema: schema, catalog: catalog)
     end
 
     # :call-seq:
@@ -801,14 +797,6 @@ module DuckDB
 
     private
 
-    def warn_deprecated_3arg # :nodoc:
-      warn(
-        'DuckDB::Appender.new(con, schema, table) is deprecated. ' \
-        'Use DuckDB::Appender.new(con, table, schema: schema) instead.',
-        category: :deprecated
-      )
-    end
-
     def initialize_with_parsed_table(con, table_name, schema:, catalog:) # :nodoc:
       table_name, schema, catalog = parse_table_name(table_name, schema, catalog)
       if catalog

data/lib/duckdb/config.rb

@@ -6,7 +6,7 @@ module DuckDB
   #   require 'duckdb'
   #   config = DuckDB::Config.new
   #   config['default_order'] = 'DESC'
-  #   db = DuckDB::Database.open(nil, config)
+  #   db = DuckDB::Database.open(config: config)
   #   con = db.connect
   #   con.query('CREATE TABLE numbers (number INTEGER)')
   #   con.query('INSERT INTO numbers VALUES (2), (1), (4), (3)')
@@ -49,7 +49,7 @@ module DuckDB
     #   # config.set_config('default_order', 'DESC')
     #   config['default_order'] = 'DESC'
     #
-    #   db = DuckDB::Database.open(nil, config)
+    #   db = DuckDB::Database.open(config: config)
     #   con = db.connect
     #   con.query('CREATE TABLE numbers (number INTEGER)')
     #   con.query('INSERT INTO numbers VALUES (2), (1), (4), (3)')

data/lib/duckdb/connection.rb

@@ -8,8 +8,6 @@ module DuckDB
   #   con = db.connect
   #   con.query(sql)
   class Connection
-    include DuckDB::TableNameParser
-
     # executes sql with args.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
@@ -84,11 +82,27 @@ module DuckDB
     #   pending_result.execute_task while pending_result.state == :not_ready
     #   result = pending_result.execute_pending
     #   result.each.first
+    #
+    # If a block is given, the block is executed with the DuckDB::PendingResult
+    # object, the block's value is returned, and the object is destroyed
+    # after the block. The yielded PendingResult must not be used after the block.
+    #
+    #   con.async_query(sql, name: 'Dave', email: 'dave@example.com') do |pending|
+    #     pending.execute_task while pending.state == :not_ready
+    #     pending.execute_pending.each.first
+    #   end
     def async_query(sql, *args, **kwargs)
-      prepare(sql) do |stmt|
+      pending = prepare(sql) do |stmt|
         stmt.bind_args(*args, **kwargs)
         stmt.pending_prepared
       end
+      return pending unless block_given?
+
+      begin
+        yield pending
+      ensure
+        pending.destroy
+      end
     end
 
     # connects DuckDB database
@@ -140,8 +154,8 @@ module DuckDB
     #
     # Raises DuckDB::Error if the table (or schema/catalog) does not exist.
     #
-    # Table name parsing (quoting, dot-notation) is handled by DuckDB::Appender.new.
-    # See DuckDB::Appender.new for details on quoting and dot-notation.
+    # Table name parsing (quoting) is handled by DuckDB::Appender.new.
+    # A table name containing a dot is used literally; use +schema:+ to qualify the table.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -164,7 +178,6 @@ module DuckDB
     #   appender.append_row(4, 'Dave')
     #   appender.close
     def appender(table, schema: nil, catalog: nil, &)
-      table, schema, catalog = parse_connection_appender_table(table, schema, catalog)
       run_appender_block(Appender.new(self, table, schema: schema, catalog: catalog), &)
     end
 
@@ -466,17 +479,6 @@ module DuckDB
       appender.close
     end
 
-    # Silently pre-parses dot-notation so Appender.new receives clean values
-    # and does not emit a misleading "DuckDB::Appender.new" warning.
-    # con.appender('a.b') has always split on dot — no warning needed.
-    # Quoted table names pass through unchanged for Appender.new to handle.
-    def parse_connection_appender_table(table, schema, catalog)
-      return [table, schema, catalog] if quoted_table_name?(table)
-      return [table, schema, catalog] unless table.include?('.')
-
-      dot_notation_split(table, schema, catalog)
-    end
-
     alias execute query
     alias async_execute async_query
     alias open connect

data/lib/duckdb/database.rb

@@ -50,9 +50,7 @@ module DuckDB
       #     con = db.connect
       #     con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
       #   end
-      def open(path = :memory, *args, config: nil)
-        path, config = _handle_deprecated_open_args(path, args, config)
-
+      def open(path = :memory, config: nil)
         db = new(path, config: config)
         return db unless block_given?
 
@@ -62,21 +60,6 @@ module DuckDB
           db.close
         end
       end
-
-      private
-
-      def _handle_deprecated_open_args(path, args, config)
-        unless args.empty?
-          raise TypeError, "expected DuckDB::Config, got #{args.first.class}" unless args.first.is_a?(DuckDB::Config)
-
-          warn 'DuckDB::Database.open(path, config) is deprecated. ' \
-               'Use DuckDB::Database.open(path, config: config) instead.'
-          config = args.first
-        end
-
-        path = :memory if path.nil?
-        [path, config]
-      end
     end
 
     private

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/pending_result.rb

@@ -18,6 +18,13 @@ module DuckDB
   #     pending_result.execute_task
   #   end
   #   result = pending_result.execute_pending
+  #
+  # Call +destroy+ to release a pending result without fetching it. On
+  # DuckDB >= 2.0 an unfetched pending result blocks its connection until it
+  # is destroyed. After +destroy+, +state+ (and +execution_finished?+) report
+  # :error, and +execute_task+, +execute_pending+ and +execute_check_state+
+  # raise DuckDB::Error. A DuckDB::Result already returned by
+  # +execute_pending+ stays readable.
   class PendingResult
     STATES = %i[ready not_ready error no_tasks].freeze # :nodoc:
 

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