duckdb 0.0.10 → 0.2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c714dfd673f10a53f717920a00ce3a8d1bd60bb31eaa7c3d678427216ef8446d
-  data.tar.gz: 8f8df0fa662a682fc977429c25a6ee41885ca4df603edfcc25cc46f960b1256a
+  metadata.gz: 309d9f5ae00645a93cd5bf8bd706f12391e1386336516d172e1963b963df5ab4
+  data.tar.gz: 8814748ae38a1b501d21b69f47b262124771ddc382dfcdbba3d7b3b88b3cb691
 SHA512:
-  metadata.gz: e67c083420270093e6a026037527f5e10273404d0666b155ee0afd5c7e308ceae268c46ef1f878b9b6a656dec6b97e048488b85be53f715d9253e1806f8601a0
-  data.tar.gz: a4501b2e7dc651147564da772f60f32dafbb21ddf846680128406ad9b64dbb6874ea3b6c15cd6e5226d35745680fb7f906eca7d0c8a72bf418594c7cd2486f53
+  metadata.gz: 96d87f3dfa1e8366e98a0a93e1f6506508c885131eb4287ec2463eea8040fb1cc87436a10871cecb83b524d97173443d9b1c42330a5f311c210ffb921b64a7d9
+  data.tar.gz: fed84bbde6a9c6b696e9a52bf769810788b7b49d845ddca065cafcfc535540d62127d395524ca4fee86cfba9213c82fe74204063ea674d14498d7f82f0c34e33

data/.github/workflows/test_on_macos.yml

@@ -0,0 +1,28 @@
+name: MacOS
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - name: Install latest duckdb by brew
+      run: |
+        brew install duckdb
+
+    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
+      run: |
+        ruby -v
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/.github/workflows/test_on_ubuntu.yml

