duckdb 1.5.2.0 → 1.5.3.0

data/ext/duckdb/result.c

@@ -10,19 +10,16 @@ static VALUE cDuckDBResult;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE duckdb_result_column_count(VALUE oDuckDBResult);
-static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
-static VALUE duckdb_result_columns(VALUE oDuckDBResult);
+static VALUE result_column_count(VALUE oDuckDBResult);
+static VALUE result_rows_changed(VALUE oDuckDBResult);
+static VALUE result_columns(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
 
-static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
+static VALUE result__chunk_stream(VALUE oDuckDBResult);
 static VALUE yield_rows(VALUE arg);
-static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx);
-static VALUE duckdb_result__return_type(VALUE oDuckDBResult);
-static VALUE duckdb_result__statement_type(VALUE oDuckDBResult);
-static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx);
-static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_idx);
-static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col_idx, VALUE idx);
+static VALUE result__return_type(VALUE oDuckDBResult);
+static VALUE result__statement_type(VALUE oDuckDBResult);
+static VALUE result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx);
 
 static VALUE vector_date(void *vector_data, idx_t row_idx);
 static VALUE vector_timestamp(void* vector_data, idx_t row_idx);
@@ -72,7 +69,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBResult);
 }
 
-rubyDuckDBResult *get_struct_result(VALUE obj) {
+rubyDuckDBResult *rbduckdb_get_struct_result(VALUE obj) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBResult, &result_data_type, ctx);
     return ctx;
@@ -100,7 +97,7 @@ rubyDuckDBResult *get_struct_result(VALUE obj) {
  *    end
  *
  */
-static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
+static VALUE result_rows_changed(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return LL2NUM(duckdb_rows_changed(&(ctx->result)));
@@ -124,7 +121,7 @@ static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
  *    end
  *
  */
-static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
+static VALUE result_column_count(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return LL2NUM(duckdb_column_count(&(ctx->result)));
@@ -137,7 +134,7 @@ static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
  *  Returns the column class Lists.
  *
  */
-static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
+static VALUE result_columns(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
@@ -159,7 +156,7 @@ static VALUE destroy_data_chunk(VALUE arg) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
+static VALUE result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     struct chunk_arg arg;
 
@@ -199,28 +196,21 @@ static VALUE yield_rows(VALUE arg) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-    return LL2NUM(duckdb_column_type(&(ctx->result), NUM2LL(col_idx)));
-}
-
-/* :nodoc: */
-static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
+static VALUE result__return_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return INT2FIX(duckdb_result_return_type(ctx->result));
 }
 
 /* :nodoc: */
-static VALUE duckdb_result__statement_type(VALUE oDuckDBResult) {
+static VALUE result__statement_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return INT2FIX(duckdb_result_statement_type(ctx->result));
 }
 
 /* :nodoc: */
-static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx) {
+static VALUE result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     VALUE type = Qnil;
     duckdb_logical_type logical_type;
@@ -234,46 +224,10 @@ static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_id
     return type;
 }
 
-/* :nodoc: */
-static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    VALUE size = Qnil;
-    duckdb_logical_type logical_type;
-
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-    logical_type = duckdb_column_logical_type(&(ctx->result), NUM2LL(col_idx));
-    if (logical_type) {
-        size = UINT2NUM(duckdb_enum_dictionary_size(logical_type));
-    }
-    duckdb_destroy_logical_type(&logical_type);
-    return size;
-}
-
-/* :nodoc: */
-static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col_idx, VALUE idx) {
-    rubyDuckDBResult *ctx;
-    VALUE value = Qnil;
-    duckdb_logical_type logical_type;
-    char *p;
-
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-    logical_type = duckdb_column_logical_type(&(ctx->result), NUM2LL(col_idx));
-    if (logical_type) {
-        p = duckdb_enum_dictionary_value(logical_type, NUM2LL(idx));
-        if (p) {
-            value = rb_utf8_str_new_cstr(p);
-            duckdb_free(p);
-        }
-    }
-    duckdb_destroy_logical_type(&logical_type);
-    return value;
-}
-
 VALUE rbduckdb_create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-
 static VALUE vector_date(void *vector_data, idx_t row_idx) {
     return rbduckdb_date_to_ruby(((duckdb_date *)vector_data)[row_idx]);
 }
