duckdb 1.5.1.0 → 1.5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c55213e9e388de53b04f29987c7714975ab5c1a8fa10a40ae378189507dae752
-  data.tar.gz: a96e6256ce85583fd395d936994d2a871727af8f7ba11fadc40a9d9ca79c15fa
+  metadata.gz: '0982b8680fcd79b493773dbbf39fd3f366fe11ccc952a8bfb4be0a140657e8fe'
+  data.tar.gz: 34cc46de733b8bc215197e5ceab3eb3022b0067ac34376b828ded5106d4b1261
 SHA512:
-  metadata.gz: 67c2d5de633c5999ca07e3deb7c98a091b4eaedb70eacce2d2f7c34b9e8795b012d4415e197d5996ca80eb9c526dc28e86ced8f1d977cc040fcfd8c59a9a3ad2
-  data.tar.gz: 38de479e2069a0b4dd1fa8684b2174d6f42c15375d54269f56983b530e2b7ea43150284b8825879cdceca1fe959f1c05b8043bb1c2202b30456c63eac8dbc6ab
+  metadata.gz: 2b3043a60bbb99bd449f709befb3b84d1036d1e0643c9ed3a93eb50e88df48962095caa537f23881bfc9434a035b240230c8d81004b1d863742916baa6540902
+  data.tar.gz: 34ff46b0100769147684a4092005838ba418ab1907fc5b0690bd37f883007b0004e4838a5fdfd04ca276d157d91d39523aba74eced99133f46a8039d52b3c036

data/.github/workflows/test_on_macos.yml

@@ -20,7 +20,7 @@ jobs:
     timeout-minutes: 120
     strategy:
       matrix:
-        ruby: ['3.2.9', '3.3.10', '3.4.9', '4.0.2', 'head']
+        ruby: ['3.2.11', '3.3.11', '3.4.9', '4.0.2', 'head']
         duckdb: ['1.4.4', '1.5.1']
 
     steps:

data/.github/workflows/test_on_ubuntu.yml

@@ -20,7 +20,7 @@ jobs:
     timeout-minutes: 120
     strategy:
       matrix:
-        ruby: ['3.2.9', '3.3.10', '3.4.9', '4.0.2', 'head']
+        ruby: ['3.2.11', '3.3.11', '3.4.9', '4.0.2', 'head']
         duckdb: ['1.4.4', '1.5.1']
 
     services:

data/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.1.1 - 2026-04-04
+
+- fix `DuckDB::ScalarFunction` to allow `HUGEINT` and `UHUGEINT` as `return_type` and parameter type (the C extension's vector write path was missing those cases).
+- add `DuckDB::ScalarFunctionSet` to register multiple overloads of a scalar function under one name (wraps `duckdb_scalar_function_set`).
+- add `DuckDB::ScalarFunctionSet#add` to add a `DuckDB::ScalarFunction` overload to the set (wraps `duckdb_add_scalar_function_to_set`).
+- add `DuckDB::Connection#register_scalar_function_set` to register a `DuckDB::ScalarFunctionSet` with the connection (wraps `duckdb_register_scalar_function_set`).
+- `DuckDB::ScalarFunction.create` now accepts `name: nil` (optional) to allow creating nameless functions for use inside a `ScalarFunctionSet`.
+- add `DuckDB::LogicalType.create_struct` to create a struct logical type.
+- add `DuckDB::LogicalType.create_enum` to create an enum logical type.
+- add `DuckDB::LogicalType.create_decimal` to create a decimal logical type.
+
 # 1.5.1.0 - 2026-03-29
 
 - add `DuckDB::ScalarFunction#varargs_type=` to register a scalar function that accepts a variable number of arguments of a given type (wraps `duckdb_scalar_function_set_varargs`).
@@ -17,6 +28,7 @@ All notable changes to this project will be documented in this file.
 - add `DuckDB::ScalarFunction::BindInfo#get_argument(index)` to return the expression at the given argument index as a `DuckDB::Expression` object (wraps `duckdb_scalar_function_bind_get_argument`). Raises `ArgumentError` for out-of-range index.
 - add `DuckDB::Expression#foldable?` to check whether an expression can be folded to a constant at query planning time (wraps `duckdb_expression_is_foldable`). Returns `true` for literals and constant arithmetic, `false` for column references and non-deterministic functions.
 - add `DuckDB::LogicalType.create_map` to create a map logical type.
+- add `DuckDB::LogicalType.create_union` to create a union logical type.
 - bump duckdb to 1.5.1 on CI
 - add `DuckDB::ScalarFunction::BindInfo#client_context` to return the client context of the bind phase as a `DuckDB::ClientContext` object (wraps `duckdb_scalar_function_get_client_context`).
 - add `DuckDB::ClientContext#connection_id` to return the connection id of the client context (wraps `duckdb_client_context_get_connection_id`).

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.5.1.0)
+    duckdb (1.5.1.1)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -14,10 +14,10 @@ GEM
     json (2.19.3)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
-    minitest (6.0.2)
+    minitest (6.0.3)
       drb (~> 2.0)
       prism (~> 1.5)
-    parallel (1.27.0)
+    parallel (1.28.0)
     parser (3.3.11.1)
       ast (~> 2.4.1)
       racc

data/ext/duckdb/connection.c

@@ -12,6 +12,7 @@ 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_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_table_function(VALUE self, VALUE table_function);
 
 static const rb_data_type_t connection_data_type = {
@@ -220,6 +221,27 @@ static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar
     return self;
 }
 
+/* :nodoc: */
+static VALUE duckdb_connection_register_scalar_function_set(VALUE self, VALUE scalar_function_set) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBScalarFunctionSet *ctxsfs;
+    duckdb_state state;
+
+    ctxcon = 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);
+
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register scalar function set");
+    }
+
+    /* Keep reference to prevent GC while connection is alive */
+    rb_ary_push(ctxcon->registered_functions, scalar_function_set);
+
+    return self;
+}
+
 static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_function) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBTableFunction *ctxtf;
