duckdb 0.2.8.0 → 0.3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a07cf98bca895ec39cc43754e6f69544e22c16cab023554daa632dc0be14d527
-  data.tar.gz: d2e96a7556e9ab139fb4b03f8306961d011c80ff9eb259bb8f29cdbd390ea757
+  metadata.gz: 96ad27d302c878ca4d207d86e1eb24e61be890c8585d6bd9231237900479053d
+  data.tar.gz: 4e0fb0daf725f53acd454ee77c179ef1af57a96b9308bc6f303853e28fe9b9a6
 SHA512:
-  metadata.gz: fc64b4021083e0837de1c22470b015be7337f2e43754771c36b4265f133542bb7161762fa51a46f2ec9f9ac992bf67bb45e7d8031206f4cd385f248bddcff14d
-  data.tar.gz: 131cb3b1ee245cb765b8b7081d8fb900634055cf6570e6220121991e275d53e7be44ac1c1274c64f4c8991cd3252823274fd887fa3b49a31c8dc9578dd4aade6
+  metadata.gz: b407a06ebf245a9534362a5106fe7d8bd74a55f2234bf2c734da067f2a8ef150472f8b40a312acd9d0957fb27515ec67fb536cf019375825e6e62d2c1ea82e8e
+  data.tar.gz: e2da40b4d0cb0eb25a77a6e1b383cf54a4bd8618cc31d670f59d5068c74603e41d14c4f57f9e3f909a339798f7e2a0d0143239483aef8ea8094c92cdcac417f4

data/.github/workflows/test_on_macos.yml

@@ -1,13 +1,22 @@
 name: MacOS
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2
@@ -17,9 +26,17 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: Install latest duckdb by brew
+    - name: download duckdb binary for MacOS 64bit
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        brew install duckdb
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/libduckdb-osx-amd64.zip
+
+    - name: extract zip file
+      run: |
+        unzip libduckdb-osx-amd64.zip
+        cp duckdb.h /usr/local/include
+        cp libduckdb.dylib /usr/local/lib
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       run: |

data/.github/workflows/test_on_ubuntu.yml

@@ -1,6 +1,14 @@
 name: Ubuntu
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
@@ -8,8 +16,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.8', '2.7.4', '3.0.2', 'head']
-        duckdb: ['0.2.8', '0.2.7']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2
@@ -19,43 +27,24 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: duckdb 0.2.8 cache
-      id: duckdb-cache-v0_2_8
-      uses: actions/cache@v1.1.0
+    - name: duckdb cache
+      id: duckdb-cache
+      uses: actions/cache@v2
       with:
-        path: duckdb-v0.2.8
-        key: ${{ runner.os }}-duckdb-v0_2_8_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_8
+        path: duckdb-v${{ matrix.duckdb }}
+        key: ${{ runner.os }}-duckdb-v${{ matrix.duckdb }}
 
