duckdb 0.9.1 → 0.9.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2948812978266d6ca2040d2071479f0484fe39719be860282e238b1e786a53e7
-  data.tar.gz: 3a3d10a5dd8e318b7a6274e6e32f0fc4850eeafada95673b42ed6c6121a36af5
+  metadata.gz: 6f3ac463fffc2fc6362c34abbfa5b862a7b8c993052ede087ca4403542c98dc8
+  data.tar.gz: c5ea1236f240a62165b7e371ae48033447868d119261def6c5310d3911e9df91
 SHA512:
-  metadata.gz: f4bf27bf6c3e378650584e9226bd0c2e16a76a2d5e68c96451f5abafb4dfe6fbb4df705ceb754ac8df30ed36bc6fe67299f61861fa882ef11acac79dea1e80cf
-  data.tar.gz: 71f42787f8368ab322c5d8c9a9a74227117dbf0454601d9ac3ec407188497c34e437fd5de14bec2038d6f3df3233098b580a8e116f8590dedd8004b7ba934f5a
+  metadata.gz: 210fe783740da4b6eb7991de416a7b5581403d8ad3661625110e275c030fe9dc1192d6fe2d73dcb778e53408b0e349eb28f37f2a1308d31ff30b0b783be5e498
+  data.tar.gz: b6fcc8d47c20ff9ce053122d9d9c03f4b19f1a72d9cd56addc1704d862ab7cfda4b3bec88bb3d8580befa006dcfeeee76138e00a2a34f065cca630bde523fb7d

data/.github/workflows/test_on_macos.yml

@@ -3,7 +3,7 @@ name: MacOS
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/.github/workflows/test_on_ubuntu.yml

@@ -3,7 +3,7 @@ name: Ubuntu
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/.github/workflows/test_on_windows.yml

@@ -3,7 +3,7 @@ name: Windows
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # ChangeLog
 
+# 0.9.1.1
+- change default branch to main from master.
+- add DuckDB::PendingResult class.
+- add DuckDB::PendingResult#state.
+- add DuckDB::PendingResult#execute_task.
+- add DuckDB::PendingResult#execute_pending.
+- add DuckDB::PreparedStatement#pending_prepared.
+
+## Breaking Changes
+- drop duckdb v0.7.x.
+
 # 0.9.1
 - add `DuckDB::PreparedStatement#parameter_name`.
 - bump duckdb to 0.9.1.
@@ -11,7 +22,7 @@
 # 0.9.0
 - bump duckdb to 0.9.0.
 
-## Breaking Change
+## Breaking Changes
 - deprecation warning when DuckDB::Result.each calling with `DuckDB::Result.use_chunk_each` is false.
   The `each` behavior will be same as `DuckDB::Result.chunk_each` in the future.
   set `DuckDB::Result.use_chunk_each = true` to suppress the warning.
@@ -54,7 +65,7 @@
 - support enum type in DuckDB::Result#chunk_each.
 - support uuid type in DuckDB::Result#chunk_each.
 
-## Breaking Change
+## Breaking Changes
 
 - DuckDB::Config.set_config does not raise exception when invalid key specified.
   Instead, DuckDB::Database.open raises DuckDB::Error with invalid key configuration.
@@ -64,7 +75,7 @@
 - add DuckDB::Result#_to_decimal_internal
 - add DuckDB::Result#_to_hugeint_internal
 
-## Breaking Change
+## Breaking Changes
 - DuckDB::Result returns BigDecimal object instead of String object if the column type is DECIMAL.
 
 # 0.7.1
@@ -81,7 +92,7 @@
 - add DuckDB::Result#__to_decimal_internal
 - add Ruby 3.2.1 on CI test
 - add Ruby mswin on CI test
-## Breaking Change
+## Breaking Changes
 - drop Ruby 2.6
 
 # 0.6.1
@@ -95,7 +106,7 @@
 - bump Ruby to 3.2.0rc1
 - bump duckdb to 0.6.0
 
-## Breaking Change
+## Breaking Changes
 - drop duckdb <= 0.4.x. ruby-duckdb supports duckdb >= 0.5.0
 
 # 0.5.1.1
