duckdb 0.3.1.0 → 0.3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba5fa57fc1eaf1a2b0bb6ffa7379b8982d3858d17075c83b949af79331322a1e
-  data.tar.gz: cbe87ed1de6de024e9941e063102e7bf31a5407945d99180121a38fde703a8d4
+  metadata.gz: 96ad27d302c878ca4d207d86e1eb24e61be890c8585d6bd9231237900479053d
+  data.tar.gz: 4e0fb0daf725f53acd454ee77c179ef1af57a96b9308bc6f303853e28fe9b9a6
 SHA512:
-  metadata.gz: 52d8cff8db75e7e2d7f86632573fda6d1fe021e7ff38524edf9307e2d3c4720541daab609caee24307c3a8b6a0fa40d6b1cca4151d1edbb8b17f3c7f770bb7d3
-  data.tar.gz: 371925fa099235c382cdd370f0d43d346f40b9dc45332931956f953ab742b0a55ec7afa52f73aa942695fe30b1df78722e7afadb1de66a6250381fdf0ed990f8
+  metadata.gz: b407a06ebf245a9534362a5106fe7d8bd74a55f2234bf2c734da067f2a8ef150472f8b40a312acd9d0957fb27515ec67fb536cf019375825e6e62d2c1ea82e8e
+  data.tar.gz: e2da40b4d0cb0eb25a77a6e1b383cf54a4bd8618cc31d670f59d5068c74603e41d14c4f57f9e3f909a339798f7e2a0d0143239483aef8ea8094c92cdcac417f4

data/.github/workflows/test_on_macos.yml

@@ -1,14 +1,22 @@
 name: MacOS
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
-        duckdb: ['0.3.0', '0.3.1']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2

data/.github/workflows/test_on_ubuntu.yml

@@ -1,6 +1,14 @@
 name: Ubuntu
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
@@ -8,8 +16,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
-        duckdb: ['0.3.0', '0.3.1']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2

data/.github/workflows/test_on_windows.yml

@@ -1,14 +1,22 @@
 name: Windows
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['2.6.8', '2.7.4', '3.0.2', 'head']
-        duckdb: ['0.3.0', '0.3.1']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'mingw', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2
@@ -26,15 +34,16 @@ jobs:
 
     - name: extract zip file
       run: |
-        7z x libduckdb-windows-amd64.zip
+        unzip libduckdb-windows-amd64.zip
+
+    - name: setup duckdb.dll
+      run: |
+        cp duckdb.dll C:/Windows/System32/
 
     - 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/
 
     - name: rake test
       run: |

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # ChangeLog
 
+# 0.3.2.0
+
+- bind_time, bind_timestamp, bind_date, bind_timeinterval to DuckDB::PreparedStatement
+- bump duckdb 0.3.2
+- bump Ruby 3.1.1, add Ruby mingw in CI.
+- bump Ruby 2.6.9, 2.7.5, 3.0.3 in CI.
+
+## BREAKING CHANGE
+- drop duckdb <= 0.2.8
+
 # 0.3.1.0
 
 - bump duckdb to 0.3.1 in CI.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.3.1.0)
