duckdb 0.10.2.0 → 1.0.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d0e4ea548efd175f016a60729dede05c52186b5880f8294be73a478103c779f
-  data.tar.gz: 818ff72b5cf52cf7126a3890f193b89e14543ccfdecb89ab2403b14db06adaa4
+  metadata.gz: ded07680dcaaa7309ed8578e6bd5d0a1e217b0c803f8527679e62e254aaea412
+  data.tar.gz: d2ff3d9a66b1487d867a95129a5c4fff3b4c01ed90198772d2a62b299c88bfca
 SHA512:
-  metadata.gz: 3c3545aca891371ccfaf570cd3a5b8c30be7743a8c34c0a05fce4685807dc9f47982a78d4379294f229e57c799d40521f1d380c21195b91379561b6db44e8069
-  data.tar.gz: 3059228114add85257763c498cf2093b089c4bbf5fb05c21df63de88c6d8384169a55b1a26767ee2b85c204f97116b8e95e71652e220cc9666f7e689c859640c
+  metadata.gz: 253d068a5c17894a482346897f499e06a79ed9741250367e76d306d3828bfdce385379bd091528ae119fa5b1d0c7a83378cb84043477f1d6d21d86d09c00cd88
+  data.tar.gz: 2c554bdd675fea28561ed291dc28e5b660ef85a7d737d6cd69450832aa3af6a84eb94ad6a55a922828841ee9c9f802a4f86734692afd35b3a2bde4c2d6edb7e7

data/.github/workflows/test_on_macos.yml

@@ -15,11 +15,11 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.0.6', '3.1.4', '3.2.3', '3.3.0', 'head']
-        duckdb: ['0.9.2', '0.10.0', '0.10.1', '0.10.2']
+        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.2', '3.4.0-preview1', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
@@ -28,7 +28,7 @@ jobs:
 
     - name: duckdb cache
       id: duckdb-cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: duckdb-v${{ matrix.duckdb }}
         key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
