duckdb 1.1.1.0 → 1.1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84935b6317fa4bef4b62197645f061b179e3358e93cba3b976672eb1988715fc
-  data.tar.gz: 7ff6b2f4b46ea16bcfa2e7de486e9a5bb30aa7d4dccb14e32af7b9886d6fcac4
+  metadata.gz: 97d0a0fdf67bcfdd00102540f9dd675e1fe87176e349ef06db6f1c72f78b5219
+  data.tar.gz: da34340b078ae95c6b9fa7ddb872de4be16f3bc298169004761d532a9f378f20
 SHA512:
-  metadata.gz: d90dbdbf57d5cc282049f6297d00674ff57d9fafbfd7bfab8db8c87fb1153d3c9ea93ceda3b440d066c24ceef5dd1e349dedea6f4b17557bda590bb92f93fc5a
-  data.tar.gz: cbcbd5c50c6ddc92c01001b36cbe5aad8a87729ea5518a881dcf8c21621679d1c3740c0ed97672d597aca351ea09548d6f7b5e722fde32077cb811a57c3dfd40
+  metadata.gz: 924d05547e0f9bf6f4772db3a93085930cd48961a0eee92d114815ea8286cd4ad6d1454764ffd97caa0cc6be103a2b084d1f402e98a973dc529b674754b4cfd7
+  data.tar.gz: 022f30d9b659b487f109d91b7d9818a26bb6d0a7fffd62fc8ae0375453688b3981b652fcb00826a826f15503ee119ca73830fe251329d51235d46ffa6c17ff50

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,9 @@ 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.6', '3.3.6', '3.4.0-preview2', 'head']
+        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.0-preview2']
+        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-preview1', 'head']
-        duckdb: ['1.1.1', '1.1.0', '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.1', '1.1.0', '1.0.0']
+        duckdb: ['1.1.3', '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

@@ -2,9 +2,38 @@
 
 All notable changes to this project will be documented in this file.
 # Unreleased
+# 1.1.3.1 - 2024-11-27
+- fix to `DuckDB::Connection#query` with multiple SQL statements. Calling PreparedStatement#destroy after each statement executed.
+- install valgrind in docker development environment.
+- add `DuckDB::Appender#append_default`.
+
+# 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`.
+- `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,21 +1,32 @@
-ARG RUBY_VERSION=3.3.5
+ARG RUBY_VERSION=3.3.6
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=1.1.1
+ARG DUCKDB_VERSION=1.1.3
+ARG VALGRIND_VERSION=3.21.0
 
 RUN apt update -qq && \
-    apt install -y build-essential curl git wget
+    apt install -y build-essential curl git wget libc6-dbg
 
 COPY getduckdb.sh .
 RUN ./getduckdb.sh
 
-RUN unzip duckdb.zip -d libduckdb
-RUN mv libduckdb/duckdb.* /usr/local/include
-RUN mv libduckdb/libduckdb.so /usr/local/lib
-RUN ldconfig /usr/local/lib
+RUN unzip duckdb.zip -d libduckdb && \
+    mv libduckdb/duckdb.* /usr/local/include && \
+    mv libduckdb/libduckdb.so /usr/local/lib && \
+    ldconfig /usr/local/lib
+
+RUN mkdir valgrind-tmp && \
+    cd valgrind-tmp && \
+    wget https://sourceware.org/pub/valgrind/valgrind-${VALGRIND_VERSION}.tar.bz2 && \
+    tar xf valgrind-${VALGRIND_VERSION}.tar.bz2 && \
+    cd valgrind-${VALGRIND_VERSION} && \
+    ./configure && \
+    make -s && \
+    make -s install && \
+    cd .. && \
+    rm -rf /valgrind-tmp
 
 COPY . /root/ruby-duckdb
 WORKDIR /root/ruby-duckdb
 RUN git config --global --add safe.directory /root/ruby-duckdb
-RUN bundle install
-RUN rake build
+RUN bundle install && rake build

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.3.1)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -9,10 +9,16 @@ GEM
   specs:
     benchmark-ips (2.14.0)
     bigdecimal (3.1.8)
-    mini_portile2 (2.8.7)
-    minitest (5.25.1)
-    nokogiri (1.16.7)
-      mini_portile2 (~> 2.8.2)
+    minitest (5.25.2)
+    nokogiri (1.16.7-aarch64-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.7-arm-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.7-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.16.7-x86-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.7-x86_64-darwin)
       racc (~> 1.4)
     nokogiri (1.16.7-x86_64-linux)
       racc (~> 1.4)
@@ -25,7 +31,11 @@ GEM
     stackprof (0.2.26)
 
 PLATFORMS
-  ruby
+  aarch64-linux
+  arm-linux
+  arm64-darwin
+  x86-linux
+  x86_64-darwin
   x86_64-linux
 
 DEPENDENCIES
@@ -39,4 +49,4 @@ DEPENDENCIES
   stackprof
 
 BUNDLED WITH
-   2.5.9
+   2.5.22

data/README.md

@@ -46,7 +46,7 @@ brew install duckdb
 
 Using [Ruby + Devkit](https://rubyinstaller.org/downloads/) is recommended.
 
-1. Download libduckdb-windows-amd64.zip from [DuckDB](https://github.com/duckdb/duckdb/releases) and extranct it.
+1. Download libduckdb-windows-amd64.zip from [DuckDB](https://github.com/duckdb/duckdb/releases) and extract it.
 2. Copy `duckdb.dll` into `C:\Windows\System32`
 
 ## How to install
@@ -115,7 +115,7 @@ con.query('SELECT * FROM users WHERE name = $name AND email = $email', name: 'Al
 ```
 ### Using prepared statement
 
-You can use prepared statement.
+You can use prepared statement. Prepared statement object is created by `Connection#prepare` method or `DuckDB::PreparedStatement.new`.
 
 ```ruby
 stmt = con.prepare('SELECT * FROM users WHERE name = $name AND email = $email')
@@ -125,7 +125,20 @@ stmt = con.prepare('SELECT * FROM users WHERE name = $name AND email = $email')
 # stmt = DuckDB::PreparedStatement.new(con, 'SELECT * FROM users WHERE name = $name AND email = $email')
 stmt.bind(name: 'Alice', email: 'alice@example.com')
 result = stmt.execute
+stmt.destroy
 ```
+You must call `PreparedStatement#destroy` method after using prepared statement. Otherwise, automatically destroyed
+when the PreparedStatement object is garbage collected.
+
+Instead of calling `PreparedStatement#destroy`, you can use block.
+
+```ruby
+result = con.prepare('SELECT * FROM users WHERE name = $name AND email = $email') do |stmt|
+           stmt.bind(name: 'Alice', email: 'alice@example.com')
+           stmt.execute
+         end
+```
+
 ### Using async query
 
 You can use async query.

data/ext/duckdb/appender.c

@@ -23,6 +23,11 @@ static VALUE appender_append_varchar(VALUE self, VALUE val);
 static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
 static VALUE appender_append_blob(VALUE self, VALUE val);
 static VALUE appender_append_null(VALUE self);
+
+#ifdef HAVE_DUCKDB_H_GE_V1_1_0
+static VALUE appender_append_default(VALUE self);
+#endif
+
 static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval);
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros);
 static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros);
