duckdb 0.3.4.0 → 0.5.0

data/ext/duckdb/config.h

@@ -1,18 +1,14 @@
 #ifndef RUBY_DUCKDB_CONFIG_H
 #define RUBY_DUCKDB_CONFIG_H
 
-#ifdef HAVE_DUCKDB_CREATE_CONFIG
-
 struct _rubyDuckDBConfig {
     duckdb_config config;
 };
 
 typedef struct _rubyDuckDBConfig rubyDuckDBConfig;
 
-void init_duckdb_config(void);
+rubyDuckDBConfig *get_struct_config(VALUE obj);
 
-#endif
+void init_duckdb_config(void);
 
 #endif
-
-

data/ext/duckdb/connection.c

@@ -4,10 +4,17 @@ VALUE cDuckDBConnection;
 
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
 static VALUE duckdb_connection_disconnect(VALUE self);
 static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase);
 static VALUE duckdb_connection_query_sql(VALUE self, VALUE str);
 
+static const rb_data_type_t connection_data_type = {
+    "DuckDB/Connection",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static void deallocate(void *ctx) {
     rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
 
@@ -17,7 +24,17 @@ static void deallocate(void *ctx) {
 
 static VALUE allocate(VALUE klass) {
     rubyDuckDBConnection *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConnection));
-    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+    return TypedData_Wrap_Struct(klass, &connection_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBConnection);
+}
+
+rubyDuckDBConnection *get_struct_connection(VALUE obj) {
+    rubyDuckDBConnection *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBConnection, &connection_data_type, ctx);
+    return ctx;
 }
 
 VALUE create_connection(VALUE oDuckDBDatabase) {
@@ -25,10 +42,10 @@ VALUE create_connection(VALUE oDuckDBDatabase) {
     rubyDuckDBConnection *ctxcon;
     VALUE obj;
 
-    Data_Get_Struct(oDuckDBDatabase, rubyDuckDB, ctxdb);
+    ctxdb = get_struct_database(oDuckDBDatabase);
 
     obj = allocate(cDuckDBConnection);
-    Data_Get_Struct(obj, rubyDuckDBConnection, ctxcon);
+    TypedData_Get_Struct(obj, rubyDuckDBConnection, &connection_data_type, ctxcon);
 
     if (duckdb_connect(ctxdb->db, &(ctxcon->con)) == DuckDBError) {
         rb_raise(eDuckDBError, "connection error");
@@ -41,7 +58,7 @@ VALUE create_connection(VALUE oDuckDBDatabase) {
 static VALUE duckdb_connection_disconnect(VALUE self) {
     rubyDuckDBConnection *ctx;
 
-    Data_Get_Struct(self, rubyDuckDBConnection, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
     duckdb_disconnect(&(ctx->con));
 
     return self;
@@ -54,8 +71,8 @@ static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     if (!rb_obj_is_kind_of(oDuckDBDatabase, cDuckDBDatabase)) {
         rb_raise(rb_eTypeError, "The first argument must be DuckDB::Database object.");
     }
-    Data_Get_Struct(oDuckDBDatabase, rubyDuckDB, ctxdb);
-    Data_Get_Struct(self, rubyDuckDBConnection, ctx);
+    ctxdb = get_struct_database(oDuckDBDatabase);
+    TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
 
     if (duckdb_connect(ctxdb->db, &(ctx->con)) == DuckDBError) {
         rb_raise(eDuckDBError, "connection error");
@@ -70,8 +87,8 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
 
     VALUE result = create_result();
 
-    Data_Get_Struct(self, rubyDuckDBConnection, ctx);
-    Data_Get_Struct(result, rubyDuckDBResult, ctxr);
+    TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
+    ctxr = get_struct_result(result);
 
     if (!(ctx->con)) {
         rb_raise(eDuckDBError, "Database connection closed");

data/ext/duckdb/connection.h

@@ -7,6 +7,7 @@ struct _rubyDuckDBConnection {
 
 typedef struct _rubyDuckDBConnection rubyDuckDBConnection;
 
+rubyDuckDBConnection *get_struct_connection(VALUE obj);
 void init_duckdb_connection(void);
 VALUE create_connection(VALUE oDuckDBDatabase);
 

data/ext/duckdb/database.c

@@ -5,11 +5,18 @@ VALUE cDuckDBDatabase;
 static void close_database(rubyDuckDB *p);
 static void deallocate(void * ctx);
 static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase);
 static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase);
 static VALUE duckdb_database_connect(VALUE self);
 static VALUE duckdb_database_close(VALUE self);
 
+static const rb_data_type_t database_data_type = {
+    "DuckDB/Database",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static void close_database(rubyDuckDB *p) {
     duckdb_close(&(p->db));
 }
@@ -21,9 +28,19 @@ static void deallocate(void * ctx) {
     xfree(p);
 }
 
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDB);
+}
+
 static VALUE allocate(VALUE klass) {
     rubyDuckDB *ctx = xcalloc((size_t)1, sizeof(rubyDuckDB));
-    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+    return TypedData_Wrap_Struct(klass, &database_data_type, ctx);
+}
+
+rubyDuckDB *get_struct_database(VALUE obj) {
+    rubyDuckDB *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
+    return ctx;
 }
 
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
@@ -40,14 +57,13 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
     }
 
     obj = allocate(cDuckDBDatabase);
-    Data_Get_Struct(obj, rubyDuckDB, ctx);
+    TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
     if (duckdb_open(pfile, &(ctx->db)) == DuckDBError) {
         rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
     }
     return obj;
 }
 
-#ifdef HAVE_DUCKDB_OPEN_EXT
 static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
@@ -65,12 +81,12 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
     }
 
     obj = allocate(cDuckDBDatabase);
-    Data_Get_Struct(obj, rubyDuckDB, ctx);
+    TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
     if (!NIL_P(config)) {
         if (!rb_obj_is_kind_of(config, cDuckDBConfig)) {
             rb_raise(rb_eTypeError, "The second argument must be DuckDB::Config object.");
         }
-        Data_Get_Struct(config, rubyDuckDBConfig, ctx_config);
+        ctx_config = get_struct_config(config);
         if (duckdb_open_ext(pfile, &(ctx->db), ctx_config->config, &perror) == DuckDBError) {
             rb_raise(eDuckDBError, "Failed to open database %s", perror);
         }
@@ -81,7 +97,6 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
     }
     return obj;
 }
-#endif /* HAVE_DUCKDB_OPEN_EXT */
 
 static VALUE duckdb_database_connect(VALUE self) {
     return create_connection(self);
@@ -95,7 +110,7 @@ static VALUE duckdb_database_connect(VALUE self) {
  */
 static VALUE duckdb_database_close(VALUE self) {
     rubyDuckDB *ctx;
-    Data_Get_Struct(self, rubyDuckDB, ctx);
+    TypedData_Get_Struct(self, rubyDuckDB, &database_data_type, ctx);
     close_database(ctx);
     return self;
 }
@@ -104,9 +119,7 @@ void init_duckdb_database(void) {
     cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
     rb_define_alloc_func(cDuckDBDatabase, allocate);
     rb_define_singleton_method(cDuckDBDatabase, "_open", duckdb_database_s_open, -1);
-#ifdef HAVE_DUCKDB_OPEN_EXT
     rb_define_singleton_method(cDuckDBDatabase, "_open_ext", duckdb_database_s_open_ext, -1);
-#endif
     rb_define_private_method(cDuckDBDatabase, "_connect", duckdb_database_connect, 0);
     rb_define_method(cDuckDBDatabase, "close", duckdb_database_close, 0);
 }

data/ext/duckdb/database.h

@@ -7,6 +7,7 @@ struct _rubyDuckDB {
 
 typedef struct _rubyDuckDB rubyDuckDB;
 
+rubyDuckDB *get_struct_database(VALUE obj);
 void init_duckdb_database(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -13,12 +13,7 @@ Init_duckdb_native(void) {
     init_duckdb_column();
     init_duckdb_prepared_statement();
     init_duckdb_blob();
-
     init_duckdb_appender();
-
-#ifdef HAVE_DUCKDB_CREATE_CONFIG
-
     init_duckdb_config();
 
-#endif /* HAVE_DUCKDB_CREATE_CONFIG */
 }

data/ext/duckdb/extconf.rb

@@ -6,15 +6,10 @@ raise 'duckdb library is not found. Install duckdb library file and header file.
 
 raise 'duckdb >= 0.2.9 is required. Install duckdb >= 0.2.9' unless have_func('duckdb_value_is_null', 'duckdb.h')
 
+# check duckdb >= 0.3.3
 # ducdb >= 0.3.3 if duckdb_append_data_chunk() is defined.
 have_func('duckdb_append_data_chunk', 'duckdb.h')
 
 have_func('duckdb_free', 'duckdb.h')
 
-have_func('duckdb_create_config', 'duckdb.h')
-have_func('duckdb_open_ext', 'duckdb.h')
-have_func('duckdb_prepare_error', 'duckdb.h')
-
-have_func('duckdb_append_date', 'duckdb.h')
-
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/prepared_statement.c

@@ -4,6 +4,7 @@ static VALUE cDuckDBPreparedStatement;
 
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
 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);
@@ -23,6 +24,12 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 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 const rb_data_type_t prepared_statement_data_type = {
+    "DuckDB/PreparedStatement",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static void deallocate(void *ctx) {
     rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
 
@@ -32,7 +39,11 @@ static void deallocate(void *ctx) {
 
 static VALUE allocate(VALUE klass) {
     rubyDuckDBPreparedStatement *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPreparedStatement));
-    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+    return TypedData_Wrap_Struct(klass, &prepared_statement_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBPreparedStatement);
 }
 
 static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
@@ -43,24 +54,19 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
         rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
     }
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-    Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    ctxcon = get_struct_connection(con);
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
-#ifdef HAVE_DUCKDB_PREPARE_ERROR
         const char *error = duckdb_prepare_error(ctx->prepared_statement);
         rb_raise(eDuckDBError, "%s", error);
-#else
-        /* TODO: include query parameter information in error message. */
-        rb_raise(eDuckDBError, "failed to prepare statement");
-#endif
     }
     return self;
 }
 
 static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     return rb_int2big(duckdb_nparams(ctx->prepared_statement));
 }
 
@@ -70,8 +76,8 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBResult *ctxr;
     VALUE result = create_result();
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-    Data_Get_Struct(result, rubyDuckDBResult, ctxr);
+    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) {
         rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
@@ -90,7 +96,7 @@ static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE v
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     if (val != Qtrue && val != Qfalse) {
         rb_raise(rb_eArgError, "binding value must be boolean");
     }
@@ -106,7 +112,7 @@ static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE v
     idx_t idx = check_index(vidx);
     int8_t i8val = (int8_t)NUM2INT(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_int8(ctx->prepared_statement, idx, i8val) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -119,7 +125,7 @@ static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE
     idx_t idx = check_index(vidx);
     int16_t i16val = NUM2INT(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_int16(ctx->prepared_statement, idx, i16val) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -132,7 +138,7 @@ static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE
     idx_t idx = check_index(vidx);
     int32_t i32val = NUM2INT(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_int32(ctx->prepared_statement, idx, i32val) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -145,7 +151,7 @@ static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE
     idx_t idx = check_index(vidx);
     int64_t i64val = NUM2LL(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_int64(ctx->prepared_statement, idx, i64val) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -158,7 +164,7 @@ static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_float(ctx->prepared_statement, idx, (float)dbl) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -171,7 +177,7 @@ static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_double(ctx->prepared_statement, idx, dbl) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -183,7 +189,8 @@ static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALU
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
     if (duckdb_bind_varchar(ctx->prepared_statement, idx, StringValuePtr(str)) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
     }
@@ -194,7 +201,8 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
     if (duckdb_bind_blob(ctx->prepared_statement, idx, (const void *)StringValuePtr(blob), (idx_t)RSTRING_LEN(blob)) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
     }
@@ -205,7 +213,8 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
     if (duckdb_bind_null(ctx->prepared_statement, idx) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
     }
@@ -219,10 +228,12 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
 
     dt = to_duckdb_date_from_value(year, month, day);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, 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;
 }
 
@@ -234,10 +245,12 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 
     time = to_duckdb_time_from_value(hour, min, sec, micros);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, 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;
 }
 
@@ -247,7 +260,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     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);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -260,7 +273,8 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
     to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {