duckdb 0.2.8.0 → 0.3.2.0

data/ext/duckdb/ruby-duckdb.h

@@ -8,13 +8,9 @@
 #include "./connection.h"
 #include "./result.h"
 #include "./prepared_statement.h"
-
-#ifdef HAVE_DUCKDB_VALUE_BLOB
+#include "./util.h"
 
 #include "./blob.h"
-
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
 #ifdef HAVE_DUCKDB_APPENDER_CREATE
 
 #include "./appender.h"
@@ -30,19 +26,8 @@
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
-
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-
 extern VALUE cDuckDBBlob;
-
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
-#ifdef HAVE_DUCKDB_CREATE_CONFIG
-
 extern VALUE cDuckDBConfig;
-
-#endif /* HAVE_DUCKDB_CREATE_CONFIG */
-
 extern VALUE eDuckDBError;
 
 #endif

data/ext/duckdb/util.c

@@ -0,0 +1,45 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+    duckdb_date_struct dt_struct;
+
+    dt_struct.year = NUM2INT(year);
+    dt_struct.month = NUM2INT(month);
+    dt_struct.day = NUM2INT(day);
+
+    return duckdb_to_date(dt_struct);
+}
+
+duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_time_struct time_st;
+
+    time_st.hour = NUM2INT(hour);
+    time_st.min = NUM2INT(min);
+    time_st.sec = NUM2INT(sec);
+    time_st.micros = NUM2INT(micros);
+
+    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_struct timestamp_st;
+
+    timestamp_st.date.year = NUM2INT(year);
+    timestamp_st.date.month = NUM2INT(month);
+    timestamp_st.date.day = NUM2INT(day);
+    timestamp_st.time.hour = NUM2INT(hour);
+    timestamp_st.time.min = NUM2INT(min);
+    timestamp_st.time.sec = NUM2INT(sec);
+    timestamp_st.time.micros = NUM2INT(micros);
+
+    return duckdb_to_timestamp(timestamp_st);
+}
+
+void 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);
+}
+#endif

data/ext/duckdb/util.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_UTIL_H
+#define RUBY_DUCKDB_UTIL_H
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+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);
+
+#endif
+
+#endif

data/lib/duckdb/appender.rb

@@ -1,4 +1,6 @@
 require 'date'
+require 'time'
+require_relative './converter'
 
 module DuckDB
   if defined?(DuckDB::Appender)
@@ -12,19 +14,161 @@ module DuckDB
     #   appender.append_row(1, 'Alice')
     #
     class Appender
+      include DuckDB::Converter
+
       RANGE_INT16 = -32_768..32_767
       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
 
+      #
+      # appends huge int value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE numbers (num HUGEINT)')
+      #   appender = con.appender('numbers')
+      #   appender
+      #     .begin_row
+      #     .append_hugeint(-170_141_183_460_469_231_731_687_303_715_884_105_727)
+      #     .end_row
+      #
       def append_hugeint(value)
         case value
         when Integer
-          append_varchar(value.to_s)
+          if respond_to?(:_append_hugeint, true)
+            half = 1 << 64
+            upper = value / half
+            lower = value - upper * half
+            _append_hugeint(lower, upper)
+          else
+            append_varchar(value.to_s)
+          end
         else
-          rb_raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+          raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
         end
       end
 
+      #
+      # appends date value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE dates (date_value DATE)')
+      #   appender = con.appender('dates')
+      #   appender.begin_row
+      #   appender.append_date(Date.today)
+      #   # or
+      #   # appender.append_date(Time.now)
+      #   # appender.append_date('2021-10-10')
+      #   appender.end_row
+      #   appender.flush
+      #
+      def append_date(value)
+        date = case value
+               when Date, Time
+                 value
+               else
+                 begin
+                   Date.parse(value)
+                 rescue
+                   raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
+                 end
+               end
+
+        _append_date(date.year, date.month, date.day)
+      end
+
+      #
+      # appends time value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE times (time_value TIME)')
+      #   appender = con.appender('times')
+      #   appender.begin_row
+      #   appender.append_time(Time.now)
+      #   # or
+      #   # appender.append_time('01:01:01')
+      #   appender.end_row
+      #   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
+
+        _append_time(time.hour, time.min, time.sec, time.usec)
+      end
+
+      #
+      # appends timestamp value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE timestamps (timestamp_value TIMESTAMP)')
+      #   appender = con.appender('timestamps')
+      #   appender.begin_row
+      #   appender.append_time(Time.now)
+      #   # or
+      #   # appender.append_time(Date.today)
+      #   # appender.append_time('2021-08-01 01:01:01')
+      #   appender.end_row
+      #   appender.flush
+      #
+      def append_timestamp(value)
+        time = case value
+               when Time
+                 value
+               when Date
+                 value.to_time
+               else
+                 begin
+                   Time.parse(value)
+                 rescue
+                   raise(ArgumentError, "Cannot parse argument `#{value}` to Time or Date.")
+                 end
+               end
+
+        _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
+      end
+
+      #
+      # appends interval.
+      # The argument must be ISO8601 duration format.
+      # WARNING: This method is expremental.
+      #
+      #   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('P1Y2D') # => append 1 year 2 days interval.
+      #     .end_row
+      #     .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)
+      end
+
       #
       # appends value.
       #
@@ -56,19 +200,23 @@ module DuckDB
             append_hugeint(value)
           end
         when String
-          if defined?(DuckDB::Blob)
-            blob?(value) ? append_blob(value) : append_varchar(value)
-          else
-            append_varchar(value)
-          end
+          blob?(value) ? append_blob(value) : append_varchar(value)
         when TrueClass, FalseClass
           append_bool(value)
         when Time
-          append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+          if respond_to?(:append_timestamp)
+            append_timestamp(value)
+          else
+            append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+          end
         when Date
-          append_varchar(value.strftime('%Y-%m-%d'))
+          if respond_to?(:append_date)
+            append_date(value)
+          else
+            append_varchar(value.strftime('%Y-%m-%d'))
+          end
         else
-          rb_raise(DuckDB::Error, "not supported type #{value} (value.class)")
+          raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
         end
       end
 

data/lib/duckdb/config.rb

@@ -34,10 +34,7 @@ module DuckDB
         # configs['default_order'] # => "The order type used when none is specified ([ASC] or DESC)"
         #
         def key_descriptions
-          return @key_descriptions if @key_descriptions
-
-          n = size
-          @key_descriptions = (0...n).each_with_object({}) do |i, hash|
+          @key_descriptions ||= (0...size).each_with_object({}) do |i, hash|
             key, description = key_description(i)
             hash[key] = description
           end

data/lib/duckdb/converter.rb

@@ -0,0 +1,52 @@
+module DuckDB
+  module Converter
+    private
+
+    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/prepared_statement.rb

@@ -1,4 +1,5 @@
 require 'date'
+require_relative './converter'
 
 module DuckDB
   # The DuckDB::PreparedStatement encapsulates connection with DuckDB prepared
@@ -12,6 +13,7 @@ module DuckDB
   #   stmt.bind(1, 'email@example.com')
   #   stmt.execute
   class PreparedStatement
+    include DuckDB::Converter
 
     RANGE_INT16 = -32768..32767
     RANGE_INT32 = -2147483648..2147483647
@@ -22,13 +24,119 @@ module DuckDB
       when Integer
         bind_varchar(i, value.to_s)
       else
-        rb_raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+        raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
       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 first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected date.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE birth_day = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   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
+
+      _bind_date(i, date.year, date.month, date.day)
+    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 time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE birth_time = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   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
+
+      _bind_time(i, time.hour, time.min, time.sec, time.usec)
+    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 time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE created_at = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   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
+
+      _bind_timestamp(i, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
+    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 ISO8601 time interval string.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT value FROM intervals WHERE interval = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, 'P1Y2D')
+    def bind_interval(i, value)
+      raise(DuckDB::Error, 'bind_interval is not available with your duckdb version. please install duckdb latest version at first') unless respond_to?(:_bind_interval, true)
+      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)
+    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 the value of prepared statement parameter.
     #
     #   require 'duckdb'
@@ -40,7 +148,7 @@ module DuckDB
     def bind(i, value)
       case value
       when NilClass
-        respond_to?(:bind_null) ? bind_null(i) : rb_raise(DuckDB::Error, 'This bind method does not support nil value. Re-compile ruby-duckdb with DuckDB version >= 0.1.1')
+        bind_null(i)
       when Float
         bind_double(i, value)
       when Integer
@@ -51,11 +159,7 @@ module DuckDB
           bind_varchar(i, value.to_s)
         end
       when String
-        if defined?(DuckDB::Blob)
-          blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
-        else
-          bind_varchar(i, value)
-        end
+        blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
       when TrueClass, FalseClass
         bind_bool(i, value)
       when Time
@@ -63,7 +167,7 @@ module DuckDB
       when Date
         bind_varchar(i, value.strftime('%Y-%m-%d'))
       else
-        rb_raise(DuckDB::Error, "not supported type #{value} (value.class)")
+        raise(DuckDB::Error, "not supported type `#{value}` (#{value.class})")
       end
     end
 

data/lib/duckdb/version.rb

@@ -1,5 +1,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '0.2.8.0'.freeze
+  VERSION = '0.3.2.0'.freeze
 end

data/lib/duckdb.rb

@@ -1,5 +1,6 @@
 require 'duckdb/duckdb_native'
 require 'duckdb/version'
+require 'duckdb/converter'
 require 'duckdb/database'
 require 'duckdb/connection'
 require 'duckdb/result'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.2.8.0
+  version: 0.3.2.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-04 00:00:00.000000000 Z
+date: 2022-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,8 +79,8 @@ files:
 - ".github/workflows/test_on_ubuntu.yml"
 - ".github/workflows/test_on_windows.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
+- CONTRIBUTION.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -108,10 +108,13 @@ files:
 - ext/duckdb/result.c
 - ext/duckdb/result.h
 - ext/duckdb/ruby-duckdb.h
+- ext/duckdb/util.c
+- ext/duckdb/util.h
 - lib/duckdb.rb
 - lib/duckdb/appender.rb
 - lib/duckdb/config.rb
 - lib/duckdb/connection.rb
+- lib/duckdb/converter.rb
 - lib/duckdb/database.rb
 - lib/duckdb/prepared_statement.rb
 - lib/duckdb/result.rb
@@ -131,14 +134,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.

data/.travis.yml

@@ -1,18 +0,0 @@
-language: ruby
-cache:
-  bundler: true
-  directories:
-    - ${HOME}/duckdb-v0.2.8
-before_install:
-  - yes | gem update --system
-  - if [[ ! -d ${HOME}/duckdb-v0.2.8/build ]]; then cd ${HOME} && git clone -b v0.2.8 https://github.com/cwida/duckdb.git duckdb-v0.2.8 && cd duckdb-v0.2.8 && make && cd ${TRAVIS_BUILD_DIR}; fi
-
-env:
-  - DUCKDB_VERSION=0.2.8
-rvm:
-  - 2.5.8
-  - 2.6.8
-  - 2.7.4
-  - 3.0.2
-  - ruby-head
-script: bundle exec rake -- --with-duckdb-include=${HOME}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${HOME}/duckdb-v${DUCKDB_VERSION}/build/release/src/