duckdb 0.2.8.0 → 0.2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a07cf98bca895ec39cc43754e6f69544e22c16cab023554daa632dc0be14d527
-  data.tar.gz: d2e96a7556e9ab139fb4b03f8306961d011c80ff9eb259bb8f29cdbd390ea757
+  metadata.gz: af998f52f46c0ef8f51501333cbaf39d720daaa389eb618d7d7ad79627d70ad9
+  data.tar.gz: 8e1c5323fa2f917c9ab6050a0350e5e25b646559492501f636af026b79cb20f8
 SHA512:
-  metadata.gz: fc64b4021083e0837de1c22470b015be7337f2e43754771c36b4265f133542bb7161762fa51a46f2ec9f9ac992bf67bb45e7d8031206f4cd385f248bddcff14d
-  data.tar.gz: 131cb3b1ee245cb765b8b7081d8fb900634055cf6570e6220121991e275d53e7be44ac1c1274c64f4c8991cd3252823274fd887fa3b49a31c8dc9578dd4aade6
+  metadata.gz: 14809adeffb7bc79f2102e29f89a6fe6ea276ab38eaeabed9f3c18a023566c3bbad06c1ab31e55499e77d3f0f9ced186d618c24639b8c16ceff1ee61304f9f67
+  data.tar.gz: 15d164af6af9d985765d7b9fa87dcf7f9cf89fb2d691c9d44ea2d2bb72341a77213647cb08bcacc66094eb1622d250fe203f41a9529866af9f358518800f7183

data/.github/workflows/test_on_macos.yml

@@ -7,7 +7,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
+        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
+        duckdb: ['0.2.8', '0.2.9']
 
     steps:
     - uses: actions/checkout@v2
@@ -17,9 +18,32 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: Install latest duckdb by brew
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v2
+      with:
+        path: /usr/local/Cellar/duckdb@${{ matrix.duckdb }}
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
+
+    - name: Install duckdb v${{ matrix.duckdb }} by brew
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
+      run: |
+        brew tap-new duckdb/taps
+        brew extract duckdb duckdb/taps --version $DUCKDB_VERSION
+        brew install duckdb/taps/duckdb@$DUCKDB_VERSION
+
+    - name: setup duckdb v${{ matrix.duckdb }} headers and libraries
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        brew install duckdb
+        if [ ! -L /usr/local/include/duckdb.h ]; then
+          header=`find /usr/local/Cellar/duckdb@$DUCKDB_VERSION -name "duckdb.h"`
+          lib=`find /usr/local/Cellar/duckdb@$DUCKDB_VERSION -name "libduckdb.dylib"`
+          ln -s $header /usr/local/include/duckdb.h
+          ln -s $lib /usr/local/lib/libduckdb.dylib
+        fi
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       run: |

data/.github/workflows/test_on_ubuntu.yml

@@ -8,8 +8,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
-        duckdb: ['0.2.8', '0.2.7']
+        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
+        duckdb: ['0.2.8', '0.2.9']
 
     steps:
     - uses: actions/checkout@v2
@@ -19,43 +19,24 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: duckdb 0.2.8 cache
-      id: duckdb-cache-v0_2_8
-      uses: actions/cache@v1.1.0
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v2
       with:
-        path: duckdb-v0.2.8
-        key: ${{ runner.os }}-duckdb-v0_2_8_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_8
+        path: duckdb-v${{ matrix.duckdb }}
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
 
