duckdb 1.0.0.2 → 1.1.0.0

data/lib/duckdb/converter/int_to_sym.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DuckDB
+  module Converter
+    module IntToSym
+      STATEMENT_TYPES = %i[
+        invalid
+        select
+        insert
+        update
+        explain
+        delete
+        prepare
+        create
+        execute
+        alter
+        transaction
+        copy
+        analyze
+        variable_set
+        create_func
+        drop
+        export
+        pragma
+        vacuum
+        call
+        set
+        load
+        relation
+        extension
+        logical_plan
+        attach
+        detach
+        multi
+      ].freeze
+
+      HASH_TYPES = if Gem::Version.new(DuckDB::LIBRARY_VERSION) == Gem::Version.new('0.10.0')
+                     {
+                       0 => :invalid,
+                       1 => :boolean,
+                       2 => :tinyint,
+                       3 => :smallint,
+                       4 => :integer,
+                       5 => :bigint,
+                       6 => :utinyint,
+                       7 => :usmallint,
+                       8 => :uinteger,
+                       9 => :ubigint,
+                       10 => :float,
+                       11 => :double,
+                       12 => :timestamp,
+                       13 => :date,
+                       14 => :time,
+                       15 => :interval,
+                       16 => :hugeint,
+                       17 => :uhugeint,
+                       18 => :varchar,
+                       19 => :blob,
+                       20 => :decimal,
+                       21 => :timestamp_s,
+                       22 => :timestamp_ms,
+                       23 => :timestamp_ns,
+                       24 => :enum,
+                       25 => :list,
+                       26 => :struct,
+                       27 => :map,
+                       28 => :uuid,
+                       29 => :union,
+                       30 => :bit,
+                       31 => :time_tz,
+                       32 => :timestamp_tz
+                     }.freeze
+                   else
+                     {
+                       0 => :invalid,
+                       1 => :boolean,
+                       2 => :tinyint,
+                       3 => :smallint,
+                       4 => :integer,
+                       5 => :bigint,
+                       6 => :utinyint,
+                       7 => :usmallint,
+                       8 => :uinteger,
+                       9 => :ubigint,
+                       10 => :float,
+                       11 => :double,
+                       12 => :timestamp,
+                       13 => :date,
+                       14 => :time,
+                       15 => :interval,
+                       16 => :hugeint,
+                       32 => :uhugeint,
+                       17 => :varchar,
+                       18 => :blob,
+                       19 => :decimal,
+                       20 => :timestamp_s,
+                       21 => :timestamp_ms,
+                       22 => :timestamp_ns,
+                       23 => :enum,
+                       24 => :list,
+                       25 => :struct,
+                       26 => :map,
+                       33 => :array,
+                       27 => :uuid,
+                       28 => :union,
+                       29 => :bit,
+                       30 => :time_tz,
+                       31 => :timestamp_tz
+                     }.freeze
+                   end
+
+      module_function
+
+      def statement_type_to_sym(val)
+        raise DuckDB::Error, "Unknown statement type: #{val}" if val >= STATEMENT_TYPES.size
+
+        STATEMENT_TYPES[val]
+      end
+
+      def type_to_sym(val)
+        raise DuckDB::Error, "Unknown type: #{val}" unless HASH_TYPES.key?(val)
+
+        HASH_TYPES[val]
+      end
+    end
+  end
+end

data/lib/duckdb/converter.rb

@@ -2,6 +2,7 @@
 
 require 'date'
 require_relative 'interval'
+require_relative 'converter/int_to_sym'
 
 module DuckDB
   QueryProgress = Struct.new(:percentage, :rows_processed, :total_rows_to_process)
@@ -15,6 +16,14 @@ module DuckDB
 
     module_function
 
+    def _to_infinity(value)
+      if value.positive?
+        DuckDB::Infinity::POSITIVE
+      else
+        DuckDB::Infinity::NEGATIVE
+      end
+    end
+
     def _to_date(year, month, day)
       Date.new(year, month, day)
     end

data/lib/duckdb/database.rb

@@ -23,7 +23,7 @@ module DuckDB
   #
   class Database
     private_class_method :_open
-    private_class_method :_open_ext if defined?(DuckDB::Config)
+    private_class_method :_open_ext
 
     class << self
       ##
@@ -55,10 +55,8 @@ module DuckDB
       private
 
       def _db_open(dbpath, config)
-        if defined?(DuckDB::Config) && config
+        if config
           _open_ext(dbpath, config)
-        elsif config
-          _open(dbpath, config)
         else
           _open(dbpath)
         end

data/lib/duckdb/infinity.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuckDB
+  module Infinity
+    POSITIVE = 'infinity'
+    NEGATIVE = '-infinity'
+  end
+end

data/lib/duckdb/pending_result.rb

@@ -8,8 +8,6 @@ module DuckDB
   #
   #   require 'duckdb'
   #
-  #   DuckDB::Result.use_chunk_each = true
-  #
   #   db = DuckDB::Database.open
   #   con = db.connect
   #   stmt = con.prepared_statement(VERY_SLOW_QUERY)