-    - name: duckdb 0.2.7 cache
-      id: duckdb-cache-v0_2_7
-      uses: actions/cache@v1.1.0
-      with:
-        path: duckdb-v0.2.7
-        key: ${{ runner.os }}-duckdb-v0_2_7_001
-        restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_7
-
-    - name: Build duckdb 0.2.8
-      if: steps.duckdb-cache-v0_2_8.outputs.cache-hit != 'true'
-      run: |
-        git clone -b v0.2.8 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.8
-        cd duckdb-tmp-v0.2.8 && make && cd ..
-        rm -rf duckdb-v0.2.8
-        mkdir -p duckdb-v0.2.8/build/release/src duckdb-v0.2.8/src
-        cp -rip duckdb-tmp-v0.2.8/build/release/src/*.so duckdb-v0.2.8/build/release/src
-        cp -rip duckdb-tmp-v0.2.8/src/include duckdb-v0.2.8/src/
-
-    - name: Build duckdb 0.2.7
-      if: steps.duckdb-cache-v0_2_7.outputs.cache-hit != 'true'
+    - name: Build duckdb ${{ matrix.duckdb }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      if: steps.duckdb-cache.outputs.cache-hit != 'true'
       run: |
-        git clone -b v0.2.7 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.7
-        cd duckdb-tmp-v0.2.7 && make && cd ..
-        rm -rf duckdb-v0.2.7
-        mkdir -p duckdb-v0.2.7/build/release/src duckdb-v0.2.7/src
-        cp -rip duckdb-tmp-v0.2.7/build/release/src/*.so duckdb-v0.2.7/build/release/src
-        cp -rip duckdb-tmp-v0.2.7/src/include duckdb-v0.2.7/src/
+        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/*.so duckdb-v$DUCKDB_VERSION/build/release/src
+        cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       env:

data/.github/workflows/test_on_windows.yml

@@ -1,13 +1,22 @@
 name: Windows
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
 
 jobs:
   build:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+        ruby: ['2.6.9', '2.7.5', '3.0.3', '3.1.1', 'mingw', 'head']
+        duckdb: ['0.3.2', '0.3.1']
 
     steps:
     - uses: actions/checkout@v2
@@ -18,20 +27,24 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
 
     - name: download duckdb binary for windows 64bit
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        curl -OL https://github.com/duckdb/duckdb/releases/download/v0.2.6/libduckdb-windows-amd64.zip
+        curl -OL https://github.com/duckdb/duckdb/releases/download/v${env:DUCKDB_VERSION}/libduckdb-windows-amd64.zip
 
     - name: extract zip file
       run: |
-        7z x libduckdb-windows-amd64.zip
+        unzip libduckdb-windows-amd64.zip
+
+    - name: setup duckdb.dll
+      run: |
+        cp duckdb.dll C:/Windows/System32/
 
     - name: Build with Rake with Ruby ${{ matrix.ruby }}
       run: |
         bundle install
         bundle exec rake build -- --with-duckdb-include=../../../.. --with-duckdb-lib=../../../..
 
-    # FIXME: rake test fails with LoadError
-    # C:/hostedtoolcache/windows/Ruby/2.7.3/x64/lib/ruby/2.7.0/rubygems/core_ext/kernel_require.rb:83:in `require': 126: The specified module could not be found.   - D:/a/ruby-duckdb/ruby-duckdb/lib/duckdb/duckdb_native.so (LoadError)`
-    # - name: rake test
-    #   run: |
-    #     rake test
+    - name: rake test
+      run: |
+        rake test

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # ChangeLog
 
+# 0.3.2.0
+
+- bind_time, bind_timestamp, bind_date, bind_timeinterval to DuckDB::PreparedStatement
+- bump duckdb 0.3.2
+- bump Ruby 3.1.1, add Ruby mingw in CI.
+- bump Ruby 2.6.9, 2.7.5, 3.0.3 in CI.
+
+## BREAKING CHANGE
+- drop duckdb <= 0.2.8
+
+# 0.3.1.0
+
+- bump duckdb to 0.3.1 in CI.
+- bump duckdb to 0.3.0 in CI.
+- append_time, append_date, append_timestamp of DuckDB::Appender accept argument
+  having to_str to convert time string.
+
+# 0.2.9.0
+
+- add DuckDB::Appender#append
+  - breaking change.
+    - append_timestamp is called when the argument is Time object.
+    - append_date is called when the argument is Date object.
+- add DuckDB::Appender#append_timestamp.
+- add DuckDB::Appender#append_interval. append_interval is expremental.
+- add DuckDB::Result#rows_changed
+- refactoring DuckDB::Append#append_hugeint with duckdb v0.2.9
+- test 2 versions of duckdb on github actions macos CI.
+- fix windows CI failes
+- update github actions CI on ubuntu
+- fix to build with duckdb v0.2.9
+- use duckdb_prepare_error when get error message of prepared statement.
+- add DuckDB::Appender#append_date
+- add DuckDB::Appender#append_time
+
+# 0.2.8.0
+
 - DuckDB::Database.open accepts 2-nd argument as DuckDB::Config object.
 - add DuckDB::Config
 - bump duckdb to 0.2.8 in CI

data/CONTRIBUTION.md

@@ -0,0 +1,24 @@
+# Contribution Guide
+
+## Issue
+
+If you spot a problem, [search if an issue already exists](https://github.com/suketa/ruby-duckdb/issues).
+If a related issue doesn't exist, you can open a [new issue](https://github.com/suketa/ruby-duckdb/issues/new).
+
+
+## Fix Issues or Add New Features.
+
+1. install [Ruby](https://www.ruby-lang.org/) into your local machine.
+2. install [duckdb](https://duckdb.org/) into your local machine.
+3. fork the repository and `git clone` to your local machine.
+4. run `bundle install`
+5. run `rake build`
+   or you might run with C duckdb header and library directories:
+   `rake build -- --with-duckdb-include=/duckdb_header_directory --with-duckdb-lib=/duckdb_library_directory`
+6. run `rake test`
+7. create new branch to change the code.
+8. change the code.
+9. write test.
+10. run `rake test` and confirm all tests pass.
+11. git push.
+12. create PR.

data/Gemfile.lock

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

data/README.md

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

data/duckdb.gemspec

@@ -21,12 +21,12 @@ Gem::Specification.new do |spec|
 
   # 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(__dir__)) 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.required_ruby_version = '>= 2.5.0'
+  spec.required_ruby_version = '>= 2.6.0'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'minitest', '~> 5.0'

data/ext/duckdb/appender.c

@@ -24,19 +24,38 @@ static VALUE appender_append_varchar(VALUE self, VALUE val);
 static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
 static VALUE appender_append_blob(VALUE self, VALUE val);
 static VALUE appender_append_null(VALUE self);
+
+#ifdef HAVE_DUCKDB_APPEND_DATE
+static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval);
+#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);
 
-static void deallocate(void * ctx)
-{
+static void deallocate(void * ctx) {
     rubyDuckDBAppender *p = (rubyDuckDBAppender *)ctx;
 
     duckdb_appender_destroy(&(p->appender));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBAppender *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBAppender));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
@@ -268,6 +287,85 @@ static VALUE appender_append_null(VALUE self) {
     return self;
 }
 
+#ifdef HAVE_DUCKDB_APPEND_DATE
+static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
+    duckdb_date dt;
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    dt = to_duckdb_date_from_value(year, month, day);
+
+    if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append date");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_INTERVAL
+static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros) {
+    duckdb_interval interval;
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    to_duckdb_interval_from_value(&interval, months, days, micros);
+
+    if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append interval");
+    }
+    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;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    time = to_duckdb_time_from_value(hour, min, sec, micros);
+
+    if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append time");
+    }
+    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;
+
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+
+    if (duckdb_append_timestamp(ctx->appender, timestamp) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append timestamp");
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_APPEND_HUGEINT
+static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
+    duckdb_hugeint hugeint;
+
+    hugeint.lower = NUM2ULL(lower);
+    hugeint.upper = NUM2LL(upper);
+
+    rubyDuckDBAppender *ctx;
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    if (duckdb_append_hugeint(ctx->appender, hugeint) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append hugeint");
+    }
+    return self;
+}
+#endif
+
 static VALUE appender_flush(VALUE self) {
     rubyDuckDBAppender *ctx;
     Data_Get_Struct(self, rubyDuckDBAppender, ctx);
@@ -309,6 +407,21 @@ void init_duckdb_appender(void) {
     rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
     rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
     rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
+#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);
 }

data/ext/duckdb/blob.c

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

data/ext/duckdb/blob.h

@@ -4,11 +4,7 @@
 /*
  * blob is supported by duckdb v0.2.5 or later
  */
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-
 void init_duckdb_blob(void);
 
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
 #endif
 