@@ -251,6 +273,7 @@ void rbduckdb_init_duckdb_connection(void) {
     rb_define_method(cDuckDBConnection, "interrupt", duckdb_connection_interrupt, 0);
     rb_define_method(cDuckDBConnection, "query_progress", duckdb_connection_query_progress, 0);
     rb_define_private_method(cDuckDBConnection, "_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_table_function", duckdb_connection_register_table_function, 1);
     rb_define_private_method(cDuckDBConnection, "_connect", duckdb_connection_connect, 1);
     /* TODO: query_sql => _query_sql */

data/ext/duckdb/converter.h

@@ -8,6 +8,7 @@ extern ID id__to_interval_from_vector;
 extern ID id__to_hugeint_from_vector;
 extern ID id__to_decimal_from_hugeint;
 extern ID id__to_uuid_from_vector;
+extern ID id__to_uuid_from_uhugeint;
 extern ID id__to_time_from_duckdb_timestamp_s;
 extern ID id__to_time_from_duckdb_timestamp_ms;
 extern ID id__to_time_from_duckdb_timestamp_ns;
@@ -15,6 +16,11 @@ extern ID id__to_time_from_duckdb_time_tz;
 extern ID id__to_time_from_duckdb_timestamp_tz;
 extern ID id__to_infinity;
 
+VALUE rbduckdb_uuid_to_ruby(duckdb_hugeint h);
+VALUE rbduckdb_uuid_uhugeint_to_ruby(duckdb_uhugeint h);
+VALUE rbduckdb_interval_to_ruby(duckdb_interval i);
+VALUE rbduckdb_hugeint_to_ruby(duckdb_hugeint h);
+VALUE rbduckdb_uhugeint_to_ruby(duckdb_uhugeint h);
 VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts);
 VALUE rbduckdb_timestamp_ms_to_ruby(duckdb_timestamp_ms ts);
 VALUE rbduckdb_timestamp_ns_to_ruby(duckdb_timestamp_ns ts);

data/ext/duckdb/conveter.c

@@ -9,6 +9,7 @@ ID id__to_interval_from_vector;
 ID id__to_hugeint_from_vector;
 ID id__to_decimal_from_hugeint;
 ID id__to_uuid_from_vector;
+ID id__to_uuid_from_uhugeint;
 ID id__to_time_from_duckdb_timestamp_s;
 ID id__to_time_from_duckdb_timestamp_ms;
 ID id__to_time_from_duckdb_timestamp_ns;
@@ -61,6 +62,42 @@ VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
     return Qnil;
 }
 
