duckdb 1.1.3.0 → 1.2.0.0

data/ext/duckdb/logical_type.c

@@ -0,0 +1,187 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBLogicalType;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_logical_type__type(VALUE self);
+static VALUE duckdb_logical_type_width(VALUE self);
+static VALUE duckdb_logical_type_scale(VALUE self);
+static VALUE duckdb_logical_type_child_type(VALUE self);
+static VALUE duckdb_logical_type_size(VALUE self);
+static VALUE duckdb_logical_type_key_type(VALUE self);
+static VALUE duckdb_logical_type_value_type(VALUE self);
+
+static const rb_data_type_t logical_type_data_type = {
+    "DuckDB/LogicalType",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBLogicalType *p = (rubyDuckDBLogicalType *)ctx;
+
+    if (p->logical_type) {
+        duckdb_destroy_logical_type(&(p->logical_type));
+    }
+
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBLogicalType *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBLogicalType));
+    return TypedData_Wrap_Struct(klass, &logical_type_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBLogicalType);
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.type -> Symbol
+ *
+ *  Returns the logical type's type symbol.
+ *
+ */
+static VALUE duckdb_logical_type__type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_get_type_id(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.width -> Integer
+ *
+ *  Returns the width of the decimal column.
+ *
+ */
+static VALUE duckdb_logical_type_width(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_decimal_width(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.scale -> Integer
+ *
+ *  Returns the scale of the decimal column.
+ *
+ */
+static VALUE duckdb_logical_type_scale(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_decimal_scale(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    list_col.logical_type.child_type -> DuckDB::LogicalType
+ *
+ *  Returns the child logical type for list and map types, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_child_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_type type_id;
+    duckdb_logical_type child_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    type_id = duckdb_get_type_id(ctx->logical_type);
+
+    switch(type_id) {
+        case DUCKDB_TYPE_LIST:
+        case DUCKDB_TYPE_MAP:
+            child_logical_type = duckdb_list_type_child_type(ctx->logical_type);
+            logical_type = rbduckdb_create_logical_type(child_logical_type);
+            break;
+        case DUCKDB_TYPE_ARRAY:
+            child_logical_type = duckdb_array_type_child_type(ctx->logical_type);
+            logical_type = rbduckdb_create_logical_type(child_logical_type);
+            break;
+        default:
+            logical_type = Qnil;
+    }
+    return logical_type;
+}
+
+/*
+ *  call-seq:
+ *    list_col.logical_type.size -> Integer
+ *
+ *  Returns the size of the array column, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_size(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_array_type_array_size(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    map_col.logical_type.key_type -> DuckDB::LogicalType
+ *
+ *  Returns the key logical type for map type, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_key_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type key_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    key_logical_type = duckdb_map_type_key_type(ctx->logical_type);
+    logical_type = rbduckdb_create_logical_type(key_logical_type);
+    return logical_type;
+}
+
+/*
+ *  call-seq:
+ *    map_col.logical_type.value_type -> DuckDB::LogicalType
+ *
+ *  Returns the value logical type for map type, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_value_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type value_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    value_logical_type = duckdb_map_type_value_type(ctx->logical_type);
+    logical_type = rbduckdb_create_logical_type(value_logical_type);
+    return logical_type;
+}
+
+VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
+    VALUE obj;
+    rubyDuckDBLogicalType *ctx;
+
+    obj = allocate(cDuckDBLogicalType);
+    TypedData_Get_Struct(obj, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    ctx->logical_type = logical_type;
+
+    return obj;
+}
+
+void rbduckdb_init_duckdb_logical_type(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBLogicalType = rb_define_class_under(mDuckDB, "LogicalType", rb_cObject);
+    rb_define_alloc_func(cDuckDBLogicalType, allocate);
+
+    rb_define_private_method(cDuckDBLogicalType, "_type", duckdb_logical_type__type, 0);
+    rb_define_method(cDuckDBLogicalType, "width", duckdb_logical_type_width, 0);
+    rb_define_method(cDuckDBLogicalType, "scale", duckdb_logical_type_scale, 0);
+    rb_define_method(cDuckDBLogicalType, "child_type", duckdb_logical_type_child_type, 0);
+    rb_define_method(cDuckDBLogicalType, "size", duckdb_logical_type_size, 0);
+    rb_define_method(cDuckDBLogicalType, "key_type", duckdb_logical_type_key_type, 0);
+    rb_define_method(cDuckDBLogicalType, "value_type", duckdb_logical_type_value_type, 0);
+}

data/ext/duckdb/logical_type.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_LOGICAL_TYPE_H
+#define RUBY_DUCKDB_LOGICAL_TYPE_H
+
+struct _rubyDuckDBLogicalType {
+    duckdb_logical_type logical_type;
+};
+
+typedef struct _rubyDuckDBLogicalType rubyDuckDBLogicalType;
+
+void rbduckdb_init_duckdb_logical_type(void);
+VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type);
+
+#endif

data/ext/duckdb/pending_result.c

@@ -124,11 +124,13 @@ static VALUE duckdb_pending_result_execute_pending(VALUE self) {
     return result;
 }
 
+/* :nodoc: */
 static VALUE duckdb_pending_result__state(VALUE self) {
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     return INT2FIX(ctx->state);
 }
 
+/* :nodoc: */
 static VALUE duckdb_pending_result__execute_check_state(VALUE self) {
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     return INT2FIX(duckdb_pending_execute_check_state(ctx->pending_result));
@@ -141,6 +143,9 @@ rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
 }
 
 void rbduckdb_init_duckdb_pending_result(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
     rb_define_alloc_func(cDuckDBPendingResult, allocate);
 

data/ext/duckdb/prepared_statement.c

@@ -72,7 +72,8 @@ VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_st
     TypedData_Get_Struct(obj, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_prepare_extracted_statement(con, extracted_statements, index, &(ctx->prepared_statement)) == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to create DuckDB::PreparedStatement object.");
+        const char *error = duckdb_prepare_error(ctx->prepared_statement);
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to create DuckDB::PreparedStatement object.");
     }
     return obj;
 }
@@ -90,7 +91,7 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
         const char *error = duckdb_prepare_error(ctx->prepared_statement);
-        rb_raise(eDuckDBError, "%s", error);
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to prepare statement(Database connection closed?).");
     }
     return self;
 }
@@ -101,21 +102,47 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     return ULL2NUM(duckdb_nparams(ctx->prepared_statement));
 }
 
+/* :nodoc: */
+typedef struct {
+    duckdb_prepared_statement prepared_statement;
+    duckdb_result *out_result;
+    duckdb_state retval;
+} duckdb_prepared_statement_execute_nogvl_args;
+
+/* :nodoc: */
+static void duckdb_prepared_statement_execute_nogvl(void *ptr) {
+    duckdb_prepared_statement_execute_nogvl_args *args = (duckdb_prepared_statement_execute_nogvl_args *)ptr;
+
+    args->retval = duckdb_execute_prepared(args->prepared_statement, args->out_result);
+}
+
 static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
+    const char *error;
     VALUE result = rbduckdb_create_result();
-    const char *p = NULL;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
-    if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        p = duckdb_result_error(&(ctxr->result));
-        if (p == NULL) {
-            p = duckdb_prepare_error(ctx->prepared_statement);
+
+    duckdb_prepared_statement_execute_nogvl_args args = {
+        .prepared_statement = ctx->prepared_statement,
+        .out_result = &(ctxr->result),
+        .retval = DuckDBError,
+    };
+
+    rb_thread_call_without_gvl((void *)duckdb_prepared_statement_execute_nogvl, &args, RUBY_UBF_IO, 0);
+    duckdb_state state = args.retval;
+
+    if (state == DuckDBError) {
+        error = duckdb_result_error(args.out_result);
+        if (error == NULL) {
+            error = duckdb_prepare_error(args.prepared_statement);
         }
-        rb_raise(eDuckDBError, "%s", p ? p : "Failed to execute prepared statement.");
+
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to execute prepared statement.");
     }
+
     return result;
 }
 
@@ -315,18 +342,21 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__statement_type(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     return INT2FIX(duckdb_prepared_statement_type(ctx->prepared_statement));
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     return INT2FIX(duckdb_param_type(ctx->prepared_statement, NUM2ULL(vidx)));
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
     rubyDuckDBPreparedStatement *ctx;
     duckdb_date dt;
@@ -343,6 +373,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
     rubyDuckDBPreparedStatement *ctx;
     duckdb_time time;
@@ -360,6 +391,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp;
     rubyDuckDBPreparedStatement *ctx;
@@ -374,6 +406,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
     rubyDuckDBPreparedStatement *ctx;
@@ -389,6 +422,7 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
     rubyDuckDBPreparedStatement *ctx;
@@ -405,6 +439,7 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale) {
     duckdb_hugeint hugeint;
     duckdb_decimal decimal;
@@ -432,6 +467,9 @@ rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
 }
 
 void rbduckdb_init_duckdb_prepared_statement(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);

data/ext/duckdb/result.c

@@ -24,12 +24,11 @@ static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE duckdb_result_column_count(VALUE oDuckDBResult);
-static VALUE duckdb_result_row_count(VALUE oDuckDBResult);
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
 static VALUE duckdb_result_columns(VALUE oDuckDBResult);
 static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
-static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult);
+static VALUE duckdb_result__chunk_each(VALUE oDuckDBResult);
 
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
 static VALUE yield_rows(VALUE arg);
