duckdb 1.5.2.0 → 1.5.2.1

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"

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

data/lib/duckdb/aggregate_function.rb

@@ -1,13 +1,153 @@
 # frozen_string_literal: true
 
 module DuckDB
-  # DuckDB::AggregateFunction encapsulates DuckDB's aggregate function.
+  # DuckDB::AggregateFunction lets you register a custom aggregate function
+  # written in Ruby and call it from SQL.
   #
-  # @note DuckDB::AggregateFunction is experimental. Phase 1.0 only supports
-  #   +set_init+ and +set_finalize+; +update+ and +combine+ are internal no-ops.
+  # An aggregate function folds many rows into a single value. You define its
+  # behaviour with four callbacks:
+  #
+  # * +set_init+    — called once per group; returns the initial state.
+  # * +set_update+  — called once per row; receives the current state and the
+  #                   input value(s), returns the new state.
+  # * +set_combine+ — merges two partial states (required for parallel
+  #                   execution); receives source and target states, returns the
+  #                   merged state.
+  # * +set_finalize+ — converts the final state into the SQL result value.
+  #
+  # Only +set_init+ is required. The other three have sensible defaults:
+  # * +set_update+   defaults to +{ |state, *| state }+ (ignore inputs)
+  # * +set_combine+  defaults to +{ |s1, _s2| s1 }+ (keep source state)
+  # * +set_finalize+ defaults to +{ |x| x }+ (return state as-is)
+  #
+  # @note The default +set_combine+ keeps the source state and discards the
+  #   target, which is only correct for single-threaded (single-partition)
+  #   execution. If DuckDB runs the aggregate in parallel it will produce
+  #   wrong results. Always supply an explicit +set_combine+ when the
+  #   aggregate must be parallel-safe.
+  #
+  # == Basic example: custom SUM
+  #
+  #   af = DuckDB::AggregateFunction.new
+  #   af.name        = 'my_sum'
+  #   af.return_type = DuckDB::LogicalType::BIGINT
+  #   af.add_parameter(DuckDB::LogicalType::BIGINT)
+  #
+  #   af.set_init    { 0 }
+  #   af.set_update  { |state, value| state + value }
+  #   af.set_combine { |s1, s2| s1 + s2 }
+  #
+  #   con.register_aggregate_function(af)
+  #   con.query('SELECT my_sum(i) FROM range(100) t(i)').first.first  # => 4950
+  #
+  # == Example: weighted average with Hash state
+  #
+  #   af = DuckDB::AggregateFunction.new
+  #   af.name        = 'weighted_avg'
+  #   af.return_type = DuckDB::LogicalType::DOUBLE
+  #   af.add_parameter(DuckDB::LogicalType::DOUBLE)  # value
+  #   af.add_parameter(DuckDB::LogicalType::DOUBLE)  # weight
+  #
+  #   af.set_init    { { sum: 0.0, weight: 0.0 } }
+  #   af.set_update  { |state, value, weight| { sum: state[:sum] + value * weight, weight: state[:weight] + weight } }
+  #   af.set_combine { |s1, s2| { sum: s1[:sum] + s2[:sum], weight: s1[:weight] + s2[:weight] } }
+  #   af.set_finalize { |state| state[:weight].zero? ? nil : state[:sum] / state[:weight] }
+  #
+  #   con.register_aggregate_function(af)
   class AggregateFunction
     include FunctionTypeValidation
 