@@ -0,0 +1,66 @@
+name: Ubuntu
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+        duckdb: ['0.2.6', '0.2.7']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - name: duckdb 0.2.6 cache
+      id: duckdb-cache-v0_2_6
+      uses: actions/cache@v1.1.0
+      with:
+        path: duckdb-v0.2.6
+        key: ${{ runner.os }}-duckdb-v0_2_6_001
+        restore-keys: |
+          ${{ runner.os }}-duckdb-v0_2_6
+
+    - 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.6
+      if: steps.duckdb-cache-v0_2_6.outputs.cache-hit != 'true'
+      run: |
+        git clone -b v0.2.6 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.6
+        cd duckdb-tmp-v0.2.6 && make && cd ..
+        rm -rf duckdb-v0.2.6
+        mkdir -p duckdb-v0.2.6/build/release/src duckdb-v0.2.6/src
+        cp -rip duckdb-tmp-v0.2.6/build/release/src/*.so duckdb-v0.2.6/build/release/src
+        cp -rip duckdb-tmp-v0.2.6/src/include duckdb-v0.2.6/src/
+
+    - name: Build duckdb 0.2.7
+      if: steps.duckdb-cache-v0_2_7.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/
+
+    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/

data/.github/workflows/test_on_windows.yml

@@ -0,0 +1,37 @@
+name: Windows
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - name: download duckdb binary for windows 64bit
+      run: |
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v0.2.6/libduckdb-windows-amd64.zip
+
+    - name: extract zip file
+      run: |
+        7z x libduckdb-windows-amd64.zip
+
+    - name: Build with Rake with Ruby ${{ matrix.ruby }}
+      run: |
+        bundle install
+        bundle exec rake build -- --with-duckdb-include=../../../.. --with-duckdb-lib=../../../..
+
+    # 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

data/.travis.yml

@@ -2,16 +2,17 @@ language: ruby
 cache:
   bundler: true
   directories:
-    - ${HOME}/duckdb-v0.2.2
+    - ${HOME}/duckdb-v0.2.7
 before_install:
   - yes | gem update --system
-  - if [[ ! -d ${HOME}/duckdb-v0.2.2/build ]]; then cd ${HOME} && git clone -b v0.2.2 https://github.com/cwida/duckdb.git duckdb-v0.2.2 && cd duckdb-v0.2.2 && make && cd ${TRAVIS_BUILD_DIR}; fi
+  - if [[ ! -d ${HOME}/duckdb-v0.2.7/build ]]; then cd ${HOME} && git clone -b v0.2.7 https://github.com/cwida/duckdb.git duckdb-v0.2.7 && cd duckdb-v0.2.7 && make && cd ${TRAVIS_BUILD_DIR}; fi
 
 env:
-  - DUCKDB_VERSION=0.2.2
+  - DUCKDB_VERSION=0.2.7
 rvm:
   - 2.5.8
-  - 2.6.6
-  - 2.7.2
+  - 2.6.7
+  - 2.7.3
+  - 3.0.1
   - 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/

data/CHANGELOG.md

@@ -1,9 +1,48 @@
 # ChangeLog
 
+# 0.2.7.0
+
+- call duckdb_free after calling duckdb_value_blob, duckdb_value_varchar.
+- bump DuckDB to v0.2.7 in CI
+- rake build on Windows in github actions.
+  - There is a issue (LoadError) when running rake test on Windows (in GitHub actions).
+
+# 0.2.6.1
+
+- add DuckDB::PreparedStatement#bind_int8
+- DuckDB::Connection#appender accepts block.
+- add DuckDB::Appender#append_row.
+- support HUGEINT type.
+- add DuckDB::Appender#append.
+- rename PreparedStatement#bind_boolean to PreparedStatement#bind_bool.
+- add DuckDB::Connection#appender.
+
+# 0.2.6.0
+
+- change version policy
+  - ruby-duckdb W.X.Y.Z supports duckdb W.X.Y
+- add DuckDB::Appender
+- bump DuckDB to v0.2.6 in CI.
+- remove unnecessary duckdb header file from MacOS CI.
+- add DuckDB::Connection#prepared_statement.
+
+## 0.0.12
+
+- bump DuckDB to v0.2.5
+- support BLOB type (with DuckDB version 0.2.5 or later)
+
+## 0.0.11
+
+- fix failure in test_close in test/duckdb_test/database_test.rb because DuckDB error message was changed.
+- bump DuckDb to v0.2.4
+- add test CI with Ruby 3.0.0
+- add test CI on MacOS.
+- bunp DuckDB to v0.2.3
+
 ## 0.0.10
 
 - bump DuckDB to v0.2.2
-- fix to build failure on MAC OS/X
+- fix to build failure on MacOS.
 
 ## 0.0.9
 

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    duckdb (0.0.10)
+    duckdb (0.2.7.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.14.2)
-    rake (13.0.1)
+    minitest (5.14.4)
+    rake (13.0.3)
     rake-compiler (1.1.1)
       rake
 
 PLATFORMS
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
   bundler (~> 2.0)
@@ -22,4 +22,4 @@ DEPENDENCIES
   rake-compiler
 
 BUNDLED WITH
-   2.1.4
+   2.2.17

data/README.md

@@ -2,6 +2,7 @@
 
 [![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)
 
 ## Description
 
@@ -63,3 +64,88 @@ DuckDB::Database.open do |db|
   end
 end
 ```
+
+### using BLOB column
+
+BLOB is available with DuckDB v0.2.5 or later.
+Use `DuckDB::Blob.new` or use sting#force_encoding(Encoding::BINARY)
+
+```
+require 'duckdb'
+
+DuckDB::Database.open do |db|
+  db.connect do |con|
+    con.query('CREATE TABLE blob_table (binary_data BLOB)')
+    stmt = DuckDB::PreparedStatement.new(con, 'INSERT INTO blob_table VALUES ($1)')
+
+    stmt.bind(1, DuckDB::Blob.new("\0\1\2\3\4\5"))
+    # stmt.bind(1, "\0\1\2\3\4\5".force_encoding(Encoding::BINARY))
+    stmt.execute
+
+    result = con.query('SELECT binary_data FROM blob_table')
+    p result.first.first
+  end
+end
+```
+
+### Appender
+
+Appender class provides Ruby interface of [DuckDB Appender](https://duckdb.org/docs/data/appender)
+
+```
+require 'duckdb'
+require 'benchmark'
+
+def insert
+  DuckDB::Database.open do |db|
+    db.connect do |con|
+      con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+      10000.times do
+        con.query("INSERT into users VALUES(1, 'Alice')")
+      end
+    end
+  end
+end
+
+def prepare
+  DuckDB::Database.open do |db|
+    db.connect do |con|
+      con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+      stmt = con.prepared_statement('INSERT INTO users VALUES($1, $2)')
+      10000.times do
+        stmt.bind(1, 1)
+        stmt.bind(2, 'Alice')
+        stmt.execute
+      end
+    end
+  end
+end
+
+def append
+  DuckDB::Database.open do |db|
+    db.connect do |con|
+      con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+      appender = con.appender('users')
+      10000.times do
+        appender.begin_row
+        appender.append(1)
+        appender.append('Alice')
+        appender.end_row
+      end
+      appender.flush
+    end
+  end
+end
+
+Benchmark.bm(8) do |x|
+  x.report('insert') { insert }
+  x.report('prepare') { prepare }
+  x.report('append') { append }
+end
+
+# =>
+#                user     system      total        real
+# insert     0.637439   0.000000   0.637439 (  0.637486 )
+# prepare    0.230457   0.000000   0.230457 (  0.230460 )
+# append     0.012666   0.000000   0.012666 (  0.012670 )
+```

data/ext/duckdb/appender.c

@@ -0,0 +1,315 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+static VALUE cDuckDBAppender;
+
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static VALUE appender_initialize(VALUE klass, VALUE con, VALUE schema, VALUE table);
+static VALUE appender_begin_row(VALUE self);
+static VALUE appender_end_row(VALUE self);
+static VALUE appender_append_bool(VALUE self, VALUE val);
+static VALUE appender_append_int8(VALUE self, VALUE val);
+static VALUE appender_append_int16(VALUE self, VALUE val);
+static VALUE appender_append_int32(VALUE self, VALUE val);
+static VALUE appender_append_int64(VALUE self, VALUE val);
+static VALUE appender_append_uint8(VALUE self, VALUE val);
+static VALUE appender_append_uint16(VALUE self, VALUE val);
+static VALUE appender_append_uint32(VALUE self, VALUE val);
+static VALUE appender_append_uint64(VALUE self, VALUE val);
+static VALUE appender_append_float(VALUE self, VALUE val);
+static VALUE appender_append_double(VALUE self, VALUE val);
+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);
+static VALUE appender_flush(VALUE self);
+static VALUE appender_close(VALUE self);
+
+static void deallocate(void * ctx)
+{
+    rubyDuckDBAppender *p = (rubyDuckDBAppender *)ctx;
+
+    duckdb_appender_destroy(&(p->appender));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass)
+{
+    rubyDuckDBAppender *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBAppender));
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE table) {
+
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAppender *ctx;
+    char *pschema = 0;
+
+    if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
+        rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
+    }
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
+
+    if (schema != Qnil) {
+        pschema = StringValuePtr(schema);
+    }
+
+    if (duckdb_appender_create(ctxcon->con, pschema, StringValuePtr(table), &(ctx->appender)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create appender");
+    }
+    return self;
+}
+
+static VALUE appender_begin_row(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_begin_row(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_end_row(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_end_row(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_append_bool(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (val != Qtrue && val != Qfalse) {
+        rb_raise(rb_eArgError, "argument must be boolean");
+    }
+
+    if (duckdb_append_bool(ctx->appender, (val == Qtrue)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append boolean");
+    }
+    return self;
+}
+
+static VALUE appender_append_int8(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int8_t i8val = (int8_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int8(ctx->appender, i8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int16(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int16_t i16val = (int16_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int16(ctx->appender, i16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int32(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int32_t i32val = (int32_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int32(ctx->appender, i32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int64(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int64_t i64val = (int64_t)NUM2LL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int64(ctx->appender, i64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint8(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int8_t ui8val = (uint8_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint8(ctx->appender, ui8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint16(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint16_t ui16val = (uint16_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint16(ctx->appender, ui16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint32(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint32_t ui32val = (uint32_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint32(ctx->appender, ui32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint64(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint64_t ui64val = (uint64_t)NUM2ULL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint64(ctx->appender, ui64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_float(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    float fval = (float)NUM2DBL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_float(ctx->appender, fval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_double(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    double dval = NUM2DBL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_double(ctx->appender, dval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_varchar(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    char *pval = StringValuePtr(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_varchar(ctx->appender, pval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
+    rubyDuckDBAppender *ctx;
+
+    char *pval = StringValuePtr(val);
+    idx_t length = (idx_t)NUM2ULL(len);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_varchar_length(ctx->appender, pval, length) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_blob(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+
+    char *pval = StringValuePtr(val);
+    idx_t length = (idx_t)RSTRING_LEN(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_blob(ctx->appender, (void *)pval, length) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_null(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_null(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_flush(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_flush(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_close(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_close(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+void init_duckdb_appender(void) {
+    cDuckDBAppender = rb_define_class_under(mDuckDB, "Appender", rb_cObject);
+    rb_define_alloc_func(cDuckDBAppender, allocate);
+    rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
+    rb_define_method(cDuckDBAppender, "begin_row", appender_begin_row, 0);
+    rb_define_method(cDuckDBAppender, "end_row", appender_end_row, 0);
+    rb_define_method(cDuckDBAppender, "append_bool", appender_append_bool, 1);
+    rb_define_method(cDuckDBAppender, "append_int8", appender_append_int8, 1);
+    rb_define_method(cDuckDBAppender, "append_int16", appender_append_int16, 1);
+    rb_define_method(cDuckDBAppender, "append_int32", appender_append_int32, 1);
+    rb_define_method(cDuckDBAppender, "append_int64", appender_append_int64, 1);
+    rb_define_method(cDuckDBAppender, "append_uint8", appender_append_uint8, 1);
+    rb_define_method(cDuckDBAppender, "append_uint16", appender_append_uint16, 1);
+    rb_define_method(cDuckDBAppender, "append_uint32", appender_append_uint32, 1);
+    rb_define_method(cDuckDBAppender, "append_uint64", appender_append_uint64, 1);
+    rb_define_method(cDuckDBAppender, "append_float", appender_append_float, 1);
+    rb_define_method(cDuckDBAppender, "append_double", appender_append_double, 1);
+    rb_define_method(cDuckDBAppender, "append_varchar", appender_append_varchar, 1);
+    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);
+    rb_define_method(cDuckDBAppender, "flush", appender_flush, 0);
+    rb_define_method(cDuckDBAppender, "close", appender_close, 0);
+}
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */

