duckdb 1.1.2.0 → 1.1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b6ad88562489a943d5ed0a4fcf56c4f84c9c3aa1a9f28d6d1fc6431c3fcea0b
-  data.tar.gz: ac3047cf0098642db942d3547d1e8069fdb53ac0c8eb7f757a0f15c31465b895
+  metadata.gz: 5d9c9c9844335a39c1c154534cb50c031f872679c98eb5434a9d664805091c96
+  data.tar.gz: ca48e19a321441194515ad781ebcedb5010bca519e53bdfe9469af6a83add301
 SHA512:
-  metadata.gz: 5614558f8685681f3369dfb4d8e36ead416b7ba1e4b0de48ff5edcc375a99c43bc1c3d996eca1f083d2df0352ced146f1e6d23bff99fa193035c9f996674e63d
-  data.tar.gz: 2ace009816b0dfee961d8db1b0864e512239186ebf7b8b0ffe20a360e0a247a68afd11c4b97993e350f7b2a7f8eb29d4b4b3fcb367b31c575a6163d1d9d333c6
+  metadata.gz: 2fa6587abdac4d639630c0a605704ed76ff5f3373dcf56f83355dcc999913689e6628db690b8004ccdfc510ade6440b7ca088d9e9ac3a71e228a68ce2a8b359f
+  data.tar.gz: 1776ead93436933f732ec46c573ef7ef056c2cb86b9d601ac6574cf252c0a9774a3f78b464ddb8fe32deb61d5f626f4e6a379276898d08176a429def29f90a10

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.1.6', '3.2.5', '3.3.5', '3.4.0-preview2', 'head']
-        duckdb: ['1.1.2', '1.1.1', '1.0.0']
+        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.0-preview2', 'head']
+        duckdb: ['1.1.3', '1.1.1', '1.0.0']
 
     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.1.6', '3.2.5', '3.3.5', '3.4.0-preview2', 'head']
-        duckdb: ['1.1.2', '1.1.1', '1.0.0']
+        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.0-preview2', 'head']
+        duckdb: ['1.1.3', '1.1.1', '1.0.0']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_windows.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['3.1.6', '3.2.5', '3.3.5', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['1.1.2', '1.1.1', '1.0.0']
+        duckdb: ['1.1.3', '1.1.1', '1.0.0']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 # Unreleased
 
+# 1.1.3.0 - 2024-11-10
+- add `DuckDB::PreparedStatement#bind_decimal`. (Thanks to @otegami)
+- bump duckdb to 1.1.3.
+
+# 1.1.2.1 - 2024-11-04
+- `DuckDB::Connection#query` accepts multiple SQL statement.
+  - When multiple SQL statements are given, `DuckDB::Connection#query` returns the last statement result.
+  - `DuckDB::Connection#query` does not support multiple SQL statements with bind parameters. If you pass 2 or more argument,
+    `DuckDB::Connection#query` will regard first argument as only one SQL statement and the rest as bind parameters.
+- add `DuckDB::ExtracteStatements#each` method.
+- add `DuckDB::ExtracteStatementsImpl#destroy` method.
+- add `DuckDB::PreparedStatement#prepare`.
+- `DuckDB::Connection#prepared_statement` accepts block and calls `PreparedStatement#destroy` after block executed.
+    ```ruby
+    con.prepared_statement('SELECT * FROM table WHERE id = ?') do |stmt|
+      stmt.bind(1)
+      stmt.execute
+    end
+    ```
 # 1.1.2.0 - 2024-10-20
 - bump duckdb to 1.1.2.
 - add `DuckDB::PreparedStatement#destroy`.

data/Dockerfile

@@ -1,7 +1,7 @@
-ARG RUBY_VERSION=3.3.5
+ARG RUBY_VERSION=3.3.6
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=1.1.2
+ARG DUCKDB_VERSION=1.1.3
 
 RUN apt update -qq && \
     apt install -y build-essential curl git wget

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.1.2.0)
+    duckdb (1.1.3.0)
       bigdecimal (>= 3.1.4)
 
 GEM

data/ext/duckdb/extracted_statements.c

@@ -17,6 +17,7 @@ static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 
 static VALUE duckdb_extracted_statements_initialize(VALUE self, VALUE con, VALUE query);