@@ -114,7 +125,7 @@
 - add DuckDB::Result#row_count, DuckDB::Result#row_size(alias of row_count).
 - add DuckDB::Result#column_count, DuckDB::Result#column_size(alias of column_count).
 
-## Breaking Change
+## Breaking Changes
 - bind_varchar does not raised DuckDB::Error when the binding column is date or datetime.
 
 # 0.3.4.0

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    duckdb (0.9.1)
+    duckdb (0.9.1.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.12.0)
-    mini_portile2 (2.8.4)
+    mini_portile2 (2.8.5)
     minitest (5.20.0)
     nokogiri (1.15.4)
       mini_portile2 (~> 2.8.2)
@@ -15,7 +15,7 @@ GEM
     nokogiri (1.15.4-x86_64-linux)
       racc (~> 1.4)
     racc (1.7.1)
-    rake (13.0.6)
+    rake (13.1.0)
     rake-compiler (1.2.5)
       rake
     ruby_memcheck (2.2.0)

data/ext/duckdb/duckdb.c

@@ -28,6 +28,7 @@ Init_duckdb_native(void) {
     init_duckdb_result();
     init_duckdb_column();
     init_duckdb_prepared_statement();
+    init_duckdb_pending_result();
     init_duckdb_blob();
     init_duckdb_appender();
     init_duckdb_config();

data/ext/duckdb/extconf.rb

@@ -20,13 +20,8 @@ end
 
 dir_config('duckdb')
 
-check_duckdb_library('duckdb_extract_statements', '0.7.0')
-
-# check duckdb >= 0.7.0
-have_func('duckdb_extract_statements', 'duckdb.h')
-
 # check duckdb >= 0.8.0
-have_func('duckdb_string_is_inlined', 'duckdb.h')
+check_duckdb_library('duckdb_string_is_inlined', '0.8.0')
 
 # check duckdb >= 0.9.0
 have_func('duckdb_bind_parameter_index', 'duckdb.h')

data/ext/duckdb/pending_result.c

@@ -0,0 +1,100 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBPendingResult;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement);
+static VALUE duckdb_pending_result_execute_task(VALUE self);
+static VALUE duckdb_pending_result_execute_pending(VALUE self);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_pending_result_execution_finished_p(VALUE self);
+#endif
+
+static VALUE duckdb_pending_result__state(VALUE self);
+
+static const rb_data_type_t pending_result_data_type = {
+    "DuckDB/PendingResult",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBPendingResult *p = (rubyDuckDBPendingResult *)ctx;
+
+    duckdb_destroy_pending(&(p->pending_result));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBPendingResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPendingResult));
+    ctx->state = DUCKDB_PENDING_RESULT_NOT_READY;
+    return TypedData_Wrap_Struct(klass, &pending_result_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBPendingResult);
+}
+
+static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
+
+    if (duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result)) == DuckDBError) {
+        rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
+    }
+    return self;
+}
+
+static VALUE duckdb_pending_result_execute_task(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    ctx->state = duckdb_pending_execute_task(ctx->pending_result);
+    return Qnil;
+}
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    return duckdb_pending_execution_is_finished(ctx->state) ? Qtrue : Qfalse;
+}
+#endif
+
+static VALUE duckdb_pending_result_execute_pending(VALUE self) {
+    rubyDuckDBPendingResult *ctx;
+    rubyDuckDBResult *ctxr;
+    VALUE result = create_result();
+
+    TypedData_Get_Struct(self, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
+    ctxr = get_struct_result(result);
+    if (duckdb_execute_pending(ctx->pending_result, &(ctxr->result)) == DuckDBError) {
+        rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
+    }
+    return result;
+}
+
+static VALUE duckdb_pending_result__state(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    return INT2FIX(ctx->state);
+}
+
+rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
+    rubyDuckDBPendingResult *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
+    return ctx;
+}
+
+void init_duckdb_pending_result(void) {
+    cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
+    rb_define_alloc_func(cDuckDBPendingResult, allocate);
+
+    rb_define_method(cDuckDBPendingResult, "initialize", duckdb_pending_result_initialize, 1);
+    rb_define_method(cDuckDBPendingResult, "execute_task", duckdb_pending_result_execute_task, 0);
+    rb_define_method(cDuckDBPendingResult, "execute_pending", duckdb_pending_result_execute_pending, 0);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+    rb_define_method(cDuckDBPendingResult, "execution_finished?", duckdb_pending_result_execution_finished_p, 0);
+#endif
+    rb_define_private_method(cDuckDBPendingResult, "_state", duckdb_pending_result__state, 0);
+}