@@ -286,7 +240,6 @@ static VALUE vector_time(void* vector_data, idx_t row_idx) {
     return rbduckdb_time_to_ruby(((duckdb_time *)vector_data)[row_idx]);
 }
 
-
 static VALUE vector_interval(void* vector_data, idx_t row_idx) {
     return rbduckdb_interval_to_ruby(((duckdb_interval *)vector_data)[row_idx]);
 }
@@ -706,7 +659,7 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
     return obj;
 }
 
-void rbduckdb_init_duckdb_result(void) {
+void rbduckdb_init_result(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
@@ -714,15 +667,12 @@ void rbduckdb_init_duckdb_result(void) {
 
     rb_define_alloc_func(cDuckDBResult, allocate);
 
-    rb_define_method(cDuckDBResult, "column_count", duckdb_result_column_count, 0);
-    rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
-    rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
-    rb_define_private_method(cDuckDBResult, "_chunk_stream", duckdb_result__chunk_stream, 0);
-    rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
-    rb_define_private_method(cDuckDBResult, "_return_type", duckdb_result__return_type, 0);
-    rb_define_private_method(cDuckDBResult, "_statement_type", duckdb_result__statement_type, 0);
-
-    rb_define_private_method(cDuckDBResult, "_enum_internal_type", duckdb_result__enum_internal_type, 1);
-    rb_define_private_method(cDuckDBResult, "_enum_dictionary_size", duckdb_result__enum_dictionary_size, 1);
-    rb_define_private_method(cDuckDBResult, "_enum_dictionary_value", duckdb_result__enum_dictionary_value, 2);
+    rb_define_method(cDuckDBResult, "column_count", result_column_count, 0);
+    rb_define_method(cDuckDBResult, "rows_changed", result_rows_changed, 0);
+    rb_define_method(cDuckDBResult, "columns", result_columns, 0);
+    rb_define_private_method(cDuckDBResult, "_chunk_stream", result__chunk_stream, 0);
+    rb_define_private_method(cDuckDBResult, "_return_type", result__return_type, 0);
+    rb_define_private_method(cDuckDBResult, "_statement_type", result__statement_type, 0);
+
+    rb_define_private_method(cDuckDBResult, "_enum_internal_type", result__enum_internal_type, 1);
 }

data/ext/duckdb/result.h

@@ -7,10 +7,9 @@ struct _rubyDuckDBResult {
 
 typedef struct _rubyDuckDBResult rubyDuckDBResult;
 
-rubyDuckDBResult *get_struct_result(VALUE obj);
-void rbduckdb_init_duckdb_result(void);
+rubyDuckDBResult *rbduckdb_get_struct_result(VALUE obj);
+void rbduckdb_init_result(void);
 VALUE rbduckdb_create_result(void);
 VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index);
 
 #endif
-

data/ext/duckdb/ruby-duckdb.h

@@ -12,6 +12,10 @@
 #define HAVE_DUCKDB_H_GE_V1_5_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_GEOMETRY_TYPE_GET_CRS
+#define HAVE_DUCKDB_H_GE_V1_5_2 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
@@ -34,6 +38,7 @@
 #include "./scalar_function.h"
 #include "./scalar_function_set.h"
 #include "./aggregate_function.h"
+#include "./aggregate_function_set.h"
 #include "./expression.h"
 #include "./client_context.h"
 #include "./scalar_function_bind_info.h"

data/ext/duckdb/scalar_function.c

@@ -139,7 +139,7 @@ static VALUE rbduckdb_scalar_function__set_return_type(VALUE self, VALUE logical
     rubyDuckDBLogicalType *lt;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
-    lt = get_struct_logical_type(logical_type);
+    lt = rbduckdb_get_struct_logical_type(logical_type);
 
     duckdb_scalar_function_set_return_type(p->scalar_function, lt->logical_type);
 
@@ -151,7 +151,7 @@ static VALUE rbduckdb_scalar_function__set_varargs(VALUE self, VALUE logical_typ
     rubyDuckDBLogicalType *lt;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
-    lt = get_struct_logical_type(logical_type);
+    lt = rbduckdb_get_struct_logical_type(logical_type);
 
     duckdb_scalar_function_set_varargs(p->scalar_function, lt->logical_type);
 
@@ -172,7 +172,7 @@ static VALUE rbduckdb_scalar_function_add_parameter(VALUE self, VALUE logical_ty
     rubyDuckDBLogicalType *lt;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
-    lt = get_struct_logical_type(logical_type);
+    lt = rbduckdb_get_struct_logical_type(logical_type);
 
     duckdb_scalar_function_add_parameter(p->scalar_function, lt->logical_type);
 

data/ext/duckdb/table_description.c

@@ -70,7 +70,7 @@ static VALUE duckdb_table_description__initialize(VALUE self, VALUE con, VALUE c
     if (!NIL_P(table)) {
         ptable = StringValuePtr(table);
     }
-    ctxcon = get_struct_connection(con);
+    ctxcon = rbduckdb_get_struct_connection(con);
     ctx = get_struct_table_description(self);
 
     if (ctx->table_description) {

data/ext/duckdb/table_function.c

@@ -148,7 +148,7 @@ static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_typ
         rb_raise(eDuckDBError, "Table function is destroyed");
     }
 
-    ctx_logical_type = get_struct_logical_type(logical_type);
+    ctx_logical_type = rbduckdb_get_struct_logical_type(logical_type);
     duckdb_table_function_add_parameter(ctx->table_function, ctx_logical_type->logical_type);
 
     return self;
@@ -174,7 +174,7 @@ static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name,
     }
 
     param_name = StringValueCStr(name);
-    ctx_logical_type = get_struct_logical_type(logical_type);
+    ctx_logical_type = rbduckdb_get_struct_logical_type(logical_type);
     duckdb_table_function_add_named_parameter(ctx->table_function, param_name, ctx_logical_type->logical_type);
 
     return self;
@@ -388,7 +388,7 @@ static void execute_execute_callback_protected(void *user_data) {
     func_info_ctx->info = darg->info;
 
     data_chunk_obj = rb_class_new_instance(0, NULL, cDuckDBDataChunk);
-    data_chunk_ctx = get_struct_data_chunk(data_chunk_obj);
+    data_chunk_ctx = rbduckdb_get_struct_data_chunk(data_chunk_obj);
     data_chunk_ctx->data_chunk = darg->output;
 
     VALUE call_args[3] = { darg->ctx->execute_proc, func_info_obj, data_chunk_obj };

data/ext/duckdb/table_function_bind_info.c

@@ -135,7 +135,7 @@ static VALUE rbduckdb_bind_info__add_result_column(VALUE self, VALUE column_name
     const char *col_name;
 
     TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
-    ctx_logical_type = get_struct_logical_type(logical_type);
+    ctx_logical_type = rbduckdb_get_struct_logical_type(logical_type);
 
     col_name = StringValueCStr(column_name);
     duckdb_bind_add_result_column(ctx->bind_info, col_name, ctx_logical_type->logical_type);

data/ext/duckdb/value.c

@@ -5,22 +5,23 @@ VALUE cDuckDBValue;
 static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE duckdb_value_s__create_bool(VALUE klass, VALUE flag);
-static VALUE duckdb_value_s__create_int8(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_int16(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_int32(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_int64(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_uint8(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_uint16(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_uint32(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_uint64(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_float(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_double(VALUE klass, VALUE val);
-static VALUE duckdb_value_s__create_varchar(VALUE klass, VALUE str);
-static VALUE duckdb_value_s__create_blob(VALUE klass, VALUE str);
-static VALUE duckdb_value_s__create_hugeint(VALUE klass, VALUE lower, VALUE upper);
-static VALUE duckdb_value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upper);
-static VALUE duckdb_value_s_create_null(VALUE klass);
+static VALUE value_s__create_bool(VALUE klass, VALUE flag);
+static VALUE value_s__create_int8(VALUE klass, VALUE val);
+static VALUE value_s__create_int16(VALUE klass, VALUE val);
+static VALUE value_s__create_int32(VALUE klass, VALUE val);
+static VALUE value_s__create_int64(VALUE klass, VALUE val);
+static VALUE value_s__create_uint8(VALUE klass, VALUE val);
+static VALUE value_s__create_uint16(VALUE klass, VALUE val);
+static VALUE value_s__create_uint32(VALUE klass, VALUE val);
+static VALUE value_s__create_uint64(VALUE klass, VALUE val);
+static VALUE value_s__create_float(VALUE klass, VALUE val);
+static VALUE value_s__create_double(VALUE klass, VALUE val);
+static VALUE value_s__create_varchar(VALUE klass, VALUE str);
+static VALUE value_s__create_blob(VALUE klass, VALUE str);
+static VALUE value_s__create_hugeint(VALUE klass, VALUE lower, VALUE upper);
+static VALUE value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upper);
+static VALUE value_s__create_decimal(VALUE klass, VALUE lower, VALUE upper, VALUE width, VALUE scale);
+static VALUE value_s_create_null(VALUE klass);
 
 static const rb_data_type_t value_data_type = {
     "DuckDB/Value",
@@ -44,76 +45,76 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBValue);
 }
 
-static VALUE duckdb_value_s__create_bool(VALUE klass, VALUE flag) {
+static VALUE value_s__create_bool(VALUE klass, VALUE flag) {
     duckdb_value value = duckdb_create_bool(RTEST(flag) ? true : false);
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_int8(VALUE klass, VALUE val) {
+static VALUE value_s__create_int8(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_int8((int8_t)NUM2INT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_int16(VALUE klass, VALUE val) {
+static VALUE value_s__create_int16(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_int16((int16_t)NUM2INT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_int32(VALUE klass, VALUE val) {
+static VALUE value_s__create_int32(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_int32(NUM2INT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_int64(VALUE klass, VALUE val) {
+static VALUE value_s__create_int64(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_int64((int64_t)NUM2LL(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_uint8(VALUE klass, VALUE val) {
+static VALUE value_s__create_uint8(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_uint8((uint8_t)NUM2UINT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_uint16(VALUE klass, VALUE val) {
+static VALUE value_s__create_uint16(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_uint16((uint16_t)NUM2UINT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_uint32(VALUE klass, VALUE val) {
+static VALUE value_s__create_uint32(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_uint32((uint32_t)NUM2UINT(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_uint64(VALUE klass, VALUE val) {
+static VALUE value_s__create_uint64(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_uint64((uint64_t)RB_NUM2ULL(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_float(VALUE klass, VALUE val) {
+static VALUE value_s__create_float(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_float((float)NUM2DBL(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_double(VALUE klass, VALUE val) {
+static VALUE value_s__create_double(VALUE klass, VALUE val) {
     duckdb_value value = duckdb_create_double(NUM2DBL(val));
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_varchar(VALUE klass, VALUE str) {
+static VALUE value_s__create_varchar(VALUE klass, VALUE str) {
     const char *str_ptr = StringValuePtr(str);
     idx_t str_len = RSTRING_LEN(str);
     duckdb_value value = duckdb_create_varchar_length(str_ptr, str_len);
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_blob(VALUE klass, VALUE str) {
+static VALUE value_s__create_blob(VALUE klass, VALUE str) {
     const uint8_t *data_ptr = (const uint8_t *)StringValuePtr(str);
     idx_t data_len = RSTRING_LEN(str);
     duckdb_value value = duckdb_create_blob(data_ptr, data_len);
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_hugeint(VALUE klass, VALUE lower, VALUE upper) {
+static VALUE value_s__create_hugeint(VALUE klass, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
     hugeint.lower = NUM2ULL(lower);
     hugeint.upper = NUM2LL(upper);
@@ -121,7 +122,7 @@ static VALUE duckdb_value_s__create_hugeint(VALUE klass, VALUE lower, VALUE uppe
     return rbduckdb_value_new(value);
 }
 
-static VALUE duckdb_value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upper) {
+static VALUE value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upper) {
     duckdb_uhugeint uhugeint;
     uhugeint.lower = NUM2ULL(lower);
     uhugeint.upper = NUM2ULL(upper);
@@ -129,6 +130,16 @@ static VALUE duckdb_value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upp
     return rbduckdb_value_new(value);
 }
 
+static VALUE value_s__create_decimal(VALUE klass, VALUE lower, VALUE upper, VALUE width, VALUE scale) {
+    duckdb_decimal decimal;
+    decimal.value.lower = NUM2ULL(lower);
+    decimal.value.upper = NUM2LL(upper);
+    decimal.width = (uint8_t)NUM2UINT(width);
+    decimal.scale = (uint8_t)NUM2UINT(scale);
+    duckdb_value value = duckdb_create_decimal(decimal);
+    return rbduckdb_value_new(value);
+}
+
 /*
  * call-seq:
  *   DuckDB::Value.create_null -> DuckDB::Value
@@ -138,7 +149,7 @@ static VALUE duckdb_value_s__create_uhugeint(VALUE klass, VALUE lower, VALUE upp
  *   require 'duckdb'
  *   value = DuckDB::Value.create_null
  */
-static VALUE duckdb_value_s_create_null(VALUE klass) {
+static VALUE value_s_create_null(VALUE klass) {
     duckdb_value value = duckdb_create_null_value();
     return rbduckdb_value_new(value);
 }
@@ -151,7 +162,7 @@ VALUE rbduckdb_value_new(duckdb_value value) {
     return obj;
 }
 
-rubyDuckDBValue *get_struct_value(VALUE obj) {
+rubyDuckDBValue *rbduckdb_get_struct_value(VALUE obj) {
     rubyDuckDBValue *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBValue, &value_data_type, ctx);
     return ctx;
@@ -252,28 +263,29 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
     return result;
 }
 
-void rbduckdb_init_duckdb_value(void) {
+void rbduckdb_init_value(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBValue = rb_define_class_under(mDuckDB, "Value", rb_cObject);
     rb_define_alloc_func(cDuckDBValue, allocate);
 
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_bool", duckdb_value_s__create_bool, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int8", duckdb_value_s__create_int8, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int16", duckdb_value_s__create_int16, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int32", duckdb_value_s__create_int32, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int64", duckdb_value_s__create_int64, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint8", duckdb_value_s__create_uint8, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint16", duckdb_value_s__create_uint16, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint32", duckdb_value_s__create_uint32, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint64", duckdb_value_s__create_uint64, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_float", duckdb_value_s__create_float, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_double", duckdb_value_s__create_double, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_varchar", duckdb_value_s__create_varchar, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_blob", duckdb_value_s__create_blob, 1);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_hugeint", duckdb_value_s__create_hugeint, 2);
-    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uhugeint", duckdb_value_s__create_uhugeint, 2);
-    rb_define_singleton_method(cDuckDBValue, "create_null", duckdb_value_s_create_null, 0);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_bool", value_s__create_bool, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int8", value_s__create_int8, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int16", value_s__create_int16, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int32", value_s__create_int32, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_int64", value_s__create_int64, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint8", value_s__create_uint8, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint16", value_s__create_uint16, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint32", value_s__create_uint32, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uint64", value_s__create_uint64, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_float", value_s__create_float, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_double", value_s__create_double, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_varchar", value_s__create_varchar, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_blob", value_s__create_blob, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_hugeint", value_s__create_hugeint, 2);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_uhugeint", value_s__create_uhugeint, 2);
+    rb_define_private_method(rb_singleton_class(cDuckDBValue), "_create_decimal", value_s__create_decimal, 4);
+    rb_define_singleton_method(cDuckDBValue, "create_null", value_s_create_null, 0);
 }
 

data/ext/duckdb/value.h

@@ -7,9 +7,9 @@ struct _rubyDuckDBValue {
 
 typedef struct _rubyDuckDBValue rubyDuckDBValue;
 
-void rbduckdb_init_duckdb_value(void);
+void rbduckdb_init_value(void);
 VALUE rbduckdb_value_new(duckdb_value value);
 VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val);
-rubyDuckDBValue *get_struct_value(VALUE obj);
+rubyDuckDBValue *rbduckdb_get_struct_value(VALUE obj);
 
 #endif

data/ext/duckdb/vector.c

@@ -5,12 +5,12 @@ VALUE cDuckDBVector;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_vector_get_data(VALUE self);
-static VALUE rbduckdb_vector_get_validity(VALUE self);
-static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALUE str);
-static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str);
-static VALUE rbduckdb_vector_logical_type(VALUE self);
-static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid);
+static VALUE vector_get_data(VALUE self);
+static VALUE vector_get_validity(VALUE self);
+static VALUE vector_assign_string_element(VALUE self, VALUE index, VALUE str);
+static VALUE vector_assign_string_element_len(VALUE self, VALUE index, VALUE str);
+static VALUE vector_logical_type(VALUE self);
+static VALUE vector_set_validity(VALUE self, VALUE index, VALUE valid);
 
 static const rb_data_type_t vector_data_type = {
     "DuckDB/Vector",
@@ -32,7 +32,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBVector);
 }
 
-rubyDuckDBVector *get_struct_vector(VALUE obj) {
+rubyDuckDBVector *rbduckdb_get_struct_vector(VALUE obj) {
     rubyDuckDBVector *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBVector, &vector_data_type, ctx);
     return ctx;
@@ -47,7 +47,7 @@ rubyDuckDBVector *get_struct_vector(VALUE obj) {
  *
  *   ptr = vector.get_data
  */
-static VALUE rbduckdb_vector_get_data(VALUE self) {
+static VALUE vector_get_data(VALUE self) {
     rubyDuckDBVector *ctx;
     void *data;
 
@@ -67,7 +67,7 @@ static VALUE rbduckdb_vector_get_data(VALUE self) {
  *
  *   validity = vector.get_validity
  */
-static VALUE rbduckdb_vector_get_validity(VALUE self) {
+static VALUE vector_get_validity(VALUE self) {
     rubyDuckDBVector *ctx;
     uint64_t *validity;
 
@@ -90,7 +90,7 @@ static VALUE rbduckdb_vector_get_validity(VALUE self) {
  *
  *   vector.assign_string_element(0, 'hello')
  */
-static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALUE str) {
+static VALUE vector_assign_string_element(VALUE self, VALUE index, VALUE str) {
     rubyDuckDBVector *ctx;
     idx_t idx;
     const char *string_val;
@@ -114,7 +114,7 @@ static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALU
  *
  *   vector.assign_string_element_len(0, "\x00\x01\x02\x03")
  */
-static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str) {
+static VALUE vector_assign_string_element_len(VALUE self, VALUE index, VALUE str) {
     rubyDuckDBVector *ctx;
     idx_t idx;
     const char *string_val;
@@ -141,7 +141,7 @@ static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index,
  *   type = vector.logical_type
  *   type.id  #=> DuckDB::Type::BIGINT
  */
-static VALUE rbduckdb_vector_logical_type(VALUE self) {
+static VALUE vector_logical_type(VALUE self) {
     rubyDuckDBVector *ctx;
     duckdb_logical_type logical_type;
 
@@ -161,7 +161,7 @@ static VALUE rbduckdb_vector_logical_type(VALUE self) {
  *   vector.set_validity(0, false)  # Mark row 0 as NULL
  *   vector.set_validity(1, true)   # Mark row 1 as valid
  */
-static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid) {
+static VALUE vector_set_validity(VALUE self, VALUE index, VALUE valid) {
     rubyDuckDBVector *ctx;
     idx_t idx;
     uint64_t *validity;
@@ -185,17 +185,17 @@ static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid)
     return self;
 }
 
-void rbduckdb_init_duckdb_vector(void) {
+void rbduckdb_init_vector(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBVector = rb_define_class_under(mDuckDB, "Vector", rb_cObject);
     rb_define_alloc_func(cDuckDBVector, allocate);
 
-    rb_define_method(cDuckDBVector, "get_data", rbduckdb_vector_get_data, 0);
-    rb_define_method(cDuckDBVector, "get_validity", rbduckdb_vector_get_validity, 0);
-    rb_define_method(cDuckDBVector, "assign_string_element", rbduckdb_vector_assign_string_element, 2);
-    rb_define_method(cDuckDBVector, "assign_string_element_len", rbduckdb_vector_assign_string_element_len, 2);
-    rb_define_method(cDuckDBVector, "logical_type", rbduckdb_vector_logical_type, 0);
-    rb_define_method(cDuckDBVector, "set_validity", rbduckdb_vector_set_validity, 2);
+    rb_define_method(cDuckDBVector, "get_data", vector_get_data, 0);
+    rb_define_method(cDuckDBVector, "get_validity", vector_get_validity, 0);
+    rb_define_method(cDuckDBVector, "assign_string_element", vector_assign_string_element, 2);
+    rb_define_method(cDuckDBVector, "assign_string_element_len", vector_assign_string_element_len, 2);
+    rb_define_method(cDuckDBVector, "logical_type", vector_logical_type, 0);
+    rb_define_method(cDuckDBVector, "set_validity", vector_set_validity, 2);
 }

data/ext/duckdb/vector.h

@@ -7,7 +7,7 @@ struct _rubyDuckDBVector {
 
 typedef struct _rubyDuckDBVector rubyDuckDBVector;
 
-rubyDuckDBVector *get_struct_vector(VALUE obj);
-void rbduckdb_init_duckdb_vector(void);
+rubyDuckDBVector *rbduckdb_get_struct_vector(VALUE obj);
+void rbduckdb_init_vector(void);
 
 #endif