duckdb 0.9.1.1 → 0.9.2

data/ext/duckdb/extconf.rb

@@ -1,31 +1,64 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 
-def duckdb_library_available?(func)
-  header = find_header('duckdb.h') || find_header('duckdb.h', '/opt/homebrew/include')
-  library = have_func(func, 'duckdb.h') || find_library('duckdb', func, '/opt/homebrew/opt/duckdb/lib')
-  header && library
+DUCKDB_REQUIRED_VERSION = '0.8.0'
+
+def check_duckdb_header(header, version)
+  found = find_header(
+    header,
+    '/opt/homebrew/include',
+    '/opt/homebrew/opt/duckdb/include',
+    '/opt/local/include'
+  )
+  return if found
+
+  msg = "#{header} is not found. Install #{header} of duckdb >= #{version}."
+  print_message(msg)
+  raise msg
 end
 
-def check_duckdb_library(func, version)
-  return if duckdb_library_available?(func)
+def check_duckdb_library(library, func, version)
+  found = find_library(
+    library,
+    func,
+    '/opt/homebrew/lib',
+    '/opt/homebrew/opt/duckdb/lib',
+    '/opt/local/lib'
+  )
+  return if found
 
-  msg = "duckdb >= #{version} is not found. Install duckdb >= #{version} library and header file."
-  puts ''
-  puts '*' * 80
-  puts msg
-  puts '*' * 80
-  puts ''
+  library_name = duckdb_library_name(library)
+  msg = "#{library_name} is not found. Install #{library_name} of duckdb >= #{version}."
+  print_message(msg)
   raise msg
 end
 
+def duckdb_library_name(library)
+  "lib#{library}.(so|dylib|dll)"
+end
+
+def print_message(msg)
+  print <<~END_OF_MESSAGE
+
+    #{'*' * 80}
+    #{msg}
+    #{'*' * 80}
+
+  END_OF_MESSAGE
+end
+
 dir_config('duckdb')
 
+check_duckdb_header('duckdb.h', DUCKDB_REQUIRED_VERSION)
+
 # check duckdb >= 0.8.0
-check_duckdb_library('duckdb_string_is_inlined', '0.8.0')
+check_duckdb_library('duckdb', 'duckdb_string_is_inlined', DUCKDB_REQUIRED_VERSION)
 
 # check duckdb >= 0.9.0
 have_func('duckdb_bind_parameter_index', 'duckdb.h')
 
+# duckdb_parameter_name is not found on Windows.
 have_func('duckdb_parameter_name', 'duckdb.h')
 
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/pending_result.c

@@ -5,7 +5,7 @@ static VALUE cDuckDBPendingResult;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement);
+static VALUE duckdb_pending_result_initialize(int argc, VALUE *args, VALUE self);
 static VALUE duckdb_pending_result_execute_task(VALUE self);
 static VALUE duckdb_pending_result_execute_pending(VALUE self);
 
@@ -38,16 +38,43 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBPendingResult);
 }
 
-static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement) {
+static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self) {
+    VALUE oDuckDBPreparedStatement;
+    VALUE streaming_p = Qfalse;
+    duckdb_state state;
+
+    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");
+    }
+
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
 
-    if (duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result)) == DuckDBError) {
+    if (!NIL_P(streaming_p) && streaming_p == Qtrue) {
+        state = duckdb_pending_prepared_streaming(stmt->prepared_statement, &(ctx->pending_result));
+    } else {
+        state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
+    }
+
+    if (state == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
     }
     return self;
 }
 
+/*
+ * call-seq:
+ *   pending_result.execute_task -> nil
+ *
+ * Executes the task in the pending result.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  pending_result = conn.async_query("slow query")
+ *  pending_result.execute_task
+ */
 static VALUE duckdb_pending_result_execute_task(VALUE self) {
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     ctx->state = duckdb_pending_execute_task(ctx->pending_result);
@@ -61,10 +88,22 @@ static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
 }
 #endif
 
+/*
+ * call-seq:
+ *   pending_result.execute_pending -> DuckDB::Result
+ *
+ * Get DuckDB::Result object after query execution finished.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  pending_result = conn.async_query("slow query")
+ *  pending_result.execute_task while pending_result.state != :ready
+ *  result = pending_result.execute_pending # => DuckDB::Result
+ */
 static VALUE duckdb_pending_result_execute_pending(VALUE self) {
     rubyDuckDBPendingResult *ctx;
     rubyDuckDBResult *ctxr;
-    VALUE result = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -85,11 +124,11 @@ rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
     return ctx;
 }
 
