duckdb 0.0.3 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43b6f8c6bf0c6c1e596e6b37a34f2cb43cd424c6709b1b8e2196ea60a7b8c117
-  data.tar.gz: 46184d2c16d824ab492871b00d538d6693406b625b89cff43fde6437a32519bb
+  metadata.gz: 743c5cd93509adeb83483bc5dfc363ef65a4b92aacc1c72b0845c2a5d722c913
+  data.tar.gz: 93f5aac3993b0b1cd1512e1dd32fbcab216e6e2ab9b94df229b29d36c1bcd89e
 SHA512:
-  metadata.gz: 424015563c661fba018d212ffcd99cc4b06c9e24aae3ea7bb44b70ca279d4518cd11a673409b19fac99939c9bcdbb2b3136d75f55e0b5ddcbc291c22b7f2ee43
-  data.tar.gz: bd6336a12f0e6a4486d113b99fe20d0c7d31b5afcd87712cd70271d489b66eb9ee55672c69fe0c476ad99ac55910ba1ac4c260547a2799e3e8056aae3f34f796
+  metadata.gz: c93239f6fe857b8761fa88a223be2a4b45e883291687feeaf1a2215ab0238d87a04d5d72a8854c2610a3333f6c282e6a17f81baae8fe61d8ebb4ce59801ad5ff
+  data.tar.gz: c2b45b34783c366075a42c22765bf2406ebbaa5ee9024b3260003d20be4321b16efc565839f93ec3fd6a6e25582b7c1d12f265d8d56e92003b9eb40e26e51a58

data/.github/workflows/test_by_github.yml