@@ -45,20 +45,18 @@ jobs:
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.dylib duckdb-v$DUCKDB_VERSION/build/release/src
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
-    - name: prepare duckdb header and libraries
+    - name: Build with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
-      run: |
-        cp duckdb-v$DUCKDB_VERSION/src/include/*.h /usr/local/include
-        cp duckdb-v$DUCKDB_VERSION/build/release/src/*.dylib /usr/local/lib
-
-    - name: Build with Ruby ${{ matrix.ruby }}
       run: |
         bundle install --jobs 4 --retry 3
-        rake build
+        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
 
-    - name: run test with Ruby ${{ matrix.ruby }}
+    - name: test with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
+        export DYLD_LIBRARY_PATH=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src:${DYLD_LIBRARY_PATH}
         env RUBYOPT=-W:deprecated rake test
 
   post-test:

data/.github/workflows/test_on_ubuntu.yml

@@ -15,11 +15,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.0.6', '3.1.4', '3.2.3', '3.3.0', 'head']
-        duckdb: ['0.9.2', '0.10.0', '0.10.1', '0.10.2']
+        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.2', '3.4.0-preview1', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
@@ -28,7 +28,7 @@ jobs:
 
     - name: duckdb cache
       id: duckdb-cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: duckdb-v${{ matrix.duckdb }}
         key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}

data/.github/workflows/test_on_windows.yml

@@ -15,11 +15,11 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['3.0.6', '3.1.4', '3.2.2', '3.3.0', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.9.2', '0.10.0', '0.10.1', '0.10.2']
+        ruby: ['3.0.7', '3.1.5', '3.2.4', '3.3.1', 'ucrt', 'mingw', 'mswin', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1

data/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+# 1.0.0.0 - 2024-06-08
+- bump duckdb to 1.0.0.
+- add `DuckDB::ExtractedStatements` class.
+- add `DuckDB::ExtractedStatements#size`.
+- add `DuckDB::ExtractedStatements#prepared_statement`.
+- raise error when `DuckDB::ExtractedStatements#new` is called with invalid SQL.
+- The following public/private methods will be deprecated.
+  - `DuckDB::Result#streaming?`
+  - `DuckDB::Result#_null?`
+  - `DuckDB::Result#_to_boolean`
+  - `DuckDB::Result#_to_smallint`
+  - `DuckDB::Result#_to_utinyint`
+  - `DuckDB::Result#_to_integer`
+  - `DuckDB::Result#_to_bigint`
+  - `DuckDB::Result#_to_hugeint`
+  - `DuckDB::Result#_to_hugeint_internal`
+  - `DuckDB::Result#__to_hugeint_internal`
+  - `DuckDB::Result#_to_decimal`
+  - `DuckDB::Result#_to_decimal_internal`
+  - `DuckDB::Result#__to_decimal_internal`
+  - `DuckDB::Result#_to_float`
+  - `DuckDB::Result#_to_double`
+  - `DuckDB::Result#_to_string`
+  - `DuckDB::Result#_to_string_internal`
+  - `DuckDB::Result#_to_blob`
+  - `DuckDB::Result.use_chunk_each=`
+  - `DuckDB::Result#use_chunk_each?`
+
+## Breaking changes
+- DuckDB::Result.use_chunk_each is true by default.
+  If you want to use the old behavior, set `DuckDB::Result.use_chunk_each = false`.
+  But the old behavior will be removed in the future release.
+
+# 0.10.3.0 - 2024-05-25
+- bump to duckdb v0.10.3.
+
 # 0.10.2.0 - 2024-04-20
 - remove version from docker-compose.yml.
 - bump to duckdb v0.10.2.

data/Dockerfile

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

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    duckdb (0.10.2.0)
+    duckdb (1.0.0.0)
       bigdecimal (>= 3.1.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.13.0)
-    bigdecimal (3.1.7)
-    mini_portile2 (2.8.6)
-    minitest (5.22.3)
-    nokogiri (1.16.4)
+    bigdecimal (3.1.8)
+    mini_portile2 (2.8.7)
+    minitest (5.23.1)
+    nokogiri (1.16.5)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.16.4-x86_64-linux)
+    nokogiri (1.16.5-x86_64-linux)
       racc (~> 1.4)
-    racc (1.7.3)
+    racc (1.8.0)
     rake (13.2.1)
     rake-compiler (1.2.7)
       rake
-    ruby_memcheck (2.3.0)
+    ruby_memcheck (3.0.0)
       nokogiri
     stackprof (0.2.26)
 
@@ -39,4 +39,4 @@ DEPENDENCIES
   stackprof
 
 BUNDLED WITH
-   2.5.3
+   2.5.9

data/README.md

@@ -133,7 +133,7 @@ Here is [the benchmark](./benchmark/async_query.rb).
 
 ### Using BLOB column
 
-Use `DuckDB::Blob.new` or use string#force_encoding(Encoding::BINARY)
+Use `DuckDB::Blob.new` or `my_string.force_encoding(Encoding::BINARY)`.
 
 ```ruby
 require 'duckdb'
@@ -166,6 +166,7 @@ def insert
   DuckDB::Database.open do |db|
     db.connect do |con|
       con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+
       10000.times do
         con.query("INSERT into users VALUES(1, 'Alice')")
       end
@@ -178,6 +179,7 @@ def prepare
     db.connect do |con|
       con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
       stmt = con.prepared_statement('INSERT INTO users VALUES($1, $2)')
+
       10000.times do
         stmt.bind(1, 1)
         stmt.bind(2, 'Alice')
@@ -192,12 +194,14 @@ def append
     db.connect do |con|
       con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
       appender = con.appender('users')
+
       10000.times do
         appender.begin_row
         appender.append(1)
         appender.append('Alice')
         appender.end_row
       end
+
       appender.flush
     end
   end

data/ext/duckdb/duckdb.c

@@ -33,4 +33,5 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_appender();
     rbduckdb_init_duckdb_config();
     rbduckdb_init_duckdb_converter();
+    rbduckdb_init_duckdb_extracted_statements();
 }

data/ext/duckdb/extconf.rb

@@ -29,6 +29,10 @@ def check_duckdb_library(library, func, version)
   have_func(func, 'duckdb.h')
   return if found
 
+  raise_not_found_library(library, version)
+end
+
+def raise_not_found_library(library, version)
   library_name = duckdb_library_name(library)
   msg = "#{library_name} is not found. Install #{library_name} of duckdb >= #{version}."
   print_message(msg)
@@ -36,7 +40,7 @@ def check_duckdb_library(library, func, version)
 end
 
 def duckdb_library_name(library)
-  "lib#{library}.(so|dylib|dll)"
+  "lib#{library}.#{RbConfig::CONFIG['DLEXT']}"
 end
 
 def print_message(msg)
@@ -60,7 +64,10 @@ have_func('duckdb_bind_parameter_index', 'duckdb.h')
 # check duckdb >= 0.10.0
 have_func('duckdb_appender_column_count', 'duckdb.h')
 
-# duckdb_parameter_name is not found on Windows.
+# check duckdb >= 1.0.0
+have_func('duckdb_fetch_chunk', 'duckdb.h')
+
+# duckdb_parameter_name in duckdb <= 0.9.1 is not found on Windows.
 have_func('duckdb_parameter_name', 'duckdb.h')
 
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/extracted_statements.c

@@ -0,0 +1,94 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBExtractedStatements;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+
+static const rb_data_type_t extract_statements_data_type = {
+    "DuckDB/ExtractedStatements",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx);
+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_size(VALUE self);
+static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index);
+
+static void deallocate(void *ctx) {
+    rubyDuckDBExtractedStatements *p = (rubyDuckDBExtractedStatements *)ctx;
+
+    duckdb_destroy_extracted(&(p->extracted_statements));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBExtractedStatements *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBExtractedStatements));
+    ctx->num_statements = 0;
+
+    return TypedData_Wrap_Struct(klass, &extract_statements_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBExtractedStatements);
+}
+
+static VALUE duckdb_extracted_statements_initialize(VALUE self, VALUE con, VALUE query) {
+    rubyDuckDBConnection *pcon;
+    rubyDuckDBExtractedStatements *ctx;
+    char *pquery;
+    const char *error;
+
+    if (rb_obj_is_kind_of(con, cDuckDBConnection) != Qtrue) {
+        rb_raise(rb_eTypeError, "1st argument must be DuckDB::Connection");
+    }
+
+    pquery = StringValuePtr(query);
+    pcon = get_struct_connection(con);
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    ctx->num_statements = duckdb_extract_statements(pcon->con, pquery, &(ctx->extracted_statements));
+
+    if (ctx->num_statements == 0) {
+        error = duckdb_extract_statements_error(ctx->extracted_statements);
+        rb_raise(eDuckDBError, "%s", error);
+    }
+
+    return self;
+}
+
+static VALUE duckdb_extracted_statements_size(VALUE self) {
+    rubyDuckDBExtractedStatements *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    return ULL2NUM(ctx->num_statements);
+}
+
+
+static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index) {
+    rubyDuckDBConnection *pcon;
+    rubyDuckDBExtractedStatements *ctx;
+
+    if (rb_obj_is_kind_of(con, cDuckDBConnection) != Qtrue) {
+        rb_raise(rb_eTypeError, "1st argument must be DuckDB::Connection");
+    }
+    pcon = get_struct_connection(con);
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    return rbduckdb_prepared_statement_new(pcon->con, ctx->extracted_statements, NUM2ULL(index));
+}
+
+void rbduckdb_init_duckdb_extracted_statements(void) {
+    cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatements", rb_cObject);
+
+    rb_define_alloc_func(cDuckDBExtractedStatements, allocate);
+    rb_define_method(cDuckDBExtractedStatements, "initialize", duckdb_extracted_statements_initialize, 2);
+    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/extracted_statements.h

@@ -0,0 +1,12 @@
+#ifndef RUBY_DUCKDB_EXTRACTED_STATEMENTS_H
+#define RUBY_DUCKDB_EXTRACTED_STATEMENTS_H
+
+struct _rubyDuckDBExtractedStatements {
+    duckdb_extracted_statements extracted_statements;
+    idx_t num_statements;
+};
+
+typedef struct _rubyDuckDBExtractedStatements rubyDuckDBExtractedStatements;
+
+void rbduckdb_init_duckdb_extracted_statements(void);
+#endif

data/ext/duckdb/pending_result.c

@@ -39,6 +39,13 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
     VALUE streaming_p = Qfalse;
     duckdb_state state;
 
+    /*
+     * FIXME: The 2nd argument is deprecated and will be removed in the future.
+     * The behavior will be same as streaming.
+    if (argc == 2) {
+        rb_warn("The 2nd argument is deprecated and will be removed in the future.");
+    }
+    */
     rb_scan_args(argc, argv, "11", &oDuckDBPreparedStatement, &streaming_p);
 
     if (rb_obj_is_kind_of(oDuckDBPreparedStatement, cDuckDBPreparedStatement) != Qtrue) {
@@ -48,11 +55,20 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
 
+#ifdef DUCKDB_API_NO_DEPRECATED
+    state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
+#else
+    /*
+     * FIXME: streaming_p check will be removed in the future.
+     *
+     * state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
+     */
     if (!NIL_P(streaming_p) && streaming_p == Qtrue) {
         state = duckdb_pending_prepared_streaming(stmt->prepared_statement, &(ctx->pending_result));
     } else {
         state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
     }
+#endif
 
     if (state == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));

