duckdb 0.2.6.0 → 0.2.9.0

data/ext/duckdb/database.c

@@ -2,6 +2,12 @@
 
 VALUE cDuckDBDatabase;
 
+static void close_database(rubyDuckDB *p);
+static void deallocate(void * ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase);
+static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase);
+
 static void close_database(rubyDuckDB *p)
 {
     duckdb_close(&(p->db));
@@ -25,6 +31,7 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
 {
     rubyDuckDB *ctx;
     VALUE obj;
+
     char *pfile = NULL;
     VALUE file = Qnil;
 
@@ -36,13 +43,49 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
 
     obj = allocate(cDuckDBDatabase);
     Data_Get_Struct(obj, rubyDuckDB, ctx);
-    if (duckdb_open(pfile, &(ctx->db)) == DuckDBError)
-    {
+    if (duckdb_open(pfile, &(ctx->db)) == DuckDBError) {
         rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
     }
     return obj;
 }
 
+#ifdef HAVE_DUCKDB_OPEN_EXT
+static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase)
+{
+    rubyDuckDB *ctx;
+    VALUE obj;
+    rubyDuckDBConfig *ctx_config;
+    char *perror;
+
+    char *pfile = NULL;
+    VALUE file = Qnil;
+    VALUE config = Qnil;
+
+    rb_scan_args(argc, argv, "02", &file, &config);
+
+    if (!NIL_P(file)) {
+        pfile = StringValuePtr(file);
+    }
+
+    obj = allocate(cDuckDBDatabase);
+    Data_Get_Struct(obj, rubyDuckDB, ctx);
+    if (!NIL_P(config)) {
+        if (!rb_obj_is_kind_of(config, cDuckDBConfig)) {
+            rb_raise(rb_eTypeError, "The second argument must be DuckDB::Config object.");
+        }
+        Data_Get_Struct(config, rubyDuckDBConfig, ctx_config);
+        if (duckdb_open_ext(pfile, &(ctx->db), ctx_config->config, &perror) == DuckDBError) {
+            rb_raise(eDuckDBError, "Failed to open database %s", perror);
+        }
+    } else {
+        if (duckdb_open(pfile, &(ctx->db)) == DuckDBError) {
+            rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
+        }
+    }
+    return obj;
+}
+#endif /* HAVE_DUCKDB_OPEN_EXT */
+
 static VALUE duckdb_database_connect(VALUE self)
 {
     return create_connection(self);
@@ -67,6 +110,9 @@ void init_duckdb_database(void)
     cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
     rb_define_alloc_func(cDuckDBDatabase, allocate);
     rb_define_singleton_method(cDuckDBDatabase, "_open", duckdb_database_s_open, -1);
+#ifdef HAVE_DUCKDB_OPEN_EXT
+    rb_define_singleton_method(cDuckDBDatabase, "_open_ext", duckdb_database_s_open_ext, -1);
+#endif
     rb_define_private_method(cDuckDBDatabase, "_connect", duckdb_database_connect, 0);
     rb_define_method(cDuckDBDatabase, "close", duckdb_database_close, 0);
 }

data/ext/duckdb/duckdb.c

@@ -24,4 +24,10 @@ Init_duckdb_native(void)
     init_duckdb_appender();
 
 #endif /* HAVE_DUCKDB_APPENDER_CREATE */
+
+#ifdef HAVE_DUCKDB_CREATE_CONFIG
+
+    init_duckdb_config();
+
+#endif /* HAVE_DUCKDB_CREATE_CONFIG */
 }

data/ext/duckdb/extconf.rb

@@ -2,8 +2,23 @@ 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')
 end

data/ext/duckdb/prepared_statement.c

@@ -29,8 +29,13 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
     Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
+#ifdef HAVE_DUCKDB_PREPARE_ERROR
+        const char *error = duckdb_prepare_error(ctx->prepared_statement);
+        rb_raise(eDuckDBError, "%s", error);
+#else
         /* TODO: include query parameter information in error message. */
         rb_raise(eDuckDBError, "failed to prepare statement");
