duckdb 1.4.2.0 → 1.4.4.0

data/ext/duckdb/table_function.c

@@ -0,0 +1,403 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBTableFunction;
+extern VALUE cDuckDBBindInfo;
+extern VALUE cDuckDBInitInfo;
+extern VALUE cDuckDBFunctionInfo;
+extern VALUE cDuckDBDataChunk;
+
+static void mark(void *ctx);
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static void compact(void *ctx);
+static VALUE duckdb_table_function_initialize(VALUE self);
+static VALUE rbduckdb_table_function_set_name(VALUE self, VALUE name);
+static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_type);
+static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type);
+static VALUE rbduckdb_table_function_set_bind(VALUE self);
+static void table_function_bind_callback(duckdb_bind_info info);
+static VALUE rbduckdb_table_function_set_init(VALUE self);
+static void table_function_init_callback(duckdb_init_info info);
+static VALUE rbduckdb_table_function_set_execute(VALUE self);
+static void table_function_execute_callback(duckdb_function_info info, duckdb_data_chunk output);
+
+static const rb_data_type_t table_function_data_type = {
+    "DuckDB/TableFunction",
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void mark(void *ctx) {
+    rubyDuckDBTableFunction *p = (rubyDuckDBTableFunction *)ctx;
+    rb_gc_mark(p->bind_proc);
+    rb_gc_mark(p->init_proc);
+    rb_gc_mark(p->execute_proc);
+}
+
+static void deallocate(void *ctx) {
+    rubyDuckDBTableFunction *p = (rubyDuckDBTableFunction *)ctx;
+
+    if (p->table_function) {
+        duckdb_destroy_table_function(&(p->table_function));
+        p->table_function = NULL;
+    }
+    xfree(p);
+}
+
+/*
+ * GC compaction callback - updates VALUE references that may have moved during compaction.
+ * This is critical for Ruby 2.7+ where GC can move objects in memory.
+ * TableFunction has three callback procs (bind, init, execute) that all need updating.
+ * Without this, these VALUE pointers could become stale after compaction,
+ * leading to crashes when DuckDB invokes the callbacks.
+ */
+static void compact(void *ctx) {
+    rubyDuckDBTableFunction *p = (rubyDuckDBTableFunction *)ctx;
+    if (p->bind_proc != Qnil) {
+        p->bind_proc = rb_gc_location(p->bind_proc);
+    }
+    if (p->init_proc != Qnil) {
+        p->init_proc = rb_gc_location(p->init_proc);
+    }
+    if (p->execute_proc != Qnil) {
+        p->execute_proc = rb_gc_location(p->execute_proc);
+    }
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBTableFunction *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBTableFunction));
+    return TypedData_Wrap_Struct(klass, &table_function_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBTableFunction);
+}
+
+/*
+ * call-seq:
+ *   DuckDB::TableFunction.new -> DuckDB::TableFunction
+ *
+ * Creates a new table function.
+ *
+ *   tf = DuckDB::TableFunction.new
+ *   tf.name = "my_function"
+ *   # ... configure tf ...
+ */
+static VALUE duckdb_table_function_initialize(VALUE self) {
+    rubyDuckDBTableFunction *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+
+    ctx->table_function = duckdb_create_table_function();
+    if (!ctx->table_function) {
+        rb_raise(eDuckDBError, "Failed to create table function");
+    }
+
+    ctx->bind_proc = Qnil;
+    ctx->init_proc = Qnil;
+    ctx->execute_proc = Qnil;
+
+    // Set extra_info to the C struct pointer (safe with GC compaction)
+    // Store ctx instead of self - ctx is xmalloc'd and won't move during GC
+    duckdb_table_function_set_extra_info(ctx->table_function, ctx, NULL);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   table_function.name = name -> name
+ *
+ * Sets the name of the table function.
+ *
+ *   tf.name = "my_function"
+ */
+static VALUE rbduckdb_table_function_set_name(VALUE self, VALUE name) {
+    rubyDuckDBTableFunction *ctx;
+    const char *func_name;
+
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+
+    if (!ctx->table_function) {
+        rb_raise(eDuckDBError, "Table function is destroyed");
+    }
+
+    func_name = StringValueCStr(name);
+    duckdb_table_function_set_name(ctx->table_function, func_name);
+
+    return name;
+}
+
+/*
+ * call-seq:
+ *   table_function.add_parameter(logical_type) -> self
+ *
+ * Adds a positional parameter to the table function.
+ *
+ *   tf.add_parameter(DuckDB::LogicalType::BIGINT)
+ *   tf.add_parameter(DuckDB::LogicalType::VARCHAR)
+ */
+static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_type) {
+    rubyDuckDBTableFunction *ctx;
+    rubyDuckDBLogicalType *ctx_logical_type;
+
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+
+    if (!ctx->table_function) {
+        rb_raise(eDuckDBError, "Table function is destroyed");
+    }
+
+    ctx_logical_type = get_struct_logical_type(logical_type);
+    duckdb_table_function_add_parameter(ctx->table_function, ctx_logical_type->logical_type);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   table_function.add_named_parameter(name, logical_type) -> self
+ *
+ * Adds a named parameter to the table function.
+ *
+ *   tf.add_named_parameter("limit", DuckDB::LogicalType::BIGINT)
+ */
+static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type) {
+    rubyDuckDBTableFunction *ctx;
+    rubyDuckDBLogicalType *ctx_logical_type;
+    const char *param_name;
+
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+
+    if (!ctx->table_function) {
+        rb_raise(eDuckDBError, "Table function is destroyed");
+    }
+
+    param_name = StringValueCStr(name);
+    ctx_logical_type = get_struct_logical_type(logical_type);
+    duckdb_table_function_add_named_parameter(ctx->table_function, param_name, ctx_logical_type->logical_type);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   table_function.bind { |bind_info| ... } -> self
+ *
+ * Sets the bind callback for the table function.
+ * The callback is called when the function is used in a query.
+ *
+ *   table_function.bind do |bind_info|
+ *     bind_info.add_result_column('id', DuckDB::LogicalType::BIGINT)
+ *     bind_info.add_result_column('name', DuckDB::LogicalType::VARCHAR)
+ *   end
+ */
+static VALUE rbduckdb_table_function_set_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");
+    }
+
+    ctx->bind_proc = rb_block_proc();
+
+    duckdb_table_function_set_bind(ctx->table_function, table_function_bind_callback);
+
+    return self;
+}
+
+static VALUE call_bind_proc(VALUE arg) {
+    VALUE *args = (VALUE *)arg;
+    return rb_funcall(args[0], rb_intern("call"), 1, args[1]);
+}
+
+static void table_function_bind_callback(duckdb_bind_info info) {
+    rubyDuckDBTableFunction *ctx;
+    rubyDuckDBBindInfo *bind_info_ctx;
+    VALUE bind_info_obj;
+    int state = 0;
+
+    // Get the C struct pointer (safe with GC compaction)
+    ctx = (rubyDuckDBTableFunction *)duckdb_bind_get_extra_info(info);
+    if (!ctx || ctx->bind_proc == Qnil) {
+        return;
+    }
+
+    // Create BindInfo wrapper
+    bind_info_obj = rb_class_new_instance(0, NULL, cDuckDBBindInfo);
+    bind_info_ctx = get_struct_bind_info(bind_info_obj);
+    bind_info_ctx->bind_info = info;
+
+    // Call Ruby block with exception protection
+    VALUE call_args[2] = { ctx->bind_proc, bind_info_obj };
+    rb_protect(call_bind_proc, (VALUE)call_args, &state);
+
+    if (state) {
+        VALUE err = rb_errinfo();
+        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        duckdb_bind_set_error(info, StringValueCStr(msg));
+        rb_set_errinfo(Qnil); // Clear the error
+    }
+}
+
+/*
+ * call-seq:
+ *   table_function.init { |init_info| ... } -> table_function
+ *
+ * Sets the init callback for the table function.
+ * The callback is invoked once during query initialization to set up execution state.
+ *
+ *   table_function.init do |init_info|
+ *     # Initialize execution state
+ *   end
+ */
+static VALUE rbduckdb_table_function_set_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");
+    }
+
+    ctx->init_proc = rb_block_proc();
+    duckdb_table_function_set_init(ctx->table_function, table_function_init_callback);
+
+    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]);
+}
+
+static void table_function_init_callback(duckdb_init_info info) {
+    rubyDuckDBTableFunction *ctx;
+    VALUE init_info_obj;
+    rubyDuckDBInitInfo *init_info_ctx;
+    int state = 0;
+
+    // Get the C struct pointer (safe with GC compaction)
+    ctx = (rubyDuckDBTableFunction *)duckdb_init_get_extra_info(info);
+    if (!ctx || ctx->init_proc == Qnil) {
+        return;
+    }
+
+    // Create InitInfo wrapper
+    init_info_obj = rb_class_new_instance(0, NULL, cDuckDBInitInfo);
+    init_info_ctx = get_struct_init_info(init_info_obj);
+    init_info_ctx->info = info;
+
+    // Call Ruby block with exception protection
+    VALUE call_args[2] = { ctx->init_proc, init_info_obj };
+    rb_protect(call_init_proc, (VALUE)call_args, &state);
+
+    if (state) {
+        VALUE err = rb_errinfo();
+        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        duckdb_init_set_error(info, StringValueCStr(msg));
+        rb_set_errinfo(Qnil); // Clear the error
+    }
+}
+
+/*
+ * call-seq:
+ *   table_function.execute { |function_info, output| ... } -> table_function
+ *
+ * Sets the execute callback for the table function.
+ * The callback is invoked during query execution to generate output rows.
+ *
+ *   table_function.execute do |func_info, output|
+ *     output.size = 10
+ *     vec = output.get_vector(0)
+ *     # Write data...
+ *   end
+ */
+static VALUE rbduckdb_table_function_set_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);
+
+    ctx->execute_proc = rb_block_proc();
+    duckdb_table_function_set_function(ctx->table_function, table_function_execute_callback);
+
+    return self;
+}
+
+static VALUE call_execute_proc(VALUE args_val) {
+    VALUE *args = (VALUE *)args_val;
+    return rb_funcall(args[0], rb_intern("call"), 2, args[1], args[2]);
+}
+
+static void table_function_execute_callback(duckdb_function_info info, duckdb_data_chunk output) {
+    rubyDuckDBTableFunction *ctx;
+    VALUE func_info_obj;
+    VALUE data_chunk_obj;
+    rubyDuckDBFunctionInfo *func_info_ctx;
+    rubyDuckDBDataChunk *data_chunk_ctx;
+    int state = 0;
+
+    // Get the C struct pointer (safe with GC compaction)
+    ctx = (rubyDuckDBTableFunction *)duckdb_function_get_extra_info(info);
+    if (!ctx || ctx->execute_proc == Qnil) {
+        return;
+    }
+
+    // Create FunctionInfo wrapper
+    func_info_obj = rb_class_new_instance(0, NULL, cDuckDBFunctionInfo);
+    func_info_ctx = get_struct_function_info(func_info_obj);
+    func_info_ctx->info = info;
+
+    // Create DataChunk wrapper
+    data_chunk_obj = rb_class_new_instance(0, NULL, cDuckDBDataChunk);
+    data_chunk_ctx = get_struct_data_chunk(data_chunk_obj);
+    data_chunk_ctx->data_chunk = output;
+
+    // Call Ruby block with exception protection
+    VALUE call_args[3] = { ctx->execute_proc, func_info_obj, data_chunk_obj };
+    rb_protect(call_execute_proc, (VALUE)call_args, &state);
+
+    if (state) {
+        VALUE err = rb_errinfo();
+        VALUE msg = rb_funcall(err, rb_intern("message"), 0);
+        duckdb_function_set_error(info, StringValueCStr(msg));
+        rb_set_errinfo(Qnil); // Clear the error
+    }
+}
+
+rubyDuckDBTableFunction *get_struct_table_function(VALUE self) {
+    rubyDuckDBTableFunction *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
+    return ctx;
+}
+
+void rbduckdb_init_duckdb_table_function(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBTableFunction = rb_define_class_under(mDuckDB, "TableFunction", rb_cObject);
+    rb_define_alloc_func(cDuckDBTableFunction, allocate);
+
+    rb_define_method(cDuckDBTableFunction, "initialize", duckdb_table_function_initialize, 0);
+    rb_define_method(cDuckDBTableFunction, "set_name", rbduckdb_table_function_set_name, 1);
+    rb_define_method(cDuckDBTableFunction, "name=", rbduckdb_table_function_set_name, 1);
+    rb_define_method(cDuckDBTableFunction, "add_parameter", rbduckdb_table_function_add_parameter, 1);
+    rb_define_method(cDuckDBTableFunction, "add_named_parameter", rbduckdb_table_function_add_named_parameter, 2);
+    rb_define_method(cDuckDBTableFunction, "bind", rbduckdb_table_function_set_bind, 0);
+    rb_define_method(cDuckDBTableFunction, "init", rbduckdb_table_function_set_init, 0);
+    rb_define_method(cDuckDBTableFunction, "execute", rbduckdb_table_function_set_execute, 0);
+}