data/ext/duckdb/appender.h

@@ -0,0 +1,17 @@
+#ifndef RUBY_DUCKDB_APPENDER_H
+#define RUBY_DUCKDB_APPENDER_H
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+struct _rubyDuckDBAppender {
+    duckdb_appender appender;
+};
+
+typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
+
+void init_duckdb_appender(void);
+
+#endif
+
+#endif
+

data/ext/duckdb/blob.c

@@ -0,0 +1,11 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+
+VALUE cDuckDBBlob;
+
+void init_duckdb_blob(void)
+{
+    cDuckDBBlob = rb_define_class_under(mDuckDB, "Blob", rb_cString);
+}
+#endif /* HAVE_DUCKDB_VALUE_BLOB */

data/ext/duckdb/blob.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_DUCKDB_BLOB_H
+#define RUBY_DUCKDB_BLOB_H
+
+/*
+ * blob is supported by duckdb v0.2.5 or later
+ */
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+
+void init_duckdb_blob(void);
+
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
+#endif
+

data/ext/duckdb/duckdb.c

@@ -12,4 +12,16 @@ Init_duckdb_native(void)
     init_duckdb_connection();
     init_duckdb_result();
     init_duckdb_prepared_statement();
+
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+
+    init_duckdb_blob();
+
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+    init_duckdb_appender();
+
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */
 }

