duckdb 1.5.2.0 → 1.5.3.0

data/ext/duckdb/appender.c

@@ -9,7 +9,8 @@ static size_t memsize(const void *p);
 
 static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE types, VALUE table, VALUE columns);
 
-static VALUE appender_initialize(VALUE klass, VALUE con, VALUE schema, VALUE table);
+static VALUE appender__initialize(VALUE self, VALUE con, VALUE schema, VALUE table);
+static VALUE appender__initialize_ext(VALUE self, VALUE con, VALUE catalog, VALUE schema, VALUE table);
 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);
@@ -36,9 +37,17 @@ 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__append_value(VALUE self, VALUE val);
 static VALUE appender__append_data_chunk(VALUE self, VALUE chunk);
+static VALUE appender__append_default_to_chunk(VALUE self, VALUE chunk, VALUE col, VALUE row);
 static VALUE appender__flush(VALUE self);
+
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+static VALUE appender__clear(VALUE self);
+#endif
+
+static VALUE appender__add_column(VALUE self, VALUE name);
+static VALUE appender__clear_columns(VALUE self);
 static VALUE appender__close(VALUE self);
-static VALUE duckdb_state_to_bool_value(duckdb_state state);
+static VALUE state_to_rbool(duckdb_state state);
 
 static const rb_data_type_t appender_data_type = {
     "DuckDB/Appender",
@@ -95,7 +104,7 @@ static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE
     type_array = ALLOCA_N(duckdb_logical_type, (size_t)column_count);
     for (idx_t i = 0; i < column_count; i++) {
         VALUE type_val = rb_ary_entry(types, i);
-        rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(type_val);
+        rubyDuckDBLogicalType *type_ctx = rbduckdb_get_struct_logical_type(type_val);
         type_array[i] = type_ctx->logical_type;
     }
 
@@ -113,7 +122,7 @@ static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE
             column_names[i] = StringValuePtr(col_name_val);
         }
     }
-    ctxcon = get_struct_connection(con);
+    ctxcon = rbduckdb_get_struct_connection(con);
     appender = allocate(klass);
     TypedData_Get_Struct(appender, rubyDuckDBAppender, &appender_data_type, ctx);
     if (duckdb_appender_create_query(ctxcon->con, query_str, column_count, type_array, table_name, column_names, &ctx->appender) == DuckDBError) {
@@ -123,18 +132,18 @@ static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE
     return appender;
 }
 
-static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE table) {
+static VALUE appender__initialize(VALUE self, VALUE con, VALUE schema, VALUE table) {
 
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBAppender *ctx;
     char *pschema = 0;
 
     if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
-        rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
+        rb_raise(rb_eTypeError, "1st argument should be instance of DuckDB::Connection");
     }
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    ctxcon = get_struct_connection(con);
+    ctxcon = rbduckdb_get_struct_connection(con);
 
     if (schema != Qnil) {
         pschema = StringValuePtr(schema);
@@ -146,6 +155,32 @@ static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE tabl
     return self;
 }
 
+static VALUE appender__initialize_ext(VALUE self, VALUE con, VALUE catalog, VALUE schema, VALUE table) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAppender *ctx;
+    char *pcatalog = 0;
+    char *pschema = 0;
+
+    if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
+        rb_raise(rb_eTypeError, "1st argument should be instance of DuckDB::Connection");
+    }
+
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+    ctxcon = rbduckdb_get_struct_connection(con);
+
+    if (catalog != Qnil) {
+        pcatalog = StringValuePtr(catalog);
+    }
+    if (schema != Qnil) {
+        pschema = StringValuePtr(schema);
+    }
+
+    if (duckdb_appender_create_ext(ctxcon->con, pcatalog, pschema, StringValuePtr(table), &(ctx->appender)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create appender");
+    }
+    return self;
+}
+
 /* call-seq:
  *   appender.error_message -> String
  *
@@ -179,7 +214,7 @@ static VALUE appender__end_row(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_appender_end_row(ctx->appender));
+    return state_to_rbool(duckdb_appender_end_row(ctx->appender));
 }
 
 /* :nodoc: */