-void init_duckdb_pending_result(void) {
+void rbduckdb_init_duckdb_pending_result(void) {
     cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
     rb_define_alloc_func(cDuckDBPendingResult, allocate);
 
-    rb_define_method(cDuckDBPendingResult, "initialize", duckdb_pending_result_initialize, 1);
+    rb_define_method(cDuckDBPendingResult, "initialize", duckdb_pending_result_initialize, -1);
     rb_define_method(cDuckDBPendingResult, "execute_task", duckdb_pending_result_execute_task, 0);
     rb_define_method(cDuckDBPendingResult, "execute_pending", duckdb_pending_result_execute_pending, 0);
 

data/ext/duckdb/pending_result.h

@@ -9,5 +9,5 @@ struct _rubyDuckDBPendingResult {
 typedef struct _rubyDuckDBPendingResult rubyDuckDBPendingResult;
 
 rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj);
-void init_duckdb_pending_result(void);
+void rbduckdb_init_duckdb_pending_result(void);
 #endif

data/ext/duckdb/prepared_statement.c

@@ -1,6 +1,6 @@
 #include "ruby-duckdb.h"
 
-static VALUE cDuckDBPreparedStatement;
+VALUE cDuckDBPreparedStatement;
 
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
@@ -83,7 +83,7 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
 static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
-    VALUE result = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -268,7 +268,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     duckdb_date dt;
     idx_t idx = check_index(vidx);
 
-    dt = to_duckdb_date_from_value(year, month, day);
+    dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -285,7 +285,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 
     idx_t idx = check_index(vidx);
 
-    time = to_duckdb_time_from_value(hour, min, sec, micros);
+    time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -301,7 +301,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
@@ -317,7 +317,7 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    to_duckdb_interval_from_value(&interval, months, days, micros);
+    rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -347,7 +347,7 @@ rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
     return ctx;
 }
 
-void init_duckdb_prepared_statement(void) {
+void rbduckdb_init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);

data/ext/duckdb/prepared_statement.h

@@ -9,6 +9,6 @@ struct _rubyDuckDBPreparedStatement {
 typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
 
 rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
-void init_duckdb_prepared_statement(void);
+void rbduckdb_init_duckdb_prepared_statement(void);
 
 #endif

data/ext/duckdb/result.c

@@ -19,6 +19,11 @@ 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 duckdb_result_chunk_each(VALUE oDuckDBResult);
+
+static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
+static void yield_rows(duckdb_data_chunk chunk, idx_t col_count);
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx);
 static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
 static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
@@ -50,7 +55,6 @@ static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, idx_t row_
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, 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 duckdb_result_chunk_each(VALUE oDuckDBResult);
 
 static const rb_data_type_t result_data_type = {
     "DuckDB/Result",
@@ -229,12 +233,85 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
 
     VALUE ary = rb_ary_new2(column_count);
     for(col_idx = 0; col_idx < column_count; col_idx++) {
-        VALUE column = create_column(oDuckDBResult, col_idx);
+        VALUE column = rbduckdb_create_column(oDuckDBResult, col_idx);
         rb_ary_store(ary, col_idx, column);
     }
     return ary;
 }
 
+/*
+ *  call-seq:
+ *    result.streaming? -> Boolean
+ *
+ *  Returns true if the result is streaming, otherwise false.
+ *
+ */
+static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
+    return duckdb_result_is_streaming(ctx->result) ? Qtrue : Qfalse;
+}
+
+static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    idx_t col_count;
+    idx_t chunk_count;
+    idx_t chunk_idx;
+    duckdb_data_chunk chunk;
+
+    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
+
+    col_count = duckdb_column_count(&(ctx->result));
+    chunk_count = duckdb_result_chunk_count(ctx->result);
+
+    RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
+
+    for (chunk_idx = 0; chunk_idx < chunk_count; chunk_idx++) {
+        chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
+        yield_rows(chunk, col_count);
+        duckdb_destroy_data_chunk(&chunk);
+    }
+    return Qnil;
+}
+
+static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    duckdb_data_chunk chunk;
+    idx_t col_count;
+
+    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
+
+    RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
+
+    col_count = duckdb_column_count(&(ctx->result));
+
+    while((chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
+        yield_rows(chunk, col_count);
+        duckdb_destroy_data_chunk(&chunk);
+    }
+    return Qnil;
+}
+
+static void yield_rows(duckdb_data_chunk chunk, idx_t col_count) {
+    idx_t row_count;
+    idx_t row_idx;
+    idx_t col_idx;
+    duckdb_vector vector;
+    VALUE row;
+    VALUE val;
+
+    row_count = duckdb_data_chunk_get_size(chunk);
+    for (row_idx = 0; row_idx < row_count; row_idx++) {
+        row = rb_ary_new2(col_count);
+        for (col_idx = 0; col_idx < col_count; col_idx++) {
+            vector = duckdb_data_chunk_get_vector(chunk, col_idx);
+            val = vector_value(vector, row_idx);
+            rb_ary_store(row, col_idx, val);
+        }
+        rb_yield(row);
+    }
+}
+
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
@@ -397,7 +474,7 @@ static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col
     return value;
 }
 