+VALUE rbduckdb_uuid_to_ruby(duckdb_hugeint h) {
+    return rb_funcall(mDuckDBConverter, id__to_uuid_from_vector, 2,
+                      ULL2NUM(h.lower),
+                      LL2NUM(h.upper)
+                      );
+}
+
+VALUE rbduckdb_uuid_uhugeint_to_ruby(duckdb_uhugeint h) {
+    return rb_funcall(mDuckDBConverter, id__to_uuid_from_uhugeint, 2,
+                      ULL2NUM(h.lower),
+                      ULL2NUM(h.upper)
+                      );
+}
+
+VALUE rbduckdb_interval_to_ruby(duckdb_interval i) {
+    return rb_funcall(mDuckDBConverter, id__to_interval_from_vector, 3,
+                      INT2NUM(i.months),
+                      INT2NUM(i.days),
+                      LL2NUM(i.micros)
+                      );
+}
+
+VALUE rbduckdb_hugeint_to_ruby(duckdb_hugeint h) {
+    return rb_funcall(mDuckDBConverter, id__to_hugeint_from_vector, 2,
+                      ULL2NUM(h.lower),
+                      LL2NUM(h.upper)
+                      );
+}
+
+VALUE rbduckdb_uhugeint_to_ruby(duckdb_uhugeint h) {
+    return rb_funcall(mDuckDBConverter, id__to_hugeint_from_vector, 2,
+                      ULL2NUM(h.lower),
+                      ULL2NUM(h.upper)
+                      );
+}
+
 VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts) {
     VALUE obj = infinite_timestamp_s_value(ts);
     if (obj != Qnil) {
@@ -160,6 +197,7 @@ void rbduckdb_init_duckdb_converter(void) {
     id__to_hugeint_from_vector = rb_intern("_to_hugeint_from_vector");
     id__to_decimal_from_hugeint = rb_intern("_to_decimal_from_hugeint");
     id__to_uuid_from_vector = rb_intern("_to_uuid_from_vector");
+    id__to_uuid_from_uhugeint = rb_intern("_to_uuid_from_uhugeint");
     id__to_time_from_duckdb_timestamp_s = rb_intern("_to_time_from_duckdb_timestamp_s");
     id__to_time_from_duckdb_timestamp_ms = rb_intern("_to_time_from_duckdb_timestamp_ms");
     id__to_time_from_duckdb_timestamp_ns = rb_intern("_to_time_from_duckdb_timestamp_ns");

data/ext/duckdb/duckdb.c

@@ -57,6 +57,7 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_instance_cache();
     rbduckdb_init_duckdb_value_impl();
     rbduckdb_init_duckdb_scalar_function();
+    rbduckdb_init_duckdb_scalar_function_set();
     rbduckdb_init_duckdb_expression();
     rbduckdb_init_duckdb_client_context();
     rbduckdb_init_duckdb_scalar_function_bind_info();

data/ext/duckdb/logical_type.c

@@ -26,6 +26,8 @@ static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
 static VALUE duckdb_logical_type_s_create_array_type(VALUE klass, VALUE child, VALUE array_size);
 static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child);
 static VALUE duckdb_logical_type_s_create_map_type(VALUE klass, VALUE key, VALUE value);
+static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members);
+static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members);
 static VALUE initialize(VALUE self, VALUE type_id_arg);
 
 static const rb_data_type_t logical_type_data_type = {
@@ -490,6 +492,143 @@ static VALUE duckdb_logical_type_s_create_map_type(VALUE klass, VALUE key, VALUE
     return rbduckdb_create_logical_type(new_type);
 }
 
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_union_type(members) -> DuckDB::LogicalType
+ *
+ *  Return a union logical type from the given member hash.
+ */
+static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members) {
+    idx_t member_size = RHASH_SIZE(members);
+    duckdb_logical_type *member_types = NULL;
+    const char **member_names = NULL;
+    duckdb_logical_type new_type;
+    VALUE keys;
+
+    if (member_size == 0) {
+        rb_raise(rb_eArgError, "members hash must not be empty");
+    }
+
+    member_types = (duckdb_logical_type *)xcalloc(member_size, sizeof(duckdb_logical_type));
+    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
+
+    keys = rb_funcall(members, rb_intern("keys"), 0);
+
+    for (idx_t i = 0; i < member_size; i++) {
+        VALUE key = rb_ary_entry(keys, (long)i);
+        VALUE val = rb_hash_aref(members, key);
+        rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(val);
+
+        member_names[i] = rb_id2name(SYM2ID(key));
+        member_types[i] = type_ctx->logical_type;
+    }
+
+    new_type = duckdb_create_union_type(member_types, member_names, member_size);
+
+    xfree(member_types);
+    xfree(member_names);
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create union type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_struct_type(members) -> DuckDB::LogicalType
+ *
+ *  Return a struct logical type from the given member hash.
+ */
+static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members) {
+    idx_t member_size = RHASH_SIZE(members);
+    duckdb_logical_type *member_types = NULL;
+    const char **member_names = NULL;
+    duckdb_logical_type new_type;
+    VALUE keys;
+
+    if (member_size == 0) {
+        rb_raise(rb_eArgError, "members hash must not be empty");
+    }
+
+    member_types = (duckdb_logical_type *)xcalloc(member_size, sizeof(duckdb_logical_type));
+    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
+
+    keys = rb_funcall(members, rb_intern("keys"), 0);
+
+    for (idx_t i = 0; i < member_size; i++) {
+        VALUE key = rb_ary_entry(keys, (long)i);
+        VALUE val = rb_hash_aref(members, key);
+        rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(val);
+
+        member_names[i] = rb_id2name(SYM2ID(key));
+        member_types[i] = type_ctx->logical_type;
+    }
+
+    new_type = duckdb_create_struct_type(member_types, member_names, member_size);
+
+    xfree(member_types);
+    xfree(member_names);
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create struct type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_enum_type(members) -> DuckDB::LogicalType
+ *
+ *  Return an enum logical type from the given array of strings.
+ */
+static VALUE duckdb_logical_type_s_create_enum_type(VALUE klass, VALUE members) {
+    idx_t member_size = RARRAY_LEN(members);
+    const char **member_names = NULL;
+    duckdb_logical_type new_type;
+
+    if (member_size == 0) {
+        rb_raise(rb_eArgError, "members must not be empty");
+    }
+
+    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
+
+    for (idx_t i = 0; i < member_size; i++) {
+        VALUE val = rb_ary_entry(members, (long)i);
+        member_names[i] = StringValueCStr(val);
+    }
+
+    new_type = duckdb_create_enum_type(member_names, member_size);
+
+    xfree(member_names);
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create enum type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_decimal_type(width, scale) -> DuckDB::LogicalType
+ *
+ *  Return a decimal logical type with the given width and scale.
+ */
+static VALUE duckdb_logical_type_s_create_decimal_type(VALUE klass, VALUE width, VALUE scale) {
+    duckdb_logical_type new_type;
+
+    new_type = duckdb_create_decimal_type((uint8_t)NUM2UINT(width), (uint8_t)NUM2UINT(scale));
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create decimal type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
 VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
     VALUE obj;
     rubyDuckDBLogicalType *ctx;
@@ -534,6 +673,14 @@ void rbduckdb_init_duckdb_logical_type(void) {
                              duckdb_logical_type_s_create_list_type, 1);
     rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_map_type",
                              duckdb_logical_type_s_create_map_type, 2);
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_union_type",
+                             duckdb_logical_type_s_create_union_type, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_struct_type",
+                             duckdb_logical_type_s_create_struct_type, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_enum_type",
+                             duckdb_logical_type_s_create_enum_type, 1);
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_decimal_type",
+                             duckdb_logical_type_s_create_decimal_type, 2);
 
     rb_define_method(cDuckDBLogicalType, "initialize", initialize, 1);
 }

data/ext/duckdb/memory_helper.c

@@ -251,22 +251,14 @@ static VALUE rbduckdb_memory_helper_write_timestamp(VALUE self, VALUE ptr, VALUE
     (void)self;
 
     if (!rb_obj_is_kind_of(value, rb_cTime)) {
-        rb_raise(rb_eTypeError, "Expected Time object for TIMESTAMP");
+        rb_raise(rb_eTypeError, "Expected Time object");
     }
 
     data = (duckdb_timestamp *)NUM2ULL(ptr);
     idx = (idx_t)NUM2ULL(index);
 
     VALUE local_time = rb_funcall(value, rb_intern("getlocal"), 0);
-    data[idx] = rbduckdb_to_duckdb_timestamp_from_value(
-        rb_funcall(local_time, rb_intern("year"), 0),
-        rb_funcall(local_time, rb_intern("month"), 0),
-        rb_funcall(local_time, rb_intern("day"), 0),
-        rb_funcall(local_time, rb_intern("hour"), 0),
-        rb_funcall(local_time, rb_intern("min"), 0),
-        rb_funcall(local_time, rb_intern("sec"), 0),
-        rb_funcall(local_time, rb_intern("usec"), 0)
-    );
+    data[idx] = rbduckdb_to_duckdb_timestamp_from_time_value(local_time);
 
     return Qnil;
 }