+    duckdb (0.3.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -12,6 +12,7 @@ GEM
       rake
 
 PLATFORMS
+  ruby
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -12,11 +12,39 @@ ruby-duckdb is Ruby binding for [DuckDB](http://www.duckdb.org) database engine
 
 You must have [DuckDB](http://www.duckdb.org) engine installed in order to build/use this module.
 
+## Pre-requisite setup (Linux):
+1. Head over to the [DuckDB](https://duckdb.org/) webpage
+
+2. Download the latest C++ package release for DuckDB
+
+3. Move the files to their respective location:
+    - Extract the `duckdb.h` and `duckdb.hpp` file to `/usr/local/include`
+    - Extract the `libduckdb.so` file to `/usr/local/lib`
+    
+    ```sh
+    unzip libduckdb-linux-amd64.zip -d libduckdb
+    sudo mv libduckdb/duckdb.* /usr/local/include/
+    sudo mv libduckdb/libduckdb.so /usr/local/lib
+    ```
+4. To create the necessary link, run `ldconfig` as root:
+  
+    ```sh
+    sudo ldconfig /usr/local/lib # adding a --verbose flag is optional - but this will let you know if the libduckdb.so library has been linked
+    ```
+## Pre-requisite setup (MacOS):
+
+Using `brew install` is recommended.
+
+```sh
+brew install duckdb
+```
+
 ## How to Install
 
 ```
 gem install duckdb
 ```
+> this will work fine with the above pre-requisite setup.
 
 or you must specify the location of the C header and library files:
 

data/ext/duckdb/appender.c

@@ -48,16 +48,14 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper);
 static VALUE appender_flush(VALUE self);
 static VALUE appender_close(VALUE self);
 
-static void deallocate(void * ctx)
-{
+static void deallocate(void * ctx) {
     rubyDuckDBAppender *p = (rubyDuckDBAppender *)ctx;
 
     duckdb_appender_destroy(&(p->appender));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBAppender *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBAppender));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
@@ -290,16 +288,12 @@ 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) {
-    duckdb_date_struct dt_struct;
+static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
     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);
+    dt = to_duckdb_date_from_value(year, month, day);
 
     if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append date");
@@ -314,9 +308,7 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
     rubyDuckDBAppender *ctx;
 
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
-    interval.months = NUM2INT(months);
-    interval.days = NUM2INT(days);
-    interval.micros = NUM2LL(micros);
+    to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append interval");
@@ -327,17 +319,11 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
 
 #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);
+    time = to_duckdb_time_from_value(hour, min, sec, micros);
 
     if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append time");
@@ -348,22 +334,13 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
 
 #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);
+    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
 
     if (duckdb_append_timestamp(ctx->appender, timestamp) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append timestamp");

data/ext/duckdb/blob.c

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

data/ext/duckdb/blob.h

@@ -4,11 +4,7 @@
 /*
  * 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/config.c

@@ -11,16 +11,14 @@ 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)
-{
+static void deallocate(void * ctx) {
     rubyDuckDBConfig *p = (rubyDuckDBConfig *)ctx;
 
     duckdb_destroy_config(&(p->config));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBConfig *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConfig));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }

data/ext/duckdb/connection.c

@@ -78,13 +78,12 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     }
 
     if (duckdb_query(ctx->con, StringValueCStr(str), &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;
 }
 
-void init_duckdb_connection(void)
-{
+void init_duckdb_connection(void) {
     cDuckDBConnection = rb_define_class_under(mDuckDB, "Connection", rb_cObject);
     rb_define_alloc_func(cDuckDBConnection, allocate);
 

data/ext/duckdb/duckdb.c

@@ -3,8 +3,7 @@
 VALUE mDuckDB;
 
 void
-Init_duckdb_native(void)
-{
+Init_duckdb_native(void) {
     mDuckDB = rb_define_module("DuckDB");
 
     init_duckdb_error();
@@ -12,13 +11,8 @@ 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();

data/ext/duckdb/error.c

@@ -2,7 +2,6 @@
 
 VALUE eDuckDBError;
 
-void init_duckdb_error(void)
-{
+void init_duckdb_error(void) {
     eDuckDBError = rb_define_class_under(mDuckDB, "Error", rb_eStandardError);
 }

data/ext/duckdb/extconf.rb

@@ -1,24 +1,33 @@
 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')
+
+raise 'duckdb library is not found. Install duckdb library file and header file.' unless have_library('duckdb')
+
+raise 'duckdb >= 0.2.9 is required. Install duckdb >= 0.2.9' unless have_func('duckdb_value_is_null', 'duckdb.h')
+
+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_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')
+
+have_func('duckdb_bind_date', 'duckdb.h')
+have_func('duckdb_bind_time', 'duckdb.h')
+have_func('duckdb_bind_timestamp', 'duckdb.h')
+have_func('duckdb_bind_interval', 'duckdb.h')
+
+create_makefile('duckdb/duckdb_native')

data/ext/duckdb/prepared_statement.c

@@ -2,22 +2,53 @@
 
 static VALUE cDuckDBPreparedStatement;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query);
+static VALUE duckdb_prepared_statement_nparams(VALUE self);
+static VALUE duckdb_prepared_statement_execute(VALUE self);
+static idx_t check_index(VALUE vidx);
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str);
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob);
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx);
+
+#ifdef HAVE_DUCKDB_BIND_DATE
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIME
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
+#endif
+
+
+static void deallocate(void *ctx) {
     rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
 
     duckdb_destroy_prepare(&(p->prepared_statement));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBPreparedStatement *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPreparedStatement));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query)
-{
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBPreparedStatement *ctx;
 
@@ -40,8 +71,7 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
     return self;
 }
 
-static VALUE duckdb_prepared_statement_nparams(VALUE self)
-{
+static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
 #ifdef HAVE_DUCKDB_NPARAMS_029
@@ -55,8 +85,7 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self)
 }
 
 
-static VALUE duckdb_prepared_statement_execute(VALUE self)
-{
+static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
     VALUE result = create_result();
@@ -64,13 +93,12 @@ static VALUE duckdb_prepared_statement_execute(VALUE self)
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
     Data_Get_Struct(result, rubyDuckDBResult, ctxr);
     if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;
 }
 
-static idx_t check_index(VALUE vidx)
-{
+static idx_t check_index(VALUE vidx) {
     idx_t idx = FIX2INT(vidx);
     if (idx <= 0) {
         rb_raise(rb_eArgError, "index of parameter must be greater than 0");
@@ -78,8 +106,7 @@ static idx_t check_index(VALUE vidx)
     return idx;
 }
 
-static VALUE duckdb_prepared_statement_bind_bool(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);
 
@@ -94,8 +121,7 @@ static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val)
-{
+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);
@@ -108,8 +134,7 @@ static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int16_t i16val = NUM2INT(val);
@@ -122,8 +147,7 @@ static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int32_t i32val = NUM2INT(val);
@@ -136,8 +160,7 @@ static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int64_t i64val = NUM2LL(val);
@@ -150,8 +173,7 @@ static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -164,8 +186,7 @@ static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -178,8 +199,7 @@ static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str)
-{
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -190,9 +210,7 @@ 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)
-{
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -202,10 +220,8 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
     }
     return self;
 }
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
-{
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -216,8 +232,72 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
     return self;
 }
 
-void init_duckdb_prepared_statement(void)
-{
+#ifdef HAVE_DUCKDB_BIND_DATE
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_date dt;
+    idx_t idx = check_index(vidx);
+
+    dt = to_duckdb_date_from_value(year, month, day);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_date(ctx->prepared_statement, idx, dt) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIME
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_time time;
+
+    idx_t idx = check_index(vidx);
+
+    time = to_duckdb_time_from_value(hour, min, sec, micros);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_time(ctx->prepared_statement, idx, time) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_timestamp timestamp;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
+    duckdb_interval interval;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    to_duckdb_interval_from_value(&interval, months, days, micros);
+
+    if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+void init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
@@ -233,8 +313,16 @@ void init_duckdb_prepared_statement(void)
     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);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", duckdb_prepared_statement__bind_date, 4);
+#ifdef HAVE_DUCKDB_BIND_TIME
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_time", duckdb_prepared_statement__bind_time, 5);
+#endif
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", duckdb_prepared_statement__bind_timestamp, 8);
+#endif
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", duckdb_prepared_statement__bind_interval, 4);
+#endif
 }

data/ext/duckdb/result.c

@@ -2,6 +2,21 @@
 
 static VALUE cDuckDBResult;
 
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE to_ruby_obj_boolean(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);
+static VALUE to_ruby_obj_integer(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);
+static VALUE to_ruby_obj_float(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);
+static VALUE to_ruby_obj_string_from_blob(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);
+static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx);
+static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj);
+static VALUE duckdb_result_each(VALUE oDuckDBResult);
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
+
 static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
@@ -44,7 +59,6 @@ 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);
@@ -60,15 +74,14 @@ static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx,
 
     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;
     VALUE obj = Qnil;
-    if (result->columns[col_idx].nullmask[row_idx]) {
+    if (duckdb_value_is_null(result, col_idx, row_idx)) {
         return obj;
     }
-    switch(result->columns[col_idx].type) {
+    switch(duckdb_column_type(result, col_idx)) {
     case DUCKDB_TYPE_BOOLEAN:
         return to_ruby_obj_boolean(result, col_idx, row_idx);
     case DUCKDB_TYPE_SMALLINT:
@@ -81,10 +94,8 @@ 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);
         if (p) {
@@ -94,7 +105,7 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
 #else
             free(p);
 #endif /* HAVE_DUCKDB_FREE */
-            if (result->columns[col_idx].type == DUCKDB_TYPE_HUGEINT) {
+            if (duckdb_column_type(result, col_idx) == DUCKDB_TYPE_HUGEINT) {
                 obj = rb_funcall(obj, rb_intern("to_i"), 0);
             }
         }
@@ -104,8 +115,10 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, 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++) {
+    idx_t column_count = duckdb_column_count(&(ctx->result));
+
+    VALUE ary = rb_ary_new2(column_count);
+    for(col_idx = 0; col_idx < column_count; col_idx++) {
         rb_ary_store(ary, col_idx, to_ruby_obj(&(ctx->result), col_idx, row_idx));
     }
     return ary;
@@ -115,17 +128,19 @@ 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);
+    return LONG2FIX(duckdb_row_count(&(ctx->result)));
 }
 
 static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     idx_t row_idx = 0;
+    idx_t row_count = 0;
 
     RETURN_SIZED_ENUMERATOR(oDuckDBResult, 0, 0, duckdb_result_row_size);
 
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
-    for (row_idx = 0; row_idx < ctx->result.row_count; row_idx++) {
+    row_count = duckdb_row_count(&(ctx->result));
+    for (row_idx = 0; row_idx < row_count; row_idx++) {
         rb_yield(row_array(ctx, row_idx));
     }
     return oDuckDBResult;
@@ -156,7 +171,7 @@ static VALUE duckdb_result_each(VALUE oDuckDBResult) {
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
-    return LL2NUM(ctx->result.rows_changed);
+    return LL2NUM(duckdb_rows_changed(&(ctx->result)));
 }
 
 VALUE create_result(void) {

data/ext/duckdb/ruby-duckdb.h

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

data/ext/duckdb/util.c

@@ -0,0 +1,45 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+    duckdb_date_struct dt_struct;
+
+    dt_struct.year = NUM2INT(year);
+    dt_struct.month = NUM2INT(month);
+    dt_struct.day = NUM2INT(day);
+
+    return duckdb_to_date(dt_struct);
+}
+
+duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_time_struct time_st;
+
+    time_st.hour = NUM2INT(hour);
+    time_st.min = NUM2INT(min);
+    time_st.sec = NUM2INT(sec);
+    time_st.micros = NUM2INT(micros);
+
+    return duckdb_to_time(time_st);
+}
+
+duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_timestamp_struct timestamp_st;
+
+    timestamp_st.date.year = NUM2INT(year);
+    timestamp_st.date.month = NUM2INT(month);
+    timestamp_st.date.day = NUM2INT(day);
+    timestamp_st.time.hour = NUM2INT(hour);
+    timestamp_st.time.min = NUM2INT(min);
+    timestamp_st.time.sec = NUM2INT(sec);
+    timestamp_st.time.micros = NUM2INT(micros);
+
+    return duckdb_to_timestamp(timestamp_st);
+}
+
+void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
+    interval->months = NUM2INT(months);
+    interval->days = NUM2INT(days);
+    interval->micros = NUM2LL(micros);
+}
+#endif