@@ -0,0 +1,66 @@
+name: Ubuntu
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ['2.5.8', '2.6.6', '2.7.1', 'head']
+        duckdb: ['0.1.8', '0.1.9']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - name: duckdb 0.1.8 cache
+      id: duckdb-cache-v0_1_8
+      uses: actions/cache@v1.1.0
+      with:
+        path: duckdb-v0.1.8
+        key: ${{ runner.os }}-duckdb-v0_1_8_001
+        restore-keys: |
+          ${{ runner.os }}-duckdb-v0_1_8
+
+    - name: duckdb 0.1.9 cache
+      id: duckdb-cache-v0_1_9
+      uses: actions/cache@v1.1.0
+      with:
+        path: duckdb-v0.1.9
+        key: ${{ runner.os }}-duckdb-v0_1_9_001
+        restore-keys: |
+          ${{ runner.os }}-duckdb-v0_1_9
+
+    - name: Build duckdb 0.1.8
+      if: steps.duckdb-cache-v0_1_8.outputs.cache-hit != 'true'
+      run: |
+        git clone -b v0.1.8 https://github.com/cwida/duckdb.git duckdb-tmp-v0.1.8
+        cd duckdb-tmp-v0.1.8 && make && cd ..
+        rm -rf duckdb-v0.1.8
+        mkdir -p duckdb-v0.1.8/build/release/src duckdb-v0.1.8/src
+        cp -rip duckdb-tmp-v0.1.8/build/release/src/*.so duckdb-v0.1.8/build/release/src
+        cp -rip duckdb-tmp-v0.1.8/src/include duckdb-v0.1.8/src/
+
+    - name: Build duckdb 0.1.9
+      if: steps.duckdb-cache-v0_1_9.outputs.cache-hit != 'true'
+      run: |
+        git clone -b v0.1.9 https://github.com/cwida/duckdb.git duckdb-tmp-v0.1.9
+        cd duckdb-tmp-v0.1.9 && make && cd ..
+        rm -rf duckdb-v0.1.9
+        mkdir -p duckdb-v0.1.9/build/release/src duckdb-v0.1.9/src
+        cp -rip duckdb-tmp-v0.1.9/build/release/src/*.so duckdb-v0.1.9/build/release/src
+        cp -rip duckdb-tmp-v0.1.9/src/include duckdb-v0.1.9/src/
+
+    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+cache:
+  bundler: true
+  directories:
+    - ${HOME}/duckdb-v0.1.9
+before_install:
+  - yes | gem update --system
+  - if [[ ! -d ${HOME}/duckdb-v0.1.9/build ]]; then cd ${HOME} && git clone -b v0.1.9 https://github.com/cwida/duckdb.git duckdb-v0.1.9 && cd duckdb-v0.1.9 && make && cd ${TRAVIS_BUILD_DIR}; fi
+
+env:
+  - DUCKDB_VERSION=0.1.9
+rvm:
+  - 2.5.8
+  - 2.6.6
+  - 2.7.0
+  - 2.7.1
+  - ruby-head
+script: bundle exec rake -- --with-duckdb-include=${HOME}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${HOME}/duckdb-v${DUCKDB_VERSION}/build/release/src/

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # ChangeLog
 
+## 0.0.8
+
+- remove test with Ruby 2.4.10
+- bump DuckDB to v0.1.8
+- bump DuckDB to v0.1.8
+- bump DuckDB to v0.1.7
+  - current ruby-duckdb supports DuckDB version 0.1.5 and 0.1.6
+- support Ruby 2.7.1
+- bump DuckDB to v0.1.6
+  - current ruby-duckdb supports DuckDB version 0.1.5 and 0.1.6
+- DuckDB::Connection#connect accepts block
+- add DuckDB::Connection#connect
+- DuckDB::Database#connect accepts block
+- DuckDB::Database.open accepts block
+- update duckdb.gemspec, required ruby version >= 2.4.0
+
+## 0.0.7
+
+- bump DuckDB to v0.1.5
+  - DuckDB version must be 0.1.5 or later.
+- add DuckDB::Connection#connect, alias method open
+- add DuckDB::Connection#disconnect, alias method close
+- add DuckDB::Database#close
+
+## 0.0.6
+
+- add alias `execute` of `DuckDB::Connection#query`
+- support `duckdb version 0.1.3`
+- add `DuckDB:PreparedStatement`
+- create CI (GitHub Actions / Travis-CI)
+- create database only once in result_test.rb
+
+## 0.0.5
+
+- add `DuckDB::Error`
+- `DuckDB::Result#each` convert DuckDB number value to Ruby's number
+- `DuckDB::Result#each` convert DuckDB NULL value to nil
+- `DuckDB::Result#each` returns Enumerator object when block is not given
+- `DuckDB::Result` include `Enumerable`
+- add test for `DuckDB::Result`
+- add test for `DuckDB::Connection`
+- fix description in duckdb.gemspec
+
+## 0.0.4
+
+- add test for `DuckDB::Database`
+- rename module name to `DuckDB` from `Duckdb`
+
+## 0.0.3
+
+- rename native extension name to duckdb_native
+
+## 0.0.2
+
+- fix gem install error
+
 ## 0.0.1
 
 - first release

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    duckdb (0.0.1)
+    duckdb (0.0.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.13.0)
-    rake (10.5.0)
-    rake-compiler (1.0.8)
+    rake (13.0.1)
+    rake-compiler (1.1.0)
       rake
 
 PLATFORMS
@@ -18,8 +18,8 @@ DEPENDENCIES
   bundler (~> 2.0)
   duckdb!
   minitest (~> 5.0)
-  rake (~> 10.0)
+  rake (~> 13.0)
   rake-compiler
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -1,5 +1,7 @@
 # ruby-duckdb
 
+[![Build Status](https://travis-ci.com/suketa/ruby-duckdb.svg?branch=master)](https://travis-ci.com/suketa/ruby-duckdb)
+[![](https://github.com/suketa/ruby-duckdb/workflows/Ubuntu/badge.svg)](https://github.com/suketa/ruby-duckdb/actions?query=workflow%3AUbuntu)
 
 ## Description
 
@@ -40,3 +42,24 @@ result.each do |row|
   p row
 end
 ```
+
+Or, you can use block.
+
+```
+require 'duckdb'
+
+DuckDB::Database.open do |db|
+  db.connect do |con|
+    con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+
+    con.query("INSERT into users VALUES(1, 'Alice')")
+    con.query("INSERT into users VALUES(2, 'Bob')")
+    con.query("INSERT into users VALUES(3, 'Cathy')")
+
+    result = con.query('SELECT * from users')
+    result.each do |row|
+      p row
+    end
+  end
+end
+```

data/duckdb.gemspec

@@ -1,32 +1,35 @@
-lib = File.expand_path("lib", __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "duckdb/version"
+require 'duckdb/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "duckdb"
-  spec.version       = Duckdb::VERSION
-  spec.authors       = ["Masaki Suketa"]
-  spec.email         = ["masaki.suketa@nifty.ne.jp"]
+  spec.name          = 'duckdb'
+  spec.version       = DuckDB::VERSION
+  spec.authors       = ['Masaki Suketa']
+  spec.email         = ['masaki.suketa@nifty.ne.jp']
 
-  spec.summary       = %q{This module is Ruby binding for DuckDB database engine.}
-  spec.description   = %q{This module is Ruby binding for DuckDB database engine.\nYou must have the DuckDB engine installed to build/use this module.}
-  spec.homepage      = "https://github.com/suketa/ruby-duckdb"
-  spec.license       = "MIT"
+  spec.summary       = 'This module is Ruby binding for DuckDB database engine.'
+  spec.description   = 'This module is Ruby binding for DuckDB database engine. You must have the DuckDB engine installed to build/use this module.'
+  spec.homepage      = 'https://github.com/suketa/ruby-duckdb'
+  spec.license       = 'MIT'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/suketa/ruby-duckdb"
-  spec.metadata["changelog_uri"] = "https://github.com/suketa/ruby-duckdb/CHANGELOG.md"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/suketa/ruby-duckdb'
+  spec.metadata['changelog_uri'] = 'https://github.com/suketa/ruby-duckdb/blob/master/CHANGELOG.md'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.require_paths = ["lib"]
-  spec.extensions    = ["ext/duckdb/extconf.rb"]
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/duckdb/extconf.rb']
+  spec.required_ruby_version = '>= 2.4.0'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rake-compiler'
 end

data/ext/duckdb/connection.c

@@ -1,7 +1,5 @@
 #include "ruby-duckdb.h"
 
-static VALUE cDuckDBConnection;
-
 static void deallocate(void *ctx)
 {
     rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
@@ -16,7 +14,8 @@ static VALUE allocate(VALUE klass)
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-VALUE create_connection(VALUE oDuckDBDatabase) {
+VALUE create_connection(VALUE oDuckDBDatabase)
+{
     rubyDuckDB *ctxdb;
     rubyDuckDBConnection *ctxcon;
     VALUE obj;
@@ -27,15 +26,43 @@ VALUE create_connection(VALUE oDuckDBDatabase) {
     Data_Get_Struct(obj, rubyDuckDBConnection, ctxcon);
 
     if (duckdb_connect(ctxdb->db, &(ctxcon->con)) == DuckDBError) {
-        rb_raise(rb_eRuntimeError, "connection error");
+        rb_raise(eDuckDBError, "connection error");
     }
 
     // rb_ivar_set(obj, rb_intern("database"), oDuckDBDatabase);
     return obj;
 }
 
-static VALUE duckdb_connection_query(VALUE self, VALUE str) {
+static VALUE duckdb_connection_disconnect(VALUE self)
+{
+    rubyDuckDBConnection *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBConnection, ctx);
+    duckdb_disconnect(&(ctx->con));
+
+    return self;
+}
 
+static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase)
+{
+    rubyDuckDBConnection *ctx;
+    rubyDuckDB *ctxdb;
+
+    if (!rb_obj_is_kind_of(oDuckDBDatabase, cDuckDBDatabase)) {
+        rb_raise(rb_eTypeError, "The first argument must be DuckDB::Database object.");
+    }
+    Data_Get_Struct(oDuckDBDatabase, rubyDuckDB, ctxdb);
+    Data_Get_Struct(self, rubyDuckDBConnection, ctx);
+
+    if (duckdb_connect(ctxdb->db, &(ctx->con)) == DuckDBError) {
+        rb_raise(eDuckDBError, "connection error");
+    }
+
+    return self;
+}
+
+static VALUE duckdb_connection_query_sql(VALUE self, VALUE str)
+{
     rubyDuckDBConnection *ctx;
     rubyDuckDBResult *ctxr;
 
@@ -44,8 +71,12 @@ static VALUE duckdb_connection_query(VALUE self, VALUE str) {
     Data_Get_Struct(self, rubyDuckDBConnection, ctx);
     Data_Get_Struct(result, rubyDuckDBResult, ctxr);
 
+    if (!(ctx->con)) {
+        rb_raise(eDuckDBError, "Database connection closed");
+    }
+
     if (duckdb_query(ctx->con, StringValueCStr(str), &(ctxr->result)) == DuckDBError) {
-        rb_raise(rb_eRuntimeError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
     }
     return result;
 }
@@ -55,5 +86,7 @@ void init_duckdb_connection(void)
     cDuckDBConnection = rb_define_class_under(mDuckDB, "Connection", rb_cObject);
     rb_define_alloc_func(cDuckDBConnection, allocate);
 
-    rb_define_method(cDuckDBConnection, "query", duckdb_connection_query, 1);
+    rb_define_method(cDuckDBConnection, "disconnect", duckdb_connection_disconnect, 0);
+    rb_define_private_method(cDuckDBConnection, "_connect", duckdb_connection_connect, 1);
+    rb_define_private_method(cDuckDBConnection, "query_sql", duckdb_connection_query_sql, 1);
 }

data/ext/duckdb/connection.h

@@ -7,6 +7,8 @@ struct _rubyDuckDBConnection {
 
 typedef struct _rubyDuckDBConnection rubyDuckDBConnection;
 
+VALUE cDuckDBConnection;
+
 void init_duckdb_connection(void);
 VALUE create_connection(VALUE oDuckDBDatabase);
 

data/ext/duckdb/database.c

@@ -1,10 +1,15 @@
 #include "ruby-duckdb.h"
 
+static void close_database(rubyDuckDB *p)
+{
+    duckdb_close(&(p->db));
+}
+
 static void deallocate(void * ctx)
 {
     rubyDuckDB *p = (rubyDuckDB *)ctx;
 
-    duckdb_close(&(p->db));
+    close_database(p);
     xfree(p);
 }
 
@@ -31,18 +36,35 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
     Data_Get_Struct(obj, rubyDuckDB, ctx);
     if (duckdb_open(pfile, &(ctx->db)) == DuckDBError)
     {
-        rb_raise(rb_eRuntimeError, "Failed to open database"); /* FIXME */
+        rb_raise(eDuckDBError, "Failed to open database"); /* FIXME */
     }
     return obj;
 }
 