@@ -24,8 +22,7 @@ module DuckDB
     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.)
+    # the result can be :ready, :not_ready, :error, :no_tasks.
     #
     # :ready means the result is ready to be fetched, and
     # you can call `execute_pending` to get the result.
@@ -33,9 +30,23 @@ module DuckDB
     # :not_ready means the result is not ready yet, so
     # you need to call `execute_task`.
     #
-    # @return [Symbol] :ready, :not_ready, :error, :no_tasks
+    # @return [symbol] :ready, :not_ready, :error, :no_tasks
     def state
       STATES[_state]
     end
+
+    # returns the state of the pending result.
+    # the result can be :ready, :not_ready, :error, :no_tasks.
+    #
+    # :ready means the result is ready to be fetched, and
+    # you can call `execute_pending` to get the result.
+    #
+    # :not_ready or :no_tasks might mean the pending result
+    # is not executed yet, so you need to call `execute_task`.
+    #
+    # @return [symbol] :ready, :not_ready, :error, :no_tasks
+    def execute_check_state
+      STATES[_execute_check_state]
+    end
   end
 end

data/lib/duckdb/prepared_statement.rb

@@ -27,11 +27,38 @@ module DuckDB
     end
 
     def pending_prepared_stream
-      raise DuckDB::Error, 'DuckDB::Result.use_chunk_each must be true.' unless DuckDB::Result.use_chunk_each?
-
       PendingResult.new(self, true)
     end
 
+    # returns statement type. The return value is one of the following symbols:
+    #  :invalid, :select, :insert, :update, :explain, :delete, :prepare, :create,
+    #  :execute, :alter, :transaction, :copy, :analyze, :variable_set, :create_func,
+    #  :drop, :export, :pragma, :vacuum, :call, :set, :load, :relation, :extension,
+    #  :logical_plan, :attach, :detach, :multi
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   stmt = con.prepared_statement('SELECT * FROM users')
+    #   stmt.statement_type # => :select
+    def statement_type
+      i = _statement_type
+      Converter::IntToSym.statement_type_to_sym(i)
+    end
+
+    # returns parameter type. The argument must be index of parameter.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(255))')
+    #   stmt = con.prepared_statement('SELECT * FROM users WHERE id = ?')
+    #   stmt.param_type(1) # => :integer
+    def param_type(index)
+      i = _param_type(index)
+      Converter::IntToSym.type_to_sym(i)
+    end
+
     # binds all parameters with SQL prepared statement.
     #
     #   require 'duckdb'

data/lib/duckdb/result.rb

@@ -24,86 +24,71 @@ module DuckDB
   #   end
   class Result
     include Enumerable
-    TO_METHODS = if Gem::Version.new(DuckDB::LIBRARY_VERSION) == Gem::Version.new('0.10.0')
-                   Hash.new(:_to_string).merge(
-                     1 => :_to_boolean,
-                     3 => :_to_smallint,
-                     4 => :_to_integer,
-                     5 => :_to_bigint,
-                     10 => :_to_float,
-                     11 => :_to_double,
-                     16 => :_to_hugeint_internal,
-                     19 => :_to_blob,
-                     20 => :_to_decimal_internal
-                   ).freeze
-                 else
-                   Hash.new(:_to_string).merge(
-                     1 => :_to_boolean,
-                     3 => :_to_smallint,
-                     4 => :_to_integer,
-                     5 => :_to_bigint,
-                     10 => :_to_float,
-                     11 => :_to_double,
-                     16 => :_to_hugeint_internal,
-                     18 => :_to_blob,
-                     19 => :_to_decimal_internal
-                   ).freeze
-                 end
+    RETURN_TYPES = %i[invalid changed_rows nothing query_result].freeze
 
     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=(value)
-        warn('`changing DuckDB::Result.use_chunk_each to false` will be deprecated.') if value == false
+        raise('`changing DuckDB::Result.use_chunk_each to false` was deprecated.') unless value
+
+        warn('`DuckDB::Result.use_chunk_each=` will be deprecated.')
 
-        @use_chunk_each = value
+        true
       end
 
       def use_chunk_each?
-        !!@use_chunk_each
+        warn('`DuckDB::Result.use_chunk_each?` will be deprecated.')
+        true
       end
     end
 
     def each
-      if self.class.use_chunk_each?
-        if streaming?
-          return _chunk_stream unless block_given?
+      if streaming?
+        return _chunk_stream unless block_given?
 
-          _chunk_stream { |row| yield row }
-        else
-          return chunk_each unless block_given?
-
-          chunk_each { |row| yield row }
-        end
+        _chunk_stream { |row| yield row }
       else
-        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?
+        return chunk_each unless block_given?
 
-        row_count.times do |row_index|
-          yield row(row_index)
-        end
+        chunk_each { |row| yield row }
       end
     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))