-    - name: duckdb 0.2.7 cache
-      id: duckdb-cache-v0_2_7
-      uses: actions/cache@v1.1.0
-      with:
-        path: duckdb-v0.2.7
-        key: ${{ runner.os }}-duckdb-v0_2_7_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_7
-
-    - name: Build duckdb 0.2.8
-      if: steps.duckdb-cache-v0_2_8.outputs.cache-hit != 'true'
-      run: |
-        git clone -b v0.2.8 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.8
-        cd duckdb-tmp-v0.2.8 && make && cd ..
-        rm -rf duckdb-v0.2.8
-        mkdir -p duckdb-v0.2.8/build/release/src duckdb-v0.2.8/src
-        cp -rip duckdb-tmp-v0.2.8/build/release/src/*.so duckdb-v0.2.8/build/release/src
-        cp -rip duckdb-tmp-v0.2.8/src/include duckdb-v0.2.8/src/
-
-    - name: Build duckdb 0.2.7
-      if: steps.duckdb-cache-v0_2_7.outputs.cache-hit != 'true'
+    - name: Build duckdb ${{ matrix.duckdb }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       run: |
-        git clone -b v0.2.7 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.7
-        cd duckdb-tmp-v0.2.7 && make && cd ..
-        rm -rf duckdb-v0.2.7
-        mkdir -p duckdb-v0.2.7/build/release/src duckdb-v0.2.7/src
-        cp -rip duckdb-tmp-v0.2.7/build/release/src/*.so duckdb-v0.2.7/build/release/src
-        cp -rip duckdb-tmp-v0.2.7/src/include duckdb-v0.2.7/src/
+        git clone -b v$DUCKDB_VERSION https://github.com/cwida/duckdb.git duckdb-tmp-v$DUCKDB_VERSION
+        cd duckdb-tmp-v$DUCKDB_VERSION && make && cd ..
+        rm -rf duckdb-v$DUCKDB_VERSION
+        mkdir -p duckdb-v$DUCKDB_VERSION/build/release/src duckdb-v$DUCKDB_VERSION/src
+        cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.so duckdb-v$DUCKDB_VERSION/build/release/src
+        cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       env:

data/.github/workflows/test_on_windows.yml

@@ -7,7 +7,8 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
+        duckdb: ['0.2.8', '0.2.9']
 
     steps:
     - uses: actions/checkout@v2
@@ -18,8 +19,10 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
 
     - name: download duckdb binary for windows 64bit
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        curl -OL https://github.com/duckdb/duckdb/releases/download/v0.2.6/libduckdb-windows-amd64.zip
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${env:DUCKDB_VERSION}/libduckdb-windows-amd64.zip
 
     - name: extract zip file
       run: |
@@ -29,9 +32,12 @@ jobs:
       run: |
         bundle install
         bundle exec rake build -- --with-duckdb-include=../../../.. --with-duckdb-lib=../../../..
+    - name: setup duckdb.dll
+      run: |
+        cp duckdb.dll C:/Windows/System32/
 
     # FIXME: rake test fails with LoadError
     # C:/hostedtoolcache/windows/Ruby/2.7.3/x64/lib/ruby/2.7.0/rubygems/core_ext/kernel_require.rb:83:in `require': 126: The specified module could not be found.   - D:/a/ruby-duckdb/ruby-duckdb/lib/duckdb/duckdb_native.so (LoadError)`
-    # - name: rake test
-    #   run: |
-    #     rake test
+    - name: rake test
+      run: |
+        rake test

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # ChangeLog
 
+# 0.2.9.0
+
+- add DuckDB::Appender#append
+  - breaking change.
+    - append_timestamp is called when the argument is Time object.
+    - append_date is called when the argument is Date object.
+- add DuckDB::Appender#append_timestamp.
+- add DuckDB::Appender#append_interval. append_interval is expremental.
+- add DuckDB::Result#rows_changed
+- refactoring DuckDB::Append#append_hugeint with duckdb v0.2.9
+- test 2 versions of duckdb on github actions macos CI.
+- fix windows CI failes
+- update github actions CI on ubuntu
+- fix to build with duckdb v0.2.9
+- use duckdb_prepare_error when get error message of prepared statement.
+- add DuckDB::Appender#append_date
+- add DuckDB::Appender#append_time
+
+# 0.2.8.0
+
 - DuckDB::Database.open accepts 2-nd argument as DuckDB::Config object.
 - add DuckDB::Config
 - bump duckdb to 0.2.8 in CI

data/CONTRIBUTION.md

@@ -0,0 +1,24 @@
+# Contribution Guide
+
+## Issue
+
+If you spot a problem, [search if an issue already exists](https://github.com/suketa/ruby-duckdb/issues).
+If a related issue doesn't exist, you can open a [new issue](https://github.com/suketa/ruby-duckdb/issues/new).
+
+
+## Fix Issues or Add New Features.
+
+1. install [Ruby](https://www.ruby-lang.org/) into your local machine.
+2. install [duckdb](https://duckdb.org/) into your local machine.
+3. fork the repository and `git clone` to your local machine.
+4. run `bundle install`
+5. run `rake build`
+   or you might run with C duckdb header and library directories:
+   `rake build -- --with-duckdb-include=/duckdb_header_directory --with-duckdb-lib=/duckdb_library_directory`
+6. run `rake test`
+7. create new branch to change the code.
+8. change the code.
+9. write test.
+10. run `rake test` and confirm all tests pass.
+11. git push.
+12. create PR.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.2.8.0)
+    duckdb (0.2.9.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,8 +1,8 @@
 # ruby-duckdb
 
-[![Build Status](https://travis-ci.com/suketa/ruby-duckdb.svg?branch=master)](https://travis-ci.com/suketa/ruby-duckdb)
 [![](https://github.com/suketa/ruby-duckdb/workflows/Ubuntu/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AUbuntu)
 [![](https://github.com/suketa/ruby-duckdb/workflows/MacOS/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AMacOS)
+[![](https://github.com/suketa/ruby-duckdb/workflows/Windows/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AWindows)
 
 ## Description
 
@@ -18,10 +18,10 @@ You must have [DuckDB](http://www.duckdb.org) engine installed in order to build
 gem install duckdb
 ```
 
-or you must specify the location of the include and lib files:
+or you must specify the location of the C header and library files:
 
 ```
-gem install duckdb -- --with-duckdb-include=/duckdb_include_directory --with-duckdb-lib=/duckdb_library_directory
+gem install duckdb -- --with-duckdb-include=/duckdb_header_directory --with-duckdb-lib=/duckdb_library_directory
 ```
 
 ## Usage

data/duckdb.gemspec

@@ -21,12 +21,12 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/duckdb/extconf.rb']
-  spec.required_ruby_version = '>= 2.5.0'
+  spec.required_ruby_version = '>= 2.6.0'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'minitest', '~> 5.0'

data/ext/duckdb/appender.c

@@ -24,6 +24,27 @@ static VALUE appender_append_varchar(VALUE self, VALUE val);
 static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
 static VALUE appender_append_blob(VALUE self, VALUE val);
 static VALUE appender_append_null(VALUE self);
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval);
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_INTERVAL
+static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_TIME
+static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_TIMESTAMP
+static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_HUGEINT
+static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper);
+#endif
+
 static VALUE appender_flush(VALUE self);
 static VALUE appender_close(VALUE self);
 
@@ -268,6 +289,106 @@ static VALUE appender_append_null(VALUE self) {
     return self;
 }
 
+#ifdef HAVE_DUCKDB_APPEND_DATE
+static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval) {
+    duckdb_date_struct dt_struct;
+    duckdb_date dt;
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    dt_struct.year = NUM2INT(yearval);
+    dt_struct.month = NUM2INT(monthval);
+    dt_struct.day = NUM2INT(dayval);
+    dt = duckdb_to_date(dt_struct);
+
+    if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append date");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_INTERVAL
+static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros) {
+    duckdb_interval interval;
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    interval.months = NUM2INT(months);
+    interval.days = NUM2INT(days);
+    interval.micros = NUM2LL(micros);
+
+    if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append interval");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_TIME
+static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_time_struct time_st;
+    duckdb_time time;
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    time_st.hour = NUM2INT(hour);
+    time_st.min = NUM2INT(min);
+    time_st.sec = NUM2INT(sec);
+    time_st.micros = NUM2INT(micros);
+
+    time = duckdb_to_time(time_st);
+
+    if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append time");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_TIMESTAMP
+static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_timestamp_struct timestamp_st;
+    duckdb_timestamp timestamp;
+
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    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);
+
+    timestamp = duckdb_to_timestamp(timestamp_st);
+
+    if (duckdb_append_timestamp(ctx->appender, timestamp) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append timestamp");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_HUGEINT
+static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
+    duckdb_hugeint hugeint;
+
+    hugeint.lower = NUM2ULL(lower);
+    hugeint.upper = NUM2LL(upper);
+
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    if (duckdb_append_hugeint(ctx->appender, hugeint) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append hugeint");
+    }
+    return self;
+}
+#endif
+
 static VALUE appender_flush(VALUE self) {
     rubyDuckDBAppender *ctx;
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
@@ -309,6 +430,21 @@ void init_duckdb_appender(void) {
     rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
     rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
     rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
+#ifdef HAVE_DUCKDB_APPEND_DATE
+    rb_define_private_method(cDuckDBAppender, "_append_date", appender__append_date, 3);
+#endif
+#ifdef HAVE_DUCKDB_APPEND_INTERVAL
+    rb_define_private_method(cDuckDBAppender, "_append_interval", appender__append_interval, 3);
+#endif
+#ifdef HAVE_DUCKDB_APPEND_TIME
+    rb_define_private_method(cDuckDBAppender, "_append_time", appender__append_time, 4);
+#endif
+#ifdef HAVE_DUCKDB_APPEND_TIMESTAMP
+    rb_define_private_method(cDuckDBAppender, "_append_timestamp", appender__append_timestamp, 7);
+#endif
+#ifdef HAVE_DUCKDB_APPEND_HUGEINT
+    rb_define_private_method(cDuckDBAppender, "_append_hugeint", appender__append_hugeint, 2);
+#endif
     rb_define_method(cDuckDBAppender, "flush", appender_flush, 0);
     rb_define_method(cDuckDBAppender, "close", appender_close, 0);
 }

data/ext/duckdb/config.c

@@ -37,7 +37,7 @@ static VALUE config_initialize(VALUE self) {
 }
 
 static VALUE config_s_size(VALUE self) {
-    return INT2NUM(duckdb_config_count());
+    return ULONG2NUM(duckdb_config_count());
 }
 
 static VALUE config_s_get_config_flag(VALUE klass, VALUE value) {

data/ext/duckdb/extconf.rb

@@ -2,11 +2,23 @@ require 'mkmf'
 
 dir_config('duckdb')
 if have_library('duckdb')
+  if have_func('duckdb_nparams(NULL)', 'duckdb.h')
+    $defs << '-DHAVE_DUCKDB_NPARAMS_029'
+  elsif have_func('duckdb_nparams(NULL, NULL)', 'duckdb.h')
+    $defs << '-DHAVE_DUCKDB_NPARAMS_028'
+  end
+
   have_func('duckdb_value_blob', 'duckdb.h')
   have_func('duckdb_bind_blob', 'duckdb.h')
   have_func('duckdb_appender_create', 'duckdb.h')
   have_func('duckdb_free', 'duckdb.h')
   have_func('duckdb_create_config', 'duckdb.h')
   have_func('duckdb_open_ext', 'duckdb.h')
+  have_func('duckdb_prepare_error', 'duckdb.h')
+  have_func('duckdb_append_date', 'duckdb.h')
+  have_func('duckdb_append_interval', 'duckdb.h')
+  have_func('duckdb_append_time', 'duckdb.h')
+  have_func('duckdb_append_timestamp', 'duckdb.h')
+  have_func('duckdb_append_hugeint', 'duckdb.h')
   create_makefile('duckdb/duckdb_native')
 end

data/ext/duckdb/prepared_statement.c

@@ -29,8 +29,13 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
     Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
+#ifdef HAVE_DUCKDB_PREPARE_ERROR
+        const char *error = duckdb_prepare_error(ctx->prepared_statement);
+        rb_raise(eDuckDBError, "%s", error);
+#else
         /* TODO: include query parameter information in error message. */
         rb_raise(eDuckDBError, "failed to prepare statement");