data/ext/duckdb/extconf.rb

@@ -2,5 +2,9 @@ require 'mkmf'
 
 dir_config('duckdb')
 if have_library('duckdb')
+  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')
   create_makefile('duckdb/duckdb_native')
 end

data/ext/duckdb/prepared_statement.c

@@ -70,7 +70,7 @@ static idx_t check_index(VALUE vidx)
     return idx;
 }
 
-static VALUE duckdb_prepared_statement_bind_boolean(VALUE self, VALUE vidx, VALUE val)
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val)
 {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
@@ -86,6 +86,20 @@ static VALUE duckdb_prepared_statement_bind_boolean(VALUE self, VALUE vidx, VALU
     return self;
 }
 
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    int8_t i8val = (int8_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_int8(ctx->prepared_statement, idx, i8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
 static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val)
 {
     rubyDuckDBPreparedStatement *ctx;
@@ -168,6 +182,20 @@ static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALU
     return self;
 }
 
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_blob(ctx->prepared_statement, idx, (const void *)StringValuePtr(blob), (idx_t)RSTRING_LEN(blob)) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
 static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
 {
     rubyDuckDBPreparedStatement *ctx;
@@ -189,12 +217,16 @@ void init_duckdb_prepared_statement(void)
     rb_define_method(cDuckDBPreparedStatement, "initialize", duckdb_prepared_statement_initialize, 2);
     rb_define_method(cDuckDBPreparedStatement, "execute", duckdb_prepared_statement_execute, 0);
     rb_define_method(cDuckDBPreparedStatement, "nparams", duckdb_prepared_statement_nparams, 0);
-    rb_define_method(cDuckDBPreparedStatement, "bind_boolean", duckdb_prepared_statement_bind_boolean, 2);
+    rb_define_method(cDuckDBPreparedStatement, "bind_bool", duckdb_prepared_statement_bind_bool, 2);
+    rb_define_method(cDuckDBPreparedStatement, "bind_int8", duckdb_prepared_statement_bind_int8, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int16", duckdb_prepared_statement_bind_int16, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int32", duckdb_prepared_statement_bind_int32, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int64", duckdb_prepared_statement_bind_int64, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_float", duckdb_prepared_statement_bind_float, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_double", duckdb_prepared_statement_bind_double, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_varchar", duckdb_prepared_statement_bind_varchar, 2);
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+    rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
     rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
 }

data/ext/duckdb/result.c

@@ -52,6 +52,25 @@ static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_
     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)
+{
+    VALUE str;
+    duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
+    str = rb_str_new(bval.data, bval.size);
+
+    if (bval.data) {
+#ifdef HAVE_DUCKDB_FREE
+        duckdb_free(bval.data);
+#else
+        free(bval.data);
+#endif
+    }
+
+    return str;
+}
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
 static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
 {
     char *p;
@@ -72,10 +91,23 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
         return to_ruby_obj_float(result, col_idx, row_idx);
     case DUCKDB_TYPE_DOUBLE:
         return to_ruby_obj_double(result, col_idx, row_idx);
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+    case DUCKDB_TYPE_BLOB:
+        return to_ruby_obj_string_from_blob(result, col_idx, row_idx);
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
     default:
         p = duckdb_value_varchar(result, col_idx, row_idx);
-        obj = rb_str_new2(p);
-        free(p);
+        if (p) {
+            obj = rb_str_new2(p);
+#ifdef HAVE_DUCKDB_FREE
+            duckdb_free(p);
+#else
+            free(p);
+#endif /* HAVE_DUCKDB_FREE */
+            if (result->columns[col_idx].type == DUCKDB_TYPE_HUGEINT) {
+                obj = rb_funcall(obj, rb_intern("to_i"), 0);
+            }
+        }
     }
     return obj;
 }