-VALUE create_result(void) {
+VALUE rbduckdb_create_result(void) {
     return allocate(cDuckDBResult);
 }
 
@@ -405,32 +482,32 @@ static VALUE vector_date(void *vector_data, idx_t row_idx) {
     duckdb_date_struct date = duckdb_from_date(((duckdb_date *) vector_data)[row_idx]);
 
     return rb_funcall(mDuckDBConverter, rb_intern("_to_date"), 3,
-            INT2FIX(date.year),
-            INT2FIX(date.month),
-            INT2FIX(date.day)
-            );
+                      INT2FIX(date.year),
+                      INT2FIX(date.month),
+                      INT2FIX(date.day)
+                      );
 }
 
 static VALUE vector_timestamp(void* vector_data, idx_t row_idx) {
     duckdb_timestamp_struct data = duckdb_from_timestamp(((duckdb_timestamp *)vector_data)[row_idx]);
     return rb_funcall(mDuckDBConverter, rb_intern("_to_time"), 7,
-            INT2FIX(data.date.year),
-            INT2FIX(data.date.month),
-            INT2FIX(data.date.day),
-            INT2FIX(data.time.hour),
-            INT2FIX(data.time.min),
-            INT2FIX(data.time.sec),
-            INT2NUM(data.time.micros)
-            );
+                      INT2FIX(data.date.year),
+                      INT2FIX(data.date.month),
+                      INT2FIX(data.date.day),
+                      INT2FIX(data.time.hour),
+                      INT2FIX(data.time.min),
+                      INT2FIX(data.time.sec),
+                      INT2NUM(data.time.micros)
+                      );
 }
 
 static VALUE vector_interval(void* vector_data, idx_t row_idx) {
     duckdb_interval data = ((duckdb_interval *)vector_data)[row_idx];
     return rb_funcall(mDuckDBConverter, rb_intern("_to_interval_from_vector"), 3,
-            INT2NUM(data.months),
-            INT2NUM(data.days),
-            LL2NUM(data.micros)
-            );
+                      INT2NUM(data.months),
+                      INT2NUM(data.days),
+                      LL2NUM(data.micros)
+                      );
 }
 
 static VALUE vector_blob(void* vector_data, idx_t row_idx) {
@@ -454,9 +531,9 @@ static VALUE vector_varchar(void* vector_data, idx_t row_idx) {
 static VALUE vector_hugeint(void* vector_data, idx_t row_idx) {
     duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
     return rb_funcall(mDuckDBConverter, rb_intern("_to_hugeint_from_vector"), 2,
-            ULL2NUM(hugeint.lower),
-            LL2NUM(hugeint.upper)
-            );
+                      ULL2NUM(hugeint.lower),
+                      LL2NUM(hugeint.upper)
+                      );
 }
 
 static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
@@ -477,11 +554,11 @@ static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row
     }
 
     return rb_funcall(mDuckDBConverter, rb_intern("_to_decimal_from_vector"), 4,
-            INT2FIX(width),
-            INT2FIX(scale),
-            ULL2NUM(value.lower),
-            LL2NUM(value.upper)
-            );
+                      INT2FIX(width),
+                      INT2FIX(scale),
+                      ULL2NUM(value.lower),
+                      LL2NUM(value.upper)
+                      );
 }
 
 static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
@@ -577,9 +654,9 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
 static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
     duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
     return rb_funcall(mDuckDBConverter, rb_intern("_to_uuid_from_vector"), 2,
-            ULL2NUM(hugeint.lower),
-            LL2NUM(hugeint.upper)
-            );
+                      ULL2NUM(hugeint.lower),
+                      LL2NUM(hugeint.upper)
+                      );
 }
 
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
@@ -617,7 +694,7 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
         case DUCKDB_TYPE_BIGINT:
             obj = LL2NUM(((int64_t *) vector_data)[row_idx]);
             break;
