duckdb 0.0.12 → 0.2.8.0

data/ext/duckdb/appender.h

@@ -0,0 +1,17 @@
+#ifndef RUBY_DUCKDB_APPENDER_H
+#define RUBY_DUCKDB_APPENDER_H
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+struct _rubyDuckDBAppender {
+    duckdb_appender appender;
+};
+
+typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
+
+void init_duckdb_appender(void);
+
+#endif
+
+#endif
+

data/ext/duckdb/config.c

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

data/ext/duckdb/config.h

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

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

@@ -18,4 +18,16 @@ Init_duckdb_native(void)
     init_duckdb_blob();
 
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+    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

@@ -3,5 +3,10 @@ require 'mkmf'
 dir_config('duckdb')
 if have_library('duckdb')
   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')
   create_makefile('duckdb/duckdb_native')
 end

data/ext/duckdb/prepared_statement.c

@@ -70,7 +70,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 +86,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 +217,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

@@ -55,8 +55,19 @@ static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_
 #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);
-    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 */
 
@@ -86,8 +97,17 @@ 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;
 }

data/ext/duckdb/ruby-duckdb.h

@@ -15,6 +15,18 @@
 
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
 
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+#include "./appender.h"
+
+#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;
@@ -25,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,102 @@
+require 'date'
+
+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
+
+      def append_hugeint(value)
+        case value
+        when Integer
+          append_varchar(value.to_s)
+        else
+          rb_raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
+        end
+      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
+          append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+        when Date
+          append_varchar(value.strftime('%Y-%m-%d'))
+        else
+          rb_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
+    end
+  end
+end