data/ext/duckdb/ruby-duckdb.h

@@ -9,9 +9,28 @@
 #include "./result.h"
 #include "./prepared_statement.h"
 
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+
+#include "./blob.h"
+
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+#include "./appender.h"
+
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
+
+#ifdef HAVE_DUCKDB_VALUE_BLOB
+
+extern VALUE cDuckDBBlob;
+
+#endif /* HAVE_DUCKDB_VALUE_BLOB */
+
 extern VALUE eDuckDBError;
 
 #endif

data/lib/duckdb.rb

@@ -4,6 +4,7 @@ require 'duckdb/database'
 require 'duckdb/connection'
 require 'duckdb/result'
 require 'duckdb/prepared_statement'
+require 'duckdb/appender'
 
 # DuckDB provides Ruby interface of DuckDB.
 module DuckDB

data/lib/duckdb/appender.rb

@@ -0,0 +1,102 @@
+require 'date'
+
+module DuckDB
+  if defined?(DuckDB::Appender)
+    # The DuckDB::Appender encapsulates DuckDB Appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+    #   appender = con.appender('users')
+    #   appender.append_row(1, 'Alice')
+    #
+    class Appender
+      RANGE_INT16 = (-32_768..32_767).freeze
+      RANGE_INT32 = (-2_147_483_648..2_147_483_647).freeze
+      RANGE_INT64 = (-9_223_372_036_854_775_808..9_223_372_036_854_775_807).freeze
+
+      def append_hugeint(value)
+        case value
+        when Integer
+          append_varchar(value.to_s)
+        else
+          rb_raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+        end
+      end
+
+      #
+      # appends value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+      #   appender = con.appender('users')
+      #   appender.begin_row
+      #   appender.append(1)
+      #   appender.append('Alice')
+      #   appender.end_row
+      #
+      def append(value)
+        case value
+        when NilClass
+          append_null
+        when Float
+          append_double(value)
+        when Integer
+          case value
+          when RANGE_INT16
+            append_int16(value)
+          when RANGE_INT32
+            append_int32(value)
+          when RANGE_INT64
+            append_int64(value)
+          else
+            append_hugeint(value)
+          end
+        when String
+          if defined?(DuckDB::Blob)
+            blob?(value) ? append_blob(value) : append_varchar(value)
+          else
+            append_varchar(value)
+          end
+        when TrueClass, FalseClass
+          append_bool(value)
+        when Time
+          append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+        when Date
+          append_varchar(value.strftime('%Y-%m-%d'))
+        else
+          rb_raise(DuckDB::Error, "not supported type #{value} (value.class)")
+        end
+      end
+
+      #
+      # append a row.
+      #
+      #   appender.append_row(1, 'Alice')
+      #
+      # is same as:
+      #
+      #   appender.begin_row
+      #   appender.append(1)
+      #   appender.append('Alice')
+      #   appender.end_row
+      #
+      def append_row(*args)
+        begin_row
+        args.each do |arg|
+          append(arg)
+        end
+        end_row
+      end
+
+      private
+
+      def blob?(value)
+        value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
+      end
+    end
+  end
+end

