duckdb 1.3.1.0 → 1.4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 979c1ffbe5e1137870bd777377ef16cb7ddde8499d5d9fd14fcd6a5fe401ffda
-  data.tar.gz: 72d970b664aed935c451a95e48818584cf0ecd029ade167bef88235eed62fc6c
+  metadata.gz: 172cad0f5262bd839bcae9bd60455db2ae92c3d2777856a807448749b4982d63
+  data.tar.gz: 7af629371eb57967458add2ad62d88bf22f4c01eb3fc8e07ec67456c9d0edcb0
 SHA512:
-  metadata.gz: cfb967f5ce29966491958e8e0c724716eacb7d36e0692a522b01ebca148e26ae5306cbc9306d64299fec16e79f96967863dad73cdc2c0d77bf4382bacfd25a00
-  data.tar.gz: 9a1edecd631f9b7e891b49afd71eea1baebdf1defc6488222469b6e435ce39510ecfaadcb3329d387500bbf49d87ac3344ac11ffb17ffb257836c6c6007b5811
+  metadata.gz: 92aa3a8b950008ff7327a27f98a76ba8e519d5f7ea1e3120b4d5310dd27bc15a7b330b5893d2a766da3533acf95a1e3b65614e28e9564a22286d8b493988fa9f
+  data.tar.gz: 53660ec068a0a15f6065d67c15323612d13b5e91fc578a81554a8e8728c92888096cf817d2649fc15d4af6bb1045ed9f4bdf2232cb67fd8701a4578c37c34e0a

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.2.7', '3.3.8', '3.4.2', 'head', '3.5.0-preview1']
-        duckdb: ['1.2.2', '1.3.1']
+        ruby: ['3.2.9', '3.3.10', '3.4.7', 'head', '3.5.0-preview1']
+        duckdb: ['1.4.1', '1.3.2']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_ubuntu.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.2.7', '3.3.8', '3.4.2', 'head', '3.5.0-preview1']
-        duckdb: ['1.2.2', '1.3.1']
+        ruby: ['3.2.9', '3.3.10', '3.4.7', 'head', '3.5.0-preview1']
+        duckdb: ['1.4.1', '1.3.2']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_windows.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['3.2.6', '3.3.8', '3.4.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['1.2.2', '1.3.1']
+        ruby: ['3.2.9', '3.3.10', '3.4.7', 'ucrt', 'mingw', 'mswin', 'head']
+        duckdb: ['1.4.1', '1.3.2']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+# Unreleased
+
+# 1.4.1.0 - 2025-11-01
+- add DuckDB::Connection#appender_from_query.
+- add DuckDB::Appender.create_query.
+- add `DuckDB::LogicalType.boolean`, `DuckDB::LogicalType.tinyint`, `DuckDB::LogicalType.smallint`,
+  `DuckDB::LogicalType.integer`, `DuckDB::LogicalType.bigint`, `DuckDB::LogicalType.utinyint`,
+  `DuckDB::LogicalType.usmallint`, `DuckDB::LogicalType.uinteger`, `DuckDB::LogicalType.ubigint`,
+  `DuckDB::LogicalType.float`, `DuckDB::LogicalType.double`, `DuckDB::LogicalType.timestamp`,
+  `DuckDB::LogicalType.date`, `DuckDB::LogicalType.time`, `DuckDB::LogicalType.interval`,
+  `DuckDB::LogicalType.hugeint`, `DuckDB::LogicalType.uhugeint`, `DuckDB::LogicalType.varchar`,
+  `DuckDB::LogicalType.blob`, `DuckDB::LogicalType.timestamp_s`,
+  `DuckDB::LogicalType.timestamp_ms`, `DuckDB::LogicalType.timestamp_ns`,
+  `DuckDB::LogicalType.bit`, `DuckDB::LogicalType.time_tz`, `DuckDB::LogicalType.timestamp_tz`.
+- add `DuckDB::LogicalType::BOOLEAN`, `DuckDB::LogicalType::TINYINT`, `DuckDB::LogicalType::SMALLINT`,
+  `DuckDB::LogicalType::INTEGER`, `DuckDB::LogicalType::BIGINT`, `DuckDB::LogicalType::UTINYINT`,
+  `DuckDB::LogicalType::USMALLINT`, `DuckDB::LogicalType::UINTEGER`, `DuckDB::LogicalType::UBIGINT`,
+  `DuckDB::LogicalType::FLOAT`, `DuckDB::LogicalType::DOUBLE`, `DuckDB::LogicalType::TIMESTAMP`,
+  `DuckDB::LogicalType::DATE`, `DuckDB::LogicalType::TIME`, `DuckDB::LogicalType::INTERVAL`,
+  `DuckDB::LogicalType::HUGEINT`, `DuckDB::LogicalType::UHUGEINT`, `DuckDB::LogicalType::VARCHAR`,
+  `DuckDB::LogicalType::BLOB`, `DuckDB::LogicalType::TIMESTAMP_S`,
+  `DuckDB::LogicalType::TIMESTAMP_MS`, `DuckDB::LogicalType::TIMESTAMP_NS`,
+  `DuckDB::LogicalType::BIT`, `DuckDB::LogicalType::TIME_TZ`, `DuckDB::LogicalType::TIMESTAMP_TZ`.
+- Support TIMESTAMP_NS infinity, -infinity value.
+- bump duckdb to 1.3.2, 1.4.1 on CI.
+- add `DuckDB::ValueImpl` class. This class is under construction. You must not use this class directly.
+- add `DuckDB::ScalarFunction` class. This class is under construction.
+- add `DuckDB::ScalarFunction#set_name`.
+- add `DuckDB::LogicalType.new(type_id)` to create a logical type from a type ID.
+
 # 1.3.1.0 - 2025-06-28
 - Support TIMESTAMP_S, TIMESTAMP_MS infinity, -infinity value.
 - bump duckdb to 1.3.1 on CI.

data/Gemfile.lock

@@ -1,31 +1,31 @@
 PATH
   remote: .
   specs:
-    duckdb (1.3.1.0)
+    duckdb (1.4.1.0)
       bigdecimal (>= 3.1.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.14.0)
-    bigdecimal (3.2.2)
+    bigdecimal (3.3.1)
     mini_portile2 (2.8.9)
-    minitest (5.25.5)
-    nokogiri (1.18.8)
+    minitest (5.26.0)
+    nokogiri (1.18.10)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.18.8-aarch64-linux-gnu)
+    nokogiri (1.18.10-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.8-arm-linux-gnu)
+    nokogiri (1.18.10-arm-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.8-arm64-darwin)
+    nokogiri (1.18.10-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.8-x86_64-darwin)
+    nokogiri (1.18.10-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.8-x86_64-linux-gnu)
+    nokogiri (1.18.10-x86_64-linux-gnu)
       racc (~> 1.4)
     racc (1.8.1)