data/ext/duckdb/prepared_statement.c

@@ -53,6 +53,20 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBPreparedStatement);
 }
 
+VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_statements extracted_statements, idx_t index) {
+    VALUE obj;
+    rubyDuckDBPreparedStatement *ctx;
+
+    obj = allocate(cDuckDBPreparedStatement);
+
+    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");
+    }
+    return obj;
+}
+
 static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBPreparedStatement *ctx;

data/ext/duckdb/prepared_statement.h

@@ -8,6 +8,7 @@ struct _rubyDuckDBPreparedStatement {
 
 typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
 
+VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_statements extracted_statements, idx_t index);
 rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
 void rbduckdb_init_duckdb_prepared_statement(void);
 

data/ext/duckdb/result.c

@@ -1,5 +1,10 @@
 #include "ruby-duckdb.h"
 
+struct chunk_arg {
+    duckdb_data_chunk chunk;
+    idx_t col_count;
+};
+
 static VALUE cDuckDBResult;
 static ID id__to_date;
 static ID id__to_time;
@@ -27,10 +32,11 @@ static VALUE duckdb_result_row_count(VALUE oDuckDBResult);
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
 static VALUE duckdb_result_columns(VALUE oDuckDBResult);
 static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult);
+static VALUE destroy_data_chunk(VALUE arg);
 static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult);
 
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
-static void yield_rows(duckdb_data_chunk chunk, idx_t col_count);
+static VALUE yield_rows(VALUE arg);
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx);
 static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
 static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
