duckdb 0.3.2.0 → 0.3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96ad27d302c878ca4d207d86e1eb24e61be890c8585d6bd9231237900479053d
-  data.tar.gz: 4e0fb0daf725f53acd454ee77c179ef1af57a96b9308bc6f303853e28fe9b9a6
+  metadata.gz: 6f88e0fda10b4ddc1b18ccc7d91a2ecab498146be652604836fd0dc29f100957
+  data.tar.gz: d8ed6ede8914c4b28295d39889c6ebfe46f2c5c034d3fd69fdb1b5abc7bd3e59
 SHA512:
-  metadata.gz: b407a06ebf245a9534362a5106fe7d8bd74a55f2234bf2c734da067f2a8ef150472f8b40a312acd9d0957fb27515ec67fb536cf019375825e6e62d2c1ea82e8e
-  data.tar.gz: e2da40b4d0cb0eb25a77a6e1b383cf54a4bd8618cc31d670f59d5068c74603e41d14c4f57f9e3f909a339798f7e2a0d0143239483aef8ea8094c92cdcac417f4
+  metadata.gz: 64be83996e4cd611a89ef3169aeb9f9b918d2c8854804eeef4b536f1987e8e9d1ea7c777c64c9b2e745d236857002b3768084991d16a8d8c3e8032d00b4b4e46
+  data.tar.gz: 293d2c3fb7a9a920996ce671657ea2f305a7aa591bbaa1bf56f5fa44fcc2cc5dce1d6f463ba9a424eaed49afdb7d6ae477762c76ca8f5bebceb83ae28f1b565f

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
-        duckdb: ['0.3.2', '0.3.1']
+        ruby: ['2.6.10', '2.7.6', '3.0.4', '3.1.2', 'head']
+        duckdb: ['0.3.2', '0.3.3']
 
     steps:
     - uses: actions/checkout@v2