data/ext/duckdb/table_function.h

@@ -0,0 +1,16 @@
+#ifndef RUBY_DUCKDB_TABLE_FUNCTION_H
+#define RUBY_DUCKDB_TABLE_FUNCTION_H
+
+struct _rubyDuckDBTableFunction {
+    duckdb_table_function table_function;
+    VALUE bind_proc;
+    VALUE init_proc;
+    VALUE execute_proc;
+};
+
+typedef struct _rubyDuckDBTableFunction rubyDuckDBTableFunction;
+
+rubyDuckDBTableFunction *get_struct_table_function(VALUE self);
+void rbduckdb_init_duckdb_table_function(void);
+
+#endif

data/ext/duckdb/vector.c

@@ -0,0 +1,201 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBVector;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE rbduckdb_vector_get_data(VALUE self);
+static VALUE rbduckdb_vector_get_validity(VALUE self);
+static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALUE str);
+static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str);
+static VALUE rbduckdb_vector_logical_type(VALUE self);
+static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid);
+
+static const rb_data_type_t vector_data_type = {
+    "DuckDB/Vector",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBVector *p = (rubyDuckDBVector *)ctx;
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBVector *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBVector));
+    return TypedData_Wrap_Struct(klass, &vector_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBVector);
+}
+
+rubyDuckDBVector *get_struct_vector(VALUE obj) {
+    rubyDuckDBVector *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBVector, &vector_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * call-seq:
+ *   vector.get_data -> Integer (pointer address)
+ *
+ * Gets the raw data pointer for the vector.
+ * Returns the memory address as an integer.
+ *
+ *   ptr = vector.get_data
+ */
+static VALUE rbduckdb_vector_get_data(VALUE self) {
+    rubyDuckDBVector *ctx;
+    void *data;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    data = duckdb_vector_get_data(ctx->vector);
+
+    return ULL2NUM((uintptr_t)data);
+}
+
+/*
+ * call-seq:
+ *   vector.get_validity -> Integer or nil (pointer address)
+ *
+ * Gets the validity mask pointer for the vector.
+ * Returns nil if all values are valid.
+ *
+ *   validity = vector.get_validity
+ */
+static VALUE rbduckdb_vector_get_validity(VALUE self) {
+    rubyDuckDBVector *ctx;
+    uint64_t *validity;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    validity = duckdb_vector_get_validity(ctx->vector);
+
+    if (!validity) {
+        return Qnil;
+    }
+
+    return ULL2NUM((uintptr_t)validity);
+}
+
+/*
+ * call-seq:
+ *   vector.assign_string_element(index, str) -> self
+ *
+ * Assigns a string value at the specified index.
+ *
+ *   vector.assign_string_element(0, 'hello')
+ */
+static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALUE str) {
+    rubyDuckDBVector *ctx;
+    idx_t idx;
+    const char *string_val;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    idx = NUM2ULL(index);
+    string_val = StringValueCStr(str);
+
+    duckdb_vector_assign_string_element(ctx->vector, idx, string_val);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   vector.assign_string_element_len(index, str) -> self
+ *
+ * Assigns a string/blob value at the specified index with explicit length.
+ * Supports strings containing null bytes (for BLOB columns).
+ *
+ *   vector.assign_string_element_len(0, "\x00\x01\x02\x03")
+ */
+static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str) {
+    rubyDuckDBVector *ctx;
+    idx_t idx;
+    const char *string_val;
+    idx_t str_len;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    idx = NUM2ULL(index);
+    string_val = StringValuePtr(str);
+    str_len = RSTRING_LEN(str);
+
+    duckdb_vector_assign_string_element_len(ctx->vector, idx, string_val, str_len);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   vector.logical_type -> DuckDB::LogicalType
+ *
+ * Gets the logical type of the vector.
+ *
+ *   vector = output.get_vector(0)
+ *   type = vector.logical_type
+ *   type.id  #=> DuckDB::Type::BIGINT
+ */
+static VALUE rbduckdb_vector_logical_type(VALUE self) {
+    rubyDuckDBVector *ctx;
+    duckdb_logical_type logical_type;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    logical_type = duckdb_vector_get_column_type(ctx->vector);
+
+    return rbduckdb_create_logical_type(logical_type);
+}
+
+/*
+ * call-seq:
+ *   vector.set_validity(index, valid) -> self
+ *
+ * Sets the validity of a value at the specified index.
+ *
+ *   vector.set_validity(0, false)  # Mark row 0 as NULL
+ *   vector.set_validity(1, true)   # Mark row 1 as valid
+ */
+static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid) {
+    rubyDuckDBVector *ctx;
+    idx_t idx;
+    uint64_t *validity;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    idx = NUM2ULL(index);
+
+    if (RTEST(valid)) {
+        // Setting to valid - ensure validity mask exists and set bit
+        duckdb_vector_ensure_validity_writable(ctx->vector);
+        validity = duckdb_vector_get_validity(ctx->vector);
+        duckdb_validity_set_row_valid(validity, idx);
+    } else {
+        // Setting to invalid (NULL)
+        duckdb_vector_ensure_validity_writable(ctx->vector);
+        validity = duckdb_vector_get_validity(ctx->vector);
+        duckdb_validity_set_row_invalid(validity, idx);
+    }
+
+    return self;
+}
+
+void rbduckdb_init_duckdb_vector(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBVector = rb_define_class_under(mDuckDB, "Vector", rb_cObject);
+    rb_define_alloc_func(cDuckDBVector, allocate);
+
+    rb_define_method(cDuckDBVector, "get_data", rbduckdb_vector_get_data, 0);
+    rb_define_method(cDuckDBVector, "get_validity", rbduckdb_vector_get_validity, 0);
+    rb_define_method(cDuckDBVector, "assign_string_element", rbduckdb_vector_assign_string_element, 2);
+    rb_define_method(cDuckDBVector, "assign_string_element_len", rbduckdb_vector_assign_string_element_len, 2);
+    rb_define_method(cDuckDBVector, "logical_type", rbduckdb_vector_logical_type, 0);
+    rb_define_method(cDuckDBVector, "set_validity", rbduckdb_vector_set_validity, 2);
+}

