duckdb 1.5.6.1 → 2.0.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74ccac3599175a19bbc80ef6e9ad8e9aae62152d96b78dd6357623f647b62ff2
-  data.tar.gz: 9302451535c8b0b32f561a7deb45bd0f1800a77889592308c5e94714abd5fa33
+  metadata.gz: ee2e890f808c2ff97b099f79c12f17a8fe856253b13a3ee2378bbb21306e3587
+  data.tar.gz: a7081554ee0ff1ebb22d688f9aafab9b434c93cb080f2abcc7ffe1e9ae3f70d1
 SHA512:
-  metadata.gz: 29981f3882568513062d0a59e04e434dd8b557635c70b51fb2bfc017a077bf7076a10b384b676a7c32e7bf0d6d24420622e4e04164fced341b9165fe11cce062
-  data.tar.gz: e16e3171bd0c0f8f0e26f2c48e6f3a4d73fb1c93b00a01a4ae5d790a66ea0a198aa722d91790eb95e3b4fb1f66e167e3a69cf0377effa39138e801d7eb9eac16
+  metadata.gz: b13a967b1e810a51220080b227b8b6dd5098e56775567b049ed722ec3a9dec02f3fe97c399fbd8a88e292bc65888ce905ef5b908f182e110abf785d2ff2aa94e
+  data.tar.gz: ff96826d03f74eedb1633bc5256addb916abd737741636918748d0fcd65c0527669100b96103beff430184a6a8b21b4387fffb2351888898c1729c4c335d01be

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 2.0.0.0 - 2026-10-24
+- bump Ruby to 4.0.9 on CI (Ubuntu and macOS).
+- bump up DuckDB 2.0.0 on CI.
+- add `DuckDB::PendingResult#destroy` (issue #1497).
+- add block form to `DuckDB::Connection#async_query` that destroys the `DuckDB::PendingResult` after the block (issue #1498).
+
+## Breaking Changes
+- remove `DuckDB::BindInfo`, `DuckDB::InitInfo` and `DuckDB::FunctionInfo` (deprecated aliases). Use `DuckDB::TableFunction::BindInfo`, `DuckDB::TableFunction::InitInfo` and `DuckDB::TableFunction::FunctionInfo`.
+- remove the positional config form `DuckDB::Database.open(path, config)`. Use `DuckDB::Database.open(path, config: config)`.
+- remove the 3-argument form `DuckDB::Appender.new(con, schema, table)`. Use `DuckDB::Appender.new(con, table, schema: schema)`.
+- `DuckDB::Appender.new`, `DuckDB::Connection#appender` and `DuckDB::TableDescription.new` no longer split dot-notation table names such as `'schema.table'`. A name containing a dot is used literally as the table name. Use the `schema:` and `catalog:` keyword arguments to qualify a table. Quoted names (`'"a.b"'` / `"'a.b'"`) still have their quotes stripped.
+- remove the private methods `DuckDB::Result#_enum_dictionary_size`, `#_enum_dictionary_value` and `#_column_type`. Use `columns[i].logical_type.dictionary_size`, `columns[i].logical_type.dictionary_value_at(j)` and `columns[i].type`.
+- `DuckDB::PendingResult.new` takes exactly one argument (the prepared statement); the meaningless second argument was removed.
+
 # 1.5.6.1 - 2026-10-17
 - fix `DuckDB::ExtractedStatements.new`, `Connection#query` and `Connection#extract` raising `Failed to extract statements(Database connection closed?).` for SQL that contains no statements, such as only a comment, whitespace or `;` (issue #1490). `ExtractedStatements#size` is now `0`, `Connection#query` returns `nil` and `Connection#extract` returns `[]`. Calling `ExtractedStatements.new` on a closed connection now raises `Database connection closed`.
 

data/README.md

@@ -251,7 +251,7 @@ 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)')

data/ext/duckdb/arrow_array_stream.c

@@ -62,8 +62,11 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBArrowArrayStream);
 }
 