data/ext/duckdb/result.c

@@ -287,12 +287,7 @@ static VALUE vector_time(void* vector_data, idx_t row_idx) {
 
 
 static VALUE vector_interval(void* vector_data, idx_t row_idx) {
-    duckdb_interval data = ((duckdb_interval *)vector_data)[row_idx];
-    return rb_funcall(mDuckDBConverter, id__to_interval_from_vector, 3,
-                      INT2NUM(data.months),
-                      INT2NUM(data.days),
-                      LL2NUM(data.micros)
-                      );
+    return rbduckdb_interval_to_ruby(((duckdb_interval *)vector_data)[row_idx]);
 }
 
 static VALUE vector_blob(void* vector_data, idx_t row_idx) {
@@ -314,19 +309,11 @@ static VALUE vector_varchar(void* vector_data, idx_t row_idx) {
 }
 
 static VALUE vector_hugeint(void* vector_data, idx_t row_idx) {
-    duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
-    return rb_funcall(mDuckDBConverter, id__to_hugeint_from_vector, 2,
-                      ULL2NUM(hugeint.lower),
-                      LL2NUM(hugeint.upper)
-                      );
+    return rbduckdb_hugeint_to_ruby(((duckdb_hugeint *)vector_data)[row_idx]);
 }
 
 static VALUE vector_uhugeint(void* vector_data, idx_t row_idx) {
-    duckdb_uhugeint uhugeint = ((duckdb_uhugeint *)vector_data)[row_idx];
-    return rb_funcall(mDuckDBConverter, id__to_hugeint_from_vector, 2,
-                      ULL2NUM(uhugeint.lower),
-                      ULL2NUM(uhugeint.upper)
-                      );
+    return rbduckdb_uhugeint_to_ruby(((duckdb_uhugeint *)vector_data)[row_idx]);
 }
 
 static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
@@ -696,11 +683,7 @@ static VALUE vector_timestamp_tz(void* vector_data, idx_t row_idx) {
 }
 
 static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
-    duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
-    return rb_funcall(mDuckDBConverter, id__to_uuid_from_vector, 2,
-                      ULL2NUM(hugeint.lower),
-                      LL2NUM(hugeint.upper)
-                      );
+    return rbduckdb_uuid_to_ruby(((duckdb_hugeint *)vector_data)[row_idx]);
 }
 
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {

data/ext/duckdb/ruby-duckdb.h

@@ -30,6 +30,7 @@
 #include "./instance_cache.h"
 #include "./value_impl.h"
 #include "./scalar_function.h"
+#include "./scalar_function_set.h"
 #include "./expression.h"
 #include "./client_context.h"
 #include "./scalar_function_bind_info.h"

data/ext/duckdb/scalar_function.c

@@ -589,6 +589,20 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
         case DUCKDB_TYPE_UBIGINT:
             ((uint64_t *)vector_data)[index] = NUM2ULL(value);
             break;
+        case DUCKDB_TYPE_HUGEINT: {
+            duckdb_hugeint hugeint;
+            hugeint.lower = NUM2ULL(rb_funcall(mDuckDBConverter, rb_intern("_hugeint_lower"), 1, value));
+            hugeint.upper = NUM2LL(rb_funcall(mDuckDBConverter, rb_intern("_hugeint_upper"), 1, value));
+            ((duckdb_hugeint *)vector_data)[index] = hugeint;
+            break;
+        }
+        case DUCKDB_TYPE_UHUGEINT: {
+            duckdb_uhugeint uhugeint;
+            uhugeint.lower = NUM2ULL(rb_funcall(mDuckDBConverter, rb_intern("_hugeint_lower"), 1, value));
+            uhugeint.upper = NUM2ULL(rb_funcall(mDuckDBConverter, rb_intern("_hugeint_upper"), 1, value));
+            ((duckdb_uhugeint *)vector_data)[index] = uhugeint;
+            break;
+        }
         case DUCKDB_TYPE_FLOAT:
             ((float *)vector_data)[index] = (float)NUM2DBL(value);
             break;
@@ -612,21 +626,33 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             break;
         }
         case DUCKDB_TYPE_TIMESTAMP: {
-            /* Convert Ruby Time to DuckDB timestamp (microseconds since epoch) */
-            if (!rb_obj_is_kind_of(value, rb_cTime)) {
-                rb_raise(rb_eTypeError, "Expected Time object for TIMESTAMP");
-            }
-
-            duckdb_timestamp_struct ts_struct;
-            ts_struct.date.year = NUM2INT(rb_funcall(value, rb_intern("year"), 0));
-            ts_struct.date.month = NUM2INT(rb_funcall(value, rb_intern("month"), 0));
-            ts_struct.date.day = NUM2INT(rb_funcall(value, rb_intern("day"), 0));
-            ts_struct.time.hour = NUM2INT(rb_funcall(value, rb_intern("hour"), 0));
-            ts_struct.time.min = NUM2INT(rb_funcall(value, rb_intern("min"), 0));
-            ts_struct.time.sec = NUM2INT(rb_funcall(value, rb_intern("sec"), 0));
-            ts_struct.time.micros = NUM2INT(rb_funcall(value, rb_intern("usec"), 0));
-
-            duckdb_timestamp ts = duckdb_to_timestamp(ts_struct);
+            duckdb_timestamp ts = rbduckdb_to_duckdb_timestamp_from_time_value(value);
+            ((duckdb_timestamp *)vector_data)[index] = ts;
+            break;
+        }
+        case DUCKDB_TYPE_TIMESTAMP_S: {
+            duckdb_timestamp ts = rbduckdb_to_duckdb_timestamp_from_time_value(value);
+            duckdb_timestamp_s ts_s;
+            ts_s.seconds = ts.micros / 1000000;
+            ((duckdb_timestamp_s *)vector_data)[index] = ts_s;
+            break;
+        }
+        case DUCKDB_TYPE_TIMESTAMP_MS: {
+            duckdb_timestamp ts = rbduckdb_to_duckdb_timestamp_from_time_value(value);
+            duckdb_timestamp_ms ts_ms;
+            ts_ms.millis = ts.micros / 1000;
+            ((duckdb_timestamp_ms *)vector_data)[index] = ts_ms;
+            break;
+        }
+        case DUCKDB_TYPE_TIMESTAMP_NS: {
+            duckdb_timestamp ts = rbduckdb_to_duckdb_timestamp_from_time_value(value);
+            duckdb_timestamp_ns ts_ns;
+            ts_ns.nanos = ts.micros * 1000;
+            ((duckdb_timestamp_ns *)vector_data)[index] = ts_ns;
+            break;
+        }
+        case DUCKDB_TYPE_TIMESTAMP_TZ: {
+            duckdb_timestamp ts = rbduckdb_to_duckdb_timestamp_from_time_value(value);
             ((duckdb_timestamp *)vector_data)[index] = ts;
             break;
         }
@@ -660,6 +686,25 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             ((duckdb_time *)vector_data)[index] = time;
             break;
         }
