duckdb 2.0.0.0 → 2.0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee2e890f808c2ff97b099f79c12f17a8fe856253b13a3ee2378bbb21306e3587
-  data.tar.gz: a7081554ee0ff1ebb22d688f9aafab9b434c93cb080f2abcc7ffe1e9ae3f70d1
+  metadata.gz: dce0a7e743dbaec8c7efce887915aa63b07814dd1552fe2030d9a3b993b4e76b
+  data.tar.gz: aa663e1016c3562af385b24488511835c8f7bb2fbb82a23ad45982d059d12af4
 SHA512:
-  metadata.gz: b13a967b1e810a51220080b227b8b6dd5098e56775567b049ed722ec3a9dec02f3fe97c399fbd8a88e292bc65888ce905ef5b908f182e110abf785d2ff2aa94e
-  data.tar.gz: ff96826d03f74eedb1633bc5256addb916abd737741636918748d0fcd65c0527669100b96103beff430184a6a8b21b4387fffb2351888898c1729c4c335d01be
+  metadata.gz: 27b9ad500f23e294806e7d957d05f804e1102a37c2c6fbbfb009421b3c1301f04dbe09acecc015247221265fcdc6bafa8dda243bee76cec4ae641a17a9e63417
+  data.tar.gz: 052a875e216cd582f90ae339fb43c93d9609190715545ebe83409ed6e0907d752114d0ee8e347d121814c55baa3944b0bcf78101c67c475b621aa49f43f4ff34

data/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 2.0.0.1 - 2026-10-25
+- `DuckDB::PreparedStatement#bind_decimal` (and `#bind` with a `BigDecimal`) raises `ArgumentError` when the DECIMAL width is out of range (1..38), instead of aborting the process or binding a wrong value.
+- raise `RangeError` instead of aborting the process when a result contains a TIMESTAMP value before `-9223372022400000000` microseconds (near INT64_MIN).
+- raise `RangeError` instead of aborting the process when an out-of-range date or timestamp is passed to `bind_date`, `bind_timestamp`, `bind_timestamp_tz`, `Appender#append_date`, `Appender#append_timestamp`, `DuckDB::Value.create_date`, `DuckDB::Value.create_timestamp*`, or returned from a UDF.
+
 # 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.

data/ext/duckdb/aggregate_function.c