+#endif
     }
     return self;
 }
@@ -39,11 +44,14 @@ 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
 }
 
 
@@ -70,7 +78,7 @@ static idx_t check_index(VALUE vidx)
     return idx;
 }
 
-static VALUE duckdb_prepared_statement_bind_boolean(VALUE self, VALUE vidx, VALUE val)
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val)
 {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
@@ -86,6 +94,20 @@ static VALUE duckdb_prepared_statement_bind_boolean(VALUE self, VALUE vidx, VALU
     return self;
 }
 
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    int8_t i8val = (int8_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_int8(ctx->prepared_statement, idx, i8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
 static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val)
 {
     rubyDuckDBPreparedStatement *ctx;
@@ -203,7 +225,8 @@ void init_duckdb_prepared_statement(void)
     rb_define_method(cDuckDBPreparedStatement, "initialize", duckdb_prepared_statement_initialize, 2);
     rb_define_method(cDuckDBPreparedStatement, "execute", duckdb_prepared_statement_execute, 0);
     rb_define_method(cDuckDBPreparedStatement, "nparams", duckdb_prepared_statement_nparams, 0);
-    rb_define_method(cDuckDBPreparedStatement, "bind_boolean", duckdb_prepared_statement_bind_boolean, 2);
+    rb_define_method(cDuckDBPreparedStatement, "bind_bool", duckdb_prepared_statement_bind_bool, 2);
+    rb_define_method(cDuckDBPreparedStatement, "bind_int8", duckdb_prepared_statement_bind_int8, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int16", duckdb_prepared_statement_bind_int16, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int32", duckdb_prepared_statement_bind_int32, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int64", duckdb_prepared_statement_bind_int64, 2);

data/ext/duckdb/result.c

@@ -2,66 +2,67 @@
 
 static VALUE cDuckDBResult;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
     duckdb_destroy_result(&(p->result));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBResult));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     bool bval = duckdb_value_boolean(result, col_idx, row_idx);
     return bval ? Qtrue : Qnil;
 }
 
-static VALUE to_ruby_obj_smallint(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) {
     int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
     return INT2FIX(i16val);
 }
 
-static VALUE to_ruby_obj_integer(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) {
     int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
     return INT2NUM(i32val);
 }
 
-static VALUE to_ruby_obj_bigint(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) {
     int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
     return rb_int2big(i64val);
 }
 
-static VALUE to_ruby_obj_float(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) {
     float fval = duckdb_value_float(result, col_idx, row_idx);
     return DBL2NUM(fval);
 }
 
-static VALUE to_ruby_obj_double(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) {
     double dval = duckdb_value_double(result, col_idx, row_idx);
     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)
-{
+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);
-    return rb_str_new(bval.data, bval.size);
+    str = rb_str_new(bval.data, bval.size);
+
+    if (bval.data) {
+#ifdef HAVE_DUCKDB_FREE
+        duckdb_free(bval.data);
+#else
+        free(bval.data);
+#endif
+    }
+
+    return str;
 }
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+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]) {
@@ -86,14 +87,22 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
     default:
         p = duckdb_value_varchar(result, col_idx, row_idx);
-        obj = rb_str_new2(p);
-        free(p);
+        if (p) {
+            obj = rb_str_new2(p);
+#ifdef HAVE_DUCKDB_FREE
+            duckdb_free(p);
+#else
+            free(p);
+#endif /* HAVE_DUCKDB_FREE */
+            if (result->columns[col_idx].type == DUCKDB_TYPE_HUGEINT) {
+                obj = rb_funcall(obj, rb_intern("to_i"), 0);
+            }
+        }
     }
     return obj;
 }
 
-static VALUE row_array(rubyDuckDBResult *ctx, 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++) {
@@ -102,16 +111,14 @@ static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx)
     return ary;
 }
 
-static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj)
-{
+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);
 }
 