@@ -147,36 +146,6 @@ static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
     return LL2NUM(duckdb_column_count(&(ctx->result)));
 }
 
-/*
- *  call-seq:
- *    result.row_count -> Integer
- *
- *  Returns the column size of the result.
- *
- *    DuckDB::Database.open do |db|
- *      db.connect do |con|
- *        r = con.query('CREATE TABLE t2 (id INT, name VARCHAR(128))')
- *        r = con.query("INSERT INTO t2 VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Catherine')")
- *        r = con.query('SELECT * FROM t2')
- *        r.row_count # => 3
- *        r = con.query('SELECT * FROM t2 where id = 1')
- *        r.row_count # => 1
- *      end
- *    end
- *
- */
-static VALUE duckdb_result_row_count(VALUE oDuckDBResult) {
-
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rubyDuckDBResult *ctx;
-    rb_warn("`row_count` will be deprecated in the future.");
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-    return LL2NUM(duckdb_row_count(&(ctx->result)));
-#endif
-}
-
 /*
  *  call-seq:
  *    result.columns -> DuckDB::Column[]
@@ -200,11 +169,7 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
 }
 
 /*
- *  call-seq:
- *    result.streaming? -> Boolean
- *
- *  Returns true if the result is streaming, otherwise false.
- *
+ * :nodoc:
  */
 static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