+#endif
     }
     return self;
 }
@@ -39,11 +44,14 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self)
 {
     rubyDuckDBPreparedStatement *ctx;
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-
+#ifdef HAVE_DUCKDB_NPARAMS_029
+    return rb_int2big(duckdb_nparams(ctx->prepared_statement));
+#else
     if (duckdb_nparams(ctx->prepared_statement, &(ctx->nparams)) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to get number of parameters");
     }
     return rb_int2big(ctx->nparams);
+#endif
 }
 
 

data/ext/duckdb/result.c

@@ -2,59 +2,50 @@
 
 static VALUE cDuckDBResult;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
     duckdb_destroy_result(&(p->result));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBResult));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     bool bval = duckdb_value_boolean(result, col_idx, row_idx);
     return bval ? Qtrue : Qnil;
 }
 
-static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
     return INT2FIX(i16val);
 }
 
-static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
     return INT2NUM(i32val);
 }
 
-static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
     return rb_int2big(i64val);
 }
 
-static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     float fval = duckdb_value_float(result, col_idx, row_idx);
     return DBL2NUM(fval);
 }
 
-static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     double dval = duckdb_value_double(result, col_idx, row_idx);
     return DBL2NUM(dval);
 }
 
 #ifdef HAVE_DUCKDB_VALUE_BLOB
