duckdb 0.8.1.3 → 0.9.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9ce44263b8239010b8a203c7cebadf9e1b07323efc89164877e8ded4e37f768
-  data.tar.gz: 44dc20be5aa79c3b29f7bd7b57aa5d9e30524919499a88e7b7d5d50318468554
+  metadata.gz: aac4fbdeca8ed41cef872ace9dd3c8784ce43ee224a733f469fcd0907e852cd5
+  data.tar.gz: 56c8a5831830264fd4dfac41ba7a60bb9e6493a40536a5502c10dc0fc41b16d7
 SHA512:
-  metadata.gz: 41fd80e244cd09100931b695533314aa29c040f7571f64747cb79533da45c8685adc1fc04bc731cff5d59e5c58f8669db2c9cb1eebb8dcdfc78f92b3d7cb49d6
-  data.tar.gz: 75e8d32f1d467be39365f0ffe3f3f40471b1b580929f025736ec6d47db9dad62a99beb490a118066a7145837717dfcc337e5f1aaafba7f068c63279ef16770f9
+  metadata.gz: b94ffce97a54769bae379a3b13765b2132df1efe80fdb8f4855f77248855e95e9370651dbbe165a64c6ee45aff5bef20b3800a680f3da5287528974a243af338
+  data.tar.gz: 96accf18b7f4df7721efaec8e215e92dcbe97d22a99d89ffb64658f4696eb462b8ceaa27a3e558cba8ef5a7ce257fc4e3b35f83178fadf8047e19280563e7ae6