+        case DUCKDB_TYPE_TIME_TZ: {
+            if (!rb_obj_is_kind_of(value, rb_cTime)) {
+                rb_raise(rb_eTypeError, "Expected Time object for TIME_TZ");
+            }
+
+            VALUE hour = rb_funcall(value, rb_intern("hour"), 0);
+            VALUE min = rb_funcall(value, rb_intern("min"), 0);
+            VALUE sec = rb_funcall(value, rb_intern("sec"), 0);
+            VALUE usec = rb_funcall(value, rb_intern("usec"), 0);
+            VALUE utc_offset = rb_funcall(value, rb_intern("utc_offset"), 0);
+
+            duckdb_time t = rbduckdb_to_duckdb_time_from_value(hour, min, sec, usec);
+            int64_t micros = t.micros;
+            int32_t offset = NUM2INT(utc_offset);
+
+            duckdb_time_tz time_tz = duckdb_create_time_tz(micros, offset);
+            ((duckdb_time_tz *)vector_data)[index] = time_tz;
+            break;
+        }
         default:
             rb_raise(rb_eArgError, "Unsupported return type for scalar function");
             break;

data/ext/duckdb/scalar_function_set.c

@@ -0,0 +1,86 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBScalarFunctionSet;
+
+static void mark(void *);
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static void compact(void *);
+static VALUE rbduckdb_scalar_function_set__initialize(VALUE self, VALUE name);
+static VALUE rbduckdb_scalar_function_set__add(VALUE self, VALUE scalar_function);
+
+static const rb_data_type_t scalar_function_set_data_type = {
+    "DuckDB/ScalarFunctionSet",
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void mark(void *ctx) {
+    rubyDuckDBScalarFunctionSet *p = (rubyDuckDBScalarFunctionSet *)ctx;
+    rb_gc_mark(p->functions);
+}
+
+static void deallocate(void *ctx) {
+    rubyDuckDBScalarFunctionSet *p = (rubyDuckDBScalarFunctionSet *)ctx;
+    duckdb_destroy_scalar_function_set(&(p->scalar_function_set));
+    xfree(p);
+}
+
+static void compact(void *ctx) {
+    rubyDuckDBScalarFunctionSet *p = (rubyDuckDBScalarFunctionSet *)ctx;
+    p->functions = rb_gc_location(p->functions);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBScalarFunctionSet *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBScalarFunctionSet));
+    VALUE obj = TypedData_Wrap_Struct(klass, &scalar_function_set_data_type, ctx);
+    ctx->functions = rb_ary_new();
+    RB_GC_GUARD(ctx->functions);
+    return obj;
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBScalarFunctionSet);
+}
+
+rubyDuckDBScalarFunctionSet *get_struct_scalar_function_set(VALUE obj) {
+    rubyDuckDBScalarFunctionSet *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, ctx);
+    return ctx;
+}
+
+/* :nodoc: */
+static VALUE rbduckdb_scalar_function_set__initialize(VALUE self, VALUE name) {
+    rubyDuckDBScalarFunctionSet *p;
+
+    TypedData_Get_Struct(self, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, p);
+    p->scalar_function_set = duckdb_create_scalar_function_set(StringValueCStr(name));
+    return self;
+}
+
+/* :nodoc: */
+static VALUE rbduckdb_scalar_function_set__add(VALUE self, VALUE scalar_function) {
+    rubyDuckDBScalarFunctionSet *p;
+    rubyDuckDBScalarFunction *sf;
+
+    TypedData_Get_Struct(self, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, p);
+    sf = get_struct_scalar_function(scalar_function);
+
+    if (duckdb_add_scalar_function_to_set(p->scalar_function_set, sf->scalar_function) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to add scalar function to set (duplicate overload?)");
+    }
+
+    rb_ary_push(p->functions, scalar_function);
+    return self;
+}
+
+void rbduckdb_init_duckdb_scalar_function_set(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBScalarFunctionSet = rb_define_class_under(mDuckDB, "ScalarFunctionSet", rb_cObject);
+    rb_define_alloc_func(cDuckDBScalarFunctionSet, allocate);
+    rb_define_private_method(cDuckDBScalarFunctionSet, "_initialize", rbduckdb_scalar_function_set__initialize, 1);
+    rb_define_private_method(cDuckDBScalarFunctionSet, "_add", rbduckdb_scalar_function_set__add, 1);
+}