-    rake (13.3.0)
+    rake (13.3.1)
     rake-compiler (1.3.0)
       rake
     ruby_memcheck (3.0.1)

data/duckdb.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/duckdb/extconf.rb']
-  spec.required_ruby_version = '>= 3.1.0'
+  spec.required_ruby_version = '>= 3.2.0'
   spec.add_dependency 'bigdecimal', '>= 3.1.4'
 
   spec.add_development_dependency 'bundler', '~> 2.3'

data/ext/duckdb/appender.c

@@ -5,6 +5,11 @@ static VALUE cDuckDBAppender;
 static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
+
+#ifdef HAVE_DUCKDB_H_GE_V1_4_0
+static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE types, VALUE table, VALUE columns);
+#endif
+
 static VALUE appender_initialize(VALUE klass, VALUE con, VALUE schema, VALUE table);
 static VALUE appender_error_message(VALUE self);
 static VALUE appender__append_bool(VALUE self, VALUE val);
@@ -56,6 +61,69 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBAppender);
 }
 
+#ifdef HAVE_DUCKDB_H_GE_V1_4_0
+/* call-seq:
+ *   DuckDB::Appender.create_query -> DuckDB::Appender
+ *
+ * Returns a new Appender instance created from a query.
+ *
+ *   require 'duckdb'
+ *   db = DuckDB::Database.open
+ *   con = db.connect
+ *   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+ *   query = 'INSERT OR REPLACE INTO users SELECT i, val FROM my_appended_data'
+ *   types = [DuckDB::LogicalType::INTEGER, DuckDB::LogicalType::VARCHAR]
+ *   appender = DuckDB::Appender.create_query(con, query, types, 'my_appended_data', %w[i val])
+ */
+static VALUE appender_s_create_query(VALUE klass, VALUE con, VALUE query, VALUE types, VALUE table, VALUE columns) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAppender *ctx;
+    char *query_str = StringValuePtr(query);
+    char *table_name = NULL;
+    const char **column_names = NULL;
+    idx_t column_count = 0;
+    duckdb_logical_type *type_array = NULL;
+    VALUE appender = Qnil;
+
+    if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
+        rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
+    }
+    if (rb_obj_is_kind_of(types, rb_cArray) == Qfalse) {
+        rb_raise(rb_eTypeError, "2nd argument should be an Array");
+    }
+    column_count = RARRAY_LEN(types);
+    type_array = ALLOCA_N(duckdb_logical_type, (size_t)column_count);
+    for (idx_t i = 0; i < column_count; i++) {
+        VALUE type_val = rb_ary_entry(types, i);
+        rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(type_val);
+        type_array[i] = type_ctx->logical_type;
+    }
+
+    if (table != Qnil) {
+        table_name = StringValuePtr(table);
+    }
+    if (columns != Qnil) {
+        if (rb_obj_is_kind_of(columns, rb_cArray) == Qfalse) {
+            rb_raise(rb_eTypeError, "4th argument should be an Array or nil");
+        }
+        idx_t col_count = RARRAY_LEN(columns);
+        column_names = ALLOCA_N(const char *, (size_t)col_count);
+        for (idx_t i = 0; i < col_count; i++) {
+            VALUE col_name_val = rb_ary_entry(columns, i);
+            column_names[i] = StringValuePtr(col_name_val);
+        }
+    }
+    ctxcon = get_struct_connection(con);
+    appender = allocate(klass);
+    TypedData_Get_Struct(appender, rubyDuckDBAppender, &appender_data_type, ctx);
+    if (duckdb_appender_create_query(ctxcon->con, query_str, column_count, type_array, table_name, column_names, &ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create appender from query");
+    }
+
+    return appender;
+}
+#endif
+
 static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE table) {
 
     rubyDuckDBConnection *ctxcon;
@@ -93,14 +161,27 @@ static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE tabl
  */
 static VALUE appender_error_message(VALUE self) {
     rubyDuckDBAppender *ctx;
-    const char *msg;
+#ifdef HAVE_DUCKDB_H_GE_V1_4_0
+    duckdb_error_data error_data;
+#endif
+    const char *msg = NULL;
+    VALUE rb_msg = Qnil;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
+#ifdef HAVE_DUCKDB_H_GE_V1_4_0
+    error_data = duckdb_appender_error_data(ctx->appender);
+    if (duckdb_error_data_has_error(error_data)) {
+        msg = duckdb_error_data_message(error_data);
+        rb_msg = rb_str_new2(msg);
+    }
+    duckdb_destroy_error_data(&error_data);
+#else
     msg = duckdb_appender_error(ctx->appender);
-    if (msg == NULL) {
-        return Qnil;
+    if (msg != NULL) {
+        rb_msg = rb_str_new2(msg);
     }
-    return rb_str_new2(msg);
+#endif
+    return rb_msg;
 }
 
 /* :nodoc: */
@@ -376,6 +457,9 @@ void rbduckdb_init_duckdb_appender(void) {
 #endif
     cDuckDBAppender = rb_define_class_under(mDuckDB, "Appender", rb_cObject);
     rb_define_alloc_func(cDuckDBAppender, allocate);
+#ifdef HAVE_DUCKDB_H_GE_V1_4_0
+    rb_define_singleton_method(cDuckDBAppender, "create_query", appender_s_create_query, 5);
+#endif
     rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
     rb_define_method(cDuckDBAppender, "error_message", appender_error_message, 0);
     rb_define_private_method(cDuckDBAppender, "_end_row", appender__end_row, 0);

data/ext/duckdb/database.c

@@ -6,6 +6,7 @@ static void close_database(rubyDuckDB *p);
 static void deallocate(void * ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
+static duckdb_config create_config_with_ruby_api(void);
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase);
 static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase);
 static VALUE duckdb_database_connect(VALUE self);
@@ -43,10 +44,27 @@ rubyDuckDB *rbduckdb_get_struct_database(VALUE obj) {
     return ctx;
 }
 
+static duckdb_config create_config_with_ruby_api(void) {
+    duckdb_config config;
+
+    if (duckdb_create_config(&config) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create config");
+    }
+
+    if (duckdb_set_config(config, "duckdb_api", "ruby") == DuckDBError) {
+        duckdb_destroy_config(&config);
+        rb_raise(eDuckDBError, "failed to set duckdb_api config");
+    }
+
+    return config;
+}
+
 /* :nodoc: */
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
+    duckdb_config config;
+    char *perror = NULL;
 
     char *pfile = NULL;
     VALUE file = Qnil;
@@ -59,9 +77,19 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
 
     obj = allocate(cDuckDBDatabase);
     TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
-    if (duckdb_open(pfile, &(ctx->db)) == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
+
+    config = create_config_with_ruby_api();
+
+    if (duckdb_open_ext(pfile, &(ctx->db), config, &perror) == DuckDBError) {
+        VALUE error_msg = rb_str_new_cstr(perror ? perror : "Unknown error");
+        if (perror) {
+            duckdb_free(perror);
+        }
+        duckdb_destroy_config(&config);
+        rb_raise(eDuckDBError, "failed to open database: %s", StringValueCStr(error_msg));
     }
+
+    duckdb_destroy_config(&config);
     return obj;
 }
 
@@ -70,7 +98,9 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
     rubyDuckDB *ctx;
     VALUE obj;
     rubyDuckDBConfig *ctx_config;
-    char *perror;
+    duckdb_config config_to_use;
+    char *perror = NULL;
+    int need_destroy_config = 0;
 
     char *pfile = NULL;
     VALUE file = Qnil;
@@ -84,19 +114,37 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
 
     obj = allocate(cDuckDBDatabase);
     TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
+
     if (!NIL_P(config)) {
         if (!rb_obj_is_kind_of(config, cDuckDBConfig)) {
             rb_raise(rb_eTypeError, "The second argument must be DuckDB::Config object.");
         }
         ctx_config = get_struct_config(config);
-        if (duckdb_open_ext(pfile, &(ctx->db), ctx_config->config, &perror) == DuckDBError) {
-            rb_raise(eDuckDBError, "Failed to open database %s", perror);
+        /* Set duckdb_api to "ruby" for the provided config */
+        if (duckdb_set_config(ctx_config->config, "duckdb_api", "ruby") == DuckDBError) {
+            rb_raise(eDuckDBError, "failed to set duckdb_api config");
         }
+        config_to_use = ctx_config->config;
     } else {
-        if (duckdb_open(pfile, &(ctx->db)) == DuckDBError) {
-            rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
+        config_to_use = create_config_with_ruby_api();
+        need_destroy_config = 1;
+    }
+
+    if (duckdb_open_ext(pfile, &(ctx->db), config_to_use, &perror) == DuckDBError) {
+        VALUE error_msg = rb_str_new_cstr(perror ? perror : "Unknown error");
+        if (perror) {
+            duckdb_free(perror);
         }
+        if (need_destroy_config) {
+            duckdb_destroy_config(&config_to_use);
+        }
+        rb_raise(eDuckDBError, "failed to open database: %s", StringValueCStr(error_msg));
+    }
+
+    if (need_destroy_config) {
+        duckdb_destroy_config(&config_to_use);
     }
+
     return obj;
 }
 

data/ext/duckdb/duckdb.c

@@ -40,4 +40,6 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_converter();
     rbduckdb_init_duckdb_extracted_statements();
     rbduckdb_init_duckdb_instance_cache();
+    rbduckdb_init_duckdb_value_impl();
+    rbduckdb_init_duckdb_scalar_function();
 }

data/ext/duckdb/extconf.rb

@@ -64,6 +64,9 @@ have_func('duckdb_create_instance_cache', 'duckdb.h')
 # check duckdb >= 1.3.0
 have_func('duckdb_get_table_names', 'duckdb.h')
 
+# check duckdb >= 1.4.0
+have_func('duckdb_appender_create_query', 'duckdb.h')
+
 $CFLAGS << ' -DDUCKDB_API_NO_DEPRECATED' if ENV['DUCKDB_API_NO_DEPRECATED']
 
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/logical_type.c

@@ -23,6 +23,7 @@ static VALUE duckdb_logical_type_dictionary_size(VALUE self);
 static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx);
 static VALUE duckdb_logical_type__get_alias(VALUE self);
 static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
+static VALUE initialize(VALUE self, VALUE type_id_arg);
 
 static const rb_data_type_t logical_type_data_type = {
     "DuckDB/LogicalType",
@@ -40,6 +41,12 @@ static void deallocate(void *ctx) {
     xfree(p);
 }
 
+rubyDuckDBLogicalType *get_struct_logical_type(VALUE obj) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return ctx;
+}
+
 static VALUE allocate(VALUE klass) {
     rubyDuckDBLogicalType *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBLogicalType));
     return TypedData_Wrap_Struct(klass, &logical_type_data_type, ctx);