@@ -93,52 +99,102 @@ rubyDuckDBResult *get_struct_result(VALUE obj) {
 }
 
 static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_boolean` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     bool bval = duckdb_value_boolean(result, col_idx, row_idx);
     return bval ? Qtrue : Qfalse;
+#endif
 }
 
 static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_smallint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
     return INT2FIX(i16val);
+#endif
 }
 
 static VALUE to_ruby_obj_utinyint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_utinyint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     uint8_t ui8val = duckdb_value_uint8(result, col_idx, row_idx);
     return UINT2NUM(ui8val);
+#endif
 }
 
 static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_integer` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
     return INT2NUM(i32val);
+#endif
 }
 
 static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_bigint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
     return LL2NUM(i64val);
+#endif
 }
 
 static VALUE to_ruby_obj_hugeint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `__to_hugeint_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_hugeint hugeint = duckdb_value_hugeint(result, col_idx, row_idx);
     return rb_ary_new3(2, ULL2NUM(hugeint.lower), LL2NUM(hugeint.upper));
+#endif
 }
 
 static VALUE to_ruby_obj_decimal(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `__to_decimal_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_decimal decimal = duckdb_value_decimal(result, col_idx, row_idx);
     return rb_ary_new3(4, ULL2NUM(decimal.value.lower), LL2NUM(decimal.value.upper), UINT2NUM(decimal.width), UINT2NUM(decimal.scale));