data/lib/duckdb/connection.rb

@@ -44,6 +44,35 @@ module DuckDB
       end
     end
 
+    #
+    # returns PreparedStatement object.
+    # The first argument is SQL string.
+    #
+    def prepared_statement(str)
+      PreparedStatement.new(self, str)
+    end
+
+    #
+    # returns Appender object.
+    # The first argument is table name
+    #
+    def appender(table)
+      appender = create_appender(table)
+
+      return appender unless block_given?
+
+      yield appender
+      appender.flush
+      appender.close
+    end
+
+    private
+
+    def create_appender(table)
+      t1, t2 = table.split('.')
+      t2 ? Appender.new(self, t1, t2) : Appender.new(self, t2, t1)
+    end
+
     alias execute query
     alias open connect
     alias close disconnect

data/lib/duckdb/prepared_statement.rb

@@ -13,6 +13,19 @@ module DuckDB
   #   stmt.execute
   class PreparedStatement
 
+    RANGE_INT16 = -32768..32767
+    RANGE_INT32 = -2147483648..2147483647
+    RANGE_INT64 = -9223372036854775808..9223372036854775807
+
+    def bind_hugeint(i, value)
+      case value
+      when Integer
+        bind_varchar(i, value.to_s)
+      else
+        rb_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.
@@ -31,11 +44,20 @@ module DuckDB
       when Float
         bind_double(i, value)
       when Integer
-        bind_int64(i, value)
+        case value
+        when RANGE_INT64
+          bind_int64(i, value)
+        else
+          bind_varchar(i, value.to_s)
+        end
       when String
-        bind_varchar(i, value)
+        if defined?(DuckDB::Blob)
+          blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
+        else
+          bind_varchar(i, value)
+        end
       when TrueClass, FalseClass
-        bind_boolean(i, value)
+        bind_bool(i, value)
       when Time
         bind_varchar(i, value.strftime('%Y-%m-%d %H:%M:%S.%N'))
       when Date