data/ext/duckdb/pending_result.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_PENDING_RESULT_H
+#define RUBY_DUCKDB_PENDING_RESULT_H
+
+struct _rubyDuckDBPendingResult {
+    duckdb_pending_result pending_result;
+    duckdb_pending_state state;
+};
+
+typedef struct _rubyDuckDBPendingResult rubyDuckDBPendingResult;
+
+rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj);
+void init_duckdb_pending_result(void);
+#endif

data/ext/duckdb/prepared_statement.c

@@ -341,6 +341,12 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
+rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return ctx;
+}
+
 void init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
@@ -356,7 +362,6 @@ void init_duckdb_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "parameter_name", duckdb_prepared_statement_parameter_name, 1);
 #endif
 #endif
-
     rb_define_method(cDuckDBPreparedStatement, "bind_bool", duckdb_prepared_statement_bind_bool, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int8", duckdb_prepared_statement_bind_int8, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int16", duckdb_prepared_statement_bind_int16, 2);

data/ext/duckdb/prepared_statement.h

@@ -8,6 +8,7 @@ struct _rubyDuckDBPreparedStatement {
 
 typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
 
+rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
 void init_duckdb_prepared_statement(void);
 
 #endif

data/ext/duckdb/result.c

@@ -37,7 +37,6 @@ static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_id
 static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_idx);
 static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col_idx, VALUE idx);
 
-#ifdef HAVE_DUCKDB_H_GE_V080
 static VALUE vector_date(void *vector_data, idx_t row_idx);
 static VALUE vector_timestamp(void* vector_data, idx_t row_idx);
 static VALUE vector_interval(void* vector_data, idx_t row_idx);
@@ -52,7 +51,6 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
 static VALUE vector_uuid(void* vector_data, idx_t row_idx);
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx);
 static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult);
-#endif
 
 static const rb_data_type_t result_data_type = {
     "DuckDB/Result",
@@ -403,7 +401,6 @@ VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-#ifdef HAVE_DUCKDB_H_GE_V080
 static VALUE vector_date(void *vector_data, idx_t row_idx) {
     duckdb_date_struct date = duckdb_from_date(((duckdb_date *) vector_data)[row_idx]);
 
@@ -719,7 +716,6 @@ static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
     }
     return Qnil;
 }
-#endif
 
 void init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
@@ -746,7 +742,5 @@ void init_duckdb_result(void) {
     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);
-#ifdef HAVE_DUCKDB_H_GE_V080
     rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
-#endif
 }

data/ext/duckdb/ruby-duckdb.h

@@ -4,14 +4,6 @@
 #include "ruby.h"
 #include <duckdb.h>
 
-#ifdef HAVE_DUCKDB_EXTRACT_STATEMENTS
-#define HAVE_DUCKDB_H_GE_V070 1
-#endif
-
-#ifdef HAVE_DUCKDB_STRING_IS_INLINED
-#define HAVE_DUCKDB_H_GE_V080 1
-#endif
-
 #ifdef HAVE_DUCKDB_BIND_PARAMETER_INDEX
 #define HAVE_DUCKDB_H_GE_V090 1
 #endif
@@ -22,6 +14,7 @@
 #include "./result.h"
 #include "./column.h"
 #include "./prepared_statement.h"
+#include "./pending_result.h"
 #include "./util.h"
 #include "./converter.h"
 

data/lib/duckdb/library_version.rb

@@ -1,3 +1,3 @@
 module DuckDB
-  LIBRARY_VERSION = library_version[1..] if defined? library_version
+  LIBRARY_VERSION = library_version[1..]
 end

data/lib/duckdb/pending_result.rb