+#endif
 }
 
 static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_float` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     float fval = duckdb_value_float(result, col_idx, row_idx);
     return DBL2NUM(fval);
+#endif
 }
 
 static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_double` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     double dval = duckdb_value_double(result, col_idx, row_idx);
     return DBL2NUM(dval);
+#endif
 }
 
 static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
     VALUE str;
+    rb_warn("private method `_to_blob` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
     str = rb_str_new(bval.data, bval.size);
 
@@ -147,6 +203,7 @@ static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_id
     }
 
     return str;
+#endif
 }
 
 /*
@@ -220,9 +277,15 @@ static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
  *
  */
 static VALUE duckdb_result_row_count(VALUE oDuckDBResult) {
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
     rubyDuckDBResult *ctx;
+    rb_warn("`row_count` will be deprecated in the future.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return LL2NUM(duckdb_row_count(&(ctx->result)));
+#endif
 }
 
 /*
@@ -256,51 +319,77 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
  */
 static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qtrue;
+#else
+    /* FIXME streaming is allways true. so this method is not useful and deprecated. */
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return duckdb_result_is_streaming(ctx->result) ? Qtrue : Qfalse;
+#endif
+}
+
+static VALUE destroy_data_chunk(VALUE arg) {
+    struct chunk_arg *p = (struct chunk_arg *)arg;
+    duckdb_destroy_data_chunk(&(p->chunk));
+    return Qnil;
 }
 
 static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
+/*
+#ifdef HAVE_DUCKDB_H_GE_V1_0_0
+    return duckdb_result__chunk_stream(oDuckDBResult);
+#else
+*/
     rubyDuckDBResult *ctx;
-    idx_t col_count;
+    struct chunk_arg arg;
     idx_t chunk_count;
     idx_t chunk_idx;
-    duckdb_data_chunk chunk;
 
+#ifdef DUCKDB_API_NO_DEPRECATED
+    //TODO: use duckdb_fetch_chunk instead of duckdb_result_chunk_count and duckdb_result_get_chunk.
+    // duckdb_result_chunk_count will be deprecated in the future.
+    // duckdb_result_get_chunk will be deprecated in the future.
+#else
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
-    col_count = duckdb_column_count(&(ctx->result));
+    arg.col_count = duckdb_column_count(&(ctx->result));
     chunk_count = duckdb_result_chunk_count(ctx->result);
 
     RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
 
     for (chunk_idx = 0; chunk_idx < chunk_count; chunk_idx++) {
-        chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
-        yield_rows(chunk, col_count);
-        duckdb_destroy_data_chunk(&chunk);
+        arg.chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
+        rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
     }
+#endif
     return Qnil;
+/*
+#endif
+*/
 }
 
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
-    duckdb_data_chunk chunk;
-    idx_t col_count;
+    struct chunk_arg arg;
 
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
 
-    col_count = duckdb_column_count(&(ctx->result));
+    arg.col_count = duckdb_column_count(&(ctx->result));
 
