duckdb 0.3.1.0 → 0.3.4.0

data/ext/duckdb/prepared_statement.c

@@ -2,22 +2,40 @@
 
 static VALUE cDuckDBPreparedStatement;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query);
+static VALUE duckdb_prepared_statement_nparams(VALUE self);
+static VALUE duckdb_prepared_statement_execute(VALUE self);
+static idx_t check_index(VALUE vidx);
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str);
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob);
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx);
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day);
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+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);
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
+
+static void deallocate(void *ctx) {
     rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
 
     duckdb_destroy_prepare(&(p->prepared_statement));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBPreparedStatement *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPreparedStatement));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query)
-{
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBPreparedStatement *ctx;
 
@@ -40,23 +58,14 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
     return self;
 }
 
-static VALUE duckdb_prepared_statement_nparams(VALUE self)
-{
+static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-#ifdef HAVE_DUCKDB_NPARAMS_029
     return rb_int2big(duckdb_nparams(ctx->prepared_statement));
-#else
-    if (duckdb_nparams(ctx->prepared_statement, &(ctx->nparams)) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to get number of parameters");
-    }
-    return rb_int2big(ctx->nparams);
-#endif
 }
 
 
-static VALUE duckdb_prepared_statement_execute(VALUE self)
-{
+static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
     VALUE result = create_result();
@@ -64,13 +73,12 @@ static VALUE duckdb_prepared_statement_execute(VALUE self)
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
     Data_Get_Struct(result, rubyDuckDBResult, ctxr);
     if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;
 }
 
-static idx_t check_index(VALUE vidx)
-{
+static idx_t check_index(VALUE vidx) {
     idx_t idx = FIX2INT(vidx);
     if (idx <= 0) {
         rb_raise(rb_eArgError, "index of parameter must be greater than 0");
@@ -78,8 +86,7 @@ static idx_t check_index(VALUE vidx)
     return idx;
 }
 
-static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -94,8 +101,7 @@ static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int8_t i8val = (int8_t)NUM2INT(val);
@@ -108,8 +114,7 @@ static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int16_t i16val = NUM2INT(val);
@@ -122,8 +127,7 @@ static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int32_t i32val = NUM2INT(val);
@@ -136,8 +140,7 @@ static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int64_t i64val = NUM2LL(val);
@@ -150,8 +153,7 @@ static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -164,8 +166,7 @@ static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -178,8 +179,7 @@ static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str)
-{
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -190,9 +190,7 @@ static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALU
     return self;
 }
 
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob)
-{
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -202,10 +200,8 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
     }
     return self;
 }
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
-{
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -216,8 +212,64 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
     return self;
 }
 
-void init_duckdb_prepared_statement(void)
-{
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_date dt;
+    idx_t idx = check_index(vidx);
+
+    dt = to_duckdb_date_from_value(year, month, day);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_date(ctx->prepared_statement, idx, dt) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_time time;
+
+    idx_t idx = check_index(vidx);
+
+    time = to_duckdb_time_from_value(hour, min, sec, micros);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_time(ctx->prepared_statement, idx, time) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+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;
+    idx_t idx = check_index(vidx);
+
+    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
+    duckdb_interval interval;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    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);
+    }
+    return self;
+}
+
+void init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
@@ -233,8 +285,10 @@ void init_duckdb_prepared_statement(void)
     rb_define_method(cDuckDBPreparedStatement, "bind_float", duckdb_prepared_statement_bind_float, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_double", duckdb_prepared_statement_bind_double, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_varchar", duckdb_prepared_statement_bind_varchar, 2);
-#ifdef HAVE_DUCKDB_VALUE_BLOB
     rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
     rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", duckdb_prepared_statement__bind_date, 4);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_time", duckdb_prepared_statement__bind_time, 5);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", duckdb_prepared_statement__bind_timestamp, 8);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", duckdb_prepared_statement__bind_interval, 4);
 }

data/ext/duckdb/result.c

@@ -2,6 +2,22 @@
 
 static VALUE cDuckDBResult;
 
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx);
+static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj);
+static VALUE duckdb_result_each(VALUE oDuckDBResult);
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
+static VALUE duckdb_result_columns(VALUE oDuckDBResult);
+
 static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
@@ -44,31 +60,25 @@ static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_
     return DBL2NUM(dval);
 }
 
-#ifdef HAVE_DUCKDB_VALUE_BLOB
 static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     VALUE str;
     duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
     str = rb_str_new(bval.data, bval.size);
 
     if (bval.data) {
-#ifdef HAVE_DUCKDB_FREE
         duckdb_free(bval.data);
-#else
-        free(bval.data);
-#endif
     }
 
     return str;
 }
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
 
 static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     char *p;
     VALUE obj = Qnil;