@@ -26,17 +26,31 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: download duckdb binary for MacOS 64bit
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v2
+      with:
+        path: duckdb-v${{ matrix.duckdb }}
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
+
+    - name: Build duckdb ${{ matrix.duckdb }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       run: |
-        curl -OL https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/libduckdb-osx-amd64.zip
+        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/*.dylib duckdb-v$DUCKDB_VERSION/build/release/src
+        cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
-    - name: extract zip file
+    - name: prepare duckdb header and libraries
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        unzip libduckdb-osx-amd64.zip
-        cp duckdb.h /usr/local/include
-        cp libduckdb.dylib /usr/local/lib
+        cp duckdb-v$DUCKDB_VERSION/src/include/*.h /usr/local/include
+        cp duckdb-v$DUCKDB_VERSION/build/release/src/*.dylib /usr/local/lib
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       run: |

data/.github/workflows/test_on_ubuntu.yml

@@ -16,8 +16,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
-        duckdb: ['0.3.2', '0.3.1']
+        ruby: ['2.6.10', '2.7.6', '3.0.4', '3.1.2', 'head']
+        duckdb: ['0.3.2', '0.3.3']
 
     steps:
     - uses: actions/checkout@v2

data/.github/workflows/test_on_windows.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'mingw', 'head']
-        duckdb: ['0.3.2', '0.3.1']
+        ruby: ['2.6.10', '2.7.6', '3.0.4', '3.1.2', 'mingw', 'head']
+        duckdb: ['0.3.2', '0.3.3']
 
     steps:
     - uses: actions/checkout@v2

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # ChangeLog
 
+# 0.3.3.0
+- DuckDB::Column#type supports :decimal.
+- bump duckdb 0.3.3.
+- bump Ruby 2.6.10, 2.7.6, 3.0.4, 3.1.2.
+
 # 0.3.2.0
 
 - bind_time, bind_timestamp, bind_date, bind_timeinterval to DuckDB::PreparedStatement

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    duckdb (0.3.2.0)
+    duckdb (0.3.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.14.4)
+    minitest (5.15.0)
     rake (13.0.6)
-    rake-compiler (1.1.1)
+    rake-compiler (1.2.0)
       rake
 
 PLATFORMS

data/README.md

@@ -1,8 +1,9 @@
 # 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)
+[![Ubuntu](https://github.com/suketa/ruby-duckdb/workflows/Ubuntu/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AUbuntu)
+[![MacOS](https://github.com/suketa/ruby-duckdb/workflows/MacOS/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AMacOS)
+[![Windows](https://github.com/suketa/ruby-duckdb/workflows/Windows/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AWindows)
+[![Gem Version](https://badge.fury.io/rb/duckdb.svg)](https://badge.fury.io/rb/duckdb)
 
 ## Description
 

data/ext/duckdb/appender.c

@@ -1,7 +1,5 @@
 #include "ruby-duckdb.h"
 
-#ifdef HAVE_DUCKDB_APPENDER_CREATE
-
 static VALUE cDuckDBAppender;
 
 static void deallocate(void *);
@@ -29,21 +27,11 @@ static VALUE appender_append_null(VALUE self);
 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);
@@ -302,7 +290,6 @@ static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE da
 }
 #endif
 
-#ifdef HAVE_DUCKDB_APPEND_INTERVAL
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
     rubyDuckDBAppender *ctx;
@@ -315,9 +302,7 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
     }
     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 time;
     rubyDuckDBAppender *ctx;
@@ -330,9 +315,7 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
     }
     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 timestamp;
 
@@ -347,9 +330,7 @@ static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VAL
     }
     return self;
 }
-#endif
 
-#ifdef HAVE_DUCKDB_APPEND_HUGEINT
 static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
 
@@ -364,7 +345,6 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     }
     return self;
 }
-#endif
 
 static VALUE appender_flush(VALUE self) {
     rubyDuckDBAppender *ctx;
@@ -410,19 +390,10 @@ void init_duckdb_appender(void) {
 #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);
 }
-#endif /* HAVE_DUCKDB_APPENDER_CREATE */

data/ext/duckdb/appender.h

@@ -1,8 +1,6 @@
 #ifndef RUBY_DUCKDB_APPENDER_H
 #define RUBY_DUCKDB_APPENDER_H
 
-#ifdef HAVE_DUCKDB_APPENDER_CREATE
-
 struct _rubyDuckDBAppender {
     duckdb_appender appender;
 };
@@ -12,6 +10,3 @@ typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
 void init_duckdb_appender(void);
 
 #endif
-
-#endif
-

data/ext/duckdb/column.c

@@ -0,0 +1,73 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBColumn;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_column__type(VALUE oDuckDBColumn);
+static VALUE duckdb_column_get_name(VALUE oDuckDBColumn);
+
+static void deallocate(void *ctx) {
+    rubyDuckDBColumn *p = (rubyDuckDBColumn *)ctx;
+
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBColumn *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBColumn));
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+/*
+ *
+ */
+VALUE duckdb_column__type(VALUE oDuckDBColumn) {
+    rubyDuckDBColumn *ctx;
+    Data_Get_Struct(oDuckDBColumn, rubyDuckDBColumn, ctx);
+
+    VALUE result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
+    rubyDuckDBResult *ctxresult;
+    Data_Get_Struct(result, rubyDuckDBResult, ctxresult);
+    duckdb_type type = duckdb_column_type(&(ctxresult->result), ctx->col);
+
+    return INT2FIX(type);
+}
+
+/*
+ *  call-seq:
+ *    column.name -> string.
+ *
+ *  Returns the column name.
+ *
+ */
+VALUE duckdb_column_get_name(VALUE oDuckDBColumn) {
+    rubyDuckDBColumn *ctx;
+    Data_Get_Struct(oDuckDBColumn, rubyDuckDBColumn, ctx);
+
+    VALUE result = rb_ivar_get(oDuckDBColumn, rb_intern("result"));
+    rubyDuckDBResult *ctxresult;
+    Data_Get_Struct(result, rubyDuckDBResult, ctxresult);
+
+    return rb_str_new2(duckdb_column_name(&(ctxresult->result), ctx->col));
+}
+
+VALUE create_column(VALUE oDuckDBResult, idx_t col) {
+    VALUE obj;
+
+    obj = allocate(cDuckDBColumn);
+    rubyDuckDBColumn *ctx;
+    Data_Get_Struct(obj, rubyDuckDBColumn, ctx);
+
+    rb_ivar_set(obj, rb_intern("result"), oDuckDBResult);
+    ctx->col = col;
+
+    return obj;
+}
+
+void init_duckdb_column(void) {
+    cDuckDBColumn = rb_define_class_under(mDuckDB, "Column", rb_cObject);
+    rb_define_alloc_func(cDuckDBColumn, allocate);
+
+    rb_define_private_method(cDuckDBColumn, "_type", duckdb_column__type, 0);
+    rb_define_method(cDuckDBColumn, "name", duckdb_column_get_name, 0);
+}