data/ext/duckdb/util.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_UTIL_H
+#define RUBY_DUCKDB_UTIL_H
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+
+duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
+duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
+
+#endif
+
+#endif

data/lib/duckdb/appender.rb

@@ -1,5 +1,6 @@
 require 'date'
 require 'time'
+require_relative './converter'
 
 module DuckDB
   if defined?(DuckDB::Appender)
@@ -13,6 +14,8 @@ module DuckDB
     #   appender.append_row(1, 'Alice')
     #
     class Appender
+      include DuckDB::Converter
+
       RANGE_INT16 = -32_768..32_767
       RANGE_INT32 = -2_147_483_648..2_147_483_647
       RANGE_INT64 = -9_223_372_036_854_775_808..9_223_372_036_854_775_807
@@ -197,11 +200,7 @@ module DuckDB
             append_hugeint(value)
           end
         when String
-          if defined?(DuckDB::Blob)
-            blob?(value) ? append_blob(value) : append_varchar(value)
-          else
-            append_varchar(value)
-          end
+          blob?(value) ? append_blob(value) : append_varchar(value)
         when TrueClass, FalseClass
           append_bool(value)
         when Time
@@ -246,53 +245,6 @@ 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/config.rb

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

data/lib/duckdb/converter.rb

@@ -0,0 +1,52 @@
+module DuckDB
+  module Converter
+    private
+
+    def iso8601_interval_to_hash(value)
+      digit = ''
+      time = false
+      hash = {}
+      hash.default = 0
+
+      value.each_char do |c|
+        if '-0123456789.'.include?(c)
+          digit += c
+        elsif c == 'T'
+          time = true
+          digit = ''
+        elsif c == 'M'
+          m_interval_to_hash(hash, digit, time)
+          digit = ''
+        elsif c == 'S'
+          s_interval_to_hash(hash, digit)
+          digit = ''
+        elsif 'YDH'.include?(c)
+          hash[c] = digit.to_i
+          digit = ''
+        elsif c != 'P'
+          raise ArgumentError, "The argument `#{value}` can't be parse."
+        end
+      end
+      hash
+    end
+
+    def m_interval_to_hash(hash, digit, time)
+      key = time ? 'TM' : 'M'
+      hash[key] = digit.to_i
+    end
+
+    def s_interval_to_hash(hash, digit)
+      sec, msec = digit.split('.')
+      hash['S'] = sec.to_i
+      hash['MS'] = "#{msec}000000"[0, 6].to_i
+      hash['MS'] *= -1 if hash['S'].negative?
+    end
+
+    def hash_to__append_interval_args(hash)
+      months = hash['Y'] * 12 + hash['M']
+      days = hash['D']
+      micros = (hash['H'] * 3600 + hash['TM'] * 60 + hash['S']) * 1_000_000 + hash['MS']
+      [months, days, micros]
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -1,4 +1,5 @@
 require 'date'