-    while((chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
-        yield_rows(chunk, col_count);
-        duckdb_destroy_data_chunk(&chunk);
+#ifdef HAVE_DUCKDB_H_GE_V1_0_0
+    while((arg.chunk = duckdb_fetch_chunk(ctx->result)) != NULL) {
+#else
+    while((arg.chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
+#endif
+        rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
     }
     return Qnil;
 }
 
-static void yield_rows(duckdb_data_chunk chunk, idx_t col_count) {
+static VALUE yield_rows(VALUE arg) {
     idx_t row_count;
     idx_t row_idx;
     idx_t col_idx;
@@ -308,16 +397,19 @@ static void yield_rows(duckdb_data_chunk chunk, idx_t col_count) {
     VALUE row;
     VALUE val;
 
-    row_count = duckdb_data_chunk_get_size(chunk);
+    struct chunk_arg *p = (struct chunk_arg *)arg;
+
+    row_count = duckdb_data_chunk_get_size(p->chunk);
     for (row_idx = 0; row_idx < row_count; row_idx++) {
-        row = rb_ary_new2(col_count);
-        for (col_idx = 0; col_idx < col_count; col_idx++) {
-            vector = duckdb_data_chunk_get_vector(chunk, col_idx);
+        row = rb_ary_new2(p->col_count);
+        for (col_idx = 0; col_idx < p->col_count; col_idx++) {
+            vector = duckdb_data_chunk_get_vector(p->chunk, col_idx);
             val = vector_value(vector, row_idx);
             rb_ary_store(row, col_idx, val);
         }
         rb_yield(row);
     }
+    return Qnil;
 }
 
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
@@ -329,10 +421,15 @@ static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
 static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     bool is_null;
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qfalse;
+#else
+    rb_warn("private method `_null?` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     is_null = duckdb_value_is_null(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
     return is_null ? Qtrue : Qfalse;
+#endif
 }
 
 static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
@@ -403,6 +500,10 @@ static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE
     duckdb_string p;
     VALUE obj;
 
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_string` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     p = duckdb_value_string(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
@@ -411,6 +512,7 @@ static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE
         duckdb_free(p.data);
         return obj;
     }
+#endif
     return Qnil;
 }
 
@@ -418,6 +520,10 @@ static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_id
     rubyDuckDBResult *ctx;
     duckdb_string p;
     VALUE obj;
+#ifdef DUCKDB_API_NO_DEPRECATED
+    // duckdb_value_string_internal will be deprecated in the future.
+#else
+    rb_warn("private method `_to_string_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     p = duckdb_value_string_internal(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
@@ -425,6 +531,7 @@ static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_id
         obj = rb_utf8_str_new(p.data, p.size);
         return obj;
     }
+#endif
     return Qnil;
 }
 
@@ -805,26 +912,27 @@ void rbduckdb_init_duckdb_result(void) {
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "column_count", duckdb_result_column_count, 0);
-    rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0);
+    rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0); /* deprecated */
     rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
     rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
     rb_define_method(cDuckDBResult, "streaming?", duckdb_result_streaming_p, 0);
     rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
     rb_define_private_method(cDuckDBResult, "_chunk_stream", duckdb_result__chunk_stream, 0);
     rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
-    rb_define_private_method(cDuckDBResult, "_null?", duckdb_result__is_null, 2);
-    rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2);
-    rb_define_private_method(cDuckDBResult, "_to_smallint", duckdb_result__to_smallint, 2);
-    rb_define_private_method(cDuckDBResult, "_to_utinyint", duckdb_result__to_utinyint, 2);
-    rb_define_private_method(cDuckDBResult, "_to_integer", duckdb_result__to_integer, 2);
-    rb_define_private_method(cDuckDBResult, "_to_bigint", duckdb_result__to_bigint, 2);
-    rb_define_private_method(cDuckDBResult, "__to_hugeint_internal", duckdb_result___to_hugeint_internal, 2);
-    rb_define_private_method(cDuckDBResult, "__to_decimal_internal", duckdb_result___to_decimal_internal, 2);
-    rb_define_private_method(cDuckDBResult, "_to_float", duckdb_result__to_float, 2);
-    rb_define_private_method(cDuckDBResult, "_to_double", duckdb_result__to_double, 2);
-    rb_define_private_method(cDuckDBResult, "_to_string", duckdb_result__to_string, 2);
-    rb_define_private_method(cDuckDBResult, "_to_string_internal", duckdb_result__to_string_internal, 2);
-    rb_define_private_method(cDuckDBResult, "_to_blob", duckdb_result__to_blob, 2);
+
+    rb_define_private_method(cDuckDBResult, "_null?", duckdb_result__is_null, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_smallint", duckdb_result__to_smallint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_utinyint", duckdb_result__to_utinyint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_integer", duckdb_result__to_integer, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_bigint", duckdb_result__to_bigint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "__to_hugeint_internal", duckdb_result___to_hugeint_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "__to_decimal_internal", duckdb_result___to_decimal_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_float", duckdb_result__to_float, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_double", duckdb_result__to_double, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_string", duckdb_result__to_string, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_string_internal", duckdb_result__to_string_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_blob", duckdb_result__to_blob, 2); /* deprecated */
     rb_define_private_method(cDuckDBResult, "_enum_internal_type", duckdb_result__enum_internal_type, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_size", duckdb_result__enum_dictionary_size, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_value", duckdb_result__enum_dictionary_value, 2);

data/ext/duckdb/ruby-duckdb.h

@@ -1,6 +1,9 @@
 #ifndef RUBY_DUCKDB_H
 #define RUBY_DUCKDB_H
 
+// #define DUCKDB_API_NO_DEPRECATED
+#define DUCKDB_NO_EXTENSION_FUNCTIONS // disable extension C-functions
+
 #include "ruby.h"
 #include <duckdb.h>
 
@@ -8,12 +11,17 @@
 #define HAVE_DUCKDB_H_GE_V0_10_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_FETCH_CHUNK
+#define HAVE_DUCKDB_H_GE_V1_0_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
 #include "./result.h"
 #include "./column.h"
 #include "./prepared_statement.h"
+#include "./extracted_statements.h"
 #include "./pending_result.h"
 #include "./util.h"
 #include "./converter.h"

data/lib/duckdb/library_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   LIBRARY_VERSION = library_version[1..]
 end

data/lib/duckdb/pending_result.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   # The DuckDB::PendingResult encapsulates connection with DuckDB pending
   # result.

data/lib/duckdb/prepared_statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'bigdecimal'
 require_relative 'converter'

data/lib/duckdb/result.rb

@@ -53,15 +53,17 @@ module DuckDB
     alias column_size column_count
     alias row_size row_count
 
+    @use_chunk_each = true
+
     class << self
       def new
         raise DuckDB::Error, 'DuckDB::Result cannot be instantiated directly.'
       end
 
-      def use_chunk_each=(val)
-        raise DuckDB::Error, 'chunk_each is not available. Install duckdb >= 0.8.0 and rerun `gem install duckdb`.' unless instance_methods.include?(:chunk_each)
+      def use_chunk_each=(value)
+        warn('`changing DuckDB::Result.use_chunk_each to false` will be deprecated.') if value == false
 
-        @use_chunk_each = val
+        @use_chunk_each = value
       end
 
       def use_chunk_each?
@@ -91,6 +93,7 @@ module DuckDB
     end
 
     def row(row_index)
+      warn("#{self.class}##{__method__} will be deprecated. set `DuckDB::Result.use_chunk_each = true`.")
       row = []
       column_count.times do |col_index|
         row << (_null?(row_index, col_index) ? nil : to_value(row_index, col_index))
@@ -99,6 +102,7 @@ module DuckDB
     end
 
     def to_value(row_index, col_index)
+      warn("#{self.class}##{__method__} will be deprecated. set `DuckDB::Result.use_chunk_each = true`.")
       send(TO_METHODS[_column_type(col_index)], row_index, col_index)
     end
 
@@ -113,19 +117,23 @@ module DuckDB
     private
 
     def _to_hugeint(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       _to_string(row, col).to_i
     end
 
     def _to_hugeint_internal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       lower, upper = __to_hugeint_internal(row, col)
       Converter._to_hugeint_from_vector(lower, upper)
     end
 
     def _to_decimal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       BigDecimal(_to_string(row, col))
     end
 
     def _to_decimal_internal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       lower, upper, width, scale = __to_decimal_internal(row, col)
       Converter._to_decimal_from_hugeint(width, scale, upper, lower)
     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 = '0.10.2.0'
+  VERSION = '1.0.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.10.2.0
+  version: 1.0.0.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-20 00:00:00.000000000 Z
+date: 2024-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -132,6 +132,8 @@ files:
 - ext/duckdb/error.c
 - ext/duckdb/error.h
 - ext/duckdb/extconf.rb
+- ext/duckdb/extracted_statements.c
+- ext/duckdb/extracted_statements.h
 - ext/duckdb/pending_result.c
 - ext/duckdb/pending_result.h
 - ext/duckdb/prepared_statement.c
@@ -179,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.