duckdb 0.0.12 → 0.2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a0f6c8a46cecbe281cf970b5e8c6fd11c2903a5ddd58bf683341bcb299d7a36
-  data.tar.gz: 6ba452c2aa37f77c68905413e3bb6cb27697f8db23bfeca1e8ca1886ce6fb1ab
+  metadata.gz: a07cf98bca895ec39cc43754e6f69544e22c16cab023554daa632dc0be14d527
+  data.tar.gz: d2e96a7556e9ab139fb4b03f8306961d011c80ff9eb259bb8f29cdbd390ea757
 SHA512:
-  metadata.gz: beb0db8d6e590ee4014aa4fb1e09a7093d6b13cebe3ad38f90cf6f29707b5e768696732f33c5d53027032ba7eacc8bf8ddecb9b112a042f05b17bbb98e086197
-  data.tar.gz: 228651ac8ed6c13044cbf0e3709444464ff552b0b431b051446def7dce074b38ef8a242f72e75c8c1ba788ae13dfc88a2041f7f2e9e70b64fb3c34c9c2c8ad85
+  metadata.gz: fc64b4021083e0837de1c22470b015be7337f2e43754771c36b4265f133542bb7161762fa51a46f2ec9f9ac992bf67bb45e7d8031206f4cd385f248bddcff14d
+  data.tar.gz: 131cb3b1ee245cb765b8b7081d8fb900634055cf6570e6220121991e275d53e7be44ac1c1274c64f4c8991cd3252823274fd887fa3b49a31c8dc9578dd4aade6

data/.github/workflows/test_on_macos.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.6', '2.7.2', '3.0.0', 'head']
+        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
 
     steps:
     - uses: actions/checkout@v2
@@ -17,15 +17,9 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: Install duckdb
-      env:
-        DUCKDB_VERSION: 0.2.4
+    - name: Install latest duckdb by brew
       run: |
         brew install duckdb
-        git clone -b v${DUCKDB_VERSION} https://github.com/cwida/duckdb.git duckdb-v${DUCKDB_VERSION}
-        cp duckdb-v${DUCKDB_VERSION}/src/include/duckdb.h /usr/local/include
-        mkdir -p /usr/local/include/duckdb/common
-        cp duckdb-v${DUCKDB_VERSION}/src/include/duckdb/common/winapi.hpp /usr/local/include/duckdb/common
 
     - 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.6', '2.7.2', '3.0.0', 'head']
-        duckdb: ['0.2.4', '0.2.5']
+        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
+        duckdb: ['0.2.8', '0.2.7']
 
     steps:
     - uses: actions/checkout@v2
@@ -19,43 +19,43 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: duckdb 0.2.4 cache
-      id: duckdb-cache-v0_2_4
+    - name: duckdb 0.2.8 cache
+      id: duckdb-cache-v0_2_8
       uses: actions/cache@v1.1.0
       with:
-        path: duckdb-v0.2.4
-        key: ${{ runner.os }}-duckdb-v0_2_4_001
+        path: duckdb-v0.2.8
+        key: ${{ runner.os }}-duckdb-v0_2_8_001
         restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_4
+          ${{ runner.os }}-duckdb-v0_2_8
 
-    - name: duckdb 0.2.5 cache
-      id: duckdb-cache-v0_2_5
+    - name: duckdb 0.2.7 cache
+      id: duckdb-cache-v0_2_7
       uses: actions/cache@v1.1.0
       with:
-        path: duckdb-v0.2.5
-        key: ${{ runner.os }}-duckdb-v0_2_5_001
+        path: duckdb-v0.2.7
+        key: ${{ runner.os }}-duckdb-v0_2_7_001
         restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_5
+          ${{ runner.os }}-duckdb-v0_2_7
 
-    - name: Build duckdb 0.2.4
-      if: steps.duckdb-cache-v0_2_4.outputs.cache-hit != 'true'
+    - name: Build duckdb 0.2.8
+      if: steps.duckdb-cache-v0_2_8.outputs.cache-hit != 'true'
       run: |
-        git clone -b v0.2.4 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.4
-        cd duckdb-tmp-v0.2.4 && make && cd ..
-        rm -rf duckdb-v0.2.4
-        mkdir -p duckdb-v0.2.4/build/release/src duckdb-v0.2.4/src
-        cp -rip duckdb-tmp-v0.2.4/build/release/src/*.so duckdb-v0.2.4/build/release/src
-        cp -rip duckdb-tmp-v0.2.4/src/include duckdb-v0.2.4/src/
+        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.5
-      if: steps.duckdb-cache-v0_2_5.outputs.cache-hit != 'true'
+    - name: Build duckdb 0.2.7
+      if: steps.duckdb-cache-v0_2_7.outputs.cache-hit != 'true'
       run: |
-        git clone -b v0.2.5 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.5
-        cd duckdb-tmp-v0.2.5 && make && cd ..
-        rm -rf duckdb-v0.2.5
-        mkdir -p duckdb-v0.2.5/build/release/src duckdb-v0.2.5/src
-        cp -rip duckdb-tmp-v0.2.5/build/release/src/*.so duckdb-v0.2.5/build/release/src
-        cp -rip duckdb-tmp-v0.2.5/src/include duckdb-v0.2.5/src/
+        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:

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

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # ChangeLog
 
+- DuckDB::Database.open accepts 2-nd argument as DuckDB::Config object.
+- add DuckDB::Config
+- bump duckdb to 0.2.8 in CI
+- bump Ruby to 2.6.8, 2.7.4, 3.0.2 in CI
+
+# 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

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    duckdb (0.0.12)
+    duckdb (0.2.8.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.14.4)
-    rake (13.0.3)
+    rake (13.0.6)
     rake-compiler (1.1.1)
       rake
 
@@ -22,4 +22,4 @@ DEPENDENCIES
   rake-compiler
 
 BUNDLED WITH
-   2.2.3
+   2.2.25

data/README.md

@@ -68,7 +68,7 @@ end
 ### using BLOB column
 
 BLOB is available with DuckDB v0.2.5 or later.
-Use `DuckDB::Blob.new` or use sting#force_encoding(Encoding::ASCII_8BIT)
+Use `DuckDB::Blob.new` or use sting#force_encoding(Encoding::BINARY)
 
 ```
 require 'duckdb'
@@ -87,3 +87,83 @@ DuckDB::Database.open do |db|
   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 )
+```
+
+### Configuration
+
+Config class provides Ruby interface of [DuckDB configuration](https://duckdb.org/docs/api/c/config).
+
+```
+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
+```

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 */