+require_relative './converter'
 
 module DuckDB
   # The DuckDB::PreparedStatement encapsulates connection with DuckDB prepared
@@ -12,6 +13,7 @@ module DuckDB
   #   stmt.bind(1, 'email@example.com')
   #   stmt.execute
   class PreparedStatement
+    include DuckDB::Converter
 
     RANGE_INT16 = -32768..32767
     RANGE_INT32 = -2147483648..2147483647
@@ -27,8 +29,114 @@ module DuckDB
     end
 
     # binds i-th parameter with SQL prepared statement.
-    # The first argument is index of parameter. The index of first parameter is
-    # 1 not 0.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected date.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE birth_day = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, Date.today)
+    #   #  or you can specify date string.
+    #   # stmt.bind(1, '2021-02-23')
+    def bind_date(i, value)
+      case value
+      when Date, Time
+        date = value
+      else
+        begin
+          date = Date.parse(value)
+        rescue => e
+          raise(ArgumentError, "Cannot parse argument value to date. #{e.message}")
+        end
+      end
+
+      _bind_date(i, date.year, date.month, date.day)
+    end
+
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE birth_time = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, Time.now)
+    #   #  or you can specify time string.
+    #   # stmt.bind(1, '07:39:45')
+    def bind_time(i, value)
+      case value
+      when Time
+        time = value
+      else
+        begin
+          time = Time.parse(value)
+        rescue => e
+          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
+        end
+      end
+
+      _bind_time(i, time.hour, time.min, time.sec, time.usec)
+    end
+
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE created_at = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, Time.now)
+    #   #  or you can specify timestamp string.
+    #   # stmt.bind(1, '2022-02-23 07:39:45')
+    def bind_timestamp(i, value)
+      case value
+      when Time
+        time = value
+      else
+        begin
+          time = Time.parse(value)
+        rescue => e
+          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
+        end
+      end
+
+      _bind_timestamp(i, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
+    end
+
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected ISO8601 time interval string.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT value FROM intervals WHERE interval = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, 'P1Y2D')
+    def bind_interval(i, value)
+      raise(DuckDB::Error, 'bind_interval is not available with your duckdb version. please install duckdb latest version at first') unless respond_to?(:_bind_interval, true)
+      raise ArgumentError, "Argument `#{value}` must be a string." unless value.is_a?(String)
+
+      hash = iso8601_interval_to_hash(value)
+
+      months, days, micros = hash_to__append_interval_args(hash)
+
+      _bind_interval(i, months, days, micros)
+    end
+
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
     # The second argument value is the value of prepared statement parameter.
     #
     #   require 'duckdb'