data/ext/duckdb/scalar_function_set.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_DUCKDB_SCALAR_FUNCTION_SET_H
+#define RUBY_DUCKDB_SCALAR_FUNCTION_SET_H
+
+struct _rubyDuckDBScalarFunctionSet {
+    duckdb_scalar_function_set scalar_function_set;
+    VALUE functions; /* Ruby Array of ScalarFunction objects — prevents GC collection */
+};
+
+typedef struct _rubyDuckDBScalarFunctionSet rubyDuckDBScalarFunctionSet;
+
+void rbduckdb_init_duckdb_scalar_function_set(void);
+rubyDuckDBScalarFunctionSet *get_struct_scalar_function_set(VALUE obj);
+
+#endif

data/ext/duckdb/util.c

@@ -21,6 +21,22 @@ duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec,
     return duckdb_to_time(time_st);
 }
 
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj) {
+    if (!rb_obj_is_kind_of(time_obj, rb_cTime)) {
+        rb_raise(rb_eTypeError, "Expected Time object");
+    }
+
+    return rbduckdb_to_duckdb_timestamp_from_value(
+        rb_funcall(time_obj, rb_intern("year"), 0),
+        rb_funcall(time_obj, rb_intern("month"), 0),
+        rb_funcall(time_obj, rb_intern("day"), 0),
+        rb_funcall(time_obj, rb_intern("hour"), 0),
+        rb_funcall(time_obj, rb_intern("min"), 0),
+        rb_funcall(time_obj, rb_intern("sec"), 0),
+        rb_funcall(time_obj, rb_intern("usec"), 0)
+    );
+}
+
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp_struct timestamp_st;
 

data/ext/duckdb/util.h

@@ -3,6 +3,7 @@
 
 duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
 duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj);
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
 

data/ext/duckdb/value_impl.c

@@ -61,6 +61,12 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
         case DUCKDB_TYPE_BIGINT:
             result = LL2NUM(duckdb_get_int64(val));
             break;
+        case DUCKDB_TYPE_HUGEINT:
+            result = rbduckdb_hugeint_to_ruby(duckdb_get_hugeint(val));
+            break;
+        case DUCKDB_TYPE_UHUGEINT:
+            result = rbduckdb_uhugeint_to_ruby(duckdb_get_uhugeint(val));
+            break;
         case DUCKDB_TYPE_UTINYINT:
             result = INT2FIX(duckdb_get_uint8(val));
             break;
@@ -88,6 +94,9 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
         case DUCKDB_TYPE_TIME:
             result = rbduckdb_time_to_ruby(duckdb_get_time(val));
             break;
+        case DUCKDB_TYPE_INTERVAL:
+            result = rbduckdb_interval_to_ruby(duckdb_get_interval(val));
+            break;
         case DUCKDB_TYPE_TIMESTAMP_S:
             result = rbduckdb_timestamp_s_to_ruby(duckdb_get_timestamp_s(val));
             break;