data/ext/duckdb/column.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_DUCKDB_COLUMN_H
+#define RUBY_DUCKDB_COLUMN_H
+
+struct _rubyDuckDBColumn {
+    VALUE result;
+    idx_t col;
+};
+
+typedef struct _rubyDuckDBColumn rubyDuckDBColumn;
+
+void init_duckdb_column(void);
+VALUE create_column(VALUE oDuckDBResult, idx_t col);
+
+#endif

data/ext/duckdb/duckdb.c

@@ -10,15 +10,12 @@ Init_duckdb_native(void) {
     init_duckdb_database();
     init_duckdb_connection();
     init_duckdb_result();
+    init_duckdb_column();
     init_duckdb_prepared_statement();
     init_duckdb_blob();
 
-#ifdef HAVE_DUCKDB_APPENDER_CREATE
-
     init_duckdb_appender();
 
-#endif /* HAVE_DUCKDB_APPENDER_CREATE */
-
 #ifdef HAVE_DUCKDB_CREATE_CONFIG
 
     init_duckdb_config();

data/ext/duckdb/extconf.rb

@@ -6,13 +6,9 @@ raise 'duckdb library is not found. Install duckdb library file and header file.
 
 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
+# ducdb >= 0.3.3 if duckdb_append_data_chunk() is defined.
+have_func('duckdb_append_data_chunk', 'duckdb.h')
 
-have_func('duckdb_appender_create', 'duckdb.h')
 have_func('duckdb_free', 'duckdb.h')
 
 have_func('duckdb_create_config', 'duckdb.h')
@@ -20,14 +16,5 @@ 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

@@ -18,23 +18,10 @@ static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE
 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;
@@ -74,14 +61,7 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
 static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-#ifdef HAVE_DUCKDB_NPARAMS_029
     return rb_int2big(duckdb_nparams(ctx->prepared_statement));
-#else
-    if (duckdb_nparams(ctx->prepared_statement, &(ctx->nparams)) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to get number of parameters");
-    }
-    return rb_int2big(ctx->nparams);
-#endif
 }
 
 
@@ -232,7 +212,6 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     return self;
 }
 
-#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;
@@ -246,9 +225,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     }
     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;
@@ -263,9 +240,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
     }
     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;
@@ -279,9 +254,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     }
     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;
@@ -295,7 +268,6 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
     }
     return self;
 }
-#endif
 
 void init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
@@ -316,13 +288,7 @@ void init_duckdb_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
     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

@@ -16,6 +16,7 @@ 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 VALUE duckdb_result_columns(VALUE oDuckDBResult);
 
 static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
@@ -65,11 +66,7 @@ static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_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;
@@ -100,11 +97,7 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
         p = duckdb_value_varchar(result, col_idx, row_idx);
         if (p) {
             obj = rb_str_new2(p);
-#ifdef HAVE_DUCKDB_FREE
             duckdb_free(p);
-#else
-            free(p);
-#endif /* HAVE_DUCKDB_FREE */
             if (duckdb_column_type(result, col_idx) == DUCKDB_TYPE_HUGEINT) {
                 obj = rb_funcall(obj, rb_intern("to_i"), 0);
             }
@@ -174,6 +167,28 @@ static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
     return LL2NUM(duckdb_rows_changed(&(ctx->result)));
 }
 
