duckdb 1.5.2.0 → 1.5.3.0

data/ext/duckdb/connection.c

@@ -6,16 +6,17 @@ static void deallocate(void *ctx);
 static void mark(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_interrupt(VALUE self);
-static VALUE duckdb_connection_query_progress(VALUE self);
-static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase);
-static VALUE duckdb_connection_query_sql(VALUE self, VALUE str);
-static VALUE duckdb_connection_register_logical_type(VALUE self, VALUE logical_type);
-static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar_function);
-static VALUE duckdb_connection_register_scalar_function_set(VALUE self, VALUE scalar_function_set);
-static VALUE duckdb_connection_register_aggregate_function(VALUE self, VALUE aggregate_function);
-static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_function);
+static VALUE connection_disconnect(VALUE self);
+static VALUE connection_interrupt(VALUE self);
+static VALUE connection_query_progress(VALUE self);
+static VALUE connection__connect(VALUE self, VALUE oDuckDBDatabase);
+static VALUE connection__query_sql(VALUE self, VALUE str);
+static VALUE connection__register_logical_type(VALUE self, VALUE logical_type);
+static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_function);
+static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_function_set);
+static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate_function);
+static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set);
+static VALUE connection__register_table_function(VALUE self, VALUE table_function);
 
 static const rb_data_type_t connection_data_type = {
     "DuckDB/Connection",
@@ -48,7 +49,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBConnection);
 }
 
