duckdb 0.2.6.0 → 0.2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96e1030a16d014daaab4b84c0c15cde0d023fcb0fb761bee97056127f3530533
-  data.tar.gz: 2010828495199a8959b2246c0de6262de273387daaa3b3b9a8ebbca6e2fda47c
+  metadata.gz: af998f52f46c0ef8f51501333cbaf39d720daaa389eb618d7d7ad79627d70ad9
+  data.tar.gz: 8e1c5323fa2f917c9ab6050a0350e5e25b646559492501f636af026b79cb20f8
 SHA512:
-  metadata.gz: da434b1e0f179cf6392beb998be0eba637cd782a74a4ea4474752b1c900afe1cbf43a5816cb7ff37c8b6e34226a0a2bcc4e4e89e54c28697e5ec39695775f31f
-  data.tar.gz: be2f05c2b472db0e548da9acd69aebd41ff0685fdcf925970af36d489882539a88fb51c49a791edd1e4f34daf9aac16311e15ce6771e9f504b987e1d29e1aa93
+  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.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
@@ -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.7', '2.7.3', '3.0.1', 'head']
-        duckdb: ['0.2.6', '0.2.5']
+        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.6 cache
-      id: duckdb-cache-v0_2_6
-      uses: actions/cache@v1.1.0
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v2
       with:
-        path: duckdb-v0.2.6
-        key: ${{ runner.os }}-duckdb-v0_2_6_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_6
+        path: duckdb-v${{ matrix.duckdb }}
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
 
-    - name: duckdb 0.2.5 cache
-      id: duckdb-cache-v0_2_5
-      uses: actions/cache@v1.1.0
-      with:
-        path: duckdb-v0.2.5
-        key: ${{ runner.os }}-duckdb-v0_2_5_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_5
-
-    - 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.5
-      if: steps.duckdb-cache-v0_2_5.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.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 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

@@ -0,0 +1,43 @@
+name: Windows
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
+        duckdb: ['0.2.8', '0.2.9']
+
+    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
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${env:DUCKDB_VERSION}/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=../../../..
+    - 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

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # 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
+- 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

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,13 +1,13 @@
 PATH
   remote: .
   specs:
-    duckdb (0.2.6.0)
+    duckdb (0.2.9.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.17
+   2.2.25

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
@@ -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/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);
 
@@ -112,7 +133,7 @@ static VALUE appender_append_int8(VALUE self, VALUE val) {
 
 static VALUE appender_append_int16(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
-    int16_t i16val = NUM2INT(val);
+    int16_t i16val = (int16_t)NUM2INT(val);
 
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
 
@@ -136,7 +157,7 @@ static VALUE appender_append_int32(VALUE self, VALUE val) {
 
 static VALUE appender_append_int64(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
-    int64_t i64val = NUM2LL(val);
+    int64_t i64val = (int64_t)NUM2LL(val);
 
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
 
@@ -184,7 +205,7 @@ static VALUE appender_append_uint32(VALUE self, VALUE val) {
 
 static VALUE appender_append_uint64(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
-    uint64_t ui64val = (int64_t)NUM2ULL(val);
+    uint64_t ui64val = (uint64_t)NUM2ULL(val);
 
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
 
@@ -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

@@ -0,0 +1,80 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_CREATE_CONFIG
+
+VALUE cDuckDBConfig;
+
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static VALUE config_s_size(VALUE klass);
+static VALUE config_s_get_config_flag(VALUE self, VALUE value);
+static VALUE config_initialize(VALUE self);
+static VALUE config_set_config(VALUE self, VALUE key, VALUE value);
+
+static void deallocate(void * ctx)
+{
+    rubyDuckDBConfig *p = (rubyDuckDBConfig *)ctx;
+
+    duckdb_destroy_config(&(p->config));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass)
+{
+    rubyDuckDBConfig *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConfig));
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+static VALUE config_initialize(VALUE self) {
+    rubyDuckDBConfig *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBConfig, ctx);
+
+    if (duckdb_create_config(&(ctx->config)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create config");
+    }
+    return self;
+}
+
+static VALUE config_s_size(VALUE self) {
+    return ULONG2NUM(duckdb_config_count());
+}
+
+static VALUE config_s_get_config_flag(VALUE klass, VALUE value) {
+    const char *pkey;
+    const char *pdesc;
+
+    size_t i = NUM2INT(value);
+
+    if (duckdb_get_config_flag(i, &pkey, &pdesc) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to get config information of index %ld", i);
+    }
+
+    return rb_ary_new3(2, rb_str_new2(pkey), rb_str_new2(pdesc));
+}
+
+static VALUE config_set_config(VALUE self, VALUE key, VALUE value) {
+    const char *pkey = StringValuePtr(key);
+    const char *pval = StringValuePtr(value);
+
+    rubyDuckDBConfig *ctx;
+    Data_Get_Struct(self, rubyDuckDBConfig, ctx);
+
+    if (duckdb_set_config(ctx->config, pkey, pval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to set config %s => %s", pkey, pval);
+    }
+    return self;
+}
+
+void init_duckdb_config(void) {
+    cDuckDBConfig = rb_define_class_under(mDuckDB, "Config", rb_cObject);
+    rb_define_alloc_func(cDuckDBConfig, allocate);
+    rb_define_singleton_method(cDuckDBConfig, "size", config_s_size, 0);
+    rb_define_singleton_method(cDuckDBConfig, "get_config_flag", config_s_get_config_flag, 1);
+
+    rb_define_method(cDuckDBConfig, "initialize", config_initialize, 0);
+    rb_define_method(cDuckDBConfig, "set_config", config_set_config, 2);
+}
+
+#endif
+

data/ext/duckdb/config.h

@@ -0,0 +1,18 @@
+#ifndef RUBY_DUCKDB_CONFIG_H
+#define RUBY_DUCKDB_CONFIG_H
+
+#ifdef HAVE_DUCKDB_CREATE_CONFIG
+
+struct _rubyDuckDBConfig {
+    duckdb_config config;
+};
+
+typedef struct _rubyDuckDBConfig rubyDuckDBConfig;
+
+void init_duckdb_config(void);
+
+#endif
+
+#endif
+
+