@@ -40,7 +148,7 @@ module DuckDB
     def bind(i, value)
       case value
       when NilClass
-        respond_to?(:bind_null) ? bind_null(i) : raise(DuckDB::Error, 'This bind method does not support nil value. Re-compile ruby-duckdb with DuckDB version >= 0.1.1')
+        bind_null(i)
       when Float
         bind_double(i, value)
       when Integer
@@ -51,11 +159,7 @@ module DuckDB
           bind_varchar(i, value.to_s)
         end
       when String
-        if defined?(DuckDB::Blob)
-          blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
-        else
-          bind_varchar(i, value)
-        end
+        blob?(value) ? bind_blob(i, value) : bind_varchar(i, value)
       when TrueClass, FalseClass
         bind_bool(i, value)
       when Time

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.3.1.0'.freeze
+  VERSION = '0.3.2.0'.freeze
 end

data/lib/duckdb.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.3.1.0
+  version: 0.3.2.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-20 00:00:00.000000000 Z
+date: 2022-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,10 +108,13 @@ files:
 - ext/duckdb/result.c
 - ext/duckdb/result.h
 - ext/duckdb/ruby-duckdb.h
+- ext/duckdb/util.c
+- ext/duckdb/util.h
 - lib/duckdb.rb
 - lib/duckdb/appender.rb
 - lib/duckdb/config.rb
 - lib/duckdb/connection.rb
+- lib/duckdb/converter.rb
 - lib/duckdb/database.rb
 - lib/duckdb/prepared_statement.rb
 - lib/duckdb/result.rb
@@ -138,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.