@@ -44,5 +66,11 @@ module DuckDB
         rb_raise(DuckDB::Error, "not supported type #{value} (value.class)")
       end
     end
+
+    private
+
+    def blob?(value)
+      value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
+    end
   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.0.10'.freeze
+  VERSION = '0.2.7.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.2.7.0
 platform: ruby
 authors:
 - Masaki Suketa
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-07 00:00:00.000000000 Z
+date: 2021-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,7 +75,9 @@ extensions:
 - ext/duckdb/extconf.rb
 extra_rdoc_files: []
 files:
-- ".github/workflows/test_by_github.yml"
+- ".github/workflows/test_on_macos.yml"
+- ".github/workflows/test_on_ubuntu.yml"
+- ".github/workflows/test_on_windows.yml"
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG.md
@@ -87,6 +89,10 @@ files:
 - bin/console
 - bin/setup
 - duckdb.gemspec
+- ext/duckdb/appender.c
+- ext/duckdb/appender.h
+- ext/duckdb/blob.c
+- ext/duckdb/blob.h
 - ext/duckdb/connection.c
 - ext/duckdb/connection.h
 - ext/duckdb/database.c
@@ -101,6 +107,7 @@ files:
 - ext/duckdb/result.h
 - ext/duckdb/ruby-duckdb.h
 - lib/duckdb.rb
+- lib/duckdb/appender.rb
 - lib/duckdb/connection.rb
 - lib/duckdb/database.rb
 - lib/duckdb/prepared_statement.rb
@@ -113,7 +120,7 @@ metadata:
   homepage_uri: https://github.com/suketa/ruby-duckdb
   source_code_uri: https://github.com/suketa/ruby-duckdb
   changelog_uri: https://github.com/suketa/ruby-duckdb/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,8 +135,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.
 test_files: []

data/.github/workflows/test_by_github.yml

@@ -1,66 +0,0 @@
-name: Ubuntu
-
-on: [push]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby: ['2.5.8', '2.6.6', '2.7.2', 'head']
-        duckdb: ['0.2.2', '0.2.1']
-
-    steps:
-    - uses: actions/checkout@v2
-
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-
-    - name: duckdb 0.2.2 cache
-      id: duckdb-cache-v0_2_2
-      uses: actions/cache@v1.1.0
-      with:
-        path: duckdb-v0.2.2
-        key: ${{ runner.os }}-duckdb-v0_2_2_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_2
-
-    - name: duckdb 0.2.1 cache
-      id: duckdb-cache-v0_2_1
-      uses: actions/cache@v1.1.0
-      with:
-        path: duckdb-v0.2.1
-        key: ${{ runner.os }}-duckdb-v0_2_1_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_1
-
-    - name: Build duckdb 0.2.2
-      if: steps.duckdb-cache-v0_2_2.outputs.cache-hit != 'true'
-      run: |
-        git clone -b v0.2.2 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.2
-        cd duckdb-tmp-v0.2.2 && make && cd ..
-        rm -rf duckdb-v0.2.2
-        mkdir -p duckdb-v0.2.2/build/release/src duckdb-v0.2.2/src
-        cp -rip duckdb-tmp-v0.2.2/build/release/src/*.so duckdb-v0.2.2/build/release/src
-        cp -rip duckdb-tmp-v0.2.2/src/include duckdb-v0.2.2/src/
-
-    - name: Build duckdb 0.2.1
-      if: steps.duckdb-cache-v0_2_1.outputs.cache-hit != 'true'
-      run: |
-        git clone -b v0.2.1 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.1
-        cd duckdb-tmp-v0.2.1 && make && cd ..
-        rm -rf duckdb-v0.2.1
-        mkdir -p duckdb-v0.2.1/build/release/src duckdb-v0.2.1/src
-        cp -rip duckdb-tmp-v0.2.1/build/release/src/*.so duckdb-v0.2.1/build/release/src
-        cp -rip duckdb-tmp-v0.2.1/src/include duckdb-v0.2.1/src/
-
-    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
-      env:
-        DUCKDB_VERSION: ${{ matrix.duckdb }}
-      run: |
-        gem install bundler
-        bundle install --jobs 4 --retry 3
-        bundle exec rake -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/