+static VALUE duckdb_extracted_statements_destroy(VALUE self);
 static VALUE duckdb_extracted_statements_size(VALUE self);
 static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index);
 
@@ -56,12 +57,22 @@ static VALUE duckdb_extracted_statements_initialize(VALUE self, VALUE con, VALUE
 
     if (ctx->num_statements == 0) {
         error = duckdb_extract_statements_error(ctx->extracted_statements);
-        rb_raise(eDuckDBError, "%s", error);
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to extract statements(Database connection closed?).");
     }
 
     return self;
 }
 
+static VALUE duckdb_extracted_statements_destroy(VALUE self) {
+    rubyDuckDBExtractedStatements *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    duckdb_destroy_extracted(&(ctx->extracted_statements));
+
+    return Qnil;
+}
+
 static VALUE duckdb_extracted_statements_size(VALUE self) {
     rubyDuckDBExtractedStatements *ctx;
 
@@ -70,7 +81,6 @@ static VALUE duckdb_extracted_statements_size(VALUE self) {
     return ULL2NUM(ctx->num_statements);
 }
 
-
 static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index) {
     rubyDuckDBConnection *pcon;
     rubyDuckDBExtractedStatements *ctx;
@@ -85,10 +95,11 @@ static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE co
 }
 
 void rbduckdb_init_duckdb_extracted_statements(void) {
-    cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatements", rb_cObject);
+    cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatementsImpl", rb_cObject);
 
     rb_define_alloc_func(cDuckDBExtractedStatements, allocate);
     rb_define_method(cDuckDBExtractedStatements, "initialize", duckdb_extracted_statements_initialize, 2);
+    rb_define_method(cDuckDBExtractedStatements, "destroy", duckdb_extracted_statements_destroy, 0);
     rb_define_method(cDuckDBExtractedStatements, "size", duckdb_extracted_statements_size, 0);
     rb_define_method(cDuckDBExtractedStatements, "prepared_statement", duckdb_extracted_statements_prepared_statement, 2);
 }

data/ext/duckdb/prepared_statement.c

@@ -32,6 +32,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
 static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
+static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale);
 
 static const rb_data_type_t prepared_statement_data_type = {
     "DuckDB/PreparedStatement",
@@ -71,7 +72,7 @@ VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_st
     TypedData_Get_Struct(obj, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_prepare_extracted_statement(con, extracted_statements, index, &(ctx->prepared_statement)) == DuckDBError) {
-        rb_raise(eDuckDBError, "Fail to get DuckDB::PreparedStatement object from ExtractedStatements object");
+        rb_raise(eDuckDBError, "Failed to create DuckDB::PreparedStatement object.");
     }
     return obj;
 }
@@ -104,11 +105,16 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
     VALUE result = rbduckdb_create_result();
+    const char *p = NULL;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
     if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
+        p = duckdb_result_error(&(ctxr->result));
+        if (p == NULL) {
+            p = duckdb_prepare_error(ctx->prepared_statement);
+        }
+        rb_raise(eDuckDBError, "%s", p ? p : "Failed to execute prepared statement.");
     }
     return result;
 }
@@ -399,6 +405,26 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
+static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale) {
+    duckdb_hugeint hugeint;
+    duckdb_decimal decimal;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    hugeint.lower = NUM2ULL(lower);
+    hugeint.upper = NUM2LL(upper);
+    decimal.value = hugeint;
+    decimal.width = (uint8_t)NUM2UINT(width);
+    decimal.scale = (uint8_t)NUM2UINT(scale);
+
+    if (duckdb_bind_decimal(ctx->prepared_statement, idx, decimal) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+
+    return self;
+}
+
 rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
@@ -434,4 +460,5 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", duckdb_prepared_statement__bind_timestamp, 8);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", duckdb_prepared_statement__bind_interval, 4);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_hugeint", duckdb_prepared_statement__bind_hugeint, 3);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_decimal", duckdb_prepared_statement__bind_decimal, 5);
 }

data/lib/duckdb/appender.rb

@@ -74,16 +74,7 @@ module DuckDB
     #   appender.flush
     #
     def append_date(value)
-      date = case value
-             when Date, Time
-               value
-             else
-               begin
-                 Date.parse(value)
-               rescue
-                 raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
-               end
-             end
+      date = to_date(value)
 
       _append_date(date.year, date.month, date.day)
     end
