duckdb 0.9.1 → 0.9.1.2

data/ext/duckdb/prepared_statement.c

@@ -83,7 +83,7 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
 static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
-    VALUE result = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -268,7 +268,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     duckdb_date dt;
     idx_t idx = check_index(vidx);
 
-    dt = to_duckdb_date_from_value(year, month, day);
+    dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -285,7 +285,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 
     idx_t idx = check_index(vidx);
 
-    time = to_duckdb_time_from_value(hour, min, sec, micros);
+    time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -301,7 +301,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
@@ -317,7 +317,7 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    to_duckdb_interval_from_value(&interval, months, days, micros);
+    rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -341,7 +341,13 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
-void init_duckdb_prepared_statement(void) {
+rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return ctx;
+}
+
+void rbduckdb_init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
@@ -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;
 
-void init_duckdb_prepared_statement(void);
+rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
+void rbduckdb_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",
@@ -231,7 +229,7 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
 
     VALUE ary = rb_ary_new2(column_count);
     for(col_idx = 0; col_idx < column_count; col_idx++) {
-        VALUE column = create_column(oDuckDBResult, col_idx);
+        VALUE column = rbduckdb_create_column(oDuckDBResult, col_idx);
         rb_ary_store(ary, col_idx, column);
     }
     return ary;
@@ -399,11 +397,10 @@ static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col
     return value;
 }
 
-VALUE create_result(void) {
+VALUE rbduckdb_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,9 +716,8 @@ static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
     }
     return Qnil;
 }
-#endif
 
-void init_duckdb_result(void) {
+void rbduckdb_init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 
@@ -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/result.h

@@ -8,8 +8,8 @@ struct _rubyDuckDBResult {
 typedef struct _rubyDuckDBResult rubyDuckDBResult;
 
 rubyDuckDBResult *get_struct_result(VALUE obj);
-void init_duckdb_result(void);
-VALUE create_result(void);
+void rbduckdb_init_duckdb_result(void);
+VALUE rbduckdb_create_result(void);
 
 #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/ext/duckdb/util.c

@@ -1,6 +1,6 @@
 #include "ruby-duckdb.h"
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     duckdb_date_struct dt_struct;
 
     dt_struct.year = NUM2INT(year);
@@ -10,7 +10,7 @@ duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     return duckdb_to_date(dt_struct);
 }
 
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_time_struct time_st;
 
     time_st.hour = NUM2INT(hour);
@@ -21,7 +21,7 @@ duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE mi
     return duckdb_to_time(time_st);
 }
 
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp_struct timestamp_st;
 
     timestamp_st.date.year = NUM2INT(year);
@@ -35,7 +35,7 @@ duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE d
     return duckdb_to_timestamp(timestamp_st);
 }
 
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
     interval->months = NUM2INT(months);
     interval->days = NUM2INT(days);
     interval->micros = NUM2LL(micros);

data/ext/duckdb/util.h

@@ -1,9 +1,9 @@
 #ifndef RUBY_DUCKDB_UTIL_H
 #define RUBY_DUCKDB_UTIL_H
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
 
 #endif

data/lib/duckdb/appender.rb

@@ -86,16 +86,7 @@ module DuckDB
     #   appender.flush
     #
     def append_time(value)
-      time = case value
-             when Time
-               value
-             else
-               begin
-                 Time.parse(value)
-               rescue
-                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
-               end
-             end
+      time = _parse_time(value)
 
       _append_time(time.hour, time.min, time.sec, time.usec)
     end

data/lib/duckdb/connection.rb

@@ -25,19 +25,38 @@ 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, **hash)
-      return query_sql(sql) if args.empty? && hash.empty?
+    def query(sql, *args, **kwargs)
+      return query_sql(sql) if args.empty? && kwargs.empty?
 
       stmt = PreparedStatement.new(self, sql)
-      args.each.with_index(1) do |arg, i|
-        stmt.bind(i, arg)
-      end
-      hash.each do |key, value|
-        stmt.bind(key, value)
-      end
+      stmt.bind_args(*args, **kwargs)
       stmt.execute
     end
 
+    #
+    # executes sql with args asynchronously.
+    # The first argument sql must be SQL string.
+    # The rest arguments are parameters of SQL string.
+    # This method returns DuckDB::PendingResult object.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_file')
+    #   con = db.connect
+    #   pending_result = con.async_query('SELECT * FROM users')
+    #   sql = 'SELECT * FROM users WHERE name = ? AND email = ?'
+    #   pending_result = con.async_query(sql, 'Dave', 'dave@example.com')
+    #
+    #   # or You can use named parameter.
+    #
+    #   sql = 'SELECT * FROM users WHERE name = $name AND email = $email'
+    #   pending_result = con.async_query(sql, name: 'Dave', email: 'dave@example.com')
+    #
+    def async_query(sql, *args, **kwargs)
+      stmt = PreparedStatement.new(self, sql)
+      stmt.bind_args(*args, **kwargs)
+      stmt.pending_prepared
+    end
+
     #
     # connects DuckDB database
     # The first argument is DuckDB::Database object