-static VALUE duckdb_result_each(VALUE oDuckDBResult)
-{
+static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     idx_t row_idx = 0;
 
@@ -124,15 +131,42 @@ static VALUE duckdb_result_each(VALUE oDuckDBResult)
     return oDuckDBResult;
 }
 
-VALUE create_result(void)
-{
+/*
+ *  call-seq:
+ *    result.rows_changed -> integer
+ *
+ *  Returns the count of rows changed.
+ *
+ *    DuckDB::Database.open do |db|
+ *      db.connect do |con|
+ *        r = con.query('CREATE TABLE t2 (id INT)')
+ *        r.rows_changed # => 0
+ *        r = con.query('INSERT INTO t2 VALUES (1), (2), (3)')
+ *        r.rows_changed # => 3
+ *        r = con.query('UPDATE t2 SET id = id + 1 WHERE id > 1')
+ *        r.rows_changed # => 2
+ *        r = con.query('DELETE FROM t2 WHERE id = 0')
+ *        r.rows_changed # => 0
+ *        r = con.query('DELETE FROM t2 WHERE id = 4')
+ *        r.rows_changed # => 1
+ *      end
+ *    end
+ *
+ */
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
+    return LL2NUM(ctx->result.rows_changed);
+}
+
+VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-void init_duckdb_result(void)
-{
+void init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "each", duckdb_result_each, 0);
+    rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
 }

data/ext/duckdb/ruby-duckdb.h

@@ -21,6 +21,12 @@
 
 #endif /* HAVE_DUCKDB_APPENDER_CREATE */
 
+#ifdef HAVE_DUCKDB_CREATE_CONFIG
+
+#include "./config.h"
+
+#endif /* HAVE_DUCKDB_CREATE_CONFIG */
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
@@ -31,6 +37,12 @@ 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/lib/duckdb/appender.rb

@@ -0,0 +1,303 @@
+require 'date'
+require 'time'
+
+module DuckDB
+  if defined?(DuckDB::Appender)
+    # The DuckDB::Appender encapsulates DuckDB Appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+    #   appender = con.appender('users')
+    #   appender.append_row(1, 'Alice')
+    #
+    class Appender
+      RANGE_INT16 = -32_768..32_767
+      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
+      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)
+        case value
+        when Date, Time
+          date = value
+        when String
+          begin
+            date = Date.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value}` to Date.")
+          end
+        else
+          raise(ArgumentError, "Argument `#{value}` must be Date, Time or String.")
+        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)
+        case value
+        when Time
+          time = value
+        when String
+          begin
+            time = Time.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
+          end
+        else
+          raise(ArgumentError, "Argument `#{value}` must be Time or String.")
+        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)
+        case value
+        when Time
+          time = value
+        when Date
+          time = value.to_time
+        when String
+          begin
+            time = Time.parse(value)
+          rescue
+            raise(ArgumentError, "Cannot parse argument `#{value.class} #{value}` to Time.")
+          end
+        else
+          raise(ArgumentError, "Argument `#{value.class} #{value}` must be Time or Date or String.")
+        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 value.
+      #
+      #   require 'duckdb'
+      #   db = DuckDB::Database.open
+      #   con = db.connect
+      #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+      #   appender = con.appender('users')
+      #   appender.begin_row
+      #   appender.append(1)
+      #   appender.append('Alice')
+      #   appender.end_row
+      #
+      def append(value)
+        case value
+        when NilClass
+          append_null
+        when Float
+          append_double(value)
+        when Integer
+          case value
+          when RANGE_INT16
+            append_int16(value)
+          when RANGE_INT32
+            append_int32(value)
+          when RANGE_INT64
+            append_int64(value)
+          else
+            append_hugeint(value)
+          end
+        when String
+          if defined?(DuckDB::Blob)
+            blob?(value) ? append_blob(value) : append_varchar(value)
+          else
+            append_varchar(value)
+          end
+        when TrueClass, FalseClass
+          append_bool(value)
+        when Time
+          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
+        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
+      end
+
+      private
+
+      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