-static VALUE duckdb_database_connect(VALUE self) {
+static VALUE duckdb_database_connect(VALUE self)
+{
     return create_connection(self);
 }
 
-void init_duckdb_database(void) {
-    VALUE cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
+/*
+ *  call-seq:
+ *    duckdb.close -> DuckDB::Database
+ *
+ *  closes DuckDB database.
+ */
+static VALUE duckdb_database_close(VALUE self)
+{
+    rubyDuckDB *ctx;
+    Data_Get_Struct(self, rubyDuckDB, ctx);
+    close_database(ctx);
+    return self;
+}
+
+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);
-    rb_define_method(cDuckDBDatabase, "connect", duckdb_database_connect, 0);
+    rb_define_singleton_method(cDuckDBDatabase, "_open", duckdb_database_s_open, -1);
+    rb_define_private_method(cDuckDBDatabase, "_connect", duckdb_database_connect, 0);
+    rb_define_method(cDuckDBDatabase, "close", duckdb_database_close, 0);
 }

data/ext/duckdb/database.h

@@ -7,6 +7,8 @@ struct _rubyDuckDB {
 
 typedef struct _rubyDuckDB rubyDuckDB;
 
+VALUE cDuckDBDatabase;
+
 void init_duckdb_database(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -3,10 +3,13 @@
 VALUE mDuckDB;
 
 void
-Init_duckdb_native(void) {
+Init_duckdb_native(void)
+{
     mDuckDB = rb_define_module("DuckDB");
 
+    init_duckdb_error();
     init_duckdb_database();
     init_duckdb_connection();
     init_duckdb_result();
+    init_duckdb_prepared_statement();
 }

data/ext/duckdb/error.c

@@ -0,0 +1,6 @@
+#include "ruby-duckdb.h"
+
+void init_duckdb_error(void)
+{
+    eDuckDBError = rb_define_class_under(mDuckDB, "Error", rb_eStandardError);
+}

data/ext/duckdb/error.h

@@ -0,0 +1,10 @@
+#ifndef RUBY_DUCKDB_ERROR_H
+#define RUBY_DUCKDB_ERROR_H
+
+VALUE eDuckDBError;
+
+void init_duckdb_error(void);
+
+#endif
+
+

data/ext/duckdb/extconf.rb

@@ -1,5 +1,6 @@
 require 'mkmf'
 
 dir_config('duckdb')
-have_library('duckdb')
-create_makefile('duckdb/duckdb_native')
+if have_library('duckdb')
+  create_makefile('duckdb/duckdb_native')
+end

data/ext/duckdb/prepared_statement.c

@@ -0,0 +1,200 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBPreparedStatement;
+
+static void deallocate(void *ctx)
+{
+    rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
+
+    duckdb_destroy_prepare(&(p->prepared_statement));
+    xfree(p);
+}
+
+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)
+{
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBPreparedStatement *ctx;
+
+    if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
+        rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
+    }
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
+
+    if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
+        /* TODO: include query parameter information in error message. */
+        rb_raise(eDuckDBError, "failed to prepare statement");
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement_nparams(VALUE self)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_nparams(ctx->prepared_statement, &(ctx->nparams)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to get number of parameters");
+    }
+    return rb_int2big(ctx->nparams);
+}
+
+
+static VALUE duckdb_prepared_statement_execute(VALUE self)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    rubyDuckDBResult *ctxr;
+    VALUE result = create_result();
+
+    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);
+    }
+    return result;
+}
+
+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");
+    }
+    return idx;
+}
+
+static VALUE duckdb_prepared_statement_bind_boolean(VALUE self, VALUE vidx, VALUE val)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (val != Qtrue && val != Qfalse) {
+        rb_raise(rb_eArgError, "binding value must be boolean");
+    }
+
+    if (duckdb_bind_boolean(ctx->prepared_statement, idx, (val == Qtrue)) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+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);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_int16(ctx->prepared_statement, idx, i16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    int32_t i32val = NUM2LONG(val);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_int32(ctx->prepared_statement, idx, i32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+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);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_int64(ctx->prepared_statement, idx, i64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+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);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_float(ctx->prepared_statement, idx, (float)dbl) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+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);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_double(ctx->prepared_statement, idx, dbl) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_varchar(ctx->prepared_statement, idx, StringValuePtr(str)) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
+{
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_null(ctx->prepared_statement, idx) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %ld parameter", idx);
+    }
+    return self;
+}
+
+void init_duckdb_prepared_statement(void)
+{
+    cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
+
+    rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
+
+    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_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);
+    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);
+    rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
+}

