duckdb 1.2.0.0 → 1.2.2.0

data/ext/duckdb/logical_type.c

@@ -8,10 +8,21 @@ 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_count(VALUE self);
+static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx);
 static VALUE duckdb_logical_type_child_type(VALUE self);
+static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx);
 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 VALUE duckdb_logical_type_member_count(VALUE self);
+static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx);
+static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx);
+static VALUE duckdb_logical_type__internal_type(VALUE self);
+static VALUE duckdb_logical_type_dictionary_size(VALUE self);
+static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx);
+static VALUE duckdb_logical_type__get_alias(VALUE self);
+static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
 
 static const rb_data_type_t logical_type_data_type = {
     "DuckDB/LogicalType",
@@ -77,6 +88,43 @@ static VALUE duckdb_logical_type_scale(VALUE self) {
     return INT2FIX(duckdb_decimal_scale(ctx->logical_type));
 }
 
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_count -> Integer
+ *
+ *  Returns the number of children of a struct type, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_child_count(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_struct_type_child_count(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_name(index) -> String
+ *
+ *  Returns the name of the struct child at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE cname;
+    const char *child_name;
+    idx_t idx = NUM2ULL(cidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    child_name = duckdb_struct_type_child_name(ctx->logical_type, idx);
+    if (child_name == NULL) {
+        rb_raise(eDuckDBError, "fail to get name of %llu child", (unsigned long long)idx);
+    }
+    cname = rb_str_new_cstr(child_name);
+    duckdb_free((void *)child_name);
+    return cname;
+}
+
 /*
  *  call-seq:
  *    list_col.logical_type.child_type -> DuckDB::LogicalType
@@ -109,6 +157,31 @@ static VALUE duckdb_logical_type_child_type(VALUE self) {
     return logical_type;
 }
 
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_type_at(index) -> DuckDB::LogicalType
+ *
+ *  Returns the child logical type for struct types at the specified index as a
+ *  DuckDB::LogicalType object.
+ *
+ */
+static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type struct_child_type;
+    idx_t idx = NUM2ULL(cidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    struct_child_type = duckdb_struct_type_child_type(ctx->logical_type, idx);
+    if (struct_child_type == NULL) {
+        rb_raise(eDuckDBError,
+                 "Failed to get the struct child type at index %llu",
+                 (unsigned long long)idx);
+    }
+
+    return rbduckdb_create_logical_type(struct_child_type);
+}
+
 /*
  *  call-seq:
  *    list_col.logical_type.size -> Integer
@@ -158,6 +231,177 @@ static VALUE duckdb_logical_type_value_type(VALUE self) {
     return logical_type;
 }
 
+/*
+ *  call-seq:
+ *    member_col.logical_type.member_count -> Integer
+ *
+ *  Returns the member count of union type, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_member_count(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_union_type_member_count(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    union_col.logical_type.member_name_at(index) -> String
+ *
+ *  Returns the name of the union member at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE mname;
+    const char *member_name;
+    idx_t idx = NUM2ULL(midx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    member_name = duckdb_union_type_member_name(ctx->logical_type, idx);
+    if (member_name == NULL) {
+        rb_raise(eDuckDBError, "fail to get name of %llu member", (unsigned long long)idx);
+    }
+    mname = rb_str_new_cstr(member_name);
+    duckdb_free((void *)member_name);
+    return mname;
+}
+
+/*
+ *  call-seq:
+ *    union_col.logical_type.member_type_at(index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the union member at the specified index as a
+ *  DuckDB::LogicalType object.
+ *
+ */
+static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type union_member_type;
+    idx_t idx = NUM2ULL(midx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    union_member_type = duckdb_union_type_member_type(ctx->logical_type, idx);
+    if (union_member_type == NULL) {
+        rb_raise(eDuckDBError,
+                 "Failed to get the union member type at index %llu",
+                 (unsigned long long)idx);
+    }
+
+    return rbduckdb_create_logical_type(union_member_type);
+}
+
+/*
+ *  call-seq:
+ *    enum_col.logical_type.internal_type -> Symbol
+ *
+ *  Returns the logical type's internal type.
+ *
+ */
+static VALUE duckdb_logical_type__internal_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_type type_id;
+    duckdb_type internal_type_id;
+
+    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_DECIMAL:
+            internal_type_id = duckdb_decimal_internal_type(ctx->logical_type);
+            break;
+        case DUCKDB_TYPE_ENUM:
+            internal_type_id = duckdb_enum_internal_type(ctx->logical_type);
+            break;
+        default:
+            internal_type_id = DUCKDB_TYPE_INVALID;
+    }
+
+    return INT2FIX(internal_type_id);
+}
+
+/*
+ *  call-seq:
+ *    enum_col.logical_type.dictionary_size -> Integer
+ *
+ *  Returns the dictionary size of the enum type.
+ *
+ */
+static VALUE duckdb_logical_type_dictionary_size(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_enum_dictionary_size(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    enum_col.logical_type.dictionary_value_at(index) -> String
+ *
+ *  Returns the dictionary value at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE dvalue;
+    const char *dict_value;
+    idx_t idx = NUM2ULL(didx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    dict_value = duckdb_enum_dictionary_value(ctx->logical_type, idx);
+    if (dict_value == NULL) {
+        rb_raise(eDuckDBError, "fail to get dictionary value of %llu", (unsigned long long)idx);
+    }
+    dvalue = rb_utf8_str_new_cstr(dict_value);
+    duckdb_free((void *)dict_value);
+    return dvalue;
+}
+
+/*
+ *  call-seq:
+ *    col.logical_type.alias -> String
+ *
+ *  Returns the alias of the logical type.
+ *
+ */
+static VALUE duckdb_logical_type__get_alias(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE alias = Qnil;
+    const char *_alias;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    _alias = duckdb_logical_type_get_alias(ctx->logical_type);
+    if (_alias != NULL) {
+        alias = rb_utf8_str_new_cstr(_alias);
+    }
+    duckdb_free((void *)_alias);
+    return alias;
+}
+
+/*
+ *  call-seq:
+ *    col.logical_type.alias(alias) -> String
+ *
+ *  Return the set alias of the logical type.
+ *
+ */
+static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE alias = Qnil;
+    const char *_alias = StringValuePtr(aname);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    duckdb_logical_type_set_alias(ctx->logical_type, _alias);
+    if (_alias != NULL) {
+        alias = rb_utf8_str_new_cstr(_alias);
+    }
+
+    return alias;
+}
+
 VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
     VALUE obj;
     rubyDuckDBLogicalType *ctx;
@@ -180,8 +424,19 @@ void rbduckdb_init_duckdb_logical_type(void) {
     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_count", duckdb_logical_type_child_count, 0);
+    rb_define_method(cDuckDBLogicalType, "child_name_at", duckdb_logical_type_child_name_at, 1);
     rb_define_method(cDuckDBLogicalType, "child_type", duckdb_logical_type_child_type, 0);
+    rb_define_method(cDuckDBLogicalType, "child_type_at", duckdb_logical_type_child_type_at, 1);
     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);
+    rb_define_method(cDuckDBLogicalType, "member_count", duckdb_logical_type_member_count, 0);
+    rb_define_method(cDuckDBLogicalType, "member_name_at", duckdb_logical_type_member_name_at, 1);
+    rb_define_method(cDuckDBLogicalType, "member_type_at", duckdb_logical_type_member_type_at, 1);
+    rb_define_method(cDuckDBLogicalType, "_internal_type", duckdb_logical_type__internal_type, 0);
+    rb_define_method(cDuckDBLogicalType, "dictionary_size", duckdb_logical_type_dictionary_size, 0);
+    rb_define_method(cDuckDBLogicalType, "dictionary_value_at", duckdb_logical_type_dictionary_value_at, 1);
+    rb_define_method(cDuckDBLogicalType, "get_alias", duckdb_logical_type__get_alias, 0);
+    rb_define_method(cDuckDBLogicalType, "set_alias", duckdb_logical_type__set_alias, 1);
 }

data/ext/duckdb/prepared_statement.c

@@ -27,11 +27,16 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
 static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx);
 static VALUE duckdb_prepared_statement__statement_type(VALUE self);
 static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx);