data/ext/duckdb/config.c

@@ -11,16 +11,14 @@ static VALUE config_s_get_config_flag(VALUE self, VALUE value);
 static VALUE config_initialize(VALUE self);
 static VALUE config_set_config(VALUE self, VALUE key, VALUE value);
 
-static void deallocate(void * ctx)
-{
+static void deallocate(void * ctx) {
     rubyDuckDBConfig *p = (rubyDuckDBConfig *)ctx;
 
     duckdb_destroy_config(&(p->config));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBConfig *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConfig));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
@@ -37,7 +35,7 @@ static VALUE config_initialize(VALUE self) {
 }
 
 static VALUE config_s_size(VALUE self) {
-    return INT2NUM(duckdb_config_count());
+    return ULONG2NUM(duckdb_config_count());
 }
 
 static VALUE config_s_get_config_flag(VALUE klass, VALUE value) {

data/ext/duckdb/connection.c

@@ -2,22 +2,25 @@
 
 VALUE cDuckDBConnection;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_connection_disconnect(VALUE self);
+static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase);
+static VALUE duckdb_connection_query_sql(VALUE self, VALUE str);
+
+static void deallocate(void *ctx) {
     rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
 
     duckdb_disconnect(&(p->con));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBConnection *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConnection));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-VALUE create_connection(VALUE oDuckDBDatabase)
-{
+VALUE create_connection(VALUE oDuckDBDatabase) {
     rubyDuckDB *ctxdb;
     rubyDuckDBConnection *ctxcon;
     VALUE obj;
@@ -35,8 +38,7 @@ VALUE create_connection(VALUE oDuckDBDatabase)
     return obj;
 }
 
-static VALUE duckdb_connection_disconnect(VALUE self)
-{
+static VALUE duckdb_connection_disconnect(VALUE self) {
     rubyDuckDBConnection *ctx;
 
     Data_Get_Struct(self, rubyDuckDBConnection, ctx);
@@ -45,8 +47,7 @@ static VALUE duckdb_connection_disconnect(VALUE self)
     return self;
 }
 
-static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase)
-{
+static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     rubyDuckDBConnection *ctx;
     rubyDuckDB *ctxdb;
 
@@ -63,8 +64,7 @@ static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase)
     return self;
 }
 
-static VALUE duckdb_connection_query_sql(VALUE self, VALUE str)
-{
+static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     rubyDuckDBConnection *ctx;
     rubyDuckDBResult *ctxr;
 
@@ -78,13 +78,12 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str)
     }
 
     if (duckdb_query(ctx->con, StringValueCStr(str), &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;
 }
 
-void init_duckdb_connection(void)
-{
+void init_duckdb_connection(void) {
     cDuckDBConnection = rb_define_class_under(mDuckDB, "Connection", rb_cObject);
     rb_define_alloc_func(cDuckDBConnection, allocate);