@@ -191,7 +226,7 @@ static VALUE appender__append_bool(VALUE self, VALUE val) {
         rb_raise(rb_eArgError, "argument must be boolean");
     }
 
-    return duckdb_state_to_bool_value(duckdb_append_bool(ctx->appender, (val == Qtrue)));
+    return state_to_rbool(duckdb_append_bool(ctx->appender, (val == Qtrue)));
 }
 
 /* :nodoc: */
@@ -201,7 +236,7 @@ static VALUE appender__append_int8(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_int8(ctx->appender, i8val));
+    return state_to_rbool(duckdb_append_int8(ctx->appender, i8val));
 }
 
 /* :nodoc: */
@@ -211,7 +246,7 @@ static VALUE appender__append_int16(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_int16(ctx->appender, i16val));
+    return state_to_rbool(duckdb_append_int16(ctx->appender, i16val));
 }
 
 /* :nodoc: */
@@ -221,7 +256,7 @@ static VALUE appender__append_int32(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_int32(ctx->appender, i32val));
+    return state_to_rbool(duckdb_append_int32(ctx->appender, i32val));
 }
 
 /* :nodoc: */
@@ -231,7 +266,7 @@ static VALUE appender__append_int64(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_int64(ctx->appender, i64val));
+    return state_to_rbool(duckdb_append_int64(ctx->appender, i64val));
 }
 
 /* :nodoc: */
@@ -241,7 +276,7 @@ static VALUE appender__append_uint8(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_uint8(ctx->appender, ui8val));
+    return state_to_rbool(duckdb_append_uint8(ctx->appender, ui8val));
 }
 
 /* :nodoc: */
@@ -251,7 +286,7 @@ static VALUE appender__append_uint16(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return  duckdb_state_to_bool_value(duckdb_append_uint16(ctx->appender, ui16val));
+    return  state_to_rbool(duckdb_append_uint16(ctx->appender, ui16val));
 }
 
 /* :nodoc: */
@@ -261,7 +296,7 @@ static VALUE appender__append_uint32(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return  duckdb_state_to_bool_value(duckdb_append_uint32(ctx->appender, ui32val));
+    return  state_to_rbool(duckdb_append_uint32(ctx->appender, ui32val));
 }
 
 /* :nodoc: */
@@ -271,7 +306,7 @@ static VALUE appender__append_uint64(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_uint64(ctx->appender, ui64val));
+    return state_to_rbool(duckdb_append_uint64(ctx->appender, ui64val));
 }
 
 /* :nodoc: */
@@ -281,7 +316,7 @@ static VALUE appender__append_float(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_float(ctx->appender, fval));
+    return state_to_rbool(duckdb_append_float(ctx->appender, fval));
 }
 
 /* :nodoc: */
@@ -291,7 +326,7 @@ static VALUE appender__append_double(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_double(ctx->appender, dval));
+    return state_to_rbool(duckdb_append_double(ctx->appender, dval));
 }
 
 /* :nodoc: */
@@ -301,7 +336,7 @@ static VALUE appender__append_varchar(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_varchar(ctx->appender, pval));
+    return state_to_rbool(duckdb_append_varchar(ctx->appender, pval));
 }
 
 /* :nodoc: */
@@ -313,7 +348,7 @@ static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_varchar_length(ctx->appender, pval, length));
+    return state_to_rbool(duckdb_append_varchar_length(ctx->appender, pval, length));
 }
 
 /* :nodoc: */
@@ -325,7 +360,7 @@ static VALUE appender__append_blob(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_blob(ctx->appender, (void *)pval, length));
+    return state_to_rbool(duckdb_append_blob(ctx->appender, (void *)pval, length));
 }
 
 /* :nodoc: */
@@ -333,7 +368,7 @@ static VALUE appender__append_null(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_null(ctx->appender));
+    return state_to_rbool(duckdb_append_null(ctx->appender));
 }
 
 /* :nodoc: */
@@ -341,7 +376,7 @@ static VALUE appender__append_default(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_default(ctx->appender));
+    return state_to_rbool(duckdb_append_default(ctx->appender));
 }
 
 /* :nodoc: */