data/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: suketa

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview1', 'head']
-        duckdb: ['0.7.1', '0.8.1']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview2', 'head']
+        duckdb: ['0.9.0', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/.github/workflows/test_on_ubuntu.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview1', 'head']
-        duckdb: ['0.7.1', '0.8.1']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview2', 'head']
+        duckdb: ['0.9.0', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/.github/workflows/test_on_windows.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.7.1', '0.8.1']
+        duckdb: ['0.9.0', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # ChangeLog
 
+# 0.9.0.1
+
+- add `DuckDB::PreparedStatement#bind_parameter_index`.
+- DuckDB::Connection#query accepts SQL with named bind parameters.
+
+# 0.9.0
+- bump duckdb to 0.9.0.
+
+## Breaking Change
+- 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.
+- DuckDB::Result#chunck_each returns DuckDB::Interval class when the column type is INTERVAL.
+
 # 0.8.1.3
 - Fix BigDecimal conversion.
 

data/CONTRIBUTION.md

@@ -8,8 +8,8 @@
 2. Build and access to docker container
 
 ```
-docker-compose build ubuntu
-docker-compose run --rm ubuntu bash
+docker compose build ubuntu
+docker compose run --rm ubuntu bash
 ```
 
 In case you want custom ruby or duckdb versions, use `--build-arg` options

data/Dockerfile

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

data/Gemfile.lock

@@ -1,24 +1,24 @@
 PATH
   remote: .
   specs:
-    duckdb (0.8.1.3)
+    duckdb (0.9.0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.12.0)
-    mini_portile2 (2.8.2)
-    minitest (5.18.1)
-    nokogiri (1.15.3)
+    mini_portile2 (2.8.4)
+    minitest (5.20.0)
+    nokogiri (1.15.4)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.15.3-x86_64-linux)
+    nokogiri (1.15.4-x86_64-linux)
       racc (~> 1.4)
     racc (1.7.1)
     rake (13.0.6)
-    rake-compiler (1.2.3)
+    rake-compiler (1.2.5)
       rake
-    ruby_memcheck (1.3.2)
+    ruby_memcheck (2.2.0)
       nokogiri
     stackprof (0.2.25)
 

data/README.md

@@ -94,6 +94,17 @@ DuckDB::Database.open do |db|
 end
 ```
 
+### using bind variables
+
+You can use bind variables.
+
+```ruby
+con.query('SELECT * FROM users WHERE name = ? AND email = ?', 'Alice', 'alice@example.com')
+# or
+con.query('SELECT * FROM users WHERE name = $name AND email = $email', name: 'Alice', email: 'alice@example.com')
+```
+
+
 ### using BLOB column
 
 BLOB is available with DuckDB v0.2.5 or later.

data/benchmark/converter_hugeint_ips.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'duckdb'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report('hugeint_convert') { DuckDB::Converter._to_hugeint_from_vector(123_456_789, 123_456_789) }
+end
+
+__END__
+
+## before
+```
+✦ ❯ ruby benchmark/converter_hugeint_ips.rb
+Warming up --------------------------------------
+       hugeint_convert   318.524k i/100ms
+Calculating -------------------------------------
+       hugeint_convert      3.940M (± 0.7%) i/s -     19.748M in   5.012440s
+```
+
+## after (use bit shift)
+✦ ❯ ruby benchmark/converter_hugeint_ips.rb
+Warming up --------------------------------------
+       hugeint_convert   347.419k i/100ms
+Calculating -------------------------------------
+       hugeint_convert      4.171M (± 0.3%) i/s -     21.193M in   5.081131s

data/ext/duckdb/duckdb.c

@@ -4,8 +4,16 @@ VALUE mDuckDB;
 
 static VALUE duckdb_s_library_version(VALUE self);
 
+/*
+ * call-seq:
+ *   DuckDB.library_version -> String
+ *
+ * Returns the version of the DuckDB library.
+ *
+ *   DuckDB.library_version # => "0.2.0"
+ */
 static VALUE duckdb_s_library_version(VALUE self) {
-  return rb_str_new2(duckdb_library_version());
+    return rb_str_new2(duckdb_library_version());
 }
 
 void

data/ext/duckdb/extconf.rb

@@ -28,4 +28,7 @@ have_func('duckdb_extract_statements', 'duckdb.h')
 # check duckdb >= 0.8.0
 have_func('duckdb_string_is_inlined', 'duckdb.h')
 
+# check duckdb >= 0.9.0
+have_func('duckdb_bind_parameter_index', 'duckdb.h')
+
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/prepared_statement.c

@@ -9,6 +9,11 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
 static VALUE duckdb_prepared_statement_nparams(VALUE self);
 static VALUE duckdb_prepared_statement_execute(VALUE self);
 static idx_t check_index(VALUE vidx);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_prepared_statement_bind_parameter_index(VALUE self, VALUE name);
+#endif
+
 static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
 static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
 static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val);
@@ -93,6 +98,20 @@ static idx_t check_index(VALUE vidx) {
     return idx;
 }
 
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_prepared_statement_bind_parameter_index(VALUE self, VALUE name) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx;
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_parameter_index(ctx->prepared_statement, &idx, StringValuePtr(name)) == DuckDBError) {;
+        rb_raise(rb_eArgError, "parameter '%s' not found", StringValuePtr(name));
+    }
+    return ULL2NUM(idx);
+}
+#endif
+
 static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
@@ -308,6 +327,11 @@ void 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, "nparams", duckdb_prepared_statement_nparams, 0);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+    rb_define_method(cDuckDBPreparedStatement, "bind_parameter_index", duckdb_prepared_statement_bind_parameter_index, 1);
+#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/ruby-duckdb.h

@@ -12,6 +12,10 @@
 #define HAVE_DUCKDB_H_GE_V080 1
 #endif
 
+#ifdef HAVE_DUCKDB_BIND_PARAMETER_INDEX
+#define HAVE_DUCKDB_H_GE_V090 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"

data/lib/duckdb/appender.rb

@@ -150,13 +150,8 @@ module DuckDB
     #     .flush
     #
     def append_interval(value)
-      raise ArgumentError, "Argument `#{value}` must be a string." unless value.is_a?(String)
-
-      hash = iso8601_interval_to_hash(value)
-
-      months, days, micros = hash_to__append_interval_args(hash)
-
-      _append_interval(months, days, micros)
+      value = Interval.to_interval(value)
+      _append_interval(value.interval_months, value.interval_days, value.interval_micros)
     end
 
     #
@@ -197,6 +192,8 @@ module DuckDB
         append_timestamp(value)
       when Date
         append_date(value)
+      when DuckDB::Interval
+        append_interval(value)
       else
         raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
       end

data/lib/duckdb/connection.rb

@@ -12,7 +12,6 @@ module DuckDB
     # executes sql with args.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
-    # The parameters must be '?' in SQL statement.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_file')
@@ -21,12 +20,20 @@ module DuckDB
     #   sql = 'SELECT * FROM users WHERE name = ? AND email = ?'
     #   dave = con.query(sql, 'Dave', 'dave@example.com')
     #
-    def query(sql, *args)
-      return query_sql(sql) if args.empty?
+    #   # or You can use named parameter.
+    #
+    #   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?
 
       stmt = PreparedStatement.new(self, sql)
-      args.each_with_index do |arg, i|
-        stmt.bind(i + 1, arg)
+      args.each.with_index(1) do |arg, i|
+        stmt.bind(i, arg)
+      end
+      hash.each do |key, value|
+        stmt.bind(key, value)
       end
       stmt.execute
     end

data/lib/duckdb/converter.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'date'
+require_relative 'interval'
 
 module DuckDB
   module Converter
-    HALF_HUGEINT = 1 << 64
+    HALF_HUGEINT_BIT = 64
+    HALF_HUGEINT = 1 << HALF_HUGEINT_BIT
     FLIP_HUGEINT = 1 << 63
 
     module_function
@@ -18,7 +20,7 @@ module DuckDB
     end
 
     def _to_hugeint_from_vector(lower, upper)
-      (upper * HALF_HUGEINT) + lower
+      (upper << HALF_HUGEINT_BIT) + lower
     end
 
     def _to_decimal_from_vector(_width, scale, lower, upper)
@@ -29,15 +31,7 @@ module DuckDB
     end
 
     def _to_interval_from_vector(months, days, micros)
-      hash = { year: 0, month: 0, day: 0, hour: 0, min: 0, sec: 0, usec: 0 }
-      hash[:year] = months / 12
-      hash[:month] = months % 12
-      hash[:day] = days
-      hash[:hour] = micros / 3_600_000_000
-      hash[:min] = (micros % 3_600_000_000) / 60_000_000
-      hash[:sec] = (micros % 60_000_000) / 1_000_000
-      hash[:usec] = micros % 1_000_000
-      hash
+      Interval.new(interval_months: months, interval_days: days, interval_micros: micros)
     end
 
     def _to_uuid_from_vector(lower, upper)
@@ -53,59 +47,12 @@ module DuckDB
     def integer_to_hugeint(value)
       case value
       when Integer
-        upper = value / HALF_HUGEINT
-        lower = value - upper * HALF_HUGEINT
+        upper = value >> HALF_HUGEINT_BIT
+        lower = value - (upper << HALF_HUGEINT_BIT)
         [lower, upper]
       else
-        raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+        raise(ArgumentError, "The argument `#{value}` must be Integer.")
       end
     end
-
-    def iso8601_interval_to_hash(value)
-      digit = ''
-      time = false
-      hash = {}
-      hash.default = 0
-
-      value.each_char do |c|
-        if '-0123456789.'.include?(c)
-          digit += c
-        elsif c == 'T'
-          time = true
-          digit = ''
-        elsif c == 'M'
-          m_interval_to_hash(hash, digit, time)
-          digit = ''
-        elsif c == 'S'
-          s_interval_to_hash(hash, digit)
-          digit = ''
-        elsif 'YDH'.include?(c)
-          hash[c] = digit.to_i
-          digit = ''
-        elsif c != 'P'
-          raise ArgumentError, "The argument `#{value}` can't be parse."
-        end
-      end
-      hash
-    end
-
-    def m_interval_to_hash(hash, digit, time)
-      key = time ? 'TM' : 'M'
-      hash[key] = digit.to_i
-    end
-
-    def s_interval_to_hash(hash, digit)
-      sec, msec = digit.split('.')
-      hash['S'] = sec.to_i
-      hash['MS'] = "#{msec}000000"[0, 6].to_i
-      hash['MS'] *= -1 if hash['S'].negative?
-    end
-
-    def hash_to__append_interval_args(hash)
-      months = hash['Y'] * 12 + hash['M']
-      days = hash['D']
-      micros = (hash['H'] * 3600 + hash['TM'] * 60 + hash['S']) * 1_000_000 + hash['MS']
-      [months, days, micros]
-    end
   end
 end

data/lib/duckdb/interval.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # Interval class represents DuckDB's interval type value.
+  #
+  # The usage is as follows:
+  #
+  #   require 'duckdb'
+  #
+  #   interval = DuckDB::Interval.new(interval_months: 14, interval_days: 3, interval_micros: 14706123456)
+  #   # or
+  #   # interval = DuckDB::Interval.mk_interval(year: 1, month: 2, day: 3, hour: 4, min: 5, sec: 6, usec: 123456)
+  #   # or
+  #   # interval = DuckDB::Interval.iso8601_parse('P1Y2M3DT4H5M6.123456S')
+  #
+  #   db = DuckDB::Database.open # database in memory
+  #   con = db.connect
+  #
+  #   con.execute('CREATE TABLE users (value INTERVAL)')
+  #
+  #   require 'duckdb'
+  #   db = DuckDB::Database.open
+  #   con = db.connect
+  #   con.query('CREATE TABLE intervals (interval_value INTERVAL)')
+  #   appender = con.appender('intervals')
+  #   appender
+  #     .begin_row
+  #     .append_interval(interval)
+  #     .end_row
+  #     .flush
+  class Interval
+    ISO8601_REGEXP = Regexp.compile(
+      '(?<negativ>-{0,1})P
+      (?<year>-{0,1}\d+Y){0,1}
+      (?<month>-{0,1}\d+M){0,1}
+      (?<day>-{0,1}\d+D){0,1}
+      T{0,1}
+      (?<hour>-{0,1}\d+H){0,1}
+      (?<min>-{0,1}\d+M){0,1}
+      ((?<sec>-{0,1}\d+)\.{0,1}(?<usec>\d*)S){0,1}',
+      Regexp::EXTENDED
+    )
+
+    class << self
+      # parses the ISO8601 format string and return the Interval object.
+      #
+      #   DuckDB::Interval.iso8601_parse('P1Y2M3DT4H5M6.123456S')
+      #   => #<DuckDB::Interval:0x00007f9b9c0b3b60 @interval_months=14, @interval_days=3, @interval_micros=14706123456>
+      def iso8601_parse(value)
+        m = ISO8601_REGEXP.match(value)
+
+        raise ArgumentError, "The argument `#{value}` can't be parse." if m.nil?
+
+        year, month, day, hour, min, sec, usec = matched_to_i(m)
+
+        mk_interval(year: year, month: month, day: day, hour: hour, min: min, sec: sec, usec: usec)
+      end
+
+      # creates the Interval object.
+      #
+      #   DuckDB::Interval.mk_interval(year: 1, month: 2, day: 3, hour: 4, min: 5, sec: 6, usec: 123456)
+      #   => #<DuckDB::Interval:0x00007f9b9c0b3b60 @interval_months=14, @interval_days=3, @interval_micros=14706123456>
+      def mk_interval(year: 0, month: 0, day: 0, hour: 0, min: 0, sec: 0, usec: 0)
+        Interval.new(
+          interval_months: (year * 12) + month,
+          interval_days: day,
+          interval_micros: (((hour * 3600) + (min * 60) + sec) * 1_000_000) + usec
+        )
+      end
+
+      # Convert the value to the Interval object.
+      # The value can be String or Interval object.
+      # If the value is String, it is parsed as ISO8601 format.
+      # If the value is Interval object, it is returned as is.
+      # Otherwise, ArgumentError is raised.
+      #
+      #   DuckDB::Interval.to_interval('P1Y2M3DT4H5M6.123456S')
+      #   => #<DuckDB::Interval:0x00007f9b9c0b3b60 @interval_months=14, @interval_days=3, @interval_micros=14706123456>
+      #
+      #   interval = DuckDB::Interval.to_interval('P1Y2M3DT4H5M6.123456S')
+      #   DuckDB::Interval.to_interval(interval)
+      #   => #<DuckDB::Interval:0x00007f9b9c0b3b60 @interval_months=14, @interval_days=3, @interval_micros=14706123456>
+      def to_interval(value)
+        case value
+        when String
+          iso8601_parse(value)
+        when Interval
+          value
+        else
+          raise ArgumentError, "The argument `#{value}` can't be parse."
+        end
+      end
+
+      private
+
+      def matched_to_i(matched)
+        sign = to_sign(matched)
+        sec = to_sec(matched)
+        usec = to_usec(matched)
+        usec *= -1 if sec.negative?
+        value = [
+          to_year(matched), to_month(matched), to_day(matched), to_hour(matched), to_min(matched), sec, usec
+        ]
+        sign.positive? ? value : value.map { |v| v * sign }
+      end
+
+      def to_sign(matched)
+        matched[:negativ] == '-' ? -1 : 1
+      end
+
+      def to_year(matched)
+        matched[:year].to_i
+      end
+
+      def to_month(matched)
+        matched[:month].to_i
+      end
+
+      def to_day(matched)
+        matched[:day].to_i
+      end
+
+      def to_hour(matched)
+        matched[:hour].to_i
+      end
+
+      def to_min(matched)
+        matched[:min].to_i
+      end
+
+      def to_sec(matched)
+        matched[:sec].to_i
+      end
+
+      def to_usec(matched)
+        matched[:usec].to_s.ljust(6, '0')[0, 6].to_i
+      end
+    end
+
+    attr_reader :interval_months, :interval_days, :interval_micros
+
+    # creates the Interval object.
+    # The arguments are the number of months, days, and microseconds.
+    # The default value is 0.
+    #
+    #   DuckDB::Interval.new(interval_months: 1, interval_days: 2, interval_micros: 3)
+    #   => #<DuckDB::Interval:0x00007f9b9c0b3b60 @interval_months=1, @interval_days=2, @interval_micros=3>
+    def initialize(interval_months: 0, interval_days: 0, interval_micros: 0)
+      @interval_months = interval_months
+      @interval_days = interval_days
+      @interval_micros = interval_micros
+    end
+
+    def ==(other)
+      other.is_a?(Interval) &&
+        @interval_months == other.interval_months &&
+        @interval_days == other.interval_days &&
+        @interval_micros == other.interval_micros
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -1,6 +1,6 @@
 require 'date'
 require 'bigdecimal'
-require_relative './converter'
+require_relative 'converter'
 
 module DuckDB
   # The DuckDB::PreparedStatement encapsulates connection with DuckDB prepared
@@ -152,13 +152,8 @@ module DuckDB
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind(1, 'P1Y2D')
     def bind_interval(i, value)
-      raise ArgumentError, "Argument `#{value}` must be a string." unless value.is_a?(String)
-
-      hash = iso8601_interval_to_hash(value)
-
-      months, days, micros = hash_to__append_interval_args(hash)
-
-      _bind_interval(i, months, days, micros)
+      value = Interval.to_interval(value)
+      _bind_interval(i, value.interval_months, value.interval_days, value.interval_micros)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -172,35 +167,55 @@ module DuckDB
     #   sql ='SELECT name, email FROM users WHERE email = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind(1, 'email@example.com')
-    def bind(i, value)
+    def bind(index, value)
+      case index
+      when Integer
+        bind_with_index(index, value)
+      when String
+        bind_with_name(index, value)
+      when Symbol
+        bind_with_name(index.to_s, value)
+      else
+        raise(ArgumentError, "1st argument `#{index}` must be Integer or String or Symbol.")
+      end
+    end
+
+    private
+
+    def bind_with_index(index, value)
       case value
       when NilClass
-        bind_null(i)
+        bind_null(index)
       when Float
-        bind_double(i, value)
+        bind_double(index, value)
       when Integer
         case value
         when RANGE_INT64
-          bind_int64(i, value)
+          bind_int64(index, value)
         else
-          bind_varchar(i, value.to_s)
+          bind_varchar(index, value.to_s)
         end
       when String
-        blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
+        blob?(value) ? bind_blob(index, value) : bind_varchar(index, value)
       when TrueClass, FalseClass
-        bind_bool(i, value)
+        bind_bool(index, value)
       when Time
-        bind_varchar(i, value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+        bind_varchar(index, value.strftime('%Y-%m-%d %H:%M:%S.%N'))
       when Date
-        bind_varchar(i, value.strftime('%Y-%m-%d'))
+        bind_varchar(index, value.strftime('%Y-%m-%d'))
       when BigDecimal
-        bind_varchar(i, value.to_s('F'))
+        bind_varchar(index, value.to_s('F'))
       else
         raise(DuckDB::Error, "not supported type `#{value}` (#{value.class})")
       end
     end
 
-    private
+    def bind_with_name(name, value)
+      raise DuckDB::Error, 'not supported binding with name' unless respond_to?(:bind_parameter_index)
+
+      i = bind_parameter_index(name)
+      bind_with_index(i, value)
+    end
 
     def blob?(value)
       value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY

data/lib/duckdb/result.rb

@@ -58,6 +58,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.')
         return to_enum { row_size } unless block_given?
 
         row_count.times do |row_index|
@@ -94,7 +95,7 @@ module DuckDB
 
     def _to_hugeint_internal(row, col)
       lower, upper = __to_hugeint_internal(row, col)
-      upper * Converter::HALF_HUGEINT + lower
+      Converter._to_hugeint_from_vector(lower, upper)
     end
 
     def _to_decimal(row, col)

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.8.1.3'
+  VERSION = '0.9.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.8.1.3
+  version: 0.9.0.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-15 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ extensions:
 - ext/duckdb/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".github/workflows/test_on_macos.yml"
 - ".github/workflows/test_on_ubuntu.yml"
 - ".github/workflows/test_on_windows.yml"
@@ -87,6 +88,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/converter_hugeint_ips.rb
 - benchmark/get_converter_module_ips.rb
 - benchmark/to_bigdecimal_ips.rb
 - benchmark/to_hugeint_ips.rb
@@ -128,6 +130,7 @@ files:
 - lib/duckdb/connection.rb
 - lib/duckdb/converter.rb
 - lib/duckdb/database.rb
+- lib/duckdb/interval.rb
 - lib/duckdb/library_version.rb
 - lib/duckdb/prepared_statement.rb
 - lib/duckdb/result.rb