duckdb 1.1.1.0 → 1.1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84935b6317fa4bef4b62197645f061b179e3358e93cba3b976672eb1988715fc
-  data.tar.gz: 7ff6b2f4b46ea16bcfa2e7de486e9a5bb30aa7d4dccb14e32af7b9886d6fcac4
+  metadata.gz: f326104e9d96a1fce6a508d481101c37eca2b12a421eb2ddb07acb838f14c118
+  data.tar.gz: 999db21104bb772564ecb41bbc2fee06d728f65618bb8538d14bc20c22173424
 SHA512:
-  metadata.gz: d90dbdbf57d5cc282049f6297d00674ff57d9fafbfd7bfab8db8c87fb1153d3c9ea93ceda3b440d066c24ceef5dd1e349dedea6f4b17557bda590bb92f93fc5a
-  data.tar.gz: cbcbd5c50c6ddc92c01001b36cbe5aad8a87729ea5518a881dcf8c21621679d1c3740c0ed97672d597aca351ea09548d6f7b5e722fde32077cb811a57c3dfd40
+  metadata.gz: 6cb7f30f39a2b768d1d6441e324f2c86f910f7af2cff9ca403b91eeb13cacbc0bee56dc54d3786f58e27af9276ae91d4a2ce22c705727b0c8ef5cd3251ab83fe
+  data.tar.gz: f17ea13a5aca9640e17e8983a37f9ba88e6ace381d5ad7e979232b0158028b92aa07ddea758ffdd9868511fb2b868354f7f15c20d6c14fb4f2e537613f8ee670

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-preview1', 'head']
-        duckdb: ['1.1.1', '1.1.0', '1.0.0']
+        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']
 
     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-preview1', 'head']
-        duckdb: ['1.1.1', '1.1.0', '1.0.0']
+        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']
 
     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.1', '1.1.0', '1.0.0']
+        duckdb: ['1.1.2', '1.1.1', '1.0.0']
 
     steps:
     - uses: actions/checkout@v4

data/.gitignore

@@ -15,3 +15,4 @@
 *.obj
 *.so
 Makefile
+ng_test

data/CHANGELOG.md

@@ -3,8 +3,29 @@
 All notable changes to this project will be documented in this file.
 # Unreleased
 
+# 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`.
+- `DuckDB::Connection#query`, `DuckDB::Connection#async_query`, `DuckDB::Connection#async_query_stream` call
+  `DuckDB::PreparedStatement#destroy` to free the prepared statement immediately (#775, #781).
+
 # 1.1.1.0 - 2024-10-06
-- bump duckdb 1.1.1.
+- bump duckdb to 1.1.1.
 ## Breaking changes
 - drop duckdb v0.10.x.
 

data/CONTRIBUTION.md

@@ -14,7 +14,7 @@ docker compose run --rm ubuntu bash
 
 In case you want custom ruby or duckdb versions, use `--build-arg` options
 ```
-docker-compose build ubuntu --build-arg RUBY_VERSION=3.1.3 --build-arg DUCKDB_VERSION=0.6.0
+docker compose build ubuntu --build-arg RUBY_VERSION=3.1.3 --build-arg DUCKDB_VERSION=1.0.0
 ```
 
 ### Without docker

data/Dockerfile

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

data/Gemfile

@@ -1,4 +1,4 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in duckdb.gemspec
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.1.1.0)
+    duckdb (1.1.2.1)
       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;
 
@@ -85,10 +96,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

@@ -2,12 +2,14 @@
 
 VALUE cDuckDBPreparedStatement;
 
+static void destroy_prepared_statement(rubyDuckDBPreparedStatement *p);
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query);
 static VALUE duckdb_prepared_statement_nparams(VALUE self);
 static VALUE duckdb_prepared_statement_execute(VALUE self);
+static VALUE duckdb_prepared_statement_destroy(VALUE self);
 static idx_t check_index(VALUE vidx);
 
 static VALUE duckdb_prepared_statement_bind_parameter_index(VALUE self, VALUE name);
@@ -30,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",
@@ -37,10 +40,17 @@ static const rb_data_type_t prepared_statement_data_type = {
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+static void destroy_prepared_statement(rubyDuckDBPreparedStatement *p) {
+    if (p->prepared_statement) {
+        duckdb_destroy_prepare(&(p->prepared_statement));
+    }
+}
+
 static void deallocate(void *ctx) {
     rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
 
-    duckdb_destroy_prepare(&(p->prepared_statement));
+    destroy_prepared_statement(p);
+    // duckdb_destroy_prepare(&(p->prepared_statement));
     xfree(p);
 }
 
@@ -62,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;
 }
@@ -91,20 +101,37 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     return ULL2NUM(duckdb_nparams(ctx->prepared_statement));
 }
 
-
 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;
 }
 
+/*
+ * :nodoc:
+ */
+static VALUE duckdb_prepared_statement_destroy(VALUE self) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    destroy_prepared_statement(ctx);
+    /*
+    ctx->prepared_statement = NULL;
+    */
+    return Qnil;
+}
+
 static idx_t check_index(VALUE vidx) {
     idx_t idx = NUM2ULL(vidx);
     if (idx <= 0) {
@@ -378,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);
@@ -391,6 +438,7 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
 
     rb_define_method(cDuckDBPreparedStatement, "initialize", duckdb_prepared_statement_initialize, 2);
     rb_define_method(cDuckDBPreparedStatement, "execute", duckdb_prepared_statement_execute, 0);
+    rb_define_method(cDuckDBPreparedStatement, "destroy", duckdb_prepared_statement_destroy, 0);
     rb_define_method(cDuckDBPreparedStatement, "nparams", duckdb_prepared_statement_nparams, 0);
     rb_define_method(cDuckDBPreparedStatement, "bind_parameter_index", duckdb_prepared_statement_bind_parameter_index, 1);
     rb_define_method(cDuckDBPreparedStatement, "parameter_name", duckdb_prepared_statement_parameter_name, 1);
@@ -412,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,11 +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
+      stmts&.destroy
     end
 
     #
@@ -50,9 +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
+      prepare(sql) do |stmt|
+        stmt.bind_args(*args, **kwargs)
+        stmt.pending_prepared
+      end
     end
 
     #
@@ -73,9 +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
+      prepare(sql) do |stmt|
+        stmt.bind_args(*args, **kwargs)
+        stmt.pending_prepared_stream
+      end
     end
 
     #
@@ -96,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')
@@ -105,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/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

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.1.0'
+  VERSION = '1.1.2.1'
 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.1.0
+  version: 1.1.2.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-06 00:00:00.000000000 Z
+date: 2024-11-04 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