@@ -49,6 +56,31 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBLogicalType);
 }
 
+static VALUE initialize(VALUE self, VALUE type_id_arg) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_type type = (duckdb_type)NUM2INT(type_id_arg);
+    duckdb_logical_type new_logical_type;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    if (ctx->logical_type) {
+        duckdb_destroy_logical_type(&(ctx->logical_type));
+    }
+
+    new_logical_type = duckdb_create_logical_type(type);
+
+    if (!new_logical_type || duckdb_get_type_id(new_logical_type) == DUCKDB_TYPE_INVALID) {
+        if (new_logical_type) {
+            duckdb_destroy_logical_type(&new_logical_type);
+        }
+        rb_raise(rb_eArgError, "Invalid or unsupported logical type ID: %d", type);
+    }
+
+    ctx->logical_type = new_logical_type;
+
+    return self;
+}
+
 /*
  *  call-seq:
  *    decimal_col.logical_type.type -> Symbol
@@ -439,4 +471,6 @@ void rbduckdb_init_duckdb_logical_type(void) {
     rb_define_method(cDuckDBLogicalType, "dictionary_value_at", duckdb_logical_type_dictionary_value_at, 1);
     rb_define_method(cDuckDBLogicalType, "get_alias", duckdb_logical_type__get_alias, 0);
     rb_define_method(cDuckDBLogicalType, "set_alias", duckdb_logical_type__set_alias, 1);
+
+    rb_define_method(cDuckDBLogicalType, "initialize", initialize, 1);
 }

data/ext/duckdb/logical_type.h

@@ -9,5 +9,5 @@ typedef struct _rubyDuckDBLogicalType rubyDuckDBLogicalType;
 
 void rbduckdb_init_duckdb_logical_type(void);
 VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type);
-
+rubyDuckDBLogicalType *get_struct_logical_type(VALUE obj);
 #endif

data/ext/duckdb/result.c

@@ -50,6 +50,7 @@ static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row
 static VALUE infinite_timestamp_value(duckdb_timestamp timestamp);
 static VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s);
 static VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms);
+static VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns);
 
 static VALUE vector_timestamp_s(void* vector_data, idx_t row_idx);
 static VALUE vector_timestamp_ms(void* vector_data, idx_t row_idx);
@@ -474,10 +475,23 @@ static VALUE vector_timestamp_ms(void* vector_data, idx_t row_idx) {
                       );
 }
 
+static VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
+    if (duckdb_is_finite_timestamp_ns(timestamp_ns) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp_ns.nanos)
+                         );
+    }
+    return Qnil;
+}
+
 static VALUE vector_timestamp_ns(void* vector_data, idx_t row_idx) {
-    duckdb_timestamp data = ((duckdb_timestamp *)vector_data)[row_idx];
+    duckdb_timestamp_ns data = ((duckdb_timestamp_ns *)vector_data)[row_idx];
+    VALUE obj = infinite_timestamp_ns_value(data);
+    if (obj != Qnil) {
+        return obj;
+    }
     return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ns, 1,
-                      LL2NUM(data.micros)
+                      LL2NUM(data.nanos)
                       );
 }
 

data/ext/duckdb/ruby-duckdb.h

@@ -12,6 +12,10 @@
 #define HAVE_DUCKDB_H_GE_V1_3_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_APPENDER_CREATE_QUERY
+#define HAVE_DUCKDB_H_GE_V1_4_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
@@ -28,6 +32,8 @@
 #include "./appender.h"
 #include "./config.h"
 #include "./instance_cache.h"
+#include "./value_impl.h"
+#include "./scalar_function.h"
 
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
@@ -40,5 +46,7 @@ extern VALUE cDuckDBPreparedStatement;
 extern VALUE PositiveInfinity;
 extern VALUE NegativeInfinity;
 extern VALUE cDuckDBInstanceCache;
+extern VALUE cDuckDBValueImpl;
+extern VALUE cDuckDBScalarFunction;
 
 #endif

data/ext/duckdb/scalar_function.c

@@ -0,0 +1,57 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBScalarFunction;
+
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_scalar_function_initialize(VALUE self);
+static VALUE rbduckdb_scalar_function_set_name(VALUE self, VALUE name);
+
+static const rb_data_type_t scalar_function_data_type = {
+    "DuckDB/ScalarFunction",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void * ctx) {
+    rubyDuckDBScalarFunction *p = (rubyDuckDBScalarFunction *)ctx;
+    duckdb_destroy_scalar_function(&(p->scalar_function));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBScalarFunction *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBScalarFunction));
+    return TypedData_Wrap_Struct(klass, &scalar_function_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBScalarFunction);
+}
+
+static VALUE duckdb_scalar_function_initialize(VALUE self) {
+    rubyDuckDBScalarFunction *p;
+    TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
+    p->scalar_function = duckdb_create_scalar_function();
+    return self;
+}
+
+static VALUE rbduckdb_scalar_function_set_name(VALUE self, VALUE name) {
+    rubyDuckDBScalarFunction *p;
+    TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
+
+    const char *str = StringValuePtr(name);
+    duckdb_scalar_function_set_name(p->scalar_function, str);
+
+    return self;
+}
+
+void rbduckdb_init_duckdb_scalar_function(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBScalarFunction = rb_define_class_under(mDuckDB, "ScalarFunction", rb_cObject);
+    rb_define_alloc_func(cDuckDBScalarFunction, allocate);
+    rb_define_method(cDuckDBScalarFunction, "initialize", duckdb_scalar_function_initialize, 0);
+    rb_define_method(cDuckDBScalarFunction, "set_name", rbduckdb_scalar_function_set_name, 1);
+}

data/ext/duckdb/scalar_function.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_DUCKDB_SCALAR_FUNCTION_H
+#define RUBY_DUCKDB_SCALAR_FUNCTION_H
+
+struct _rubyDuckDBScalarFunction {
+    duckdb_scalar_function scalar_function;
+};
+
+typedef struct _rubyDuckDBScalarFunction rubyDuckDBScalarFunction;
+
+void rbduckdb_init_duckdb_scalar_function(void);
+
+#endif
+
+

data/ext/duckdb/value_impl.c

@@ -0,0 +1,38 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBValueImpl;
+
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+
+static const rb_data_type_t value_impl_data_type = {
+    "DuckDB/ValueImpl",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void * ctx) {
+    rubyDuckDBValueImpl *p = (rubyDuckDBValueImpl *)ctx;
+
+    duckdb_destroy_value(&(p->value));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBValueImpl *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBValueImpl));
+    return TypedData_Wrap_Struct(klass, &value_impl_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBValueImpl);
+}
+
+void rbduckdb_init_duckdb_value_impl(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBValueImpl = rb_define_class_under(mDuckDB, "ValueImpl", rb_cObject);
+    rb_define_alloc_func(cDuckDBValueImpl, allocate);
+}
+

data/ext/duckdb/value_impl.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_VALUE_IMPL_H
+#define RUBY_DUCKDB_VALUE_IMPL_H
+
+struct _rubyDuckDBValueImpl {
+    duckdb_value value;
+};
+
+typedef struct _rubyDuckDBValueImpl rubyDuckDBValueImpl;
+
+void rbduckdb_init_duckdb_value_impl(void);
+
+#endif
+

data/getduckdb.sh

@@ -3,8 +3,16 @@
 MACHINE=`uname -m`
 
 case "$MACHINE" in
-  "x86_64" ) ARC=amd64 ;;
-  "aarch64" ) ARC=aarch64 ;;
+  "x86_64")
+    ARCH=amd64
+    ;;
+  "aarch64")
+    if printf '%s\n' '1.3.0' "$DUCKDB_VERSION" | sort -C -V; then
+      ARCH=arm64
+    else
+      ARCH=aarch64
+    fi
+    ;;
 esac
 
-wget -O duckdb.zip "https://github.com/duckdb/duckdb/releases/download/v$DUCKDB_VERSION/libduckdb-linux-$ARC.zip"
+wget -O duckdb.zip "https://github.com/duckdb/duckdb/releases/download/v$DUCKDB_VERSION/libduckdb-linux-$ARCH.zip"

data/lib/duckdb/appender.rb

@@ -23,6 +23,10 @@ module DuckDB
     private_constant :RANGE_INT16, :RANGE_INT32, :RANGE_INT64
     # :startdoc:
 
+    class << self
+      alias from_query create_query if DuckDB::Appender.respond_to?(:create_query)
+    end
+
     # :call-seq:
     #   appender.begin_row -> self
     # A nop method, provided for backwards compatibility reasons.

data/lib/duckdb/connection.rb

@@ -136,6 +136,28 @@ module DuckDB
       appender.close
     end
 
+    if Appender.respond_to?(:create_query)
+      # :call-seq:
+      #   connection.appender_from_query(query, types, table_name = nil, column_names = nil) -> DuckDB::Appender
+      #
+      # Creates an appender object that executes the given query with any data appended to it.
+      # The `table_name` parameter is used to refer to the appended data in the query. If omitted, it defaults to "appended_data".
+      # The `column_names` parameter provides names for the columns of the appended data. If omitted, it defaults to "col1", "col2", etc.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE t (i INT PRIMARY KEY, value VARCHAR)')
+      #   query = 'INSERT OR REPLACE INTO t SELECT i, val FROM my_appended_data'
+      #   types = [DuckDB::LogicalType::INTEGER, DuckDB::LogicalType::VARCHAR]
+      #   appender = con.appender_from_query(query, types, 'my_appended_data', %w[i val])
+      #   appender.append_row(1, 'hello world')
+      #   appender.close
+      def appender_from_query(query, types, table_name = nil, column_names = nil)
+        Appender.create_query(self, query, types, table_name, column_names)
+      end
+    end
+
     private
 
     def create_appender(table)

data/lib/duckdb/converter/int_to_sym.rb

@@ -68,7 +68,11 @@ module DuckDB
         28 => :union,
         29 => :bit,
         30 => :time_tz,
-        31 => :timestamp_tz
+        31 => :timestamp_tz,
+        35 => :bignum,
+        36 => :sqlnull,
+        37 => :string_literal,
+        38 => :integer_literal
       }.freeze
 
       module_function

data/lib/duckdb/logical_type.rb

@@ -5,6 +5,55 @@ module DuckDB
     alias :alias get_alias
     alias :alias= set_alias
 
+    @logical_types = {}
+
+    {
+      boolean: 1,
+      tinyint: 2,
+      smallint: 3,
+      integer: 4,
+      bigint: 5,
+      utinyint: 6,
+      usmallint: 7,
+      uinteger: 8,
+      ubigint: 9,
+      float: 10,
+      double: 11,
+      timestamp: 12,
+      date: 13,
+      time: 14,
+      interval: 15,
+      hugeint: 16,
+      uhugeint: 32,
+      varchar: 17,
+      blob: 18,
+      # decimal: 19,
+      timestamp_s: 20,
+      timestamp_ms: 21,
+      timestamp_ns: 22,
+      # enum: 23,
+      # list: 24,
+      # struct: 25,
+      # map: 26,
+      # array: 33,
+      # uuid: 27,
+      # union: 28,
+      bit: 29,
+      time_tz: 30,
+      timestamp_tz: 31,
+      any: 34,
+      bignum: 35,
+      sqlnull: 36,
+      string_literal: 37,
+      integer_literal: 38
+      # time_ns: 39
+    }.each do |method_name, type_id|
+      define_singleton_method(method_name) do
+        @logical_types[type_id] ||= DuckDB::LogicalType.new(type_id)
+      end
+      const_set(method_name.upcase, send(method_name))
+    end
+
     # returns logical type's type symbol
     # `:unknown` means that the logical type's type is unknown/unsupported by ruby-duckdb.
     # `:invalid` means that the logical type's type is invalid in duckdb.

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.3.1.0'
+  VERSION = '1.4.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.3.1.0
+  version: 1.4.1.0
 platform: ruby
 authors:
 - Masaki Suketa
@@ -143,8 +143,12 @@ files:
 - ext/duckdb/result.c
 - ext/duckdb/result.h
 - ext/duckdb/ruby-duckdb.h
+- ext/duckdb/scalar_function.c
+- ext/duckdb/scalar_function.h
 - ext/duckdb/util.c
 - ext/duckdb/util.h
+- ext/duckdb/value_impl.c
+- ext/duckdb/value_impl.h
 - getduckdb.sh
 - lib/duckdb.rb
 - lib/duckdb/appender.rb
@@ -181,14 +185,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.
 test_files: []