-static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     VALUE str;
     duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
     str = rb_str_new(bval.data, bval.size);
@@ -71,8 +62,7 @@ static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx,
 }
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     char *p;
     VALUE obj = Qnil;
     if (result->columns[col_idx].nullmask[row_idx]) {
@@ -112,8 +102,7 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
     return obj;
 }
 
-static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx)
-{
+static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx) {
     idx_t col_idx;
     VALUE ary = rb_ary_new2(ctx->result.column_count);
     for(col_idx = 0; col_idx < ctx->result.column_count; col_idx++) {
@@ -122,16 +111,14 @@ static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx)
     return ary;
 }
 
-static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj)
-{
+static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj) {
     rubyDuckDBResult *ctx;
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
 
     return LONG2FIX(ctx->result.row_count);
 }
 
-static VALUE duckdb_result_each(VALUE oDuckDBResult)
-{
+static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     idx_t row_idx = 0;
 
@@ -144,15 +131,42 @@ static VALUE duckdb_result_each(VALUE oDuckDBResult)
     return oDuckDBResult;
 }
 
-VALUE create_result(void)
-{
+/*
+ *  call-seq:
+ *    result.rows_changed -> integer
+ *
+ *  Returns the count of rows changed.
+ *
+ *    DuckDB::Database.open do |db|
+ *      db.connect do |con|
+ *        r = con.query('CREATE TABLE t2 (id INT)')
+ *        r.rows_changed # => 0
+ *        r = con.query('INSERT INTO t2 VALUES (1), (2), (3)')
+ *        r.rows_changed # => 3
+ *        r = con.query('UPDATE t2 SET id = id + 1 WHERE id > 1')
+ *        r.rows_changed # => 2
+ *        r = con.query('DELETE FROM t2 WHERE id = 0')
+ *        r.rows_changed # => 0
+ *        r = con.query('DELETE FROM t2 WHERE id = 4')
+ *        r.rows_changed # => 1
+ *      end
+ *    end
+ *
+ */
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
+    return LL2NUM(ctx->result.rows_changed);
+}
+
+VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-void init_duckdb_result(void)
-{
+void init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "each", duckdb_result_each, 0);
+    rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
 }