-rubyDuckDBConnection *get_struct_connection(VALUE obj) {
+rubyDuckDBConnection *rbduckdb_get_struct_connection(VALUE obj) {
     rubyDuckDBConnection *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBConnection, &connection_data_type, ctx);
     return ctx;
@@ -71,7 +72,7 @@ VALUE rbduckdb_create_connection(VALUE oDuckDBDatabase) {
     return obj;
 }
 
-static VALUE duckdb_connection_disconnect(VALUE self) {
+static VALUE connection_disconnect(VALUE self) {
     rubyDuckDBConnection *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
@@ -98,7 +99,7 @@ static VALUE duckdb_connection_disconnect(VALUE self) {
  *  pending_result.execute_task
  *  con.interrupt # => nil
  */
-static VALUE duckdb_connection_interrupt(VALUE self) {
+static VALUE connection_interrupt(VALUE self) {
     rubyDuckDBConnection *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
@@ -122,7 +123,7 @@ static VALUE duckdb_connection_interrupt(VALUE self) {
  *  pending_result.execute_task
  *  con.query_progress # => Float
  */
-static VALUE duckdb_connection_query_progress(VALUE self) {
+static VALUE connection_query_progress(VALUE self) {
     rubyDuckDBConnection *ctx;
     duckdb_query_progress_type progress;
 
@@ -133,7 +134,7 @@ static VALUE duckdb_connection_query_progress(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
+static VALUE connection__connect(VALUE self, VALUE oDuckDBDatabase) {
     rubyDuckDBConnection *ctx;
     rubyDuckDB *ctxdb;
 
@@ -169,14 +170,14 @@ static void *duckdb_query_nogvl(void *arg) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
+static VALUE connection__query_sql(VALUE self, VALUE str) {
     rubyDuckDBConnection *ctx;
     rubyDuckDBResult *ctxr;
 
     VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
-    ctxr = get_struct_result(result);
+    ctxr = rbduckdb_get_struct_result(result);
 
     if (!(ctx->con)) {
         rb_raise(eDuckDBError, "Database connection closed");
@@ -203,13 +204,13 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_register_logical_type(VALUE self, VALUE logical_type) {
+static VALUE connection__register_logical_type(VALUE self, VALUE logical_type) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBLogicalType *ctxlt;
     duckdb_state state;
 
-    ctxcon = get_struct_connection(self);
-    ctxlt = get_struct_logical_type(logical_type);
+    ctxcon = rbduckdb_get_struct_connection(self);
+    ctxlt = rbduckdb_get_struct_logical_type(logical_type);
 
     state = duckdb_register_logical_type(ctxcon->con, ctxlt->logical_type, NULL);
 
@@ -224,12 +225,12 @@ static VALUE duckdb_connection_register_logical_type(VALUE self, VALUE logical_t
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar_function) {
+static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_function) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBScalarFunction *ctxsf;
     duckdb_state state;
 
-    ctxcon = get_struct_connection(self);
+    ctxcon = rbduckdb_get_struct_connection(self);
     ctxsf = get_struct_scalar_function(scalar_function);
 
     state = duckdb_register_scalar_function(ctxcon->con, ctxsf->scalar_function);
@@ -245,12 +246,12 @@ static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_register_scalar_function_set(VALUE self, VALUE scalar_function_set) {
+static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_function_set) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBScalarFunctionSet *ctxsfs;
     duckdb_state state;
 
-    ctxcon = get_struct_connection(self);
+    ctxcon = rbduckdb_get_struct_connection(self);
     ctxsfs = get_struct_scalar_function_set(scalar_function_set);
 
     state = duckdb_register_scalar_function_set(ctxcon->con, ctxsfs->scalar_function_set);
@@ -266,13 +267,13 @@ static VALUE duckdb_connection_register_scalar_function_set(VALUE self, VALUE sc
 }
 
 /* :nodoc: */
-static VALUE duckdb_connection_register_aggregate_function(VALUE self, VALUE aggregate_function) {
+static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate_function) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBAggregateFunction *ctxaf;
     duckdb_state state;
 
-    ctxcon = get_struct_connection(self);
-    ctxaf = get_struct_aggregate_function(aggregate_function);
+    ctxcon = rbduckdb_get_struct_connection(self);
+    ctxaf = rbduckdb_get_struct_aggregate_function(aggregate_function);
 
     state = duckdb_register_aggregate_function(ctxcon->con, ctxaf->aggregate_function);
 
@@ -286,12 +287,33 @@ static VALUE duckdb_connection_register_aggregate_function(VALUE self, VALUE agg
     return self;
 }
 
-static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_function) {
+/* :nodoc: */
+static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAggregateFunctionSet *ctxafs;
+    duckdb_state state;
+
+    ctxcon = rbduckdb_get_struct_connection(self);
+    ctxafs = rbduckdb_get_struct_aggregate_function_set(aggregate_function_set);
+
+    state = duckdb_register_aggregate_function_set(ctxcon->con, ctxafs->aggregate_function_set);
+
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register aggregate function set");
+    }
+
+    /* Keep reference to prevent GC while connection is alive */
+    rb_ary_push(ctxcon->registered_functions, aggregate_function_set);
+
+    return self;
+}
+
+static VALUE connection__register_table_function(VALUE self, VALUE table_function) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBTableFunction *ctxtf;
     duckdb_state state;
 
-    ctxcon = get_struct_connection(self);
+    ctxcon = rbduckdb_get_struct_connection(self);
     ctxtf = get_struct_table_function(table_function);
 
     state = duckdb_register_table_function(ctxcon->con, ctxtf->table_function);
@@ -306,22 +328,22 @@ static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_f
     return self;
 }
 
-void rbduckdb_init_duckdb_connection(void) {
+void rbduckdb_init_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);
 
-    rb_define_method(cDuckDBConnection, "disconnect", duckdb_connection_disconnect, 0);
-    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, "_register_logical_type", duckdb_connection_register_logical_type, 1);
-    rb_define_private_method(cDuckDBConnection, "_register_scalar_function", duckdb_connection_register_scalar_function, 1);
-    rb_define_private_method(cDuckDBConnection, "_register_scalar_function_set", duckdb_connection_register_scalar_function_set, 1);
-    rb_define_private_method(cDuckDBConnection, "_register_aggregate_function", duckdb_connection_register_aggregate_function, 1);
-    rb_define_private_method(cDuckDBConnection, "_register_table_function", duckdb_connection_register_table_function, 1);
-    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);
+    rb_define_method(cDuckDBConnection, "disconnect", connection_disconnect, 0);
+    rb_define_method(cDuckDBConnection, "interrupt", connection_interrupt, 0);
+    rb_define_method(cDuckDBConnection, "query_progress", connection_query_progress, 0);
+    rb_define_private_method(cDuckDBConnection, "_register_logical_type", connection__register_logical_type, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_scalar_function", connection__register_scalar_function, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_scalar_function_set", connection__register_scalar_function_set, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_aggregate_function", connection__register_aggregate_function, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_aggregate_function_set", connection__register_aggregate_function_set, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_table_function", connection__register_table_function, 1);
+    rb_define_private_method(cDuckDBConnection, "_connect", connection__connect, 1);
+    rb_define_private_method(cDuckDBConnection, "_query_sql", connection__query_sql, 1);
 }

data/ext/duckdb/connection.h

@@ -8,8 +8,8 @@ struct _rubyDuckDBConnection {
 
 typedef struct _rubyDuckDBConnection rubyDuckDBConnection;
 
-rubyDuckDBConnection *get_struct_connection(VALUE obj);
-void rbduckdb_init_duckdb_connection(void);
+rubyDuckDBConnection *rbduckdb_get_struct_connection(VALUE obj);
+void rbduckdb_init_connection(void);
 VALUE rbduckdb_create_connection(VALUE oDuckDBDatabase);
 
 #endif

data/ext/duckdb/converter.h

@@ -32,12 +32,6 @@ VALUE rbduckdb_time_to_ruby(duckdb_time t);
 VALUE rbduckdb_date_to_ruby(duckdb_date date);
 VALUE rbduckdb_timestamp_to_ruby(duckdb_timestamp ts);
 
-VALUE infinite_date_value(duckdb_date date);
-VALUE infinite_timestamp_value(duckdb_timestamp timestamp);
-VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s);
-VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms);
-VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns);
-
-void rbduckdb_init_duckdb_converter(void);
+void rbduckdb_init_converter(void);
 
 #endif

data/ext/duckdb/conveter.c

@@ -17,7 +17,7 @@ ID id__to_time_from_duckdb_timestamp_tz;
 ID id__to_infinity;
 ID id__decimal_to_unscaled;
 
-VALUE infinite_date_value(duckdb_date date) {
+static VALUE infinite_date_value(duckdb_date date) {
     if (duckdb_is_finite_date(date) == false) {
         return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
                           INT2NUM(date.days)
@@ -26,7 +26,7 @@ VALUE infinite_date_value(duckdb_date date) {
     return Qnil;
 }
 
-VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
+static VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
     if (duckdb_is_finite_timestamp(timestamp) == false) {
         return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
                           LL2NUM(timestamp.micros)
@@ -35,7 +35,7 @@ VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
     return Qnil;
 }
 
-VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s) {
+static VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s) {
     if (duckdb_is_finite_timestamp_s(timestamp_s) == false) {
         return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
                           LL2NUM(timestamp_s.seconds)
@@ -44,7 +44,7 @@ VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s) {
     return Qnil;
 }
 
-VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms) {
+static VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms) {
     if (duckdb_is_finite_timestamp_ms(timestamp_ms) == false) {
         return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
                           LL2NUM(timestamp_ms.millis)
@@ -53,7 +53,7 @@ VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms) {
     return Qnil;
 }
 
-VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
+static VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
     if (duckdb_is_finite_timestamp_ns(timestamp_ns) == false) {
         return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
                           LL2NUM(timestamp_ns.nanos)
@@ -320,7 +320,7 @@ VALUE rbduckdb_timestamp_to_ruby(duckdb_timestamp ts) {
     return obj;
 }
 
-void rbduckdb_init_duckdb_converter(void) {
+void rbduckdb_init_converter(void) {
     mDuckDBConverter = rb_define_module_under(mDuckDB, "Converter");
 
     id__to_date = rb_intern("_to_date");

data/ext/duckdb/data_chunk.c

@@ -6,12 +6,12 @@ extern VALUE cDuckDBVector;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE initialize(int argc, VALUE *argv, VALUE self);
-static VALUE rbduckdb_data_chunk_column_count(VALUE self);
-static VALUE rbduckdb_data_chunk_get_size(VALUE self);
-static VALUE rbduckdb_data_chunk_set_size(VALUE self, VALUE size);
-static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx);
-static VALUE rbduckdb_data_chunk__reset(VALUE self);
+static VALUE data_chunk_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE data_chunk_column_count(VALUE self);
+static VALUE data_chunk_size(VALUE self);
+static VALUE data_chunk_set_size(VALUE self, VALUE size);
+static VALUE data_chunk_get_vector(VALUE self, VALUE col_idx);
+static VALUE data_chunk__reset(VALUE self);
 
 static const rb_data_type_t data_chunk_data_type = {
     "DuckDB/DataChunk",
@@ -38,13 +38,13 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBDataChunk);
 }
 
-rubyDuckDBDataChunk *get_struct_data_chunk(VALUE obj) {
+rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj) {
     rubyDuckDBDataChunk *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
     return ctx;
 }
 
-static VALUE initialize(int argc, VALUE *argv, VALUE self) {
+static VALUE data_chunk_initialize(int argc, VALUE *argv, VALUE self) {
     rubyDuckDBDataChunk *ctx;
     VALUE logical_types;
     idx_t column_count;
@@ -70,7 +70,7 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self) {
 
     for (i = 0; i < RARRAY_LEN(logical_types); i++) {
         VALUE logical_type = rb_ary_entry(logical_types, i);
-        rubyDuckDBLogicalType *logical_type_ctx = get_struct_logical_type(logical_type);
+        rubyDuckDBLogicalType *logical_type_ctx = rbduckdb_get_struct_logical_type(logical_type);
         types[i] = logical_type_ctx->logical_type;
     }
 
@@ -94,7 +94,7 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self) {
  *
  *   data_chunk.column_count  # => 2
  */
-static VALUE rbduckdb_data_chunk_column_count(VALUE self) {
+static VALUE data_chunk_column_count(VALUE self) {
     rubyDuckDBDataChunk *ctx;
     idx_t count;
 
@@ -113,7 +113,7 @@ static VALUE rbduckdb_data_chunk_column_count(VALUE self) {
  *
  *   data_chunk.size  # => 100
  */
-static VALUE rbduckdb_data_chunk_get_size(VALUE self) {
+static VALUE data_chunk_size(VALUE self) {
     rubyDuckDBDataChunk *ctx;
     idx_t size;
 
@@ -132,7 +132,7 @@ static VALUE rbduckdb_data_chunk_get_size(VALUE self) {
  *
  *   data_chunk.size = 50
  */
-static VALUE rbduckdb_data_chunk_set_size(VALUE self, VALUE size) {
+static VALUE data_chunk_set_size(VALUE self, VALUE size) {
     rubyDuckDBDataChunk *ctx;
     idx_t sz;
 
@@ -152,7 +152,7 @@ static VALUE rbduckdb_data_chunk_set_size(VALUE self, VALUE size) {
  *
  *   vector = data_chunk.get_vector(0)
  */
-static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx) {
+static VALUE data_chunk_get_vector(VALUE self, VALUE col_idx) {
     rubyDuckDBDataChunk *ctx;
     idx_t idx;
     duckdb_vector vector;
@@ -166,7 +166,7 @@ static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx) {
 
     // Create Vector wrapper
     vector_obj = rb_class_new_instance(0, NULL, cDuckDBVector);
-    vector_ctx = get_struct_vector(vector_obj);
+    vector_ctx = rbduckdb_get_struct_vector(vector_obj);
     vector_ctx->vector = vector;
 
     return vector_obj;
@@ -180,7 +180,7 @@ static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx) {
  *
  *   data_chunk._reset
  */
-static VALUE rbduckdb_data_chunk__reset(VALUE self) {
+static VALUE data_chunk__reset(VALUE self) {
     rubyDuckDBDataChunk *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
@@ -190,17 +190,17 @@ static VALUE rbduckdb_data_chunk__reset(VALUE self) {
     return self;
 }
 
-void rbduckdb_init_duckdb_data_chunk(void) {
+void rbduckdb_init_data_chunk(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBDataChunk = rb_define_class_under(mDuckDB, "DataChunk", rb_cObject);
     rb_define_alloc_func(cDuckDBDataChunk, allocate);
 
-    rb_define_method(cDuckDBDataChunk, "initialize", initialize, -1);
-    rb_define_method(cDuckDBDataChunk, "column_count", rbduckdb_data_chunk_column_count, 0);
-    rb_define_method(cDuckDBDataChunk, "size", rbduckdb_data_chunk_get_size, 0);
-    rb_define_method(cDuckDBDataChunk, "size=", rbduckdb_data_chunk_set_size, 1);
-    rb_define_method(cDuckDBDataChunk, "get_vector", rbduckdb_data_chunk_get_vector, 1);
-    rb_define_private_method(cDuckDBDataChunk, "_reset", rbduckdb_data_chunk__reset, 0);
+    rb_define_method(cDuckDBDataChunk, "initialize", data_chunk_initialize, -1);
+    rb_define_method(cDuckDBDataChunk, "column_count", data_chunk_column_count, 0);
+    rb_define_method(cDuckDBDataChunk, "size", data_chunk_size, 0);
+    rb_define_method(cDuckDBDataChunk, "size=", data_chunk_set_size, 1);
+    rb_define_method(cDuckDBDataChunk, "get_vector", data_chunk_get_vector, 1);
+    rb_define_private_method(cDuckDBDataChunk, "_reset", data_chunk__reset, 0);
 }

data/ext/duckdb/data_chunk.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBDataChunk {
 
 typedef struct _rubyDuckDBDataChunk rubyDuckDBDataChunk;
 
-rubyDuckDBDataChunk *get_struct_data_chunk(VALUE obj);
-void rbduckdb_init_duckdb_data_chunk(void);
+rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj);
+void rbduckdb_init_data_chunk(void);
 
 #endif

data/ext/duckdb/database.c

@@ -7,9 +7,9 @@ static void deallocate(void * ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static duckdb_config create_config_with_ruby_api(void);
-static VALUE duckdb_database__initialize(VALUE self, VALUE file, VALUE config);
-static VALUE duckdb_database_connect(VALUE self);
-static VALUE duckdb_database_close(VALUE self);
+static VALUE database__initialize(VALUE self, VALUE file, VALUE config);
+static VALUE database__connect(VALUE self);
+static VALUE database_close(VALUE self);
 
 static const rb_data_type_t database_data_type = {
     "DuckDB/Database",
@@ -59,7 +59,7 @@ static duckdb_config create_config_with_ruby_api(void) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_database__initialize(VALUE self, VALUE file, VALUE config) {
+static VALUE database__initialize(VALUE self, VALUE file, VALUE config) {
     rubyDuckDB *ctx;
     rubyDuckDBConfig *ctx_config;
     duckdb_config config_to_use;
@@ -106,7 +106,7 @@ static VALUE duckdb_database__initialize(VALUE self, VALUE file, VALUE config) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_database_connect(VALUE self) {
+static VALUE database__connect(VALUE self) {
     return rbduckdb_create_connection(self);
 }
 
@@ -116,7 +116,7 @@ static VALUE duckdb_database_connect(VALUE self) {
  *
  *  closes DuckDB database.
  */
-static VALUE duckdb_database_close(VALUE self) {
+static VALUE database_close(VALUE self) {
     rubyDuckDB *ctx;
     TypedData_Get_Struct(self, rubyDuckDB, &database_data_type, ctx);
     close_database(ctx);
@@ -131,13 +131,13 @@ VALUE rbduckdb_create_database_obj(duckdb_database db) {
     return obj;
 }
 
-void rbduckdb_init_duckdb_database(void) {
+void rbduckdb_init_database(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
     rb_define_alloc_func(cDuckDBDatabase, allocate);
-    rb_define_private_method(cDuckDBDatabase, "_initialize", duckdb_database__initialize, 2);
-    rb_define_private_method(cDuckDBDatabase, "_connect", duckdb_database_connect, 0);
-    rb_define_method(cDuckDBDatabase, "close", duckdb_database_close, 0);
+    rb_define_private_method(cDuckDBDatabase, "_initialize", database__initialize, 2);
+    rb_define_private_method(cDuckDBDatabase, "_connect", database__connect, 0);
+    rb_define_method(cDuckDBDatabase, "close", database_close, 0);
 }

data/ext/duckdb/database.h

@@ -9,6 +9,6 @@ typedef struct _rubyDuckDB rubyDuckDB;
 
 rubyDuckDB *rbduckdb_get_struct_database(VALUE obj);
 VALUE rbduckdb_create_database_obj(duckdb_database db);
-void rbduckdb_init_duckdb_database(void);
+void rbduckdb_init_database(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -42,28 +42,29 @@ Init_duckdb_native(void) {
     rb_define_singleton_method(mDuckDB, "vector_size", duckdb_s_vector_size, 0);
 
     rbduckdb_init_duckdb_error();
-    rbduckdb_init_duckdb_database();
-    rbduckdb_init_duckdb_connection();
-    rbduckdb_init_duckdb_result();
-    rbduckdb_init_duckdb_column();
-    rbduckdb_init_duckdb_logical_type();
-    rbduckdb_init_duckdb_prepared_statement();
-    rbduckdb_init_duckdb_pending_result();
+    rbduckdb_init_database();
+    rbduckdb_init_connection();
+    rbduckdb_init_result();
+    rbduckdb_init_column();
+    rbduckdb_init_logical_type();
+    rbduckdb_init_prepared_statement();
+    rbduckdb_init_pending_result();
     rbduckdb_init_duckdb_blob();
-    rbduckdb_init_duckdb_appender();
+    rbduckdb_init_appender();
     rbduckdb_init_duckdb_config();
-    rbduckdb_init_duckdb_converter();
-    rbduckdb_init_duckdb_extracted_statements();
-    rbduckdb_init_duckdb_instance_cache();
-    rbduckdb_init_duckdb_value();
+    rbduckdb_init_converter();
+    rbduckdb_init_extracted_statements();
+    rbduckdb_init_instance_cache();
+    rbduckdb_init_value();
     rbduckdb_init_duckdb_scalar_function();
     rbduckdb_init_duckdb_scalar_function_set();
-    rbduckdb_init_duckdb_aggregate_function();
-    rbduckdb_init_duckdb_expression();
-    rbduckdb_init_duckdb_client_context();
+    rbduckdb_init_aggregate_function();
+    rbduckdb_init_aggregate_function_set();
+    rbduckdb_init_expression();
+    rbduckdb_init_client_context();
     rbduckdb_init_duckdb_scalar_function_bind_info();
-    rbduckdb_init_duckdb_vector();
-    rbduckdb_init_duckdb_data_chunk();
+    rbduckdb_init_vector();
+    rbduckdb_init_data_chunk();
     rbduckdb_init_memory_helper();
     rbduckdb_init_duckdb_table_function();
     rbduckdb_init_duckdb_table_function_bind_info();

data/ext/duckdb/expression.c

@@ -5,8 +5,8 @@ VALUE cDuckDBExpression;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_expression_foldable_p(VALUE self);
-static VALUE rbduckdb_expression_fold(VALUE self, VALUE client_context);
+static VALUE expression_foldable_p(VALUE self);
+static VALUE expression__fold(VALUE self, VALUE client_context);
 
 static const rb_data_type_t expression_data_type = {
     "DuckDB/Expression",
@@ -51,7 +51,7 @@ VALUE rbduckdb_expression_new(duckdb_expression expression) {
  * planning time (e.g. literals, constant arithmetic), +false+ otherwise
  * (e.g. column references, non-deterministic functions).
  */
-static VALUE rbduckdb_expression_foldable_p(VALUE self) {
+static VALUE expression_foldable_p(VALUE self) {
     rubyDuckDBExpression *ctx;
     TypedData_Get_Struct(self, rubyDuckDBExpression, &expression_data_type, ctx);
     return duckdb_expression_is_foldable(ctx->expression) ? Qtrue : Qfalse;
@@ -66,7 +66,7 @@ static VALUE rbduckdb_expression_foldable_p(VALUE self) {
  * Use the public Expression#fold instead, which guards against non-foldable
  * expressions before calling this method.
  */
-static VALUE rbduckdb_expression_fold(VALUE self, VALUE client_context) {
+static VALUE expression__fold(VALUE self, VALUE client_context) {
     rubyDuckDBExpression *expr_ctx;
     rubyDuckDBClientContext *cc_ctx;
     duckdb_value out_value = NULL;
@@ -74,7 +74,7 @@ static VALUE rbduckdb_expression_fold(VALUE self, VALUE client_context) {
     VALUE result;
 
     TypedData_Get_Struct(self, rubyDuckDBExpression, &expression_data_type, expr_ctx);
-    cc_ctx = get_struct_client_context(client_context);
+    cc_ctx = rbduckdb_get_struct_client_context(client_context);
 
     error_data = duckdb_expression_fold(cc_ctx->client_context, expr_ctx->expression, &out_value);
 
@@ -93,12 +93,12 @@ static VALUE rbduckdb_expression_fold(VALUE self, VALUE client_context) {
     return result;
 }
 
-void rbduckdb_init_duckdb_expression(void) {
+void rbduckdb_init_expression(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBExpression = rb_define_class_under(mDuckDB, "Expression", rb_cObject);
     rb_define_alloc_func(cDuckDBExpression, allocate);
-    rb_define_method(cDuckDBExpression, "foldable?", rbduckdb_expression_foldable_p, 0);
-    rb_define_private_method(cDuckDBExpression, "_fold", rbduckdb_expression_fold, 1);
+    rb_define_method(cDuckDBExpression, "foldable?", expression_foldable_p, 0);
+    rb_define_private_method(cDuckDBExpression, "_fold", expression__fold, 1);
 }

data/ext/duckdb/expression.h

@@ -7,7 +7,7 @@ struct _rubyDuckDBExpression {
 
 typedef struct _rubyDuckDBExpression rubyDuckDBExpression;
 
-void rbduckdb_init_duckdb_expression(void);
+void rbduckdb_init_expression(void);
 VALUE rbduckdb_expression_new(duckdb_expression expression);
 
 #endif