@@ -126,18 +117,7 @@ module DuckDB
     #   appender.flush
     #
     def append_timestamp(value)
-      time = case value
-             when Time
-               value
-             when Date
-               value.to_time
-             else
-               begin
-                 Time.parse(value)
-               rescue
-                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time or Date.")
-               end
-             end
+      time = to_time(value)
 
       _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
     end
@@ -233,5 +213,33 @@ module DuckDB
     def blob?(value)
       value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
     end
+
+    def to_date(value)
+      case value
+      when Date, Time
+        value
+      else
+        begin
+          Date.parse(value)
+        rescue StandardError
+          raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
+        end
+      end
+    end
+
+    def to_time(value)
+      case value
+      when Time
+        value
+      when Date
+        value.to_time
+      else
+        begin
+          Time.parse(value)
+        rescue StandardError
+          raise(ArgumentError, "Cannot parse argument `#{value}` to Time or Date.")
+        end
+      end
+    end
   end
 end

data/lib/duckdb/connection.rb

@@ -26,13 +26,23 @@ module DuckDB
     #   dave = con.query(sql, name: 'Dave', email: 'dave@example.com')
     #
     def query(sql, *args, **kwargs)
-      return query_sql(sql) if args.empty? && kwargs.empty?
+      return query_multi_sql(sql) if args.empty? && kwargs.empty?
 
-      stmt = PreparedStatement.new(self, sql)
-      stmt.bind_args(*args, **kwargs)
-      stmt.execute
+      prepare(sql) do |stmt|
+        stmt.bind_args(*args, **kwargs)
+        stmt.execute
+      end
+    end
+
+    def query_multi_sql(sql)
+      stmts = ExtractedStatements.new(self, sql)
+      result = nil
+      stmts.each do |stmt|
+        result = stmt.execute
+      end
+      result
     ensure
-      stmt&.destroy
+      stmts&.destroy
     end
 
     #
@@ -52,11 +62,10 @@ module DuckDB
     #   result.each.first
     #
     def async_query(sql, *args, **kwargs)
-      stmt = PreparedStatement.new(self, sql)
-      stmt.bind_args(*args, **kwargs)
-      stmt.pending_prepared
-    ensure
-      stmt&.destroy
+      prepare(sql) do |stmt|
+        stmt.bind_args(*args, **kwargs)
+        stmt.pending_prepared
+      end
     end
 
     #
@@ -77,11 +86,10 @@ module DuckDB
     #   result.each.first
     #
     def async_query_stream(sql, *args, **kwargs)
-      stmt = PreparedStatement.new(self, sql)
-      stmt.bind_args(*args, **kwargs)
-      stmt.pending_prepared_stream
-    ensure
-      stmt&.destroy
+      prepare(sql) do |stmt|
+        stmt.bind_args(*args, **kwargs)
+        stmt.pending_prepared_stream
+      end
     end
 
     #
@@ -102,6 +110,8 @@ module DuckDB
     #
     # returns PreparedStatement object.
     # The first argument is SQL string.
+    # If block is given, the block is executed with PreparedStatement object
+    # and the object is cleaned up immediately.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_file')
@@ -111,8 +121,17 @@ module DuckDB
     #   stmt = con.prepared_statement(sql)
     #   stmt.bind_args(name: 'Dave', email: 'dave@example.com')
     #   result = stmt.execute
-    def prepared_statement(str)
-      PreparedStatement.new(self, str)
+    #
+    #   # or
+    #   result = con.prepared_statement(sql) do |stmt|
+    #              stmt.bind_args(name: 'Dave', email: 'dave@example.com')
+    #              stmt.execute
+    #            end
+    #
+    def prepared_statement(str, &)
+      return PreparedStatement.new(self, str) unless block_given?
+
+      PreparedStatement.prepare(self, str, &)
     end
 
     #

data/lib/duckdb/converter.rb

@@ -155,6 +155,19 @@ module DuckDB
       end
     end
 
