duckdb 1.1.3.1 → 1.2.1.0

data/ext/duckdb/appender.c

@@ -6,36 +6,33 @@ static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE appender_initialize(VALUE klass, VALUE con, VALUE schema, VALUE table);
-static VALUE appender_begin_row(VALUE self);
-static VALUE appender_end_row(VALUE self);
-static VALUE appender_append_bool(VALUE self, VALUE val);
-static VALUE appender_append_int8(VALUE self, VALUE val);
-static VALUE appender_append_int16(VALUE self, VALUE val);
-static VALUE appender_append_int32(VALUE self, VALUE val);
-static VALUE appender_append_int64(VALUE self, VALUE val);
-static VALUE appender_append_uint8(VALUE self, VALUE val);
-static VALUE appender_append_uint16(VALUE self, VALUE val);
-static VALUE appender_append_uint32(VALUE self, VALUE val);
-static VALUE appender_append_uint64(VALUE self, VALUE val);
-static VALUE appender_append_float(VALUE self, VALUE val);
-static VALUE appender_append_double(VALUE self, VALUE val);
-static VALUE appender_append_varchar(VALUE self, VALUE val);
-static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
-static VALUE appender_append_blob(VALUE self, VALUE val);
-static VALUE appender_append_null(VALUE self);
-
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-static VALUE appender_append_default(VALUE self);
-#endif
-
+static VALUE appender_error_message(VALUE self);
+static VALUE appender__append_bool(VALUE self, VALUE val);
+static VALUE appender__append_int8(VALUE self, VALUE val);
+static VALUE appender__append_int16(VALUE self, VALUE val);
+static VALUE appender__append_int32(VALUE self, VALUE val);
+static VALUE appender__append_int64(VALUE self, VALUE val);
+static VALUE appender__append_uint8(VALUE self, VALUE val);
+static VALUE appender__append_uint16(VALUE self, VALUE val);
+static VALUE appender__append_uint32(VALUE self, VALUE val);
+static VALUE appender__append_uint64(VALUE self, VALUE val);
+static VALUE appender__append_float(VALUE self, VALUE val);
+static VALUE appender__append_double(VALUE self, VALUE val);
+static VALUE appender__append_varchar(VALUE self, VALUE val);
+static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len);
+static VALUE appender__append_blob(VALUE self, VALUE val);
+static VALUE appender__append_null(VALUE self);
+static VALUE appender__append_default(VALUE self);
+static VALUE appender__end_row(VALUE self);
 static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval);
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros);
 static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper);
 static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper);
-static VALUE appender_flush(VALUE self);
-static VALUE appender_close(VALUE self);
+static VALUE appender__flush(VALUE self);
+static VALUE appender__close(VALUE self);
+static VALUE duckdb_state_to_bool_value(duckdb_state state);
 
 static const rb_data_type_t appender_data_type = {
     "DuckDB/Appender",
@@ -82,27 +79,40 @@ static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE tabl
     return self;
 }
 
