duckdb 1.0.0.1 → 1.1.0.0

data/ext/duckdb/ruby-duckdb.h

@@ -15,6 +15,10 @@
 #define HAVE_DUCKDB_H_GE_V1_0_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_RESULT_ERROR_TYPE
+#define HAVE_DUCKDB_H_GE_V1_1_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
@@ -38,5 +42,7 @@ extern VALUE cDuckDBConfig;
 extern VALUE eDuckDBError;
 extern VALUE mDuckDBConverter;
 extern VALUE cDuckDBPreparedStatement;
+extern VALUE PositiveInfinity;
+extern VALUE NegativeInfinity;
 
 #endif

data/lib/duckdb/column.rb

@@ -17,44 +17,8 @@ module DuckDB
     #   columns.first.type #=> :integer
     #
     def type
-      types = %i[
-        invalid
-        boolean
-        tinyint
-        smallint
-        integer
-        bigint
-        utinyint
-        usmallint
-        uinteger
-        ubigint
-        float
-        double
-        timestamp
-        date
-        time
-        interval
-        hugeint
-        varchar
-        blob
-        decimal
-        timestamp_s
-        timestamp_ms
-        timestamp_ns
-        enum
-        list
-        struct
-        map
-        uuid
-        json
-      ]
-      if Gem::Version.new(DuckDB::LIBRARY_VERSION) == Gem::Version.new('0.10.0')
-        types[17, 0] = :uhugeint
-      end
-      index = _type
-      return :unknown if index >= types.size
-
-      types[index]
+      type_id = _type
+      DuckDB::Converter::IntToSym.type_to_sym(type_id)
     end
   end
 end

data/lib/duckdb/config.rb

@@ -1,64 +1,62 @@
 # frozen_string_literal: true
 
 module DuckDB
-  if defined?(DuckDB::Config)
-    # The DuckDB::Config encapsulates DuckDB Configuration.
+  # The DuckDB::Config encapsulates DuckDB Configuration.
+  #
+  #   require 'duckdb'
+  #   config = DuckDB::Config.new
+  #   config['default_order'] = 'DESC'
+  #   db = DuckDB::Database.open(nil, config)
+  #   con = db.connect
+  #   con.query('CREATE TABLE numbers (number INTEGER)')
+  #   con.query('INSERT INTO numbers VALUES (2), (1), (4), (3)')
+  #
+  #   # number is ordered by descending.
+  #   r = con.query('SELECT number FROM numbers ORDER BY number)
+  #   r.first.first # => 4
+  class Config
+    class << self
+      #
+      # returns available configuration name and the description.
+      # The return value is array object. The first element is the configuration
+      # name. The second is the description.
+      #
+      #   key, desc = DuckDB::Config.key_description(0)
+      #   key # => "access_mode"
+      #   desc # => "Access mode of the database ([AUTOMATIC], READ_ONLY or READ_WRITE)"
+      #
+      alias key_description get_config_flag
+
+      #
+      # returns the Hash object of all available configuration names and
+      # the descriptions.
+      #
+      # configs = DuckDB::Config.key_descriptions
+      # configs['default_order'] # => "The order type used when none is specified ([ASC] or DESC)"
+      #
+      def key_descriptions
+        @key_descriptions ||= (0...size).each_with_object({}) do |i, hash|
+          key, description = key_description(i)
+          hash[key] = description
+        end
+      end
+    end
+
+    #
+    # set configuration value
     #
-    #   require 'duckdb'
     #   config = DuckDB::Config.new
+    #   # config.set_config('default_order', 'DESC')
     #   config['default_order'] = 'DESC'
+    #
     #   db = DuckDB::Database.open(nil, config)
     #   con = db.connect
     #   con.query('CREATE TABLE numbers (number INTEGER)')
     #   con.query('INSERT INTO numbers VALUES (2), (1), (4), (3)')
     #
-    #   # number is ordered by descending.
+    #   # numbers are ordered by descending.
     #   r = con.query('SELECT number FROM numbers ORDER BY number)
     #   r.first.first # => 4