+    class << self
+      # Creates a new AggregateFunction in a single call.
+      #
+      # This is a convenience factory that builds and configures an
+      # AggregateFunction without requiring you to set each attribute
+      # separately.
+      #
+      # @param name [String] the SQL function name
+      # @param return_type [DuckDB::LogicalType | Symbol] the SQL return type
+      # @param params [Array<DuckDB::LogicalType | Symbol>] input parameter types
+      #   (empty array for a zero-argument aggregate)
+      # @param init [#call] callable that returns the initial per-group state
+      # @param update [#call] callable that folds one row into the state;
+      #   receives +state, *inputs+ and must return the updated state.
+      #   Default: +->( state, *) { state }+ (ignore inputs)
+      # @param combine [#call] callable that merges two partial states;
+      #   receives +source_state, target_state+ and must return the merged
+      #   state. Default: +->(state, _other) { state }+ (keep source only —
+      #   only correct for single-threaded execution)
+      # @param finalize [#call] callable that converts the final state into the
+      #   SQL result value; receives +state+ and must return a value compatible
+      #   with +return_type+.
+      #   Default: +->(state) { state }+ (return state as-is)
+      # @param null_handling [Boolean] when +true+, enables special NULL
+      #   handling so that rows with NULL inputs are passed to +update+ as
+      #   +nil+ instead of being skipped (default: +false+)
+      # @return [DuckDB::AggregateFunction] the configured aggregate function,
+      #   ready to be passed to +Connection#register_aggregate_function+
+      # @raise [ArgumentError] if any of +init+, +update+, +combine+, or
+      #   +finalize+ does not respond to +call+
+      #
+      # == Example: custom SUM
+      #
+      #   af = DuckDB::AggregateFunction.create(
+      #     name:        'my_sum',
+      #     return_type: :bigint,
+      #     params:      [:bigint],
+      #     init:        -> { 0 },
+      #     update:      ->(state, value) { state + value },
+      #     combine:     ->(state, other) { state + other }
+      #   )
+      #   con.register_aggregate_function(af)
+      #   con.query('SELECT my_sum(i) FROM range(100) t(i)').first.first  # => 4950
+      #
+      # == Example: count including NULL values
+      #
+      #   af = DuckDB::AggregateFunction.create(
+      #     name:         'count_with_nulls',
+      #     return_type:  :bigint,
+      #     params:       [:bigint],
+      #     init:         -> { 0 },
+      #     update:       ->(state, _value) { state + 1 },
+      #     combine:      ->(state, other) { state + other },
+      #     null_handling: true
+      #   )
+      def create( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists, Metrics/AbcSize
+        name:,
+        return_type:,
+        params: [], # rubocop:disable Style/KeywordParametersOrder
+        init:,
+        update: ->(state, *_inputs) { state },
+        combine: ->(state, _other_state) { state },
+        finalize: ->(state) { state },
+        null_handling: false
+      )
+        callable!(:init, init)
+        callable!(:update, update)
+        callable!(:combine, combine)
+        callable!(:finalize, finalize)
+
+        af = AggregateFunction.new
+        af.name = name
+        af.return_type = return_type
+        params.each do |param|
+          af.add_parameter(param)
+        end
+        af.set_init { init.call }
+        af.set_update { |state, *inputs| update.call(state, *inputs) }
+        af.set_combine { |state, other_state| combine.call(state, other_state) }
+        af.set_finalize { |state| finalize.call(state) }
+        af.set_special_handling if null_handling
+        af
+      end
+
+      private
+
+      def callable!(name, arg)
+        raise ArgumentError, "#{name} must respond to `call`" unless arg.respond_to?(:call)
+      end
+    end
+
     # Sets the return type for the aggregate function.
     #
     # @param logical_type [DuckDB::LogicalType | :logical_type_symbol] the return type
@@ -30,6 +170,65 @@ module DuckDB
       _add_parameter(logical_type)
     end
 
+    # Sets the block that initialises the per-group state.
+    # The block takes no arguments and returns the initial state value.
+    # This is the only required callback; defaults for +set_update+,
+    # +set_combine+, and +set_finalize+ are injected automatically on the
+    # first call if those methods have not been called explicitly.
+    #
+    # @note The injected default for +set_combine+ is +{ |s1, _s2| s1 }+, which
+    #   is only correct for single-threaded execution. Always call +set_combine+
+    #   explicitly when the aggregate must be parallel-safe.
+    #
+    # @return [DuckDB::AggregateFunction] self
+    def set_init(&)
+      unless @init_set
+        _set_update { |state, *| state } unless @update_set
+        _set_combine { |s1, _s2| s1 } unless @combine_set
+        _set_finalize { |x| x } unless @finalize_set
+      end
+      _set_init(&)
+      @init_set = true
+    end
+
+    # Sets the block that accumulates one row into the state.
+    # The block receives the current state followed by the input column
+    # value(s) for that row, and must return the updated state.
+    # Default: +{ |state, *| state }+ (ignore inputs, keep state unchanged).
+    # May be called after +set_init+ to override the injected default.
+    #
+    # @return [DuckDB::AggregateFunction] self
+    def set_update(&)
+      @update_set = true
+      _set_update(&)
+    end
+
+    # Sets the block that merges two partial states during parallel execution.
+    # The block receives the source and target states and must return the
+    # merged state.
+    # May be called after +set_init+ to override the injected default.
+    #
+    # @note The default +{ |s1, _s2| s1 }+ is only correct for single-threaded
+    #   execution. Supply an explicit combine block for parallel-safe aggregates.
+    #
+    # @return [DuckDB::AggregateFunction] self
+    def set_combine(&)
+      @combine_set = true
+      _set_combine(&)
+    end
+
+    # Sets the block that converts the final state into the SQL result value.
+    # The block receives the accumulated state and must return a value
+    # compatible with the declared +return_type+.
+    # Default: +{ |x| x }+ (return the state as-is).
+    # May be called after +set_init+ to override the injected default.
+    #
+    # @return [DuckDB::AggregateFunction] self
+    def set_finalize(&)
+      @finalize_set = true
+      _set_finalize(&)
+    end
+
     # Sets special NULL handling for the aggregate function.
     # By default DuckDB skips rows with NULL input values.  Calling this
     # method disables that behaviour so the update callback is invoked even