@@ -108,6 +117,9 @@ VALUE rbduckdb_duckdb_value_to_ruby(duckdb_value val) {
             result = rb_str_new_cstr(str);
             duckdb_free(str);
             break;
+        case DUCKDB_TYPE_UUID:
+            result = rbduckdb_uuid_uhugeint_to_ruby(duckdb_get_uuid(val));
+            break;
         default:
             result = Qnil;
             break;

data/lib/duckdb/connection.rb

@@ -187,6 +187,28 @@ module DuckDB
       _register_scalar_function(sf)
     end
 
+    # Registers a scalar function set with the connection.
+    # A scalar function set groups multiple overloads of a function under one name,
+    # allowing DuckDB to dispatch to the correct implementation based on argument types.
+    #
+    # @param scalar_function_set [DuckDB::ScalarFunctionSet] the function set to register
+    # @return [void]
+    # @raise [TypeError] if argument is not a DuckDB::ScalarFunctionSet
+    #
+    # @example Register multiple overloads under one name
+    #   add_int = DuckDB::ScalarFunction.create(return_type: :integer, parameter_types: %i[integer integer]) { |a, b| a + b }
+    #   add_dbl = DuckDB::ScalarFunction.create(return_type: :double,  parameter_types: %i[double  double])  { |a, b| a + b }
+    #   set = DuckDB::ScalarFunctionSet.new(:add)
+    #   set.add(add_int).add(add_dbl)
+    #   con.register_scalar_function_set(set)
+    def register_scalar_function_set(scalar_function_set)
+      unless scalar_function_set.is_a?(ScalarFunctionSet)
+        raise TypeError, "#{scalar_function_set.class} is not a DuckDB::ScalarFunctionSet"
+      end
+
+      _register_scalar_function_set(scalar_function_set)
+    end
+
     #
     # Registers a table function with the database connection.
     #

data/lib/duckdb/converter.rb

@@ -10,6 +10,7 @@ module DuckDB
   module Converter # :nodoc: all
     HALF_HUGEINT_BIT = 64
     HALF_HUGEINT = 1 << HALF_HUGEINT_BIT
+    LOWER_HUGEINT_MASK = HALF_HUGEINT - 1
     FLIP_HUGEINT = 1 << 63
     EPOCH = Time.local(1970, 1, 1)
     EPOCH_UTC = Time.utc(1970, 1, 1)
@@ -93,16 +94,21 @@ module DuckDB
       (upper << HALF_HUGEINT_BIT) + lower
     end
 
+    def _hugeint_lower(value)
+      value & LOWER_HUGEINT_MASK
+    end
+
+    def _hugeint_upper(value)
+      value >> HALF_HUGEINT_BIT
+    end
+
     def _to_decimal_from_hugeint(width, scale, upper, lower = nil)
       v = lower.nil? ? upper : _to_hugeint_from_vector(lower, upper)
       _to_decimal_from_value(width, scale, v)
     end
 
     def _to_decimal_from_value(_width, scale, value)
-      v = value.to_s
-      v = v.rjust(scale + 1, '0') if v.length < scale
-      v[-scale, 0] = '.' if scale.positive?
-      BigDecimal(v)
+      BigDecimal("#{value}e-#{scale}")
     end
 
     def _to_interval_from_vector(months, days, micros)
@@ -117,6 +123,11 @@ module DuckDB
       "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20, 12]}"
     end
 
+    def _to_uuid_from_uhugeint(lower, upper)
+      str = _to_hugeint_from_vector(lower, upper).to_s(16).rjust(32, '0')
+      "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20, 12]}"
+    end
+
     def _parse_date(value)
       case value
       when Date, Time
@@ -177,9 +188,7 @@ module DuckDB
     def integer_to_hugeint(value)
       case value
       when Integer
-        upper = value >> HALF_HUGEINT_BIT
-        lower = value - (upper << HALF_HUGEINT_BIT)
-        [lower, upper]
+        [_hugeint_lower(value), _hugeint_upper(value)]
       else
         raise(ArgumentError, "The argument `#{value.inspect}` must be Integer.")
       end

data/lib/duckdb/logical_type.rb

@@ -2,6 +2,8 @@
 
 module DuckDB
   class LogicalType # rubocop:disable Metrics/ClassLength
+    RANGE_DECIMAL_WIDTH = 1..38
+
     alias :alias get_alias
     alias :alias= set_alias
 
@@ -38,6 +40,7 @@ module DuckDB
       # array: 33,
       # uuid: 27,
       # union: 28,
+      uuid: 27,
       bit: 29,
       time_tz: 30,
       timestamp_tz: 31,
@@ -111,6 +114,69 @@ module DuckDB
         _create_map_type(LogicalType.resolve(key_type), LogicalType.resolve(value_type))
       end
 
+      # Creates a union logical type with the given member names and types.
+      #
+      # The keyword arguments map member names to types. Each type can be
+      # a symbol or a DuckDB::LogicalType instance.
+      #
+      #   require 'duckdb'
+      #
+      #   union_type = DuckDB::LogicalType.create_union(num: :integer, str: :varchar)
+      #   union_type.type #=> :union
+      #   union_type.member_count #=> 2
+      #   union_type.member_name_at(0) #=> "num"
+      #   union_type.member_type_at(0).type #=> :integer
+      def create_union(**members)
+        resolved = members.transform_values { |v| LogicalType.resolve(v) }
+        _create_union_type(resolved)
+      end
+
+      # Creates a struct logical type with the given member names and types.
+      #
+      # The keyword arguments map member names to types. Each type can be
+      # a symbol or a DuckDB::LogicalType instance.
+      #
+      #   require 'duckdb'
+      #
+      #   struct_type = DuckDB::LogicalType.create_struct(name: :varchar, age: :integer)
+      #   struct_type.type #=> :struct
+      #   struct_type.child_count #=> 2
+      #   struct_type.child_name_at(0) #=> "name"
+      #   struct_type.child_type_at(0).type #=> :varchar
+      def create_struct(**members)
+        resolved = members.transform_values { |v| LogicalType.resolve(v) }
+        _create_struct_type(resolved)
+      end
+
+      # Creates an enum logical type with the given members.
+      #
+      # Each member must be a String representing an enum member.
+      #
+      #   require 'duckdb'
+      #
+      #   enum_type = DuckDB::LogicalType.create_enum('happy', 'sad', 'neutral')
+      #   enum_type.type #=> :enum
+      #   enum_type.dictionary_size #=> 3
+      #   enum_type.dictionary_value_at(0) #=> "happy"
+      def create_enum(*members)
+        _create_enum_type(members.map(&:to_s))
+      end
+
+      # Creates a decimal logical type with the given width and scale.
+      #
+      #   require 'duckdb'
+      #
+      #   decimal_type = DuckDB::LogicalType.create_decimal(18, 3)
+      #   decimal_type.type #=> :decimal
+      #   decimal_type.width #=> 18
+      #   decimal_type.scale #=> 3
+      def create_decimal(width, scale)
+        raise DuckDB::Error, 'width must be between 1 and 38' unless RANGE_DECIMAL_WIDTH.cover?(width)
+        raise DuckDB::Error, "scale must be between 0 and width(#{width})" unless (0..width).cover?(scale)
+
+        _create_decimal_type(width, scale)
+      end
+
       private
 
       def raise_resolve_error(symbol)

data/lib/duckdb/scalar_function.rb

@@ -7,7 +7,8 @@ module DuckDB
   class ScalarFunction
     # Create and configure a scalar function in one call
     #
-    # @param name [String, Symbol] the function name
+    # @param name [String, Symbol, nil] the function name; use +nil+ when creating overloads
+    #   intended for use in a +DuckDB::ScalarFunctionSet+ (the set provides the name)
     # @param return_type [DuckDB::LogicalType|:logical_type_symbol] the return type
     # @param parameter_type [DuckDB::LogicalType|:logical_type_symbol, nil] single fixed parameter type
     # @param parameter_types [Array<DuckDB::LogicalType|:logical_type_symbol>, nil] multiple fixed parameter types
@@ -63,7 +64,7 @@ module DuckDB
     #     null_handling: true
     #   ) { |v| v.nil? ? 0 : v }
     def self.create( # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/ParameterLists
-      name:, return_type:, parameter_type: nil, parameter_types: nil, varargs_type: nil, null_handling: false, &
+      return_type:, name: nil, parameter_type: nil, parameter_types: nil, varargs_type: nil, null_handling: false, &
     )
       raise ArgumentError, 'Block required' unless block_given?
       raise ArgumentError, 'Cannot specify both parameter_type and parameter_types' if parameter_type && parameter_types
@@ -77,7 +78,7 @@ module DuckDB
                end
 
       sf = new
-      sf.name = name.to_s
+      sf.name = name.to_s if name
       sf.return_type = return_type
       params.each { |type| sf.add_parameter(type) }
       sf.varargs_type = varargs_type if varargs_type
@@ -95,7 +96,9 @@ module DuckDB
       date
       double
       float
+      hugeint
       integer
+      interval
       smallint
       time
       timestamp
@@ -106,18 +109,20 @@ module DuckDB
       timestamp_tz
       tinyint
       ubigint
+      uhugeint
       uinteger
       usmallint
       utinyint
+      uuid
       varchar
     ].freeze
 
     private_constant :SUPPORTED_TYPES
 
     # Adds a parameter to the scalar function.