@@ -487,13 +487,7 @@ static VALUE update_process_rows(VALUE varg) {
      * a GC, and the earlier columns' objects must stay reachable. */
     VALUE args = rb_ary_new_capa((long)arg->col_count + 1);
 
-    arg->input_vectors = ALLOC_N(duckdb_vector, arg->col_count);
-    arg->input_types = ALLOC_N(duckdb_logical_type, arg->col_count);
-
-    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);
 
     for (i = 0; i < arg->row_count; i++) {
         ruby_aggregate_state *state = arg->constant_states ? states[0] : states[i];
@@ -557,17 +551,8 @@ static VALUE update_process_rows(VALUE varg) {
 
 static VALUE update_cleanup_callback(VALUE varg) {
     struct update_callback_arg *arg = (struct update_callback_arg *)varg;
-    idx_t j;
 
-    if (arg->input_types != NULL) {
-        for (j = 0; j < arg->col_count; j++) {
-            duckdb_destroy_logical_type(&arg->input_types[j]);
-        }
-        xfree(arg->input_types);
-    }
-    if (arg->input_vectors != NULL) {
-        xfree(arg->input_vectors);
-    }
+    rbduckdb_input_columns_free(arg->input_vectors, arg->input_types, arg->col_count);
 
     return Qnil;
 }
@@ -598,23 +583,39 @@ static void execute_update_callback_protected(void *user_data) {
     }
 }
 
+/*
+ * Shared preamble for update/combine/finalize callbacks: returns the context,
+ * or NULL (after setting a DuckDB error if the proc is missing).
+ * A missing proc is reached only if _set_init was called directly (bypassing
+ * the Ruby wrapper); raise rather than silently misbehave or SIGSEGV.
+ */
+static rubyDuckDBAggregateFunction *aggregate_ctx_with_proc(duckdb_function_info info,
+                                                            size_t proc_offset,
+                                                            const char *missing_msg) {
+    rubyDuckDBAggregateFunction *ctx;
+
+    ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
+    if (ctx == NULL) {
+        return NULL;
+    }
+    if (*(VALUE *)((char *)ctx + proc_offset) == Qnil) {
+        duckdb_aggregate_function_set_error(info, missing_msg);
+        return NULL;
+    }
+    return ctx;
+}
+
 static void update_callback(duckdb_function_info info,
                             duckdb_data_chunk input,
                             duckdb_aggregate_state *states) {
     rubyDuckDBAggregateFunction *ctx;
     struct update_callback_arg arg;
 
-    ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
+    ctx = aggregate_ctx_with_proc(info, offsetof(rubyDuckDBAggregateFunction, update_proc),
+                                  "update callback invoked with no update proc set");
     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;
-    }
 
     arg.ctx = ctx;
     arg.info = info;
@@ -694,16 +695,11 @@ static void combine_callback(duckdb_function_info info,
     rubyDuckDBAggregateFunction *ctx;
     struct combine_callback_arg arg;
 
-    ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
+    ctx = aggregate_ctx_with_proc(info, offsetof(rubyDuckDBAggregateFunction, combine_proc),
+                                  "combine callback invoked with no combine proc set");
     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;
-    }
 
     arg.ctx = ctx;
     arg.info = info;
@@ -805,16 +801,11 @@ static void finalize_callback(duckdb_function_info info,
     rubyDuckDBAggregateFunction *ctx;
     struct finalize_callback_arg arg;
 
-    ctx = (rubyDuckDBAggregateFunction *)duckdb_aggregate_function_get_extra_info(info);
+    ctx = aggregate_ctx_with_proc(info, offsetof(rubyDuckDBAggregateFunction, finalize_proc),
+                                  "finalize callback invoked with no finalize proc set");
     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;
-    }
 
     arg.ctx = ctx;
     arg.info = info;
@@ -886,8 +877,7 @@ static void maybe_set_functions(rubyDuckDBAggregateFunction *p) {
     rbduckdb_function_executor_ensure_started();
 }
 
-/* :nodoc: */
-static VALUE aggregate_function__set_init(VALUE self) {
+static VALUE aggregate_function_store_block_proc(VALUE self, size_t slot_offset) {
     rubyDuckDBAggregateFunction *p;
 
     if (!rb_block_given_p()) {
@@ -895,7 +885,7 @@ static VALUE aggregate_function__set_init(VALUE self) {
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    RB_OBJ_WRITE(self, &p->init_proc, rb_block_proc());
+    RB_OBJ_WRITE(self, (VALUE *)((char *)p + slot_offset), rb_block_proc());
 
     maybe_set_functions(p);
 
@@ -903,51 +893,23 @@ static VALUE aggregate_function__set_init(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE aggregate_function__set_update(VALUE self) {
-    rubyDuckDBAggregateFunction *p;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    RB_OBJ_WRITE(self, &p->update_proc, rb_block_proc());
-
-    maybe_set_functions(p);
+static VALUE aggregate_function__set_init(VALUE self) {
+    return aggregate_function_store_block_proc(self, offsetof(rubyDuckDBAggregateFunction, init_proc));
+}
 
-    return self;
+/* :nodoc: */
+static VALUE aggregate_function__set_update(VALUE self) {
+    return aggregate_function_store_block_proc(self, offsetof(rubyDuckDBAggregateFunction, update_proc));
 }
 
 /* :nodoc: */
 static VALUE aggregate_function__set_combine(VALUE self) {
-    rubyDuckDBAggregateFunction *p;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    RB_OBJ_WRITE(self, &p->combine_proc, rb_block_proc());
-
-    maybe_set_functions(p);
-
-    return self;
+    return aggregate_function_store_block_proc(self, offsetof(rubyDuckDBAggregateFunction, combine_proc));
 }
 
 /* :nodoc: */
 static VALUE aggregate_function__set_finalize(VALUE self) {
-    rubyDuckDBAggregateFunction *p;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "block is required");
-    }
-
-    TypedData_Get_Struct(self, rubyDuckDBAggregateFunction, &aggregate_function_data_type, p);
-    RB_OBJ_WRITE(self, &p->finalize_proc, rb_block_proc());
-
-    maybe_set_functions(p);
-
-    return self;
+    return aggregate_function_store_block_proc(self, offsetof(rubyDuckDBAggregateFunction, finalize_proc));
 }
 
 /* :nodoc: */

data/ext/duckdb/appender.c

@@ -78,6 +78,12 @@ static VALUE allocate(VALUE klass) {
     return TypedData_Wrap_Struct(klass, &appender_data_type, ctx);
 }
 
+static duckdb_appender appender_of(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+    return ctx->appender;
+}
+
 static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBAppender);
 }
@@ -219,13 +225,11 @@ static VALUE appender__initialize_ext(VALUE self, VALUE con, VALUE catalog, VALU
  *   appender.error_message # => nil
  */
 static VALUE appender_error_message(VALUE self) {
-    rubyDuckDBAppender *ctx;
     duckdb_error_data error_data;
     const char *msg = NULL;
     VALUE rb_msg = Qnil;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    error_data = duckdb_appender_error_data(ctx->appender);
+    error_data = duckdb_appender_error_data(appender_of(self));
     if (duckdb_error_data_has_error(error_data)) {
         msg = duckdb_error_data_message(error_data);
         rb_msg = rb_str_new2(msg);
@@ -236,220 +240,159 @@ static VALUE appender_error_message(VALUE self) {
 
 /* :nodoc: */
 static VALUE appender__end_row(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_appender_end_row(ctx->appender));
+    return state_to_rbool(duckdb_appender_end_row(appender_of(self)));
 }
 
 /* :nodoc: */
 static VALUE appender__append_bool(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
     if (val != Qtrue && val != Qfalse) {
         rb_raise(rb_eArgError, "argument must be boolean");
     }
 
-    return state_to_rbool(duckdb_append_bool(ctx->appender, (val == Qtrue)));
+    return state_to_rbool(duckdb_append_bool(appender_of(self), (val == Qtrue)));
 }
 
 /* :nodoc: */
 static VALUE appender__append_int8(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     int8_t i8val = (int8_t)NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_int8(ctx->appender, i8val));
+    return state_to_rbool(duckdb_append_int8(appender_of(self), i8val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_int16(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     int16_t i16val = (int16_t)NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_int16(ctx->appender, i16val));
+    return state_to_rbool(duckdb_append_int16(appender_of(self), i16val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_int32(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     int32_t i32val = (int32_t)NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_int32(ctx->appender, i32val));
+    return state_to_rbool(duckdb_append_int32(appender_of(self), i32val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_int64(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     int64_t i64val = (int64_t)NUM2LL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_int64(ctx->appender, i64val));
+    return state_to_rbool(duckdb_append_int64(appender_of(self), i64val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_uint8(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     uint8_t ui8val = (uint8_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_uint8(ctx->appender, ui8val));
+    return state_to_rbool(duckdb_append_uint8(appender_of(self), ui8val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_uint16(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     uint16_t ui16val = (uint16_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return  state_to_rbool(duckdb_append_uint16(ctx->appender, ui16val));
+    return  state_to_rbool(duckdb_append_uint16(appender_of(self), ui16val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_uint32(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     uint32_t ui32val = (uint32_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return  state_to_rbool(duckdb_append_uint32(ctx->appender, ui32val));
+    return  state_to_rbool(duckdb_append_uint32(appender_of(self), ui32val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_uint64(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     uint64_t ui64val = (uint64_t)NUM2ULL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_uint64(ctx->appender, ui64val));
+    return state_to_rbool(duckdb_append_uint64(appender_of(self), ui64val));
 }
 
 /* :nodoc: */
 static VALUE appender__append_float(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     float fval = (float)NUM2DBL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_float(ctx->appender, fval));
+    return state_to_rbool(duckdb_append_float(appender_of(self), fval));
 }
 
 /* :nodoc: */
 static VALUE appender__append_double(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     double dval = NUM2DBL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_double(ctx->appender, dval));
+    return state_to_rbool(duckdb_append_double(appender_of(self), dval));
 }
 
 /* :nodoc: */
 static VALUE appender__append_varchar(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     /* Length-aware, as duckdb_append_varchar would stop at an embedded NUL. */
     char *pval = StringValuePtr(val);
     long len = RSTRING_LEN(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_varchar_length(ctx->appender, pval, (idx_t)len));
+    return state_to_rbool(duckdb_append_varchar_length(appender_of(self), pval, (idx_t)len));
 }
 
 /* :nodoc: */
 static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len) {
-    rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
     idx_t length = (idx_t)NUM2ULL(len);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_varchar_length(ctx->appender, pval, length));
+    return state_to_rbool(duckdb_append_varchar_length(appender_of(self), pval, length));
 }
 
 /* :nodoc: */
 static VALUE appender__append_blob(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
     idx_t length = (idx_t)RSTRING_LEN(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_blob(ctx->appender, (void *)pval, length));
+    return state_to_rbool(duckdb_append_blob(appender_of(self), (void *)pval, length));
 }
 
 /* :nodoc: */
 static VALUE appender__append_null(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_null(ctx->appender));
+    return state_to_rbool(duckdb_append_null(appender_of(self)));
 }
 
 /* :nodoc: */
 static VALUE appender__append_default(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_default(ctx->appender));
+    return state_to_rbool(duckdb_append_default(appender_of(self)));
 }
 
 /* :nodoc: */
 static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
     duckdb_date dt;
-    rubyDuckDBAppender *ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
-    return state_to_rbool(duckdb_append_date(ctx->appender, dt));
+    return state_to_rbool(duckdb_append_date(appender_of(self), dt));
 }
 
 /* :nodoc: */
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
-    rubyDuckDBAppender *ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
-    return state_to_rbool(duckdb_append_interval(ctx->appender, interval));
+    return state_to_rbool(duckdb_append_interval(appender_of(self), interval));
 }
 
 /* :nodoc: */
 static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_time time;
-    rubyDuckDBAppender *ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
-    return state_to_rbool(duckdb_append_time(ctx->appender, time));
+    return state_to_rbool(duckdb_append_time(appender_of(self), time));
 }
 
 /* :nodoc: */
 static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp;
 
-    rubyDuckDBAppender *ctx;
-
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
     timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
 
-    return state_to_rbool(duckdb_append_timestamp(ctx->appender, timestamp));
+    return state_to_rbool(duckdb_append_timestamp(appender_of(self), timestamp));
 }
 
 /* :nodoc: */
@@ -459,11 +402,7 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     hugeint.lower = NUM2ULL(lower);
     hugeint.upper = NUM2LL(upper);
 
-    rubyDuckDBAppender *ctx;
-
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_hugeint(ctx->appender, hugeint));
+    return state_to_rbool(duckdb_append_hugeint(appender_of(self), hugeint));
 }
 
 /* :nodoc: */
@@ -473,102 +412,76 @@ static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
     uhugeint.lower = NUM2ULL(lower);
     uhugeint.upper = NUM2ULL(upper);
 
-    rubyDuckDBAppender *ctx;
-
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_append_uhugeint(ctx->appender, uhugeint));
+    return state_to_rbool(duckdb_append_uhugeint(appender_of(self), uhugeint));
 }
 
 /* :nodoc: */
 static VALUE appender__append_uuid(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     duckdb_uhugeint uhugeint;
     duckdb_value uuid_val;
     duckdb_state state;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     rbduckdb_uuid_str_to_uhugeint(val, &uhugeint);
     uuid_val = duckdb_create_uuid(uhugeint);
-    state = duckdb_append_value(ctx->appender, uuid_val);
+    state = duckdb_append_value(appender_of(self), uuid_val);
     duckdb_destroy_value(&uuid_val);
     return state_to_rbool(state);
 }
 
 /* :nodoc: */
 static VALUE appender__append_value(VALUE self, VALUE val) {
-    rubyDuckDBAppender *ctx;
     rubyDuckDBValue *value_ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     value_ctx = rbduckdb_get_struct_value(val);
 
-    return state_to_rbool(duckdb_append_value(ctx->appender, value_ctx->value));
+    return state_to_rbool(duckdb_append_value(appender_of(self), value_ctx->value));
 }
 
 /* :nodoc: */
 static VALUE appender__append_data_chunk(VALUE self, VALUE chunk) {
-    rubyDuckDBAppender *ctx;
     rubyDuckDBDataChunk *chunk_ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     chunk_ctx = rbduckdb_get_struct_data_chunk(chunk);
 
-    return state_to_rbool(duckdb_append_data_chunk(ctx->appender, chunk_ctx->data_chunk));
+    return state_to_rbool(duckdb_append_data_chunk(appender_of(self), chunk_ctx->data_chunk));
 }
 
 /* :nodoc: */
 static VALUE appender__append_default_to_chunk(VALUE self, VALUE chunk, VALUE col, VALUE row) {
-    rubyDuckDBAppender *ctx;
     rubyDuckDBDataChunk *chunk_ctx;
 
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     chunk_ctx = rbduckdb_get_struct_data_chunk(chunk);
 
-    return state_to_rbool(duckdb_append_default_to_chunk(ctx->appender, chunk_ctx->data_chunk, NUM2ULL(col), NUM2ULL(row)));
+    return state_to_rbool(duckdb_append_default_to_chunk(appender_of(self), chunk_ctx->data_chunk, NUM2ULL(col), NUM2ULL(row)));
 }
 
 /* :nodoc: */
 static VALUE appender__flush(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_appender_flush(ctx->appender));
+    return state_to_rbool(duckdb_appender_flush(appender_of(self)));
 }
 
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
 /* :nodoc: */
 static VALUE appender__clear(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_appender_clear(ctx->appender));
+    return state_to_rbool(duckdb_appender_clear(appender_of(self)));
 }
 #endif
 
 /* :nodoc: */
 static VALUE appender__add_column(VALUE self, VALUE name) {
     char *p = StringValuePtr(name);
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return state_to_rbool(duckdb_appender_add_column(ctx->appender, p));
+    return state_to_rbool(duckdb_appender_add_column(appender_of(self), p));
 }
 
 /* :nodoc: */
 static VALUE appender__clear_columns(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_appender_clear_columns(ctx->appender));
+    return state_to_rbool(duckdb_appender_clear_columns(appender_of(self)));
 }
 
 /* :nodoc: */
 static VALUE appender__close(VALUE self) {
-    rubyDuckDBAppender *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-
-    return state_to_rbool(duckdb_appender_close(ctx->appender));
+    return state_to_rbool(duckdb_appender_close(appender_of(self)));
 }
 
 static VALUE state_to_rbool(duckdb_state state) {