@@ -352,7 +387,7 @@ 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);
 
-    return duckdb_state_to_bool_value(duckdb_append_date(ctx->appender, dt));
+    return state_to_rbool(duckdb_append_date(ctx->appender, dt));
 }
 
 /* :nodoc: */
@@ -363,7 +398,7 @@ 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);
 
-    return duckdb_state_to_bool_value(duckdb_append_interval(ctx->appender, interval));
+    return state_to_rbool(duckdb_append_interval(ctx->appender, interval));
 }
 
 /* :nodoc: */
@@ -374,7 +409,7 @@ 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);
 
-    return duckdb_state_to_bool_value(duckdb_append_time(ctx->appender, time));
+    return state_to_rbool(duckdb_append_time(ctx->appender, time));
 }
 
 /* :nodoc: */
@@ -387,7 +422,7 @@ 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);
 
-    return duckdb_state_to_bool_value(duckdb_append_timestamp(ctx->appender, timestamp));
+    return state_to_rbool(duckdb_append_timestamp(ctx->appender, timestamp));
 }
 
 /* :nodoc: */
@@ -401,7 +436,7 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_hugeint(ctx->appender, hugeint));
+    return state_to_rbool(duckdb_append_hugeint(ctx->appender, hugeint));
 }
 
 /* :nodoc: */
@@ -415,7 +450,7 @@ static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_append_uhugeint(ctx->appender, uhugeint));
+    return state_to_rbool(duckdb_append_uhugeint(ctx->appender, uhugeint));
 }
 
 /* :nodoc: */
@@ -424,9 +459,9 @@ static VALUE appender__append_value(VALUE self, VALUE val) {
     rubyDuckDBValue *value_ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    value_ctx = get_struct_value(val);
+    value_ctx = rbduckdb_get_struct_value(val);
 
-    return duckdb_state_to_bool_value(duckdb_append_value(ctx->appender, value_ctx->value));
+    return state_to_rbool(duckdb_append_value(ctx->appender, value_ctx->value));
 }
 
 /* :nodoc: */
@@ -435,9 +470,20 @@ static VALUE appender__append_data_chunk(VALUE self, VALUE chunk) {
     rubyDuckDBDataChunk *chunk_ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    chunk_ctx = get_struct_data_chunk(chunk);
+    chunk_ctx = rbduckdb_get_struct_data_chunk(chunk);
 
-    return duckdb_state_to_bool_value(duckdb_append_data_chunk(ctx->appender, chunk_ctx->data_chunk));
+    return state_to_rbool(duckdb_append_data_chunk(ctx->appender, chunk_ctx->data_chunk));
+}
+
+/* :nodoc: */
+static VALUE appender__append_default_to_chunk(VALUE self, VALUE chunk, VALUE col, VALUE row) {
+    rubyDuckDBAppender *ctx;
+    rubyDuckDBDataChunk *chunk_ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+    chunk_ctx = rbduckdb_get_struct_data_chunk(chunk);
+
+    return state_to_rbool(duckdb_append_default_to_chunk(ctx->appender, chunk_ctx->data_chunk, NUM2ULL(col), NUM2ULL(row)));
 }
 
 /* :nodoc: */
@@ -445,7 +491,34 @@ static VALUE appender__flush(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_appender_flush(ctx->appender));
+    return state_to_rbool(duckdb_appender_flush(ctx->appender));
+}
+
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+/* :nodoc: */
+static VALUE appender__clear(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+
+    return state_to_rbool(duckdb_appender_clear(ctx->appender));
+}
+#endif
+
+/* :nodoc: */
+static VALUE appender__add_column(VALUE self, VALUE name) {
+    char *p = StringValuePtr(name);
+    rubyDuckDBAppender *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+
+    return state_to_rbool(duckdb_appender_add_column(ctx->appender, p));
+}
+
+/* :nodoc: */
+static VALUE appender__clear_columns(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+
+    return state_to_rbool(duckdb_appender_clear_columns(ctx->appender));
 }
 
 /* :nodoc: */