-    class Config
-      class << self
-        #
-        # returns available configuration name and the description.
-        # The return value is array object. The first element is the configuration
-        # name. The second is the description.
-        #
-        #   key, desc = DuckDB::Config.key_description(0)
-        #   key # => "access_mode"
-        #   desc # => "Access mode of the database ([AUTOMATIC], READ_ONLY or READ_WRITE)"
-        #
-        alias key_description get_config_flag
-
-        #
-        # returns the Hash object of all available configuration names and
-        # the descriptions.
-        #
-        # configs = DuckDB::Config.key_descriptions
-        # configs['default_order'] # => "The order type used when none is specified ([ASC] or DESC)"
-        #
-        def key_descriptions
-          @key_descriptions ||= (0...size).each_with_object({}) do |i, hash|
-            key, description = key_description(i)
-            hash[key] = description
-          end
-        end
-      end
-
-      #
-      # set configuration value
-      #
-      #   config = DuckDB::Config.new
-      #   # config.set_config('default_order', 'DESC')
-      #   config['default_order'] = 'DESC'
-      #
-      #   db = DuckDB::Database.open(nil, config)
-      #   con = db.connect
-      #   con.query('CREATE TABLE numbers (number INTEGER)')
-      #   con.query('INSERT INTO numbers VALUES (2), (1), (4), (3)')
-      #
-      #   # numbers are ordered by descending.
-      #   r = con.query('SELECT number FROM numbers ORDER BY number)
-      #   r.first.first # => 4
-      alias []= set_config
-    end
+    alias []= set_config
   end
 end

data/lib/duckdb/connection.rb

@@ -62,7 +62,6 @@ module DuckDB
     # This method returns DuckDB::PendingResult object.
     #
     #   require 'duckdb'
-    #   DuckDB::Result.use_chunk_each = true # must be true
     #   db = DuckDB::Database.open('duckdb_file')
     #   con = db.connect
     #

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)
@@ -10,9 +11,19 @@ module DuckDB
     HALF_HUGEINT_BIT = 64
     HALF_HUGEINT = 1 << HALF_HUGEINT_BIT
     FLIP_HUGEINT = 1 << 63
+    EPOCH = Time.local(1970, 1, 1)
+    EPOCH_UTC = Time.new(1970, 1, 1, 0, 0, 0, 0)
 
     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
@@ -33,6 +44,63 @@ module DuckDB
       )
     end
 
+    def _to_time_from_duckdb_timestamp_s(time)
+      EPOCH + time
+    end
+
+    def _to_time_from_duckdb_timestamp_ms(time)
+      tm = EPOCH + (time / 1000)
+      Time.local(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1000 * 1000)
+    end
+
+    def _to_time_from_duckdb_timestamp_ns(time)
+      tm = EPOCH + (time / 1_000_000_000)
+      Time.local(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1_000_000_000 / 1000)
+    end
+
+    def _to_time_from_duckdb_time_tz(hour, min, sec, micro, timezone)
+      sign = '+'
+      if timezone.negative?
+        timezone = -timezone
+        sign = '-'
+      end
+
+      tzhour = timezone / 3600
+      tzmin = (timezone % 3600) / 60
+
+      Time.parse(
+        format(
+          '%<hour>02d:%<min>02d:%<sec>02d.%<micro>06d%<sign>s%<tzhour>02d:%<tzmin>02d',
+          hour: hour,
+          min: min,
+          sec: sec,
+          micro: micro,
+          sign: sign,
+          tzhour: tzhour,
+          tzmin: tzmin
+        )
+      )
+    end
+
+    def _to_time_from_duckdb_timestamp_tz(bits)
+      micro = bits % 1_000_000
+      sec = (bits / 1_000_000)
+      time = EPOCH_UTC + sec
+
+      Time.parse(
+        format(
+          '%<year>04d-%<mon>02d-%<day>02d %<hour>02d:%<min>02d:%<sec>02d.%<micro>06d +0000',
+          year: time.year,
+          mon: time.month,
+          day: time.day,
+          hour: time.hour,
+          min: time.min,
+          sec: time.sec,
+          micro: micro
+        )
+      )
+    end
+
     def _to_hugeint_from_vector(lower, upper)
       (upper << HALF_HUGEINT_BIT) + lower
     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.1'
+  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