-	    case DUCKDB_TYPE_UTINYINT:
+        case DUCKDB_TYPE_UTINYINT:
             obj = INT2FIX(((uint8_t *) vector_data)[row_idx]);
             break;
         case DUCKDB_TYPE_USMALLINT:
@@ -680,44 +757,7 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
     return obj;
 }
 
-static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
-    rubyDuckDBResult *ctx;
-    VALUE row;
-    idx_t col_count;
-    idx_t row_count;
-    idx_t chunk_count;
-    idx_t col_idx;
-    idx_t row_idx;
-    idx_t chunk_idx;
-    duckdb_data_chunk chunk;
-    duckdb_vector vector;
-    VALUE val;
-
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    col_count = duckdb_column_count(&(ctx->result));
-    chunk_count = duckdb_result_chunk_count(ctx->result);
-
-    RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
-
-    for (chunk_idx = 0; chunk_idx < chunk_count; chunk_idx++) {
-        chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
-        row_count = duckdb_data_chunk_get_size(chunk);
-        for (row_idx = 0; row_idx < row_count; row_idx++) {
-            row = rb_ary_new2(col_count);
-            for (col_idx = 0; col_idx < col_count; col_idx++) {
-                vector = duckdb_data_chunk_get_vector(chunk, col_idx);
-                val = vector_value(vector, row_idx);
-                rb_ary_store(row, col_idx, val);
-            }
-            rb_yield(row);
-        }
-        duckdb_destroy_data_chunk(&chunk);
-    }
-    return Qnil;
-}
-
-void init_duckdb_result(void) {
+void rbduckdb_init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 
@@ -725,6 +765,9 @@ void init_duckdb_result(void) {
     rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0);
     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_stream", duckdb_result__chunk_stream, 0);
     rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
     rb_define_private_method(cDuckDBResult, "_null?", duckdb_result__is_null, 2);
     rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2);
@@ -742,5 +785,4 @@ void init_duckdb_result(void) {
     rb_define_private_method(cDuckDBResult, "_enum_internal_type", duckdb_result__enum_internal_type, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_size", duckdb_result__enum_dictionary_size, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_value", duckdb_result__enum_dictionary_value, 2);
-    rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
 }

data/ext/duckdb/result.h

@@ -8,8 +8,8 @@ struct _rubyDuckDBResult {
 typedef struct _rubyDuckDBResult rubyDuckDBResult;
 
 rubyDuckDBResult *get_struct_result(VALUE obj);
-void init_duckdb_result(void);
-VALUE create_result(void);
+void rbduckdb_init_duckdb_result(void);
+VALUE rbduckdb_create_result(void);
 
 #endif
 

data/ext/duckdb/ruby-duckdb.h

@@ -29,5 +29,6 @@ extern VALUE cDuckDBBlob;
 extern VALUE cDuckDBConfig;
 extern VALUE eDuckDBError;
 extern VALUE mDuckDBConverter;
+extern VALUE cDuckDBPreparedStatement;
 
 #endif

data/ext/duckdb/util.c

@@ -1,6 +1,6 @@
 #include "ruby-duckdb.h"
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     duckdb_date_struct dt_struct;
 
     dt_struct.year = NUM2INT(year);
@@ -10,7 +10,7 @@ duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     return duckdb_to_date(dt_struct);
 }
 
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_time_struct time_st;
 
     time_st.hour = NUM2INT(hour);
@@ -21,7 +21,7 @@ duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE mi
     return duckdb_to_time(time_st);
 }
 
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp_struct timestamp_st;
 
     timestamp_st.date.year = NUM2INT(year);
@@ -35,7 +35,7 @@ duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE d
     return duckdb_to_timestamp(timestamp_st);
 }
 
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
     interval->months = NUM2INT(months);
     interval->days = NUM2INT(days);
     interval->micros = NUM2LL(micros);

data/ext/duckdb/util.h

@@ -1,9 +1,9 @@
 #ifndef RUBY_DUCKDB_UTIL_H
 #define RUBY_DUCKDB_UTIL_H
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
 
 #endif

data/lib/duckdb/appender.rb

@@ -86,16 +86,7 @@ module DuckDB
     #   appender.flush
     #
     def append_time(value)
-      time = case value
-             when Time
-               value
-             else
-               begin
-                 Time.parse(value)
-               rescue
-                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
-               end
-             end
+      time = _parse_time(value)
 
       _append_time(time.hour, time.min, time.sec, time.usec)
     end