-    if (result->columns[col_idx].nullmask[row_idx]) {
+    if (duckdb_value_is_null(result, col_idx, row_idx)) {
         return obj;
     }
-    switch(result->columns[col_idx].type) {
+    switch(duckdb_column_type(result, col_idx)) {
     case DUCKDB_TYPE_BOOLEAN:
         return to_ruby_obj_boolean(result, col_idx, row_idx);
     case DUCKDB_TYPE_SMALLINT:
@@ -81,20 +91,14 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
         return to_ruby_obj_float(result, col_idx, row_idx);
     case DUCKDB_TYPE_DOUBLE:
         return to_ruby_obj_double(result, col_idx, row_idx);
-#ifdef HAVE_DUCKDB_VALUE_BLOB
     case DUCKDB_TYPE_BLOB:
         return to_ruby_obj_string_from_blob(result, col_idx, row_idx);
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
     default:
         p = duckdb_value_varchar(result, col_idx, row_idx);
         if (p) {
             obj = rb_str_new2(p);
-#ifdef HAVE_DUCKDB_FREE
             duckdb_free(p);
-#else
-            free(p);
-#endif /* HAVE_DUCKDB_FREE */
-            if (result->columns[col_idx].type == DUCKDB_TYPE_HUGEINT) {
+            if (duckdb_column_type(result, col_idx) == DUCKDB_TYPE_HUGEINT) {
                 obj = rb_funcall(obj, rb_intern("to_i"), 0);
             }
         }
@@ -104,8 +108,10 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
 
 static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx) {
     idx_t col_idx;
-    VALUE ary = rb_ary_new2(ctx->result.column_count);
-    for(col_idx = 0; col_idx < ctx->result.column_count; col_idx++) {
+    idx_t column_count = duckdb_column_count(&(ctx->result));
+
+    VALUE ary = rb_ary_new2(column_count);
+    for(col_idx = 0; col_idx < column_count; col_idx++) {
         rb_ary_store(ary, col_idx, to_ruby_obj(&(ctx->result), col_idx, row_idx));
     }
     return ary;
@@ -115,17 +121,19 @@ static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj)
     rubyDuckDBResult *ctx;
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
 
-    return LONG2FIX(ctx->result.row_count);
+    return LONG2FIX(duckdb_row_count(&(ctx->result)));
 }
 
 static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     idx_t row_idx = 0;
+    idx_t row_count = 0;
 
     RETURN_SIZED_ENUMERATOR(oDuckDBResult, 0, 0, duckdb_result_row_size);
 
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
-    for (row_idx = 0; row_idx < ctx->result.row_count; row_idx++) {
+    row_count = duckdb_row_count(&(ctx->result));
+    for (row_idx = 0; row_idx < row_count; row_idx++) {
         rb_yield(row_array(ctx, row_idx));
     }
     return oDuckDBResult;
@@ -156,7 +164,29 @@ static VALUE duckdb_result_each(VALUE oDuckDBResult) {
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
-    return LL2NUM(ctx->result.rows_changed);
+    return LL2NUM(duckdb_rows_changed(&(ctx->result)));
+}
+
+/*
+ *  call-seq:
+ *    result.columns -> DuckDB::Column[]
+ *
+ *  Returns the column class Lists.
+ *
+ */
+static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
+
+    idx_t col_idx;
+    idx_t column_count = duckdb_column_count(&(ctx->result));
+
+    VALUE ary = rb_ary_new2(column_count);
+    for(col_idx = 0; col_idx < column_count; col_idx++) {
+        VALUE column = create_column(oDuckDBResult, col_idx);
+        rb_ary_store(ary, col_idx, column);
+    }
+    return ary;
 }
 
 VALUE create_result(void) {
@@ -169,4 +199,5 @@ void init_duckdb_result(void) {
 
     rb_define_method(cDuckDBResult, "each", duckdb_result_each, 0);
     rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
+    rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
 }

data/ext/duckdb/ruby-duckdb.h

@@ -3,24 +3,22 @@
 
 #include "ruby.h"
 #include <duckdb.h>
+
+#ifdef HAVE_DUCKDB_APPEND_DATA_CHUNK
+#define HAVE_DUCKDB_H_GE_V033 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
 #include "./result.h"
+#include "./column.h"
 #include "./prepared_statement.h"
-
-#ifdef HAVE_DUCKDB_VALUE_BLOB
+#include "./util.h"
 
 #include "./blob.h"
-
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
-#ifdef HAVE_DUCKDB_APPENDER_CREATE
-
 #include "./appender.h"
 
-#endif /* HAVE_DUCKDB_APPENDER_CREATE */
-
 #ifdef HAVE_DUCKDB_CREATE_CONFIG
 
 #include "./config.h"
@@ -30,19 +28,8 @@
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
-
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-
 extern VALUE cDuckDBBlob;
-
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
-#ifdef HAVE_DUCKDB_CREATE_CONFIG
-
 extern VALUE cDuckDBConfig;
-
-#endif /* HAVE_DUCKDB_CREATE_CONFIG */
-
 extern VALUE eDuckDBError;
 
 #endif

data/ext/duckdb/util.c

@@ -0,0 +1,45 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+    duckdb_date_struct dt_struct;
+
+    dt_struct.year = NUM2INT(year);
+    dt_struct.month = NUM2INT(month);
+    dt_struct.day = NUM2INT(day);
+
+    return duckdb_to_date(dt_struct);
+}
+
+duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_time_struct time_st;
+
+    time_st.hour = NUM2INT(hour);
+    time_st.min = NUM2INT(min);
+    time_st.sec = NUM2INT(sec);
+    time_st.micros = NUM2INT(micros);
+
+    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_struct timestamp_st;
+
+    timestamp_st.date.year = NUM2INT(year);
+    timestamp_st.date.month = NUM2INT(month);
+    timestamp_st.date.day = NUM2INT(day);
+    timestamp_st.time.hour = NUM2INT(hour);
+    timestamp_st.time.min = NUM2INT(min);
+    timestamp_st.time.sec = NUM2INT(sec);
+    timestamp_st.time.micros = NUM2INT(micros);
+
+    return duckdb_to_timestamp(timestamp_st);
+}
+
+void 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);
+}
+#endif

data/ext/duckdb/util.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_UTIL_H
+#define RUBY_DUCKDB_UTIL_H
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+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);
+
+#endif
+
+#endif