+    def _parse_deciaml(value)
+      case value
+      when BigDecimal
+        value
+      else
+        begin
+          BigDecimal(value.to_s)
+        rescue StandardError => e
+          raise(ArgumentError, "Cannot parse `#{value.inspect}` to BigDecimal object. #{e.message}")
+        end
+      end
+    end
+
     def _to_query_progress(percentage, rows_processed, total_rows_to_process)
       DuckDB::QueryProgress.new(percentage, rows_processed, total_rows_to_process).freeze
     end
@@ -171,5 +184,12 @@ module DuckDB
         raise(ArgumentError, "The argument `#{value.inspect}` must be Integer.")
       end
     end
+
+    def decimal_to_hugeint(value)
+      integer_value = (value * (10 ** value.scale)).to_i
+      integer_to_hugeint(integer_value)
+    rescue FloatDomainError => e
+      raise(ArgumentError, "The argument `#{value.inspect}` must be converted to Integer. #{e.message}")
+    end
   end
 end

data/lib/duckdb/extracted_statements.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DuckDB
+  class ExtractedStatements < ExtractedStatementsImpl
+    include Enumerable
+
+    def initialize(con, sql)
+      @con = con
+      super(con, sql)
+    end
+
+    def each
+      return to_enum(__method__) { size } unless block_given?
+
+      size.times do |i|
+        yield prepared_statement(@con, i)
+      end
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -22,6 +22,31 @@ module DuckDB
     RANGE_INT32 = -2_147_483_648..2_147_483_647
     RANGE_INT64 = -9_223_372_036_854_775_808..9_223_372_036_854_775_807
 
+    class << self
+      # return DuckDB::PreparedStatement object.
+      # The first argument is DuckDB::Connection object.
+      # The second argument is SQL string.
+      # If block is given, the block is executed and the statement is destroyed.
+      #
+      #  require 'duckdb'
+      #  db = DuckDB::Database.open('duckdb_database')
+      #  con = db.connection
+      #  DuckDB::PreparedStatement.prepare(con, 'SELECT * FROM users WHERE id = ?') do |stmt|
+      #    stmt.bind(1, 1)
+      #    stmt.execute
+      #  end
+      def prepare(con, sql)
+        stmt = new(con, sql)
+        return stmt unless block_given?
+
+        begin
+          yield stmt
+        ensure
+          stmt.destroy
+        end
+      end
+    end
+
     def pending_prepared
       PendingResult.new(self)
     end
@@ -191,6 +216,25 @@ module DuckDB
       _bind_interval(index, value.interval_months, value.interval_days, value.interval_micros)
     end
 
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected BigDecimal value or any value
+    # that can be parsed into a BigDecimal.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT value FROM decimals WHERE decimal = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind_decimal(1, BigDecimal('987654.321'))
+    def bind_decimal(index, value)
+      decimal = _parse_deciaml(value)
+      lower, upper = decimal_to_hugeint(decimal)
+      width = decimal.to_s('F').gsub(/[^0-9]/, '').length
+      _bind_decimal(index, lower, upper, width, decimal.scale)
+    end
+
     # binds i-th parameter with SQL prepared statement.
     # The first argument is index of parameter.
     # The index of first parameter is 1 not 0.
@@ -239,7 +283,7 @@ module DuckDB
       when Date
         bind_varchar(index, value.strftime('%Y-%m-%d'))
       when BigDecimal
-        bind_varchar(index, value.to_s('F'))
+        bind_decimal(index, value)
       else
         raise(DuckDB::Error, "not supported type `#{value}` (#{value.class})")
       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.1.2.0'
+  VERSION = '1.1.3.0'
 end

data/lib/duckdb.rb

@@ -6,6 +6,7 @@ require 'duckdb/version'
 require 'duckdb/converter'
 require 'duckdb/database'
 require 'duckdb/connection'
+require 'duckdb/extracted_statements'
 require 'duckdb/result'
 require 'duckdb/prepared_statement'
 require 'duckdb/pending_result'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.1.2.0
+  version: 1.1.3.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-20 00:00:00.000000000 Z
+date: 2024-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -149,6 +149,7 @@ files:
 - lib/duckdb/converter.rb
 - lib/duckdb/converter/int_to_sym.rb
 - lib/duckdb/database.rb
+- lib/duckdb/extracted_statements.rb
 - lib/duckdb/infinity.rb
 - lib/duckdb/interval.rb
 - lib/duckdb/library_version.rb