-    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, INTEGER, SMALLINT, TIME, TIMESTAMP,
-    # TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UINTEGER, USMALLINT, UTINYINT,
-    # and VARCHAR types.
+    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, HUGEINT, INTEGER, INTERVAL, SMALLINT, TIME,
+    # TIMESTAMP, TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UHUGEINT,
+    # UINTEGER, USMALLINT, UTINYINT, UUID, and VARCHAR types.
     #
     # @param logical_type [DuckDB::LogicalType | :logical_type_symbol] the parameter type
     # @return [DuckDB::ScalarFunction] self
@@ -129,9 +134,9 @@ module DuckDB
     end
 
     # Sets the return type for the scalar function.
-    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, INTEGER, SMALLINT, TIME, TIMESTAMP,
-    # TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UINTEGER, USMALLINT, UTINYINT,
-    # and VARCHAR types.
+    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, HUGEINT, INTEGER, INTERVAL, SMALLINT, TIME,
+    # TIMESTAMP, TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UHUGEINT,
+    # UINTEGER, USMALLINT, UTINYINT, UUID, and VARCHAR types.
     #
     # @param logical_type [DuckDB::LogicalType | :logical_type_symbol] the return type
     # @return [DuckDB::ScalarFunction] self
@@ -161,9 +166,9 @@ module DuckDB
     # given type. Can be combined with add_parameter to add fixed leading parameters
     # (e.g. a separator followed by a variable list of values).
     # The block receives fixed parameters positionally, then varargs as a splat (|fixed, *rest|).
-    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, INTEGER, SMALLINT, TIME, TIMESTAMP,
-    # TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UINTEGER, USMALLINT, UTINYINT,
-    # and VARCHAR types.
+    # Currently supports BIGINT, BLOB, BOOLEAN, DATE, DOUBLE, FLOAT, HUGEINT, INTEGER, INTERVAL, SMALLINT, TIME,
+    # TIMESTAMP, TIMESTAMP_S, TIMESTAMP_MS, TIMESTAMP_NS, TIME_TZ, TIMESTAMP_TZ, TINYINT, UBIGINT, UHUGEINT,
+    # UINTEGER, USMALLINT, UTINYINT, UUID, and VARCHAR types.
     #
     # @param logical_type [DuckDB::LogicalType | :logical_type_symbol] the varargs element type
     # @return [DuckDB::ScalarFunction] self

data/lib/duckdb/scalar_function_set.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # DuckDB::ScalarFunctionSet encapsulates DuckDB's scalar function set,
+  # which allows registering multiple overloads of a scalar function under one name.
+  #
+  # @note DuckDB::ScalarFunctionSet is experimental.
+  class ScalarFunctionSet
+    # @param name [String, Symbol] the function set name shared by all overloads
+    # @raise [TypeError] if name is not a String or Symbol
+    def initialize(name)
+      raise TypeError, "#{name.class} is not a String or Symbol" unless name.is_a?(String) || name.is_a?(Symbol)
+
+      @name = name.to_s
+      _initialize(@name)
+    end
+
+    # @param scalar_function [DuckDB::ScalarFunction] the overload to add
+    # @return [self]
+    # @raise [TypeError] if scalar_function is not a DuckDB::ScalarFunction
+    # @raise [DuckDB::Error] if the overload already exists in the set
+    def add(scalar_function)
+      unless scalar_function.is_a?(DuckDB::ScalarFunction)
+        raise TypeError, "#{scalar_function.class} is not a DuckDB::ScalarFunction"
+      end
+
+      scalar_function.name = @name
+      _add(scalar_function)
+    end
+  end
+end

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.5.1.0'
+  VERSION = '1.5.1.1'
 end

data/lib/duckdb.rb

@@ -15,6 +15,7 @@ require 'duckdb/config'
 require 'duckdb/column'
 require 'duckdb/logical_type'
 require 'duckdb/scalar_function'
+require 'duckdb/scalar_function_set'
 require 'duckdb/expression'
 require 'duckdb/client_context'
 require 'duckdb/scalar_function/bind_info'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.5.1.0
+  version: 1.5.1.1
 platform: ruby
 authors:
 - Masaki Suketa
@@ -101,6 +101,8 @@ files:
 - ext/duckdb/scalar_function.h
 - ext/duckdb/scalar_function_bind_info.c
 - ext/duckdb/scalar_function_bind_info.h
+- ext/duckdb/scalar_function_set.c
+- ext/duckdb/scalar_function_set.h
 - ext/duckdb/table_function.c
 - ext/duckdb/table_function.h
 - ext/duckdb/table_function_bind_info.c
@@ -139,6 +141,7 @@ files:
 - lib/duckdb/result.rb
 - lib/duckdb/scalar_function.rb
 - lib/duckdb/scalar_function/bind_info.rb
+- lib/duckdb/scalar_function_set.rb
 - lib/duckdb/table_function.rb
 - lib/duckdb/table_function/bind_info.rb
 - lib/duckdb/table_function/function_info.rb