@@ -281,6 +286,18 @@ static VALUE appender_append_null(VALUE self) {
     return self;
 }
 
+#ifdef HAVE_DUCKDB_H_GE_V1_1_0
+static VALUE appender_append_default(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+
+    if (duckdb_append_default(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+#endif
+
 static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
     duckdb_date dt;
     rubyDuckDBAppender *ctx;
@@ -406,6 +423,11 @@ void rbduckdb_init_duckdb_appender(void) {
     rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
     rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
     rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
+
+#ifdef HAVE_DUCKDB_H_GE_V1_1_0
+    rb_define_method(cDuckDBAppender, "append_default", appender_append_default, 0);
+#endif
+
     rb_define_private_method(cDuckDBAppender, "_append_date", appender__append_date, 3);
     rb_define_private_method(cDuckDBAppender, "_append_interval", appender__append_interval, 3);
     rb_define_private_method(cDuckDBAppender, "_append_time", appender__append_time, 4);

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

@@ -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,8 @@ 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");
+        const char *error = duckdb_prepare_error(ctx->prepared_statement);
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to create DuckDB::PreparedStatement object.");
     }
     return obj;
 }
@@ -80,7 +91,7 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
         const char *error = duckdb_prepare_error(ctx->prepared_statement);
-        rb_raise(eDuckDBError, "%s", error);
+        rb_raise(eDuckDBError, "%s", error ? error : "Failed to prepare statement(Database connection closed?).");
     }
     return self;
 }