+/*
+ *  call-seq:
+ *    result.columns -> DuckDB::Column[]
+ *
+ *  Returns the column class Lists.
+ *
+ */
+static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
+
+    idx_t 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++) {
+        VALUE column = create_column(oDuckDBResult, col_idx);
+        rb_ary_store(ary, col_idx, column);
+    }
+    return ary;
+}
+
 VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
@@ -184,4 +199,5 @@ void init_duckdb_result(void) {
 
     rb_define_method(cDuckDBResult, "each", duckdb_result_each, 0);
     rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
+    rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
 }

data/ext/duckdb/ruby-duckdb.h

@@ -3,20 +3,22 @@
 
 #include "ruby.h"
 #include <duckdb.h>
+
+#ifdef HAVE_DUCKDB_APPEND_DATA_CHUNK
+#define HAVE_DUCKDB_HEADER_VERSION_033 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
 #include "./result.h"
+#include "./column.h"
 #include "./prepared_statement.h"
 #include "./util.h"
 
 #include "./blob.h"
-#ifdef HAVE_DUCKDB_APPENDER_CREATE
-
 #include "./appender.h"
 
-#endif /* HAVE_DUCKDB_APPENDER_CREATE */
-
 #ifdef HAVE_DUCKDB_CREATE_CONFIG
 
 #include "./config.h"

data/lib/duckdb/appender.rb

@@ -3,248 +3,242 @@ require 'time'
 require_relative './converter'
 
 module DuckDB
-  if defined?(DuckDB::Appender)
-    # The DuckDB::Appender encapsulates 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
+    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
+
+    #
+    # appends huge int value.
     #
     #   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')
+    #   con.query('CREATE TABLE numbers (num HUGEINT)')
+    #   appender = con.appender('numbers')
+    #   appender
+    #     .begin_row
+    #     .append_hugeint(-170_141_183_460_469_231_731_687_303_715_884_105_727)
+    #     .end_row
     #
-    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
-
-      #
-      # appends huge int value.
-      #
-      #   require 'duckdb'
-      #   db = DuckDB::Database.open
-      #   con = db.connect
-      #   con.query('CREATE TABLE numbers (num HUGEINT)')
-      #   appender = con.appender('numbers')
-      #   appender
-      #     .begin_row
-      #     .append_hugeint(-170_141_183_460_469_231_731_687_303_715_884_105_727)
-      #     .end_row
-      #
-      def append_hugeint(value)
-        case value
-        when Integer
-          if respond_to?(:_append_hugeint, true)
-            half = 1 << 64
-            upper = value / half
-            lower = value - upper * half
-            _append_hugeint(lower, upper)
-          else
-            append_varchar(value.to_s)
-          end
-        else
-          raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
-        end
+    def append_hugeint(value)
+      case value
+      when Integer
+        half = 1 << 64
+        upper = value / half
+        lower = value - upper * half
+        _append_hugeint(lower, upper)
+      else
+        raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
       end
+    end
 
-      #
-      # appends date value.
-      #
-      #   require 'duckdb'
-      #   db = DuckDB::Database.open
-      #   con = db.connect
-      #   con.query('CREATE TABLE dates (date_value DATE)')
-      #   appender = con.appender('dates')
-      #   appender.begin_row
-      #   appender.append_date(Date.today)
-      #   # or
-      #   # appender.append_date(Time.now)
-      #   # appender.append_date('2021-10-10')
-      #   appender.end_row
-      #   appender.flush
-      #
-      def append_date(value)
-        date = case value
-               when Date, Time
-                 value
-               else
-                 begin
-                   Date.parse(value)
-                 rescue
-                   raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
-                 end
+    #
+    # appends date value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE dates (date_value DATE)')
+    #   appender = con.appender('dates')
+    #   appender.begin_row
+    #   appender.append_date(Date.today)
+    #   # or
+    #   # appender.append_date(Time.now)
+    #   # appender.append_date('2021-10-10')
+    #   appender.end_row
+    #   appender.flush
+    #
+    def append_date(value)
+      date = case value
+             when Date, Time
+               value
+             else
+               begin
+                 Date.parse(value)
+               rescue
+                 raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
                end