@@ -212,6 +177,7 @@ static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
 #ifdef DUCKDB_API_NO_DEPRECATED
     return Qtrue;
 #else
+    rb_warn("`DuckDB::Result#streaming?` will be deprecated in the future.");
     /* FIXME streaming is allways true. so this method is not useful and deprecated. */
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return duckdb_result_is_streaming(ctx->result) ? Qtrue : Qfalse;
@@ -224,7 +190,8 @@ static VALUE destroy_data_chunk(VALUE arg) {
     return Qnil;
 }
 
-static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
+/* :nodoc: */
+static VALUE duckdb_result__chunk_each(VALUE oDuckDBResult) {
 /*
 #ifdef HAVE_DUCKDB_H_GE_V1_0_0
     return duckdb_result__chunk_stream(oDuckDBResult);
@@ -258,6 +225,7 @@ static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
 */
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     struct chunk_arg arg;
@@ -268,11 +236,7 @@ static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
 
     arg.col_count = duckdb_column_count(&(ctx->result));
 
-#ifdef HAVE_DUCKDB_H_GE_V1_0_0
     while((arg.chunk = duckdb_fetch_chunk(ctx->result)) != NULL) {
-#else
-    while((arg.chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
-#endif
         rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
     }
     return Qnil;
@@ -301,12 +265,14 @@ static VALUE yield_rows(VALUE arg) {
     return Qnil;
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return LL2NUM(duckdb_column_type(&(ctx->result), NUM2LL(col_idx)));
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
@@ -320,12 +286,14 @@ static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
 #endif
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__statement_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return INT2FIX(duckdb_result_statement_type(ctx->result));
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     VALUE type = Qnil;
@@ -340,6 +308,7 @@ static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_id
     return type;
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     VALUE size = Qnil;
@@ -354,6 +323,7 @@ static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_
     return size;
 }
 
+/* :nodoc: */
 static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col_idx, VALUE idx) {
     rubyDuckDBResult *ctx;
     VALUE value = Qnil;
@@ -884,6 +854,9 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
 }
 
 void rbduckdb_init_duckdb_result(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     id__to_date = rb_intern("_to_date");
     id__to_time = rb_intern("_to_time");
@@ -902,11 +875,10 @@ void rbduckdb_init_duckdb_result(void) {
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "column_count", duckdb_result_column_count, 0);
-    rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0); /* deprecated */
     rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
     rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
     rb_define_method(cDuckDBResult, "streaming?", duckdb_result_streaming_p, 0);
-    rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
+    rb_define_private_method(cDuckDBResult, "_chunk_each", duckdb_result__chunk_each, 0);
     rb_define_private_method(cDuckDBResult, "_chunk_stream", duckdb_result__chunk_stream, 0);
     rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
     rb_define_private_method(cDuckDBResult, "_return_type", duckdb_result__return_type, 0);

data/ext/duckdb/ruby-duckdb.h

@@ -5,6 +5,7 @@
 #define DUCKDB_NO_EXTENSION_FUNCTIONS // disable extension C-functions
 
 #include "ruby.h"
+#include "ruby/thread.h"
 #include <duckdb.h>
 
 #ifdef HAVE_DUCKDB_FETCH_CHUNK
@@ -24,6 +25,7 @@
 #include "./connection.h"
 #include "./result.h"
 #include "./column.h"
+#include "./logical_type.h"
 #include "./prepared_statement.h"
 #include "./extracted_statements.h"
 #include "./pending_result.h"