duckdb 1.1.2.0 → 1.1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b6ad88562489a943d5ed0a4fcf56c4f84c9c3aa1a9f28d6d1fc6431c3fcea0b
-  data.tar.gz: ac3047cf0098642db942d3547d1e8069fdb53ac0c8eb7f757a0f15c31465b895
+  metadata.gz: f326104e9d96a1fce6a508d481101c37eca2b12a421eb2ddb07acb838f14c118
+  data.tar.gz: 999db21104bb772564ecb41bbc2fee06d728f65618bb8538d14bc20c22173424
 SHA512:
-  metadata.gz: 5614558f8685681f3369dfb4d8e36ead416b7ba1e4b0de48ff5edcc375a99c43bc1c3d996eca1f083d2df0352ced146f1e6d23bff99fa193035c9f996674e63d
-  data.tar.gz: 2ace009816b0dfee961d8db1b0864e512239186ebf7b8b0ffe20a360e0a247a68afd11c4b97993e350f7b2a7f8eb29d4b4b3fcb367b31c575a6163d1d9d333c6
+  metadata.gz: 6cb7f30f39a2b768d1d6441e324f2c86f910f7af2cff9ca403b91eeb13cacbc0bee56dc54d3786f58e27af9276ae91d4a2ce22c705727b0c8ef5cd3251ab83fe
+  data.tar.gz: f17ea13a5aca9640e17e8983a37f9ba88e6ace381d5ad7e979232b0158028b92aa07ddea758ffdd9868511fb2b868354f7f15c20d6c14fb4f2e537613f8ee670

data/CHANGELOG.md

@@ -3,6 +3,21 @@
 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`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.1.2.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

@@ -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/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.2.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.2.0
+  version: 1.1.2.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-20 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