+             end
 
-        _append_date(date.year, date.month, date.day)
-      end
+      _append_date(date.year, date.month, date.day)
+    end
 
-      #
-      # appends time value.
-      #
-      #   require 'duckdb'
-      #   db = DuckDB::Database.open
-      #   con = db.connect
-      #   con.query('CREATE TABLE times (time_value TIME)')
-      #   appender = con.appender('times')
-      #   appender.begin_row
-      #   appender.append_time(Time.now)
-      #   # or
-      #   # appender.append_time('01:01:01')
-      #   appender.end_row
-      #   appender.flush
-      #
-      def append_time(value)
-        time = case value
-               when Time
-                 value
-               else
-                 begin
-                   Time.parse(value)
-                 rescue
-                   raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
-                 end
+    #
+    # appends time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE times (time_value TIME)')
+    #   appender = con.appender('times')
+    #   appender.begin_row
+    #   appender.append_time(Time.now)
+    #   # or
+    #   # appender.append_time('01:01:01')
+    #   appender.end_row
+    #   appender.flush
+    #
+    def append_time(value)
+      time = case value
+             when Time
+               value
+             else
+               begin
+                 Time.parse(value)
+               rescue
+                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
                end
+             end
 
-        _append_time(time.hour, time.min, time.sec, time.usec)
-      end
+      _append_time(time.hour, time.min, time.sec, time.usec)
+    end
 
-      #
-      # appends timestamp value.
-      #
-      #   require 'duckdb'
-      #   db = DuckDB::Database.open
-      #   con = db.connect
-      #   con.query('CREATE TABLE timestamps (timestamp_value TIMESTAMP)')
-      #   appender = con.appender('timestamps')
-      #   appender.begin_row
-      #   appender.append_time(Time.now)
-      #   # or
-      #   # appender.append_time(Date.today)
-      #   # appender.append_time('2021-08-01 01:01:01')
-      #   appender.end_row
-      #   appender.flush
-      #
-      def append_timestamp(value)
-        time = case value
-               when Time
-                 value
-               when Date
-                 value.to_time
-               else
-                 begin
-                   Time.parse(value)
-                 rescue
-                   raise(ArgumentError, "Cannot parse argument `#{value}` to Time or Date.")
-                 end
+    #
+    # appends timestamp value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE timestamps (timestamp_value TIMESTAMP)')
+    #   appender = con.appender('timestamps')
+    #   appender.begin_row
+    #   appender.append_time(Time.now)
+    #   # or
+    #   # appender.append_time(Date.today)
+    #   # appender.append_time('2021-08-01 01:01:01')
+    #   appender.end_row
+    #   appender.flush
+    #
+    def append_timestamp(value)
+      time = case value
+             when Time
+               value
+             when Date
+               value.to_time
+             else
+               begin
+                 Time.parse(value)
+               rescue
+                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time or Date.")
                end
+             end
 
-        _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
-      end
+      _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
+    end
 