data/lib/duckdb/appender.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'time'
 
 module DuckDB
   if defined?(DuckDB::Appender)
@@ -16,13 +17,158 @@ 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
 
+      #
+      # 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
+          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)
+        case value
+        when Date, Time
+          date = value
+        when String
+          begin
+            date = Date.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
+          end
+        else
+          raise(ArgumentError, "Argument `#{value}` must be Date, Time or String.")
+        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)
+        case value
+        when Time
+          time = value
+        when String
+          begin
+            time = Time.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
+          end
+        else
+          raise(ArgumentError, "Argument `#{value}` must be Time or String.")
+        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)
+        case value
+        when Time
+          time = value
+        when Date
+          time = value.to_time
+        when String
+          begin
+            time = Time.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value.class} #{value}` to Time.")
+          end
         else
-          rb_raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+          raise(ArgumentError, "Argument `#{value.class} #{value}` must be Time or Date or String.")
         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
 
       #
@@ -64,11 +210,19 @@ module DuckDB
         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
 
@@ -97,6 +251,53 @@ module DuckDB
       def blob?(value)
         value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
       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
 end

data/lib/duckdb/prepared_statement.rb

@@ -22,7 +22,7 @@ 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
 
@@ -40,7 +40,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')
+        respond_to?(:bind_null) ? bind_null(i) : raise(DuckDB::Error, 'This bind method does not support nil value. Re-compile ruby-duckdb with DuckDB version >= 0.1.1')
       when Float
         bind_double(i, value)
       when Integer
@@ -63,7 +63,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.2.9.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.2.8.0
+  version: 0.2.9.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-04 00:00:00.000000000 Z
+date: 2021-10-24 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
@@ -131,7 +131,7 @@ 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:
   - - ">="

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/