-static VALUE appender_begin_row(VALUE self) {
+/* call-seq:
+ *   appender.error_message -> String
+ *
+ * Returns the error message of the appender. If there is no error, then it returns nil.
+ *
+ *   require 'duckdb'
+ *   db = DuckDB::Database.open
+ *   con = db.connect
+ *   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+ *   appender = con.appender('users')
+ *   appender.error_message # => nil
+ */
+static VALUE appender_error_message(VALUE self) {
     rubyDuckDBAppender *ctx;
+    const char *msg;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_appender_begin_row(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to flush");
+    msg = duckdb_appender_error(ctx->appender);
+    if (msg == NULL) {
+        return Qnil;
     }
-    return self;
+    return rb_str_new2(msg);
 }
 
-static VALUE appender_end_row(VALUE self) {
+/* :nodoc: */
+static VALUE appender__end_row(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_appender_end_row(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to flush");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_appender_end_row(ctx->appender));
 }
 
-static VALUE appender_append_bool(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_bool(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
@@ -110,145 +120,121 @@ static VALUE appender_append_bool(VALUE self, VALUE val) {
         rb_raise(rb_eArgError, "argument must be boolean");
     }
 
-    if (duckdb_append_bool(ctx->appender, (val == Qtrue)) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append boolean");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_bool(ctx->appender, (val == Qtrue)));
 }
 
-static VALUE appender_append_int8(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_int8(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     int8_t i8val = (int8_t)NUM2INT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_int8(ctx->appender, i8val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_int8(ctx->appender, i8val));
 }
 
-static VALUE appender_append_int16(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_int16(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     int16_t i16val = (int16_t)NUM2INT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_int16(ctx->appender, i16val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_int16(ctx->appender, i16val));
 }
 
-static VALUE appender_append_int32(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_int32(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     int32_t i32val = (int32_t)NUM2INT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_int32(ctx->appender, i32val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_int32(ctx->appender, i32val));
 }
 
-static VALUE appender_append_int64(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_int64(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     int64_t i64val = (int64_t)NUM2LL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_int64(ctx->appender, i64val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_int64(ctx->appender, i64val));
 }
 
-static VALUE appender_append_uint8(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint8(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
-    int8_t ui8val = (uint8_t)NUM2UINT(val);
+    uint8_t ui8val = (uint8_t)NUM2UINT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint8(ctx->appender, ui8val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_uint8(ctx->appender, ui8val));
 }
 
-static VALUE appender_append_uint16(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint16(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint16_t ui16val = (uint16_t)NUM2UINT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint16(ctx->appender, ui16val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return  duckdb_state_to_bool_value(duckdb_append_uint16(ctx->appender, ui16val));
 }
 
-static VALUE appender_append_uint32(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint32(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint32_t ui32val = (uint32_t)NUM2UINT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint32(ctx->appender, ui32val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return  duckdb_state_to_bool_value(duckdb_append_uint32(ctx->appender, ui32val));
 }
 
-static VALUE appender_append_uint64(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint64(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint64_t ui64val = (uint64_t)NUM2ULL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint64(ctx->appender, ui64val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_uint64(ctx->appender, ui64val));
 }
 
-static VALUE appender_append_float(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_float(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     float fval = (float)NUM2DBL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_float(ctx->appender, fval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_float(ctx->appender, fval));
 }
 
-static VALUE appender_append_double(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_double(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     double dval = NUM2DBL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_double(ctx->appender, dval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_double(ctx->appender, dval));
 }
 
-static VALUE appender_append_varchar(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_varchar(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     char *pval = StringValuePtr(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_varchar(ctx->appender, pval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_varchar(ctx->appender, pval));
 }
 
-static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
+/* :nodoc: */
+static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len) {
     rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
@@ -256,13 +242,11 @@ static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_varchar_length(ctx->appender, pval, length) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_varchar_length(ctx->appender, pval, length));
 }
 
-static VALUE appender_append_blob(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_blob(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
@@ -270,34 +254,26 @@ static VALUE appender_append_blob(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_blob(ctx->appender, (void *)pval, length) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_blob(ctx->appender, (void *)pval, length));
 }
 
-static VALUE appender_append_null(VALUE self) {
+/* :nodoc: */
+static VALUE appender__append_null(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_null(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_null(ctx->appender));
 }
 
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-static VALUE appender_append_default(VALUE self) {
+/* :nodoc: */
+static VALUE appender__append_default(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_default(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_default(ctx->appender));
 }
-#endif
 
+/* :nodoc: */
 static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
     duckdb_date dt;
     rubyDuckDBAppender *ctx;
@@ -305,12 +281,10 @@ static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE da
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
-    if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append date");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_date(ctx->appender, dt));
 }
 
+/* :nodoc: */
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
     rubyDuckDBAppender *ctx;
@@ -318,12 +292,10 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
-    if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append interval");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_interval(ctx->appender, interval));
 }
 
+/* :nodoc: */
 static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_time time;
     rubyDuckDBAppender *ctx;
@@ -331,12 +303,10 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
-    if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append time");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_time(ctx->appender, time));
 }
 
+/* :nodoc: */
 static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp;
 
@@ -346,12 +316,10 @@ static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VAL
 
     timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
 
-    if (duckdb_append_timestamp(ctx->appender, timestamp) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append timestamp");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_timestamp(ctx->appender, timestamp));
 }
 
+/* :nodoc: */
 static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
 
@@ -361,12 +329,11 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    if (duckdb_append_hugeint(ctx->appender, hugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append hugeint");
-    }
-    return self;
+
+    return duckdb_state_to_bool_value(duckdb_append_hugeint(ctx->appender, hugeint));
 }
 
+/* :nodoc: */
 static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
     duckdb_uhugeint uhugeint;
 
@@ -376,64 +343,64 @@ static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    if (duckdb_append_uhugeint(ctx->appender, uhugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append uhugeint");
-    }
-    return self;
+
+    return duckdb_state_to_bool_value(duckdb_append_uhugeint(ctx->appender, uhugeint));
 }
 
-static VALUE appender_flush(VALUE self) {
+/* :nodoc: */
+static VALUE appender__flush(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_appender_flush(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to flush");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_appender_flush(ctx->appender));
 }
 
-static VALUE appender_close(VALUE self) {
+/* :nodoc: */
+static VALUE appender__close(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_appender_close(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to flush");
+    return duckdb_state_to_bool_value(duckdb_appender_close(ctx->appender));
+}
+
+static VALUE duckdb_state_to_bool_value(duckdb_state state) {
+    if (state == DuckDBSuccess) {
+        return Qtrue;
     }
-    return self;
+    return Qfalse;
 }
 
 void rbduckdb_init_duckdb_appender(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBAppender = rb_define_class_under(mDuckDB, "Appender", rb_cObject);
     rb_define_alloc_func(cDuckDBAppender, allocate);
     rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
-    rb_define_method(cDuckDBAppender, "begin_row", appender_begin_row, 0);
-    rb_define_method(cDuckDBAppender, "end_row", appender_end_row, 0);
-    rb_define_method(cDuckDBAppender, "append_bool", appender_append_bool, 1);
-    rb_define_method(cDuckDBAppender, "append_int8", appender_append_int8, 1);
-    rb_define_method(cDuckDBAppender, "append_int16", appender_append_int16, 1);
-    rb_define_method(cDuckDBAppender, "append_int32", appender_append_int32, 1);
-    rb_define_method(cDuckDBAppender, "append_int64", appender_append_int64, 1);
-    rb_define_method(cDuckDBAppender, "append_uint8", appender_append_uint8, 1);
-    rb_define_method(cDuckDBAppender, "append_uint16", appender_append_uint16, 1);
-    rb_define_method(cDuckDBAppender, "append_uint32", appender_append_uint32, 1);
-    rb_define_method(cDuckDBAppender, "append_uint64", appender_append_uint64, 1);
-    rb_define_method(cDuckDBAppender, "append_float", appender_append_float, 1);
-    rb_define_method(cDuckDBAppender, "append_double", appender_append_double, 1);
-    rb_define_method(cDuckDBAppender, "append_varchar", appender_append_varchar, 1);
-    rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
-    rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
-    rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
-
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-    rb_define_method(cDuckDBAppender, "append_default", appender_append_default, 0);
-#endif
-
+    rb_define_method(cDuckDBAppender, "error_message", appender_error_message, 0);
+    rb_define_private_method(cDuckDBAppender, "_end_row", appender__end_row, 0);
+    rb_define_private_method(cDuckDBAppender, "_flush", appender__flush, 0);
+    rb_define_private_method(cDuckDBAppender, "_close", appender__close, 0);
+    rb_define_private_method(cDuckDBAppender, "_append_bool", appender__append_bool, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_int8", appender__append_int8, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_int16", appender__append_int16, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_int32", appender__append_int32, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_int64", appender__append_int64, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint8", appender__append_uint8, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint16", appender__append_uint16, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint32", appender__append_uint32, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint64", appender__append_uint64, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_float", appender__append_float, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_double", appender__append_double, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_varchar", appender__append_varchar, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_varchar_length", appender__append_varchar_length, 2);
+    rb_define_private_method(cDuckDBAppender, "_append_blob", appender__append_blob, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_null", appender__append_null, 0);
+    rb_define_private_method(cDuckDBAppender, "_append_default", appender__append_default, 0);
     rb_define_private_method(cDuckDBAppender, "_append_date", appender__append_date, 3);
     rb_define_private_method(cDuckDBAppender, "_append_interval", appender__append_interval, 3);
     rb_define_private_method(cDuckDBAppender, "_append_time", appender__append_time, 4);
     rb_define_private_method(cDuckDBAppender, "_append_timestamp", appender__append_timestamp, 7);
     rb_define_private_method(cDuckDBAppender, "_append_hugeint", appender__append_hugeint, 2);
     rb_define_private_method(cDuckDBAppender, "_append_uhugeint", appender__append_uhugeint, 2);
-    rb_define_method(cDuckDBAppender, "flush", appender_flush, 0);
-    rb_define_method(cDuckDBAppender, "close", appender_close, 0);
 }

data/ext/duckdb/blob.c

@@ -3,5 +3,8 @@
 VALUE cDuckDBBlob;
 
 void rbduckdb_init_duckdb_blob(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBBlob = rb_define_class_under(mDuckDB, "Blob", rb_cString);
 }

data/ext/duckdb/column.c

@@ -6,6 +6,7 @@ static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE duckdb_column__type(VALUE oDuckDBColumn);
+static VALUE duckdb_column__logical_type(VALUE oDuckDBColumn);
 static VALUE duckdb_column_get_name(VALUE oDuckDBColumn);
 
 static const rb_data_type_t column_data_type = {
@@ -29,9 +30,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBColumn);
 }
 
-/*
- *
- */
+/* :nodoc: */
 VALUE duckdb_column__type(VALUE oDuckDBColumn) {
     rubyDuckDBColumn *ctx;
     rubyDuckDBResult *ctxresult;
@@ -47,6 +46,33 @@ VALUE duckdb_column__type(VALUE oDuckDBColumn) {
     return INT2FIX(type);
 }
 
+/*
+ *  call-seq:
+ *    column.logical_type -> DuckDB::LogicalType
+ *
+ *  Returns the logical type class.
+ *
+ */
+VALUE duckdb_column__logical_type(VALUE oDuckDBColumn) {
+    rubyDuckDBColumn *ctx;
+    rubyDuckDBResult *ctxresult;
+    VALUE result;
+    duckdb_logical_type _logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(oDuckDBColumn, rubyDuckDBColumn, &column_data_type, ctx);
+
+    result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
+    ctxresult = get_struct_result(result);
+    _logical_type = duckdb_column_logical_type(&(ctxresult->result), ctx->col);
+
+    if (_logical_type) {
+        logical_type = rbduckdb_create_logical_type(_logical_type);
+    }
+
+    return logical_type;
+}
+
 /*
  *  call-seq:
  *    column.name -> string.
@@ -82,9 +108,13 @@ VALUE rbduckdb_create_column(VALUE oDuckDBResult, idx_t col) {
 }
 
 void rbduckdb_init_duckdb_column(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBColumn = rb_define_class_under(mDuckDB, "Column", rb_cObject);
     rb_define_alloc_func(cDuckDBColumn, allocate);
 
     rb_define_private_method(cDuckDBColumn, "_type", duckdb_column__type, 0);
+    rb_define_method(cDuckDBColumn, "logical_type", duckdb_column__logical_type, 0);
     rb_define_method(cDuckDBColumn, "name", duckdb_column_get_name, 0);
 }

data/ext/duckdb/config.c

@@ -80,6 +80,9 @@ static VALUE config_set_config(VALUE self, VALUE key, VALUE value) {
 }
 
 void rbduckdb_init_duckdb_config(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBConfig = rb_define_class_under(mDuckDB, "Config", rb_cObject);
     rb_define_alloc_func(cDuckDBConfig, allocate);
     rb_define_singleton_method(cDuckDBConfig, "size", config_s_size, 0);

data/ext/duckdb/connection.c

@@ -114,6 +114,7 @@ static VALUE duckdb_connection_query_progress(VALUE self) {
     return rb_funcall(mDuckDBConverter, rb_intern("_to_query_progress"), 3, DBL2NUM(progress.percentage), ULL2NUM(progress.rows_processed), ULL2NUM(progress.total_rows_to_process));
 }
 
+/* :nodoc: */
 static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     rubyDuckDBConnection *ctx;
     rubyDuckDB *ctxdb;
@@ -131,6 +132,7 @@ static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     rubyDuckDBConnection *ctx;
     rubyDuckDBResult *ctxr;
@@ -151,6 +153,9 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
 }
 
 void rbduckdb_init_duckdb_connection(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBConnection = rb_define_class_under(mDuckDB, "Connection", rb_cObject);
     rb_define_alloc_func(cDuckDBConnection, allocate);
 
@@ -158,5 +163,6 @@ void rbduckdb_init_duckdb_connection(void) {
     rb_define_method(cDuckDBConnection, "interrupt", duckdb_connection_interrupt, 0);
     rb_define_method(cDuckDBConnection, "query_progress", duckdb_connection_query_progress, 0);
     rb_define_private_method(cDuckDBConnection, "_connect", duckdb_connection_connect, 1);
+    /* TODO: query_sql => _query_sql */
     rb_define_private_method(cDuckDBConnection, "query_sql", duckdb_connection_query_sql, 1);
 }