@@ -0,0 +1,39 @@
+module DuckDB
+  # The DuckDB::PendingResult encapsulates connection with DuckDB pending
+  # result.
+  # PendingResult provides methods to execute SQL asynchronousely and check
+  # if the result is ready and to get the result.
+  #
+  #   require 'duckdb'
+  #
+  #   DuckDB::Result.use_chunk_each = true
+  #
+  #   db = DuckDB::Database.open
+  #   con = db.connect
+  #   stmt = con.prepared_statement(VERY_SLOW_QUERY)
+  #   pending_result = stmt.pending_prepared
+  #   while pending_result.state == :not_ready
+  #     print '.'
+  #     sleep(0.01)
+  #     pending_result.execute_task
+  #   end
+  #   result = pending_result.execute_pending
+  class PendingResult
+    STATES = %i[ready not_ready error no_tasks].freeze
+
+    # returns the state of the pending result.
+    # The result can be :ready, :not_ready, :error, :no_tasks.
+    # (:no_tasks is available only with duckdb 0.9.0 or later.)
+    #
+    # :ready means the result is ready to be fetched, and
+    # you can call `execute_pending` to get the result.
+    #
+    # :not_ready means the result is not ready yet, so
+    # you need to call `execute_task`.
+    #
+    # @return [Symbol] :ready, :not_ready, :error, :no_tasks
+    def state
+      STATES[_state]
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -20,6 +20,10 @@ 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
 
+    def pending_prepared
+      PendingResult.new(self)
+    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.

data/lib/duckdb/result.rb

@@ -25,7 +25,7 @@ module DuckDB
   class Result
     include Enumerable
 
-    ToRuby = {
+    TO_METHODS = Hash.new(:_to_string).merge(
       1 => :_to_boolean,
       3 => :_to_smallint,
       4 => :_to_integer,
@@ -35,21 +35,25 @@ module DuckDB
       16 => :_to_hugeint_internal,
       18 => :_to_blob,
       19 => :_to_decimal_internal
-    }
-
-    ToRuby.default = :_to_string
+    ).freeze
 
     alias column_size column_count
     alias row_size row_count
 
-    def self.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)
+    class << self
+      def new
+        raise DuckDB::Error, 'DuckDB::Result cannot be instantiated directly.'
+      end
 
-      @use_chunk_each = val
-    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 self.use_chunk_each?
-      !!@use_chunk_each
+        @use_chunk_each = val
+      end
+
+      def use_chunk_each?
+        !!@use_chunk_each
+      end
     end
 
     def each
@@ -58,7 +62,7 @@ module DuckDB
 
         chunk_each { |row| yield row }
       else
-        warn('this `each` behavior will be deprecated in the future. set `Result.use_chunk_each = true` to use new `each` behavior.')
+        warn('this `each` behavior will be deprecated in the future. set `DuckDB::Result.use_chunk_each = true` to use new `each` behavior.')
         return to_enum { row_size } unless block_given?
 
         row_count.times do |row_index|
@@ -76,7 +80,7 @@ module DuckDB
     end
 
     def to_value(row_index, col_index)
-      send(ToRuby[_column_type(col_index)], row_index, col_index)
+      send(TO_METHODS[_column_type(col_index)], row_index, col_index)
     end
 
     def enum_dictionary_values(col_index)

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.9.1'
+  VERSION = '0.9.1.1'
 end

data/lib/duckdb.rb

@@ -8,6 +8,7 @@ require 'duckdb/database'
 require 'duckdb/connection'
 require 'duckdb/result'
 require 'duckdb/prepared_statement'
+require 'duckdb/pending_result'
 require 'duckdb/appender'
 require 'duckdb/config'
 require 'duckdb/column'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.1.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-14 00:00:00.000000000 Z
+date: 2023-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,6 +115,8 @@ files:
 - ext/duckdb/error.c
 - ext/duckdb/error.h
 - ext/duckdb/extconf.rb
+- ext/duckdb/pending_result.c
+- ext/duckdb/pending_result.h
 - ext/duckdb/prepared_statement.c
 - ext/duckdb/prepared_statement.h
 - ext/duckdb/result.c
@@ -132,6 +134,7 @@ files:
 - lib/duckdb/database.rb
 - lib/duckdb/interval.rb
 - lib/duckdb/library_version.rb
+- lib/duckdb/pending_result.rb
 - lib/duckdb/prepared_statement.rb
 - lib/duckdb/result.rb
 - lib/duckdb/version.rb