@@ -91,20 +102,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 +406,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 +439,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 +461,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

@@ -8,7 +8,6 @@ module DuckDB
   #   con = db.connect
   #   con.query(sql)
   class Connection
-    #
     # executes sql with args.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
@@ -24,16 +23,27 @@ module DuckDB
     #
     #   sql = 'SELECT * FROM users WHERE name = $name AND email = $email'
     #   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
+        stmt.destroy
+      end
+      result
+    ensure
+      stmts&.destroy
     end
 
-    #
     # executes sql with args asynchronously.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
@@ -48,14 +58,13 @@ module DuckDB
     #   pending_result.execute_task while pending_result.state == :not_ready
     #   result = pending_result.execute_pending
     #   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
 
-    #
     # executes sql with args asynchronously and provides streaming result.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
@@ -71,17 +80,15 @@ module DuckDB
     #   pending_result.execute_task while pending_result.state == :not_ready
     #   result = pending_result.execute_pending
     #   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
 
-    #
     # connects DuckDB database
     # The first argument is DuckDB::Database object
-    #
     def connect(db)
       conn = _connect(db)
       return conn unless block_given?
@@ -93,9 +100,10 @@ module DuckDB
       end
     end
 
-    #
     # 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,14 +113,20 @@ 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
 
-    #
     # returns Appender object.
     # The first argument is table name
-    #
     def appender(table)
       appender = create_appender(table)
 

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/database.rb

@@ -20,13 +20,11 @@ module DuckDB
   #   result.each do |row|
   #     p row
   #   end
-  #
   class Database
     private_class_method :_open
     private_class_method :_open_ext
 
     class << self
-      ##
       # Opens database.
       # The first argument is DuckDB database file path to open.
       # If there is no argument, the method opens DuckDB database in memory.
@@ -40,7 +38,6 @@ module DuckDB
       #     con = db.connect
       #     con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
       #   end
-      #
       def open(dbpath = nil, config = nil)
         db = _db_open(dbpath, config)
         return db unless block_given?
@@ -54,7 +51,7 @@ module DuckDB
 
       private
 
-      def _db_open(dbpath, config)
+      def _db_open(dbpath, config) # :nodoc:
         if config
           _open_ext(dbpath, config)
         else
@@ -63,7 +60,6 @@ module DuckDB
       end
     end
 
-    ##
     # connects database.
     #
     # The method yields block and disconnects the database if block given
@@ -75,7 +71,6 @@ module DuckDB
     #   db.connect do |con|
     #     con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
     #   end
-    #
     def connect
       conn = _connect
       return conn unless block_given?

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/library_version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module DuckDB
+  # represents the version of the DuckDB library.
+  # If DuckDB.library_version is v0.2.0, then DuckDB::LIBRARY_VERSION is 0.2.0.
   LIBRARY_VERSION = library_version[1..]
 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.1.0'
+  VERSION = '1.1.3.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.3.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-06 00:00:00.000000000 Z
+date: 2024-11-27 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
@@ -180,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.