-/* Context memory is managed with plain malloc/free because the release
- * callback may run outside Ruby's memory bookkeeping. */
+/*
+ * Use malloc/free (not xmalloc/xfree): the stream callbacks are invoked by
+ * Arrow consumers, possibly from a non-Ruby thread where xmalloc/xfree are
+ * unsafe.
+ */
 static void stream_set_error(arrowArrayStreamContext *ctx, const char *msg) {
     size_t len = strlen(msg) + 1;
 
@@ -96,6 +99,7 @@ static int stream_get_schema(struct ArrowArrayStream *stream, struct ArrowSchema
     idx_t i;
 
     column_count = duckdb_column_count(&(ctx->presult_ctx->result));
+    /* Use calloc (not xcalloc): see stream_set_error. */
     types = calloc((size_t)column_count, sizeof(duckdb_logical_type));
     names = calloc((size_t)column_count, sizeof(const char *));
     if (column_count > 0 && (types == NULL || names == NULL)) {
@@ -172,6 +176,10 @@ VALUE rbduckdb_create_arrow_array_stream(VALUE oDuckDBResult) {
     TypedData_Get_Struct(obj, rubyDuckDBArrowArrayStream, &arrow_array_stream_data_type, p);
     presult_ctx = rbduckdb_get_struct_result(oDuckDBResult);
 
+    /*
+     * Use calloc (not xcalloc): stream_release frees the context, possibly
+     * from a non-Ruby thread where xfree is unsafe.
+     */
     ctx = calloc((size_t)1, sizeof(arrowArrayStreamContext));
     if (ctx == NULL) {
         rb_raise(rb_eNoMemError, "failed to allocate ArrowArrayStream context");

data/ext/duckdb/expression.c

@@ -71,7 +71,6 @@ static VALUE expression__fold(VALUE self, VALUE client_context) {
     rubyDuckDBClientContext *cc_ctx;
     duckdb_value out_value = NULL;
     duckdb_error_data error_data;
-    VALUE result;
 
     TypedData_Get_Struct(self, rubyDuckDBExpression, &expression_data_type, expr_ctx);
     cc_ctx = rbduckdb_get_struct_client_context(client_context);
@@ -88,9 +87,7 @@ static VALUE expression__fold(VALUE self, VALUE client_context) {
     }
     duckdb_destroy_error_data(&error_data);
 
-    result = rbduckdb_duckdb_value_to_ruby(out_value);
-    duckdb_destroy_value(&out_value);
-    return result;
+    return rbduckdb_duckdb_value_to_ruby_and_destroy(out_value);
 }
 
 void rbduckdb_init_expression(void) {

data/ext/duckdb/pending_result.c

@@ -5,12 +5,14 @@ static VALUE cDuckDBPendingResult;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE pending_result_initialize(int argc, VALUE *args, VALUE self);
+static VALUE pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement);
 static VALUE pending_result_execute_task(VALUE self);
+static VALUE pending_result_destroy(VALUE self);
 static VALUE pending_result_execute_pending(VALUE self);
 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);
+static rubyDuckDBPendingResult *get_live_pending_result(VALUE self);
 
 /*
  * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
@@ -30,6 +32,28 @@ static void deallocate(void *ctx) {
     xfree(p);
 }
 
+/*
+ * Returns the struct, raising DuckDB::Error if the pending result was
+ * destroyed or never initialized.
+ */
+static rubyDuckDBPendingResult *get_live_pending_result(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
+    if (!ctx->pending_result) {
+        rb_raise(eDuckDBError, "pending result is already destroyed or not initialized");
+    }
+    return ctx;
+}
+
+/*
+ * duckdb_destroy_pending can block (cancelling the pipeline may run UDF
+ * teardown callbacks that need the GVL, or shut the database down), so it
+ * is called without the GVL. See database_close in database.c.
+ */
+static void *destroy_pending_without_gvl(void *ctx) {
+    duckdb_destroy_pending((duckdb_pending_result *)ctx);
+    return NULL;
+}
+
 static VALUE allocate(VALUE klass) {
     rubyDuckDBPendingResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPendingResult));
     ctx->state = DUCKDB_PENDING_RESULT_NOT_READY;
@@ -40,16 +64,9 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBPendingResult);
 }
 
-static VALUE pending_result_initialize(int argc, VALUE *argv, VALUE self) {
-    VALUE oDuckDBPreparedStatement;
-    VALUE streaming_p = Qfalse;
+static VALUE pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement) {
     duckdb_state state;
 
-    if (argc == 2) {
-        rb_warn("The second argument of `DuckDB::PendingResult#new` is now meaningless. The result is the same when it is set to true.");
-    }
-    rb_scan_args(argc, argv, "11", &oDuckDBPreparedStatement, &streaming_p);
-
     if (rb_obj_is_kind_of(oDuckDBPreparedStatement, cDuckDBPreparedStatement) != Qtrue) {
         rb_raise(rb_eTypeError, "1st argument must be DuckDB::PreparedStatement");
     }
@@ -77,11 +94,31 @@ static VALUE pending_result_initialize(int argc, VALUE *argv, VALUE self) {
  *  pending_result.execute_task
  */
 static VALUE pending_result_execute_task(VALUE self) {
-    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
+    rubyDuckDBPendingResult *ctx = get_live_pending_result(self);
     ctx->state = duckdb_pending_execute_task(ctx->pending_result);
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   pending_result.destroy -> nil
+ *
+ * Releases the pending result without executing it. Required on DuckDB >= 2.0.0,
+ * where an open pending result blocks the connection. Safe to call more than once.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  pending_result = conn.async_query("slow query")
+ *  pending_result.destroy
+ *  conn.query("SELECT 1")
+ */
+static VALUE pending_result_destroy(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
+    rb_thread_call_without_gvl(destroy_pending_without_gvl, &(ctx->pending_result), NULL, NULL);
+    ctx->state = DUCKDB_PENDING_ERROR;
+    return Qnil;
+}
+
 static VALUE pending_result_execution_finished_p(VALUE self) {
     rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
     return duckdb_pending_execution_is_finished(ctx->state) ? Qtrue : Qfalse;
@@ -102,9 +139,10 @@ static VALUE pending_result_execution_finished_p(VALUE self) {
 static VALUE pending_result_execute_pending(VALUE self) {
     rubyDuckDBPendingResult *ctx;
     rubyDuckDBResult *ctxr;
-    VALUE result = rbduckdb_create_result();
+    VALUE result;
 
-    TypedData_Get_Struct(self, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
+    ctx = get_live_pending_result(self);
+    result = rbduckdb_create_result();
     ctxr = rbduckdb_get_struct_result(result);
     if (duckdb_execute_pending(ctx->pending_result, &(ctxr->result)) == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
@@ -120,7 +158,7 @@ static VALUE pending_result__state(VALUE self) {
 
 /* :nodoc: */
 static VALUE pending_result__execute_check_state(VALUE self) {
-    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
+    rubyDuckDBPendingResult *ctx = get_live_pending_result(self);
     return INT2FIX(duckdb_pending_execute_check_state(ctx->pending_result));
 }
 
@@ -137,8 +175,9 @@ void rbduckdb_init_pending_result(void) {
     cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
     rb_define_alloc_func(cDuckDBPendingResult, allocate);
 
-    rb_define_method(cDuckDBPendingResult, "initialize", pending_result_initialize, -1);
+    rb_define_method(cDuckDBPendingResult, "initialize", pending_result_initialize, 1);
     rb_define_method(cDuckDBPendingResult, "execute_task", pending_result_execute_task, 0);
+    rb_define_method(cDuckDBPendingResult, "destroy", pending_result_destroy, 0);
     rb_define_method(cDuckDBPendingResult, "execute_pending", pending_result_execute_pending, 0);
     rb_define_method(cDuckDBPendingResult, "execution_finished?", pending_result_execution_finished_p, 0);
     rb_define_private_method(cDuckDBPendingResult, "_state", pending_result__state, 0);

data/ext/duckdb/result.c

@@ -3,6 +3,30 @@
 struct chunk_arg {
     duckdb_data_chunk chunk;
     idx_t col_count;
+    duckdb_logical_type *types;
+};
+
+struct owned_type_arg {
+    duckdb_vector vector;
+    duckdb_logical_type type;
+    idx_t bgn;
+    idx_t end;
+};
+
+struct struct_fields_arg {
+    duckdb_logical_type ty;
+    duckdb_vector vector;
+    idx_t row_idx;
+    duckdb_logical_type child_type;
+};
+
+struct map_entries_arg {
+    duckdb_vector key_vector;
+    duckdb_vector value_vector;
+    duckdb_logical_type key_type;
+    duckdb_logical_type value_type;
+    idx_t bgn;
+    idx_t end;
 };
 
 static VALUE cDuckDBResult;
@@ -14,6 +38,7 @@ static VALUE result_column_count(VALUE oDuckDBResult);
 static VALUE result_rows_changed(VALUE oDuckDBResult);
 static VALUE result_columns(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
+static duckdb_logical_type *result_column_types(rubyDuckDBResult *ctx);
 
 static VALUE result__chunk_stream(VALUE oDuckDBResult);
 static VALUE result_arrow_c_stream(VALUE oDuckDBResult);
@@ -46,7 +71,13 @@ static VALUE vector_bit(void* vector_data, idx_t row_idx);
 static VALUE vector_time_tz(void* vector_data, idx_t row_idx);
 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);
+static VALUE convert_values_in_range(VALUE varg);
+static VALUE destroy_owned_type(VALUE varg);
+static VALUE vector_values_with_owned_type(duckdb_vector vector, duckdb_logical_type type, idx_t bgn, idx_t end);
+static VALUE convert_map_entries(VALUE varg);
+static VALUE destroy_map_types(VALUE varg);
+static VALUE convert_struct_fields(VALUE varg);
+static VALUE destroy_struct_child_type(VALUE varg);
 
 /*
  * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
@@ -66,6 +97,11 @@ static void deallocate(void *ctx) {
 }
 
 static VALUE allocate(VALUE klass) {
+    /*
+     * Use calloc (not xcalloc): rbduckdb_result_unref frees the struct, and it
+     * can run from the Arrow stream release callback on a non-Ruby thread
+     * where xfree is unsafe.
+     */
     rubyDuckDBResult *ctx = calloc((size_t)1, sizeof(rubyDuckDBResult));
 
     if (ctx == NULL) {
@@ -80,7 +116,13 @@ void rbduckdb_result_ref(rubyDuckDBResult *ctx) {
 }
 
 void rbduckdb_result_unref(rubyDuckDBResult *ctx) {
+    idx_t col_idx;
+
     if (RUBY_ATOMIC_FETCH_SUB(ctx->refcount, 1) == 1) {
+        for (col_idx = 0; col_idx < ctx->column_types_count; col_idx++) {
+            duckdb_destroy_logical_type(&(ctx->column_types[col_idx]));
+        }
+        free(ctx->column_types);
         duckdb_destroy_result(&(ctx->result));
         free(ctx);
     }
@@ -176,6 +218,25 @@ static VALUE destroy_data_chunk(VALUE arg) {
     return Qnil;
 }
 
+static duckdb_logical_type *result_column_types(rubyDuckDBResult *ctx) {
+    idx_t col_idx;
+    idx_t column_count;
+
+    if (ctx->column_types == NULL) {
+        column_count = duckdb_column_count(&(ctx->result));
+        /* Use calloc (not xcalloc): freed by rbduckdb_result_unref (see allocate). */
+        ctx->column_types = calloc(column_count + 1, sizeof(duckdb_logical_type));
+        if (ctx->column_types == NULL) {
+            rb_raise(rb_eNoMemError, "failed to allocate DuckDB::Result column types");
+        }
+        for (col_idx = 0; col_idx < column_count; col_idx++) {
+            ctx->column_types[col_idx] = duckdb_column_logical_type(&(ctx->result), col_idx);
+        }
+        ctx->column_types_count = column_count;
+    }
+    return ctx->column_types;
+}
+
 /* :nodoc: */
 static VALUE result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
@@ -186,6 +247,7 @@ static VALUE result__chunk_stream(VALUE oDuckDBResult) {
     RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
 
     arg.col_count = duckdb_column_count(&(ctx->result));
+    arg.types = result_column_types(ctx);
 
     while((arg.chunk = duckdb_fetch_chunk(ctx->result)) != NULL) {
         rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
@@ -208,7 +270,7 @@ static VALUE yield_rows(VALUE arg) {
         row = rb_ary_new2(p->col_count);
         for (col_idx = 0; col_idx < p->col_count; col_idx++) {
             vector = duckdb_data_chunk_get_vector(p->chunk, col_idx);
-            val = vector_value(vector, row_idx);
+            val = rbduckdb_vector_value_at(vector, p->types[col_idx], row_idx);
             rb_ary_store(row, col_idx, val);
         }
         rb_yield(row);
@@ -371,23 +433,11 @@ static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_id
 }
 
 static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
-    VALUE ary = Qnil;
-    VALUE value = Qnil;
-
-    duckdb_logical_type child_logical_type = duckdb_array_type_child_type(ty);
     idx_t size = duckdb_array_type_array_size(ty);
     idx_t bgn = row_idx * size;
-    idx_t end = bgn + size;
-	duckdb_vector child = duckdb_array_vector_get_child(vector);
+    duckdb_vector child = duckdb_array_vector_get_child(vector);
 
-    ary = rb_ary_new2(size);
-    for (idx_t i = bgn; i < end; ++i) {
-        value = rbduckdb_vector_value_at(child, child_logical_type, i);
-        rb_ary_store(ary, i - bgn, value);
-    }
-
-    duckdb_destroy_logical_type(&child_logical_type);
-    return ary;
+    return vector_values_with_owned_type(child, duckdb_array_type_child_type(ty), bgn, bgn + size);
 }
 
 VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
@@ -519,93 +569,121 @@ VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element
 }
 
 static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, void * vector_data, idx_t row_idx) {
-    VALUE ary = Qnil;
-    VALUE value = Qnil;
-    idx_t i;
-
-    duckdb_logical_type child_logical_type = duckdb_list_type_child_type(ty);
-
     duckdb_list_entry list_entry = ((duckdb_list_entry *)vector_data)[row_idx];
     idx_t bgn = list_entry.offset;
-    idx_t end = bgn + list_entry.length;
-    ary = rb_ary_new2(list_entry.length);
-
     duckdb_vector child = duckdb_list_vector_get_child(vector);
 
-    for (i = bgn; i < end; ++i) {
-        value = rbduckdb_vector_value_at(child, child_logical_type, i);
-        rb_ary_store(ary, i - bgn, value);
-    }
-    duckdb_destroy_logical_type(&child_logical_type);
-    return ary;
+    return vector_values_with_owned_type(child, duckdb_list_type_child_type(ty), bgn, bgn + list_entry.length);
 }
 
 static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx) {
-    VALUE hash = rb_hash_new();
-    VALUE key = Qnil;
-    VALUE value = Qnil;
-
-    duckdb_logical_type key_logical_type = duckdb_map_type_key_type(ty);
-    duckdb_logical_type value_logical_type = duckdb_map_type_value_type(ty);
-
+    struct map_entries_arg arg;
     duckdb_list_entry list_entry = ((duckdb_list_entry *)vector_data)[row_idx];
+    duckdb_vector child = duckdb_list_vector_get_child(vector);
 
-    idx_t bgn = list_entry.offset;
-    idx_t end = bgn + list_entry.length;
+    arg.key_vector = duckdb_struct_vector_get_child(child, 0);
+    arg.value_vector = duckdb_struct_vector_get_child(child, 1);
+    arg.key_type = duckdb_map_type_key_type(ty);
+    arg.value_type = duckdb_map_type_value_type(ty);
+    arg.bgn = list_entry.offset;
+    arg.end = list_entry.offset + list_entry.length;
 
-    duckdb_vector child = duckdb_list_vector_get_child(vector);
-    duckdb_vector key_vector = duckdb_struct_vector_get_child(child, 0);
-    duckdb_vector value_vector = duckdb_struct_vector_get_child(child, 1);
+    return rb_ensure(convert_map_entries, (VALUE)&arg, destroy_map_types, (VALUE)&arg);
+}
 
-    for (idx_t i = bgn; i < end; ++i) {
-        key = rbduckdb_vector_value_at(key_vector, key_logical_type, i);
-        value = rbduckdb_vector_value_at(value_vector, value_logical_type, i);
+static VALUE convert_map_entries(VALUE varg) {
+    struct map_entries_arg *arg = (struct map_entries_arg *)varg;
+    VALUE hash = rb_hash_new();
+    VALUE key;
+    VALUE value;
+
+    for (idx_t i = arg->bgn; i < arg->end; ++i) {
+        key = rbduckdb_vector_value_at(arg->key_vector, arg->key_type, i);
+        value = rbduckdb_vector_value_at(arg->value_vector, arg->value_type, i);
         rb_hash_aset(hash, key, value);
     }
-
-    duckdb_destroy_logical_type(&key_logical_type);
-    duckdb_destroy_logical_type(&value_logical_type);
     return hash;
 }
 
+static VALUE destroy_map_types(VALUE varg) {
+    struct map_entries_arg *arg = (struct map_entries_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->key_type));
+    duckdb_destroy_logical_type(&(arg->value_type));
+    return Qnil;
+}
+
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    struct struct_fields_arg arg = {ty, vector, row_idx, NULL};
+
+    return rb_ensure(convert_struct_fields, (VALUE)&arg, destroy_struct_child_type, (VALUE)&arg);
+}
+
+static VALUE convert_struct_fields(VALUE varg) {
+    struct struct_fields_arg *arg = (struct struct_fields_arg *)varg;
     VALUE hash = rb_hash_new();
     VALUE value = Qnil;
     VALUE key = Qnil;
     duckdb_vector child;
-    duckdb_logical_type child_type;
     char *p;
 
-    idx_t child_count = duckdb_struct_type_child_count(ty);
+    idx_t child_count = duckdb_struct_type_child_count(arg->ty);
 
     for (idx_t i = 0; i < child_count; ++i) {
-        p = duckdb_struct_type_child_name(ty, i);
+        p = duckdb_struct_type_child_name(arg->ty, i);
         if (p) {
             key = ID2SYM(rb_intern_const(p));
-            child = duckdb_struct_vector_get_child(vector, i);
-            child_type = duckdb_struct_type_child_type(ty, i);
-            value = rbduckdb_vector_value_at(child, child_type, row_idx);
-            rb_hash_aset(hash, key, value);
-            duckdb_destroy_logical_type(&child_type);
             duckdb_free(p);
+            child = duckdb_struct_vector_get_child(arg->vector, i);
+            arg->child_type = duckdb_struct_type_child_type(arg->ty, i);
+            value = rbduckdb_vector_value_at(child, arg->child_type, arg->row_idx);
+            duckdb_destroy_logical_type(&(arg->child_type));
+            rb_hash_aset(hash, key, value);
         }
     }
 
     return hash;
 }
 
+static VALUE destroy_struct_child_type(VALUE varg) {
+    struct struct_fields_arg *arg = (struct struct_fields_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->child_type));
+    return Qnil;
+}
+
 static VALUE vector_union(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx){
-    VALUE value = Qnil;
     duckdb_vector type_vector = duckdb_struct_vector_get_child(vector, 0);
     void *data = duckdb_vector_get_data(type_vector);
     uint8_t index = ((int8_t *)data)[row_idx];
 
-    duckdb_logical_type  child_type = duckdb_union_type_member_type(ty, index);
+    duckdb_vector member_vector = duckdb_struct_vector_get_child(vector, index + 1);
+    VALUE values = vector_values_with_owned_type(member_vector, duckdb_union_type_member_type(ty, index), row_idx, row_idx + 1);
 
-    duckdb_vector vector_value = duckdb_struct_vector_get_child(vector, index + 1);
-    value = rbduckdb_vector_value_at(vector_value, child_type, row_idx);
-    duckdb_destroy_logical_type(&child_type);
-    return value;
+    return rb_ary_entry(values, 0);
+}
+
+static VALUE convert_values_in_range(VALUE varg) {
+    struct owned_type_arg *arg = (struct owned_type_arg *)varg;
+    VALUE ary = rb_ary_new2(arg->end - arg->bgn);
+
+    for (idx_t i = arg->bgn; i < arg->end; ++i) {
+        rb_ary_store(ary, i - arg->bgn, rbduckdb_vector_value_at(arg->vector, arg->type, i));
+    }
+    return ary;
+}
+
+static VALUE destroy_owned_type(VALUE varg) {
+    struct owned_type_arg *arg = (struct owned_type_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->type));
+    return Qnil;
+}
+
+static VALUE vector_values_with_owned_type(duckdb_vector vector, duckdb_logical_type type, idx_t bgn, idx_t end) {
+    struct owned_type_arg arg = {vector, type, bgn, end};
+
+    return rb_ensure(convert_values_in_range, (VALUE)&arg, destroy_owned_type, (VALUE)&arg);
 }
 
 static VALUE str_concat_byte(VALUE str, unsigned char byte, int offset) {
@@ -642,16 +720,17 @@ static VALUE vector_bit(void* vector_data, idx_t row_idx) {
     VALUE str = Qnil;
 
     if(duckdb_string_is_inlined(s)) {
-        length = s.value.inlined.length - 1;
-        p = &s.value.inlined.inlined[1];
-        offset = s.value.inlined.inlined[0];
-        str = bytes_to_string(p, length, offset);
+        length = s.value.inlined.length;
+        p = s.value.inlined.inlined;
     } else {
-        length = s.value.pointer.length - 1;
-        p = &s.value.pointer.ptr[1];
-        offset = s.value.pointer.ptr[0];
-        str = bytes_to_string(p, length, offset);
+        length = s.value.pointer.length;
+        p = s.value.pointer.ptr;
+    }
+    if (length < 2 || (unsigned char)p[0] > 7) {
+        rb_raise(eDuckDBError, "invalid BIT value");
     }
+    offset = (unsigned char)p[0];
+    str = bytes_to_string(p + 1, length - 1, offset);
     return str;
 }
 
@@ -697,18 +776,6 @@ static VALUE result_arrow_c_stream(VALUE oDuckDBResult) {
     return stream;
 }
 
-static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
-    duckdb_logical_type ty;
-    VALUE obj = Qnil;
-
-    ty = duckdb_vector_get_column_type(vector);
-
-    obj = rbduckdb_vector_value_at(vector, ty, row_idx);
-
-    duckdb_destroy_logical_type(&ty);
-    return obj;
-}
-
 void rbduckdb_init_result(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");

data/ext/duckdb/result.h

@@ -12,6 +12,8 @@ struct _rubyDuckDBResult {
     duckdb_result result;
     bool arrow_exported;
     rb_atomic_t refcount;
+    duckdb_logical_type *column_types;
+    idx_t column_types_count;
 };
 
 typedef struct _rubyDuckDBResult rubyDuckDBResult;

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

@@ -95,34 +95,5 @@ module DuckDB
       end
       values
     end
-
-    private
-
-    def _enum_dictionary_size(idx)
-      warn(":_enum_dictionary_size is deprecated. use columns[#{idx}].logical_type.dictionary_size instead.")
-
-      raise ArgumentError, "Invalid index: #{idx}" if idx.negative?
-
-      columns[idx]&.logical_type&.dictionary_size
-    end
-
-    def _enum_dictionary_value(col_index, idx)
-      warn(":_enum_dictionary_value is deprecated.\
-           use columns[#{col_index}].logical_type.dictionary_value_at(#{idx}) instead.")
-
-      raise ArgumentError, "Invalid index: #{col_index}" if col_index.negative?
-
-      lt = columns[col_index]&.logical_type
-
-      raise DuckDB::Error, "Column[#{col_index}] type is not enum" if lt&.type != :enum
-
-      lt.dictionary_value_at(idx)
-    end
-
-    def _column_type(idx)
-      warn(":_column_type is deprecated. use columns[#{idx}].send(:_type) instead.")
-
-      columns[idx].send(:_type)
-    end
   end
 end

data/lib/duckdb/table_description.rb

@@ -28,9 +28,9 @@ module DuckDB
       # +con+ must be a DuckDB::Connection. +table+ is the table name (String).
       # Optionally pass +schema:+ and/or +catalog:+ to qualify the table.
       #
-      # The +table+ argument supports dot-notation and quoting:
-      # - <tt>'schema.table'</tt> — interpreted as schema-qualified (deprecated; use +schema:+ instead)
-      # - <tt>'"a.b"'</tt> or <tt>"'a.b'"</tt> — treated as a literal table name containing a dot
+      # The +table+ argument is used as a literal table name, even if it contains a dot.
+      # Use +schema:+ and +catalog:+ to qualify the table. Surrounding double or single
+      # quotes (<tt>'"a.b"'</tt> or <tt>"'a.b'"</tt>) are stripped.
       #
       # Raises DuckDB::Error if the connection is invalid, the table name is nil,
       # or the table (or schema/catalog) does not exist.

data/lib/duckdb/table_name_parser.rb

@@ -4,23 +4,17 @@ module DuckDB
   # DuckDB::TableNameParser provides shared table name parsing for classes that
   # accept a table name argument, such as DuckDB::Appender and DuckDB::TableDescription.
   #
-  # It handles:
-  # - Dot-notation: <tt>'schema.table'</tt> is split into schema and table (deprecated).
-  # - Quoting: <tt>'"a.b"'</tt> or <tt>"'a.b'"</tt> strips the quotes and treats the name literally.
+  # It handles quoting: <tt>'"a.b"'</tt> or <tt>"'a.b'"</tt> strips the quotes and treats the name literally.
+  # A name containing a dot (e.g. <tt>'a.b'</tt>) is used as-is, as a literal table name; it is
+  # never split into schema and table. Use the +schema:+ and +catalog:+ keyword arguments to qualify a table.
   module TableNameParser
     private
 
-    # Parses +table+, +schema+, and +catalog+, handling quoting and dot-notation.
+    # Parses +table+, +schema+, and +catalog+, handling quoting.
     # Returns <tt>[table, schema, catalog]</tt>.
     def parse_table_name(table, schema, catalog)
-      if quoted_table_name?(table)
-        [unquote_table_name(table), schema, catalog]
-      elsif table.include?('.')
-        warn_dot_notation_deprecated(table)
-        dot_notation_split(table, schema, catalog)
-      else
-        [table, schema, catalog]
-      end
+      table = unquote_table_name(table) if quoted_table_name?(table)
+      [table, schema, catalog]
     end
 
     def quoted_table_name?(name) # :nodoc:
@@ -30,29 +24,5 @@ module DuckDB
     def unquote_table_name(name) # :nodoc:
       name[1..-2]
     end
-
-    # Splits a dot-notation string into [table, schema, catalog].
-    # Explicit keyword args take precedence over dot-notation parts.
-    def dot_notation_split(table, schema, catalog) # :nodoc:
-      parts = table.split('.')
-      raise ArgumentError, "Too many dot-separated segments in '#{table}'" if parts.length > 3
-
-      case parts.length
-      when 2 then [parts[1], schema || parts[0], catalog]
-      when 3 then [parts[2], schema || parts[1], catalog || parts[0]]
-      else raise ArgumentError, "Unexpected segment count in '#{table}'"
-      end
-    end
-
-    def warn_dot_notation_deprecated(table) # :nodoc:
-      class_name = self.class.name
-      warn(
-        "Passing dot-notation '#{table}' to #{class_name}.new is deprecated. " \
-        "If '#{table}' is a schema-qualified table, use #{class_name}.new(con, table, schema: schema) instead. " \
-        "If '#{table}' is a literal table name containing a dot, " \
-        "use #{class_name}.new(con, '\"#{table}\"') instead.",
-        category: :deprecated
-      )
-    end
   end
 end

data/lib/duckdb/version.rb

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

data/lib/duckdb.rb

@@ -59,22 +59,8 @@ module DuckDB
 
       @default_timezone = value
     end
-
-    def const_missing(name)
-      deprecated = DEPRECATED_CONSTANTS[name]
-      return super unless deprecated
-
-      warn "DuckDB::#{name} is deprecated. Use #{deprecated} instead.", uplevel: 1
-      const_set(name, deprecated.split('::').reduce(Object) { |mod, part| mod.const_get(part) })
-    end
   end
 
-  DEPRECATED_CONSTANTS = {
-    BindInfo: 'DuckDB::TableFunction::BindInfo',
-    InitInfo: 'DuckDB::TableFunction::InitInfo',
-    FunctionInfo: 'DuckDB::TableFunction::FunctionInfo'
-  }.freeze
-
   # Default to local time to preserve existing behavior unless explicitly
   # configured otherwise.
   self.default_timezone = :local

metadata

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