data/ext/duckdb/prepared_statement.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_PREPARED_STATEMENT_H
+#define RUBY_DUCKDB_PREPARED_STATEMENT_H
+
+struct _rubyDuckDBPreparedStatement {
+    duckdb_prepared_statement prepared_statement;
+    idx_t nparams;
+};
+
+typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
+
+void init_duckdb_prepared_statement(void);
+
+#endif

data/ext/duckdb/result.c

@@ -16,23 +16,94 @@ static VALUE allocate(VALUE klass)
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE row_array(rubyDuckDBResult *ctx, size_t row_idx) {
-    size_t col_idx;
-    VALUE ary = rb_ary_new2(ctx->result.column_count);
-    for(col_idx = 0; col_idx < ctx->result.column_count; col_idx++) {
-        char *p = duckdb_value_varchar(&(ctx->result), col_idx, row_idx);
-        rb_ary_store(ary, col_idx, rb_str_new2(p));
+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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    double dval = duckdb_value_double(result, col_idx, row_idx);
+    return DBL2NUM(dval);
+}
+
+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]) {
+        return obj;
+    }
+    switch(result->columns[col_idx].type) {
+    case DUCKDB_TYPE_BOOLEAN:
+        return to_ruby_obj_boolean(result, col_idx, row_idx);
+    case DUCKDB_TYPE_SMALLINT:
+        return to_ruby_obj_smallint(result, col_idx, row_idx);
+    case DUCKDB_TYPE_INTEGER:
+        return to_ruby_obj_integer(result, col_idx, row_idx);
+    case DUCKDB_TYPE_BIGINT:
+        return to_ruby_obj_bigint(result, col_idx, row_idx);
+    case DUCKDB_TYPE_FLOAT:
+        return to_ruby_obj_float(result, col_idx, row_idx);
+    case DUCKDB_TYPE_DOUBLE:
+        return to_ruby_obj_double(result, col_idx, row_idx);
+    default:
+        p = duckdb_value_varchar(result, col_idx, row_idx);
+        obj = rb_str_new2(p);
         free(p);
     }