data/ext/duckdb/vector.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_VECTOR_H
+#define RUBY_DUCKDB_VECTOR_H
+
+struct _rubyDuckDBVector {
+    duckdb_vector vector;
+};
+
+typedef struct _rubyDuckDBVector rubyDuckDBVector;
+
+rubyDuckDBVector *get_struct_vector(VALUE obj);
+void rbduckdb_init_duckdb_vector(void);
+
+#endif

data/lib/duckdb/appender.rb

@@ -580,6 +580,7 @@ module DuckDB
     #   appender.append(1)
     #   appender.append('Alice')
     #   appender.end_row
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
     def append(value)
       case value
       when NilClass
@@ -587,18 +588,9 @@ module DuckDB
       when Float
         append_double(value)
       when Integer
-        case value
-        when RANGE_INT16
-          append_int16(value)
-        when RANGE_INT32
-          append_int32(value)
-        when RANGE_INT64
-          append_int64(value)
-        else
-          append_hugeint(value)
-        end
+        append_integer_value(value)
       when String
-        blob?(value) ? append_blob(value) : append_varchar(value)
+        append_string_value(value)
       when TrueClass, FalseClass
         append_bool(value)
       when Time
@@ -611,6 +603,7 @@ module DuckDB
         raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     # append a row.
     #
@@ -639,6 +632,23 @@ module DuckDB
       value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
     end
 
+    def append_integer_value(value) # :nodoc:
+      case value
+      when RANGE_INT16
+        append_int16(value)
+      when RANGE_INT32
+        append_int32(value)
+      when RANGE_INT64
+        append_int64(value)
+      else
+        append_hugeint(value)
+      end
+    end
+
+    def append_string_value(value) # :nodoc:
+      blob?(value) ? append_blob(value) : append_varchar(value)
+    end
+
     def to_time(value) # :nodoc:
       case value
       when Date