@@ -83,6 +102,7 @@ module DuckDB
     end
 
     alias execute query
+    alias async_execute async_query
     alias open connect
     alias close disconnect
   end

data/lib/duckdb/converter.rb

@@ -42,6 +42,32 @@ module DuckDB
       "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20, 12]}"
     end
 
+    def _parse_date(value)
+      case value
+      when Date, Time
+        value
+      else
+        begin
+          Date.parse(value)
+        rescue StandardError => e
+          raise(ArgumentError, "Cannot parse `#{value.inspect}` to Date object. #{e.message}")
+        end
+      end
+    end
+
+    def _parse_time(value)
+      case value
+      when Time
+        value
+      else
+        begin
+          Time.parse(value)
+        rescue StandardError => e
+          raise(ArgumentError, "Cannot parse `#{value.inspect}` to Time object. #{e.message}")
+        end
+      end
+    end
+
     private
 
     def integer_to_hugeint(value)
@@ -51,7 +77,7 @@ module DuckDB
         lower = value - (upper << HALF_HUGEINT_BIT)
         [lower, upper]
       else
-        raise(ArgumentError, "The argument `#{value}` must be Integer.")
+        raise(ArgumentError, "The argument `#{value.inspect}` must be Integer.")
       end
     end
   end

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,21 +20,47 @@ 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 all parameters with SQL prepared statement.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE id = ?'
+    #   # or
+    #   # sql ='SELECT name FROM users WHERE id = $id'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind_args([1])
+    #   # or
+    #   # stmt.bind_args(id: 1)
+    def bind_args(*args, **kwargs)
+      args.each.with_index(1) do |arg, i|
+        bind(i, arg)
+      end
+      kwargs.each do |key, value|
+        bind(key, value)
+      end
+    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 Integer value.
     # This method uses bind_varchar internally.
+    #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_database')
     #   con = db.connect
     #   sql ='SELECT name FROM users WHERE bigint_col = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind_hugeint(1, 1_234_567_890_123_456_789_012_345)
-    def bind_hugeint(i, value)
+    def bind_hugeint(index, value)
       case value
       when Integer
-        bind_varchar(i, value.to_s)
+        bind_varchar(index, value.to_s)
       else
         raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
       end
@@ -45,6 +71,7 @@ module DuckDB
     # The index of first parameter is 1 not 0.
     # The second argument value must be Integer value.
     # This method uses duckdb_bind_hugeint internally.
+    #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_database')
     #   con = db.connect
@@ -69,19 +96,10 @@ module DuckDB
     #   stmt.bind(1, Date.today)
     #   #  or you can specify date string.
     #   # stmt.bind(1, '2021-02-23')
-    def bind_date(i, value)
-      case value
-      when Date, Time
-        date = value
-      else
-        begin
-          date = Date.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to date. #{e.message}")
-        end
-      end
+    def bind_date(index, value)
+      date = _parse_date(value)
 
-      _bind_date(i, date.year, date.month, date.day)
+      _bind_date(index, date.year, date.month, date.day)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -97,19 +115,10 @@ module DuckDB
     #   stmt.bind(1, Time.now)
     #   #  or you can specify time string.
     #   # stmt.bind(1, '07:39:45')
-    def bind_time(i, value)
-      case value
-      when Time
-        time = value
-      else
-        begin
-          time = Time.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
-        end
-      end
+    def bind_time(index, value)
+      time = _parse_time(value)
 
-      _bind_time(i, time.hour, time.min, time.sec, time.usec)
+      _bind_time(index, time.hour, time.min, time.sec, time.usec)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -125,19 +134,10 @@ module DuckDB
     #   stmt.bind(1, Time.now)
     #   #  or you can specify timestamp string.
     #   # stmt.bind(1, '2022-02-23 07:39:45')
-    def bind_timestamp(i, value)
-      case value
-      when Time
-        time = value
-      else
-        begin
-          time = Time.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
-        end
-      end
+    def bind_timestamp(index, value)
+      time = _parse_time(value)
 
-      _bind_timestamp(i, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
+      _bind_timestamp(index, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -151,9 +151,9 @@ module DuckDB
     #   sql ='SELECT value FROM intervals WHERE interval = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind(1, 'P1Y2D')
-    def bind_interval(i, value)
+    def bind_interval(index, value)
       value = Interval.to_interval(value)
-      _bind_interval(i, value.interval_months, value.interval_days, value.interval_micros)
+      _bind_interval(index, value.interval_months, value.interval_days, value.interval_micros)
     end
 
     # binds i-th parameter with SQL prepared statement.

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.2'
 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.2
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-14 00:00:00.000000000 Z
+date: 2023-11-05 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