-      #
-      # appends interval.
-      # The argument must be ISO8601 duration format.
-      # WARNING: This method is expremental.
-      #
-      #   require 'duckdb'
-      #   db = DuckDB::Database.open
-      #   con = db.connect
-      #   con.query('CREATE TABLE intervals (interval_value INTERVAL)')
-      #   appender = con.appender('intervals')
-      #   appender
-      #     .begin_row
-      #     .append_interval('P1Y2D') # => append 1 year 2 days interval.
-      #     .end_row
-      #     .flush
-      #
-      def append_interval(value)
-        raise ArgumentError, "Argument `#{value}` must be a string." unless value.is_a?(String)
-
-        hash = iso8601_interval_to_hash(value)
-
-        months, days, micros = hash_to__append_interval_args(hash)
-
-        _append_interval(months, days, micros)
-      end
+    #
+    # appends interval.
+    # The argument must be ISO8601 duration format.
+    # WARNING: This method is expremental.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE intervals (interval_value INTERVAL)')
+    #   appender = con.appender('intervals')
+    #   appender
+    #     .begin_row
+    #     .append_interval('P1Y2D') # => append 1 year 2 days interval.
+    #     .end_row
+    #     .flush
+    #
+    def append_interval(value)
+      raise ArgumentError, "Argument `#{value}` must be a string." unless value.is_a?(String)
+
+      hash = iso8601_interval_to_hash(value)
+
+      months, days, micros = hash_to__append_interval_args(hash)
 
-      #
-      # 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)
+      _append_interval(months, days, micros)
+    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 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
-          blob?(value) ? append_blob(value) : append_varchar(value)
-        when TrueClass, FalseClass
-          append_bool(value)
-        when Time
-          if respond_to?(:append_timestamp)
-            append_timestamp(value)
-          else
-            append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
-          end
-        when Date
-          if respond_to?(:append_date)
-            append_date(value)
-          else
-            append_varchar(value.strftime('%Y-%m-%d'))
-          end
+        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
+        blob?(value) ? append_blob(value) : append_varchar(value)
+      when TrueClass, FalseClass
+        append_bool(value)
+      when Time
+        if respond_to?(:append_timestamp)
+          append_timestamp(value)
         else
-          raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
+          append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
         end
+      when Date
+        if respond_to?(:append_date)
+          append_date(value)
+        else
+          append_varchar(value.strftime('%Y-%m-%d'))
+        end
+      else
+        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
+    #
+    # 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
+    private
 
-      def blob?(value)
-        value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
-      end
+    def blob?(value)
+      value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
     end
   end
 end

data/lib/duckdb/column.rb

@@ -0,0 +1,55 @@
+module DuckDB
+  class Column
+    #
+    # returns column type symbol
+    # `:unknown` means that the column type is unknown/unsupported by ruby-duckdb.
+    # `:invalid` means that the column type is invalid in duckdb.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+    #
+    #   users = con.query('SELECT * FROM users')
+    #   columns = users.columns
+    #   columns.first.type #=> :integer
+    #
+    def type
+      types = %i[
+        invalid
+        boolean
+        tinyint
+        smallint
+        integer
+        bigint
+        utinyint
+        usmallint
+        uinteger
+        ubigint
+        float
+        double
+        timestamp
+        date
+        time
+        interval
+        hugeint
+        varchar
+        blob
+        decimal
+        timestamp_s
+        timestamp_ms
+        timestamp_ns
+        enum
+        list
+        struct
+        map
+        uuid
+        json
+      ]
+      index = _type
+      return :unknown if index >= types.size
+
+      types[index]
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -124,7 +124,6 @@ module DuckDB
     #   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)

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.2.0'.freeze
+  VERSION = '0.3.3.0'.freeze
 end

data/lib/duckdb.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.3.2.0
+  version: 0.3.3.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-23 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,6 +93,8 @@ files:
 - ext/duckdb/appender.h
 - ext/duckdb/blob.c
 - ext/duckdb/blob.h
+- ext/duckdb/column.c
+- ext/duckdb/column.h
 - ext/duckdb/config.c
 - ext/duckdb/config.h
 - ext/duckdb/connection.c
@@ -112,6 +114,7 @@ files:
 - ext/duckdb/util.h
 - lib/duckdb.rb
 - lib/duckdb/appender.rb
+- lib/duckdb/column.rb
 - lib/duckdb/config.rb
 - lib/duckdb/connection.rb
 - lib/duckdb/converter.rb
@@ -141,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.10
 signing_key:
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.