+static VALUE duckdb_prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint64(VALUE self, VALUE vidx, VALUE val);
 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 VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
+static VALUE duckdb_prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
 static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale);
 
 static const rb_data_type_t prepared_statement_data_type = {
@@ -121,6 +126,7 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBResult *ctxr;
     const char *error;
     VALUE result = rbduckdb_create_result();
+    VALUE msg;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -135,12 +141,13 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     duckdb_state state = args.retval;
 
     if (state == DuckDBError) {
-        error = duckdb_result_error(args.out_result);
+        error = duckdb_prepare_error(args.prepared_statement);
         if (error == NULL) {
-            error = duckdb_prepare_error(args.prepared_statement);
+            error = duckdb_result_error(args.out_result);
         }
+        msg = rb_str_new2(error ? error : "Failed to execute prepared statement.");
 
-        rb_raise(eDuckDBError, "%s", error ? error : "Failed to execute prepared statement.");
+        rb_raise(eDuckDBError, "%s", StringValuePtr(msg));
     }
 
     return result;
@@ -241,6 +248,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) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
@@ -356,6 +364,62 @@ static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx) {
     return INT2FIX(duckdb_param_type(ctx->prepared_statement, NUM2ULL(vidx)));
 }
 
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint8_t ui8val = (uint8_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint8(ctx->prepared_statement, idx, ui8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint16_t ui16val = (uint16_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint16(ctx->prepared_statement, idx, ui16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint32_t ui32val = (uint32_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint32(ctx->prepared_statement, idx, ui32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint64(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint64_t ui64val = (uint64_t)NUM2ULL(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint64(ctx->prepared_statement, idx, ui64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
 /* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
     rubyDuckDBPreparedStatement *ctx;
@@ -439,6 +503,23 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
+    duckdb_uhugeint uhugeint;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    uhugeint.lower = NUM2ULL(lower);
+    uhugeint.upper = NUM2ULL(upper);
+
+    if (duckdb_bind_uhugeint(ctx->prepared_statement, idx, uhugeint) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+
+    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;
@@ -491,6 +572,10 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "bind_varchar", duckdb_prepared_statement_bind_varchar, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint8", duckdb_prepared_statement__bind_uint8, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint16", duckdb_prepared_statement__bind_uint16, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint32", duckdb_prepared_statement__bind_uint32, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint64", duckdb_prepared_statement__bind_uint64, 2);
     rb_define_private_method(cDuckDBPreparedStatement, "_statement_type", duckdb_prepared_statement__statement_type, 0);
     rb_define_private_method(cDuckDBPreparedStatement, "_param_type", duckdb_prepared_statement__param_type, 1);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", duckdb_prepared_statement__bind_date, 4);
@@ -498,5 +583,6 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
     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);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_hugeint", duckdb_prepared_statement__bind_hugeint, 3);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uhugeint", duckdb_prepared_statement__bind_uhugeint, 3);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_decimal", duckdb_prepared_statement__bind_decimal, 5);
 }

data/ext/duckdb/result.c

@@ -279,7 +279,7 @@ static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
 /*
  * remove this #if ... #else statement when dropping duckdb 1.1.0.
  */
-#if !defined(HAVE_DUCKDB_H_GE_V1_1_1) && defined(HAVE_DUCKDB_H_GE_V1_1_0) && defined(DUCKDB_API_NO_DEPRECATED)
+#if !defined(HAVE_DUCKDB_H_GE_V1_1_1) && defined(DUCKDB_API_NO_DEPRECATED)
     rb_raise(eDuckDBError, "duckdb_result_return_type C-API is not available with duckdb v1.1.0 with enabled DUCKDB_API_NO_DEPRECATED.");
 #else
     return INT2FIX(duckdb_result_return_type(ctx->result));

data/ext/duckdb/ruby-duckdb.h

@@ -8,18 +8,14 @@
 #include "ruby/thread.h"
 #include <duckdb.h>
 
-#ifdef HAVE_DUCKDB_FETCH_CHUNK
-#define HAVE_DUCKDB_H_GE_V1_0_0 1
-#endif
-
-#ifdef HAVE_DUCKDB_RESULT_ERROR_TYPE
-#define HAVE_DUCKDB_H_GE_V1_1_0 1
-#endif
-
 #ifdef HAVE_CONST_DUCKDB_TYPE_SQLNULL
 #define HAVE_DUCKDB_H_GE_V1_1_1 1
 #endif
 
+#ifdef HAVE_DUCKDB_CREATE_INSTANCE_CACHE
+#define HAVE_DUCKDB_H_GE_V1_2_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
@@ -36,6 +32,10 @@
 #include "./appender.h"
 #include "./config.h"
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+#include "./instance_cache.h"
+#endif
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
@@ -47,4 +47,8 @@ extern VALUE cDuckDBPreparedStatement;
 extern VALUE PositiveInfinity;
 extern VALUE NegativeInfinity;
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+extern VALUE cDuckDBInstanceCache;
+#endif
+
 #endif