@@ -453,27 +526,35 @@ static VALUE appender__close(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    return duckdb_state_to_bool_value(duckdb_appender_close(ctx->appender));
+    return state_to_rbool(duckdb_appender_close(ctx->appender));
 }
 
-static VALUE duckdb_state_to_bool_value(duckdb_state state) {
+static VALUE state_to_rbool(duckdb_state state) {
     if (state == DuckDBSuccess) {
         return Qtrue;
     }
     return Qfalse;
 }
 
-void rbduckdb_init_duckdb_appender(void) {
+void rbduckdb_init_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_singleton_method(cDuckDBAppender, "create_query", appender_s_create_query, 5);
-    rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
+    rb_define_private_method(cDuckDBAppender, "_initialize", appender__initialize, 3);
+    rb_define_private_method(cDuckDBAppender, "_initialize_ext", appender__initialize_ext, 4);
     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);
+
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+    rb_define_private_method(cDuckDBAppender, "_clear", appender__clear, 0);
+#endif
+
+    rb_define_private_method(cDuckDBAppender, "_add_column", appender__add_column, 1);
+    rb_define_private_method(cDuckDBAppender, "_clear_columns", appender__clear_columns, 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);
@@ -499,4 +580,5 @@ void rbduckdb_init_duckdb_appender(void) {
     rb_define_private_method(cDuckDBAppender, "_append_uhugeint", appender__append_uhugeint, 2);
     rb_define_private_method(cDuckDBAppender, "_append_value", appender__append_value, 1);
     rb_define_private_method(cDuckDBAppender, "_append_data_chunk", appender__append_data_chunk, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_default_to_chunk", appender__append_default_to_chunk, 3);
 }

data/ext/duckdb/appender.h

@@ -7,6 +7,6 @@ struct _rubyDuckDBAppender {
 
 typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
 
-void rbduckdb_init_duckdb_appender(void);
+void rbduckdb_init_appender(void);
 
 #endif

data/ext/duckdb/client_context.c

@@ -5,7 +5,7 @@ VALUE cDuckDBClientContext;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_client_context_connection_id(VALUE self);
+static VALUE client_context_connection_id(VALUE self);
 
 static const rb_data_type_t client_context_data_type = {
     "DuckDB/ClientContext",
@@ -42,7 +42,7 @@ VALUE rbduckdb_client_context_new(duckdb_client_context client_context) {
     return obj;
 }
 
-rubyDuckDBClientContext *get_struct_client_context(VALUE obj) {
+rubyDuckDBClientContext *rbduckdb_get_struct_client_context(VALUE obj) {
     rubyDuckDBClientContext *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBClientContext, &client_context_data_type, ctx);
     return ctx;
@@ -54,17 +54,17 @@ rubyDuckDBClientContext *get_struct_client_context(VALUE obj) {
  *
  * Returns the connection id of the client context.
  */
-static VALUE rbduckdb_client_context_connection_id(VALUE self) {
+static VALUE client_context_connection_id(VALUE self) {
     rubyDuckDBClientContext *ctx;
     TypedData_Get_Struct(self, rubyDuckDBClientContext, &client_context_data_type, ctx);
     return ULL2NUM(duckdb_client_context_get_connection_id(ctx->client_context));
 }
 
-void rbduckdb_init_duckdb_client_context(void) {
+void rbduckdb_init_client_context(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBClientContext = rb_define_class_under(mDuckDB, "ClientContext", rb_cObject);
     rb_define_alloc_func(cDuckDBClientContext, allocate);
-    rb_define_method(cDuckDBClientContext, "connection_id", rbduckdb_client_context_connection_id, 0);
+    rb_define_method(cDuckDBClientContext, "connection_id", client_context_connection_id, 0);
 }

data/ext/duckdb/client_context.h

@@ -7,8 +7,8 @@ struct _rubyDuckDBClientContext {
 
 typedef struct _rubyDuckDBClientContext rubyDuckDBClientContext;
 
-void rbduckdb_init_duckdb_client_context(void);
+void rbduckdb_init_client_context(void);
 VALUE rbduckdb_client_context_new(duckdb_client_context client_context);
-rubyDuckDBClientContext *get_struct_client_context(VALUE obj);
+rubyDuckDBClientContext *rbduckdb_get_struct_client_context(VALUE obj);
 
 #endif

data/ext/duckdb/column.c

@@ -5,9 +5,9 @@ static VALUE cDuckDBColumn;
 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 VALUE column__type(VALUE oDuckDBColumn);
+static VALUE column_logical_type(VALUE oDuckDBColumn);
+static VALUE column_name(VALUE oDuckDBColumn);
 
 static const rb_data_type_t column_data_type = {
     "DuckDB/Column",
@@ -31,7 +31,7 @@ static size_t memsize(const void *p) {
 }
 
 /* :nodoc: */
-VALUE duckdb_column__type(VALUE oDuckDBColumn) {
+VALUE column__type(VALUE oDuckDBColumn) {
     rubyDuckDBColumn *ctx;
     rubyDuckDBResult *ctxresult;
     VALUE result;
@@ -40,7 +40,7 @@ VALUE duckdb_column__type(VALUE oDuckDBColumn) {
     TypedData_Get_Struct(oDuckDBColumn, rubyDuckDBColumn, &column_data_type, ctx);
 
     result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
-    ctxresult = get_struct_result(result);
+    ctxresult = rbduckdb_get_struct_result(result);
     type = duckdb_column_type(&(ctxresult->result), ctx->col);
 
     return INT2FIX(type);
@@ -53,7 +53,7 @@ VALUE duckdb_column__type(VALUE oDuckDBColumn) {
  *  Returns the logical type class.
  *
  */
-VALUE duckdb_column__logical_type(VALUE oDuckDBColumn) {
+VALUE column_logical_type(VALUE oDuckDBColumn) {
     rubyDuckDBColumn *ctx;
     rubyDuckDBResult *ctxresult;
     VALUE result;
@@ -63,7 +63,7 @@ VALUE duckdb_column__logical_type(VALUE oDuckDBColumn) {
     TypedData_Get_Struct(oDuckDBColumn, rubyDuckDBColumn, &column_data_type, ctx);
 
     result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
-    ctxresult = get_struct_result(result);
+    ctxresult = rbduckdb_get_struct_result(result);
     _logical_type = duckdb_column_logical_type(&(ctxresult->result), ctx->col);
 
     if (_logical_type) {
@@ -80,7 +80,7 @@ VALUE duckdb_column__logical_type(VALUE oDuckDBColumn) {
  *  Returns the column name.
  *
  */
-VALUE duckdb_column_get_name(VALUE oDuckDBColumn) {
+VALUE column_name(VALUE oDuckDBColumn) {
     rubyDuckDBColumn *ctx;
     VALUE result;
     rubyDuckDBResult *ctxresult;
@@ -89,7 +89,7 @@ VALUE duckdb_column_get_name(VALUE oDuckDBColumn) {
 
     result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
 
-    ctxresult = get_struct_result(result);
+    ctxresult = rbduckdb_get_struct_result(result);
 
     return rb_utf8_str_new_cstr(duckdb_column_name(&(ctxresult->result), ctx->col));
 }
@@ -107,14 +107,14 @@ VALUE rbduckdb_create_column(VALUE oDuckDBResult, idx_t col) {
     return obj;
 }
 
-void rbduckdb_init_duckdb_column(void) {
+void rbduckdb_init_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);
+    rb_define_private_method(cDuckDBColumn, "_type", column__type, 0);
+    rb_define_method(cDuckDBColumn, "logical_type", column_logical_type, 0);
+    rb_define_method(cDuckDBColumn, "name", column_name, 0);
 }

data/ext/duckdb/column.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBColumn {
 
 typedef struct _rubyDuckDBColumn rubyDuckDBColumn;
 
-void rbduckdb_init_duckdb_column(void);
+void rbduckdb_init_column(void);
 VALUE rbduckdb_create_column(VALUE oDuckDBResult, idx_t col);
 
 #endif