+    return obj;
+}
+
+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++) {
+        rb_ary_store(ary, col_idx, to_ruby_obj(&(ctx->result), col_idx, row_idx));
+    }
     return ary;
 }
 
-static VALUE duckdb_result_each(VALUE oDuckDBResult) {
+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)
+{
     rubyDuckDBResult *ctx;
-    size_t row_idx = 0;
+    idx_t row_idx = 0;
 
-    // RETURN_ENUMERATOR(oDuckDBResult, 0, 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++) {
@@ -41,7 +112,8 @@ static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     return oDuckDBResult;
 }
 
-VALUE create_result(void) {
+VALUE create_result(void)
+{
     return allocate(cDuckDBResult);
 }
 

data/ext/duckdb/ruby-duckdb.h

@@ -3,9 +3,11 @@
 
 #include "ruby.h"
 #include <duckdb.h>
+#include "./error.h"
 #include "./database.h"
 #include "./connection.h"
 #include "./result.h"
+#include "./prepared_statement.h"
 
 extern VALUE mDuckDB;
 

data/lib/duckdb.rb

@@ -1,5 +1,10 @@
-require "duckdb/version"
-require "duckdb/duckdb_native"
+require 'duckdb/duckdb_native'
+require 'duckdb/version'
+require 'duckdb/database'
+require 'duckdb/connection'
+require 'duckdb/result'
+require 'duckdb/prepared_statement'
 
-module Duckdb
+# DuckDB provides Ruby interface of DuckDB.
+module DuckDB
 end

data/lib/duckdb/connection.rb

@@ -0,0 +1,51 @@
+module DuckDB
+  # The DuckDB::Connection encapsulates connection with DuckDB database.
+  #
+  #   require 'duckdb'
+  #   db = DuckDB::Database.open
+  #   con = db.connect
+  #   con.query(sql)
+  class Connection
+    #
+    # executes sql with args.
+    # The first argument sql must be SQL string.
+    # The rest arguments are parameters of SQL string.
+    # The parameters must be '?' in SQL statement.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_file')
+    #   con = db.connect
+    #   users = con.query('SELECT * FROM users')
+    #   sql = 'SELECT * FROM users WHERE name = ? AND email = ?'
+    #   dave = con.query(sql, 'Dave', 'dave@example.com')
+    #
+    def query(sql, *args)
+      return query_sql(sql) if args.empty?
+
+      stmt = PreparedStatement.new(self, sql)
+      args.each_with_index do |arg, i|
+        stmt.bind(i + 1, arg)
+      end
+      stmt.execute
+    end
+
+    #
+    # connects DuckDB database
+    # The first argument is DuckDB::Database object
+    #
+    def connect(db)
+      conn = _connect(db)
+      return conn unless block_given?
+
+      begin
+        yield conn
+      ensure
+        conn.disconnect
+      end
+    end
+
+    alias execute query
+    alias open connect
+    alias close disconnect
+  end
+end

data/lib/duckdb/database.rb

@@ -0,0 +1,77 @@
+module DuckDB
+  # The Database class encapsulates a DuckDB database.
+  #
+  # The usage is as follows:
+  #
+  #   require 'duckdb'
+  #
+  #   db = DuckDB::Database.open # database in memory
+  #   con = db.connect
+  #
+  #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+  #
+  #   con.query("INSERT into users VALUES(1, 'Alice')")
+  #   con.query("INSERT into users VALUES(2, 'Bob')")
+  #   con.query("INSERT into users VALUES(3, 'Cathy')")
+  #
+  #   result = con.query('SELECT * from users')
+  #   result.each do |row|
+  #     p row
+  #   end
+  #
+  class Database
+    private_class_method :_open
+
+    class << self
+      ##
+      # Opens database.
+      # The first argument is DuckDB database file path to open.
+      # If there is no argument, the method opens DuckDB database in memory.
+      # The method yields block if block is given.
+      #
+      #   DuckDB::Database.open('duckdb_database.db') #=> DuckDB::Database
+      #
+      #   DuckDB::Database.open #=> opens DuckDB::Database in memory.
+      #
+      #   DuckDB::Database.open do |db|
+      #     con = db.connect
+      #     con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+      #   end
+      #
+      def open(*args)
+        db = _open(*args)
+        return db unless block_given?
+
+        begin
+          yield db
+        ensure
+          db.close
+        end
+      end
+    end
+
+    ##
+    # connects database.
+    #
+    # The method yields block and disconnects the database if block given
+    #
+    #   db = DuckDB::Database.open
+    #
+    #   con = db.connect # => DuckDB::Connection
+    #
+    #   db.connect do |con|
+    #     con.query('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+    #   end
+    #
+    def connect
+      conn = _connect
+      return conn unless block_given?
+
+      begin
+        yield conn
+      ensure
+        conn.disconnect
+      end
+    end
+  end
+end

data/lib/duckdb/prepared_statement.rb

@@ -0,0 +1,48 @@
+require 'date'
+
+module DuckDB
+  # The DuckDB::PreparedStatement encapsulates connection with DuckDB prepared
+  # statement.
+  #
+  #   require 'duckdb'
+  #   db = DuckDB::Database.open('duckdb_database')
+  #   con = db.connect
+  #   sql ='SELECT name, email FROM users WHERE email = ?'
+  #   stmt = PreparedStatement.new(con, sql)
+  #   stmt.bind(1, 'email@example.com')
+  #   stmt.execute
+  class PreparedStatement
+
+    # 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'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name, email FROM users WHERE email = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind(1, 'email@example.com')
+    def bind(i, value)
+      case value
+      when NilClass
+        respond_to?(:bind_null) ? bind_null(i) : rb_raise(DuckDB::Error, 'This bind method does not support nil value. Re-compile ruby-duckdb with DuckDB version >= 0.1.1')
+      when Float
+        bind_double(i, value)
+      when Integer
+        bind_int64(i, value)
+      when String
+        bind_varchar(i, value)
+      when TrueClass, FalseClass
+        bind_boolean(i, value)
+      when Time
+        bind_varchar(i, value.strftime('%Y-%m-%d %H:%M:%S.%N'))
+      when Date
+        bind_varchar(i, value.strftime('%Y-%m-%d'))
+      else
+        rb_raise(DuckDB::Error, "not supported type #{value} (value.class)")
+      end
+    end
+  end
+end

data/lib/duckdb/result.rb

@@ -0,0 +1,24 @@
+module DuckDB
+  # The Result class encapsulates a execute result of DuckDB database.
+  #
+  # The usage is as follows:
+  #
+  #   require 'duckdb'
+  #
+  #   db = DuckDB::Database.open # database in memory
+  #   con = db.connect
+  #
+  #   con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
+  #
+  #   con.execute("INSERT into users VALUES(1, 'Alice')")
+  #   con.execute("INSERT into users VALUES(2, 'Bob')")
+  #   con.execute("INSERT into users VALUES(3, 'Cathy')")
+  #
+  #   result = con.execute('SELECT * from users')
+  #   result.each do |row|
+  #     p row
+  #   end
+  class Result
+    include Enumerable
+  end
+end

data/lib/duckdb/version.rb

@@ -1,3 +1,5 @@
-module Duckdb
-  VERSION = "0.0.3"
+module DuckDB
+  # The version string of ruby-duckdb.
+  # Currently, ruby-duckdb is NOT semantic versioning.
+  VERSION = '0.0.8'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.8
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-02 00:00:00.000000000 Z
+date: 2020-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,48 +25,48 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-description: This module is Ruby binding for DuckDB database engine.\nYou must have
+        version: '0'
+description: This module is Ruby binding for DuckDB database engine. You must have
   the DuckDB engine installed to build/use this module.
 email:
 - masaki.suketa@nifty.ne.jp
@@ -75,14 +75,15 @@ extensions:
 - ext/duckdb/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/test_by_github.yml"
 - ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
-- TODO
 - bin/console
 - bin/setup
 - duckdb.gemspec
@@ -91,11 +92,19 @@ files:
 - ext/duckdb/database.c
 - ext/duckdb/database.h
 - ext/duckdb/duckdb.c
+- ext/duckdb/error.c
+- ext/duckdb/error.h
 - ext/duckdb/extconf.rb
+- ext/duckdb/prepared_statement.c
+- ext/duckdb/prepared_statement.h
 - ext/duckdb/result.c
 - ext/duckdb/result.h
 - ext/duckdb/ruby-duckdb.h
 - lib/duckdb.rb
+- lib/duckdb/connection.rb
+- lib/duckdb/database.rb
+- lib/duckdb/prepared_statement.rb
+- lib/duckdb/result.rb
 - lib/duckdb/version.rb
 homepage: https://github.com/suketa/ruby-duckdb
 licenses:
@@ -103,7 +112,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/suketa/ruby-duckdb
   source_code_uri: https://github.com/suketa/ruby-duckdb
-  changelog_uri: https://github.com/suketa/ruby-duckdb/CHANGELOG.md
+  changelog_uri: https://github.com/suketa/ruby-duckdb/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -112,14 +121,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.

data/TODO

@@ -1,2 +0,0 @@
-- add test
-- support prepared statement