-      end
-      row
+    # returns return type. The return value is one of the following symbols:
+    #  :invalid, :changed_rows, :nothing, :query_result
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   result = con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+    #   result.return_type # => :nothing
+    def return_type
+      i = _return_type
+      raise DuckDB::Error, "Unknown return type: #{i}" if i >= RETURN_TYPES.size
+
+      RETURN_TYPES[i]
     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)
+    # returns statement type. The return value is one of the following symbols:
+    #  :invalid, :select, :insert, :update, :explain, :delete, :prepare, :create,
+    #  :execute, :alter, :transaction, :copy, :analyze, :variable_set, :create_func,
+    #  :drop, :export, :pragma, :vacuum, :call, :set, :load, :relation, :extension,
+    #  :logical_plan, :attach, :detach, :multi
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   result = con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+    #   result.statement_type # => :create
+    def statement_type
+      i = _statement_type
+      Converter::IntToSym.statement_type_to_sym(i)
     end
 
     def enum_dictionary_values(col_index)
@@ -113,29 +98,5 @@ module DuckDB
       end
       values
     end
-
-    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
   end
 end

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.0.0.2'
+  VERSION = '1.1.0.0'
 end

data/lib/duckdb.rb

@@ -12,6 +12,7 @@ require 'duckdb/pending_result'
 require 'duckdb/appender'
 require 'duckdb/config'
 require 'duckdb/column'
+require 'duckdb/infinity'
 
 # DuckDB provides Ruby interface of DuckDB.
 module DuckDB

data/sample/async_query.rb

@@ -1,6 +1,5 @@
 require 'duckdb'
 
-DuckDB::Result.use_chunk_each = true
 DuckDB::Database.open do |db|
   db.connect do |con|
     con.query('SET threads=1')

data/sample/async_query_stream.rb

@@ -1,6 +1,5 @@
 require 'duckdb'
 
-DuckDB::Result.use_chunk_each = true
 DuckDB::Database.open do |db|
   db.connect do |con|
     con.query('SET threads=1')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.0.0.2
+  version: 1.1.0.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-23 00:00:00.000000000 Z
+date: 2024-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -106,9 +106,6 @@ files:
 - benchmark/async_query.rb
 - benchmark/converter_hugeint_ips.rb
 - benchmark/get_converter_module_ips.rb
-- benchmark/to_bigdecimal_ips.rb
-- benchmark/to_hugeint_ips.rb
-- benchmark/to_hugeint_profile.rb
 - benchmark/to_intern_ips.rb
 - bin/console
 - bin/setup
@@ -150,7 +147,9 @@ files:
 - lib/duckdb/config.rb
 - lib/duckdb/connection.rb
 - lib/duckdb/converter.rb
+- lib/duckdb/converter/int_to_sym.rb
 - lib/duckdb/database.rb
+- lib/duckdb/infinity.rb
 - lib/duckdb/interval.rb
 - lib/duckdb/library_version.rb
 - lib/duckdb/pending_result.rb
@@ -174,14 +173,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.16
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.

data/benchmark/to_bigdecimal_ips.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'duckdb'
-require 'benchmark/ips'
-
-db = DuckDB::Database.open
-con = db.connect
-con.query('CREATE TABLE decimals (decimal_value DECIMAL(38, 3))')
-con.query('INSERT INTO decimals VALUES (1234567890123.456)')
-result = con.query('SELECT decimal_value FROM decimals')
-
-Benchmark.ips do |x|
-  x.report('_to_decimal') { result.send(:_to_decimal, 0, 0) }
-  x.report('_to_decimal_internal') { result.send(:_to_decimal_internal, 0, 0) }
-end

data/benchmark/to_hugeint_ips.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'duckdb'
-require 'benchmark/ips'
-
-db = DuckDB::Database.open
-con = db.connect
-con.query('CREATE TABLE hugeints (hugeint_value HUGEINT)')
-con.query('INSERT INTO hugeints VALUES (123456789012345678901234567890123456789)')
-result = con.query('SELECT hugeint_value FROM hugeints')
-
-Benchmark.ips do |x|
-  x.report('_to_hugeint') { result.send(:_to_hugeint, 0, 0) }
-  x.report('_to_hugeint_internal') { result.send(:_to_hugeint_internal, 0, 0) }
-end

data/benchmark/to_hugeint_profile.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'duckdb'
-require 'stackprof'
-
-db = DuckDB::Database.open
-con = db.connect
-con.query('CREATE TABLE hugeints (hugeint_value HUGEINT)')
-con.query('INSERT INTO hugeints VALUES (123456789012345678901234567890123456789)')
-result = con.query('SELECT hugeint_value FROM hugeints')
-
-def profile(name, &block)
-  profile = StackProf.run(mode: :wall, interval: 1_000) do
-    2_000_000.times(&block)
-  end
-
-  result = StackProf::Report.new(profile)
-  puts
-  puts "=== #{name} ==="
-  result.print_text
-  puts
-end
-
-profile(:_to_hugeint) { result.send(:_to_hugeint, 0, 0) }
-profile(:_to_hugeint_internal) { result.send(:_to_hugeint_internal, 0, 0) }