duckdb 0.9.1.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f3ac463fffc2fc6362c34abbfa5b862a7b8c993052ede087ca4403542c98dc8
-  data.tar.gz: c5ea1236f240a62165b7e371ae48033447868d119261def6c5310d3911e9df91
+  metadata.gz: afbb8627bfcb9764d6928d64558b55c18b26932b1ad50946cfe777169b6986f9
+  data.tar.gz: b560803df1d4b93d1e1b9f5c56b55f779c34095780592b9cdae51f7d4da2c0ec
 SHA512:
-  metadata.gz: 210fe783740da4b6eb7991de416a7b5581403d8ad3661625110e275c030fe9dc1192d6fe2d73dcb778e53408b0e349eb28f37f2a1308d31ff30b0b783be5e498
-  data.tar.gz: b6fcc8d47c20ff9ce053122d9d9c03f4b19f1a72d9cd56addc1704d862ab7cfda4b3bec88bb3d8580befa006dcfeeee76138e00a2a34f065cca630bde523fb7d
+  metadata.gz: 4c16acf784261f874501381aa9c764bc461d56fd35b066bae88c6cf0b4de654a867a6d309641cf0cf39d60854d268ce610fd3997534adcd11f322e7e4cd76401
+  data.tar.gz: 24d26d68b843c27ca306980e0d1acdfed2c6f24bb573cb89ba684879c4d05d43256d2335085e82fb1c352b7cdffcd016f2c2dadf3d924fc747cc4c450b142693

data/.gitattributes

@@ -0,0 +1 @@
+*.rb diff=ruby

data/.github/workflows/test_on_macos.yml

@@ -1,9 +1,9 @@
 name: MacOS
 
 on:
-  push:
-    branches:
-      - main
+  # push:
+  #   branches:
+  #     - main
   pull_request:
     types:
       - opened
@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview2', 'head']
-        duckdb: ['0.9.1', '0.8.1']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview3', 'head']
+        duckdb: ['0.9.2', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3
@@ -59,7 +59,7 @@ jobs:
 
     - name: run test with Ruby ${{ matrix.ruby }}
       run: |
-        rake test
+        env RUBYOPT=-W:deprecated rake test
 
   post-test:
     name: All tests passed on macos

data/.github/workflows/test_on_ubuntu.yml

@@ -1,9 +1,9 @@
 name: Ubuntu
 
 on:
-  push:
-    branches:
-      - main
+  # push:
+  #   branches:
+  #     - main
   pull_request:
     types:
       - opened
@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview2', 'head']
-        duckdb: ['0.9.1', '0.8.1']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview3', 'head']
+        duckdb: ['0.9.2', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3
@@ -57,7 +57,7 @@ jobs:
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
-        rake test
+        env RUBYOPT=-W:deprecated rake test
 
   post-test:
     name: All tests passed on Ubuntu

data/.github/workflows/test_on_windows.yml

@@ -1,9 +1,9 @@
 name: Windows
 
 on:
-  push:
-    branches:
-      - main
+  # push:
+  #   branches:
+  #     - main
   pull_request:
     types:
       - opened
@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.9.1', '0.8.1']
+        duckdb: ['0.9.2', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # ChangeLog
 
+# 0.9.2
+- add DuckDB::Connection#async_query_stream
+- DuckDB::PendingResult accepts second argument. If the second argument is
+  true, PendingResult#execute_pending returns streaming DuckDB::Result object.
+- add DuckDB::PreparedStatement#pending_prepared_stream
+- add DuckDB::Result#streaming?.
+
+# 0.9.1.2
+- add DuckDB::Connection#interrupt, DuckDB::Connection#query_progress
+- add DuckDB::Connection#async_query, alias method async_execute.
+
 # 0.9.1.1
 - change default branch to main from master.
 - add DuckDB::PendingResult class.

data/Dockerfile

@@ -1,7 +1,7 @@
 ARG RUBY_VERSION=3.2.2
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=0.9.1
+ARG DUCKDB_VERSION=0.9.2
 
 RUN apt update -qq && \
     apt install -y build-essential curl git wget

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.9.1.1)
+    duckdb (0.9.2)
 
 GEM
   remote: https://rubygems.org/
@@ -9,16 +9,16 @@ GEM
     benchmark-ips (2.12.0)
     mini_portile2 (2.8.5)
     minitest (5.20.0)
-    nokogiri (1.15.4)
+    nokogiri (1.15.5)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.15.4-x86_64-linux)
+    nokogiri (1.15.5-x86_64-linux)
       racc (~> 1.4)
-    racc (1.7.1)
+    racc (1.7.3)
     rake (13.1.0)
     rake-compiler (1.2.5)
       rake
-    ruby_memcheck (2.2.0)
+    ruby_memcheck (2.2.1)
       nokogiri
     stackprof (0.2.25)
 

data/README.md

@@ -104,10 +104,25 @@ con.query('SELECT * FROM users WHERE name = ? AND email = ?', 'Alice', 'alice@ex
 con.query('SELECT * FROM users WHERE name = $name AND email = $email', name: 'Alice', email: 'alice@example.com')
 ```
 
+### using async query
+
+You can use async query.
+
+```ruby
+DuckDB::Result.use_chunk_each = true # must be true.
+...
+
+pending_result = con.async_query_stream('SLOW QUERY')
+pending_result.execute_task while pending_result.state == :not_ready
+
+result = pending_result.execute_pending
+result.each.first
+```
+
+Here is [the benchmark](./benchmark/async_query.rb).
 
 ### using BLOB column
 
-BLOB is available with DuckDB v0.2.5 or later.
 Use `DuckDB::Blob.new` or use sting#force_encoding(Encoding::BINARY)
 
 ```ruby
@@ -119,6 +134,7 @@ DuckDB::Database.open do |db|
     stmt = DuckDB::PreparedStatement.new(con, 'INSERT INTO blob_table VALUES ($1)')
 
     stmt.bind(1, DuckDB::Blob.new("\0\1\2\3\4\5"))
+    #  or
     # stmt.bind(1, "\0\1\2\3\4\5".force_encoding(Encoding::BINARY))
     stmt.execute
 

data/benchmark/async_query.rb

@@ -0,0 +1,90 @@
+require 'bundler/setup'
+require 'duckdb'
+require 'benchmark/ips'
+
+
+DuckDB::Result.use_chunk_each = true
+DuckDB::Database.open do |db|
+  db.connect do |con|
+    con.query('SET threads=1')
+    con.query('CREATE TABLE tbl as SELECT range a, mod(range, 10) b FROM range(100000)')
+    con.query('CREATE TABLE tbl2 as SELECT range a, mod(range, 10) b FROM range(100000)')
+    query_sql = 'SELECT * FROM tbl where b = (SELECT min(b) FROM tbl2)'
+    print <<~END_OF_HEAD
+
+      Benchmark: Get first record ======================================
+    END_OF_HEAD
+
+    Benchmark.ips do |x|
+      x.report('async_query') do
+        pending_result = con.async_query(query_sql)
+
+        pending_result.execute_task while pending_result.state == :not_ready
+        result = pending_result.execute_pending
+        result.each.first
+      end
+      x.report('query') do
+        result = con.query(query_sql)
+        result.each.first
+      end
+      x.report('async_query_stream') do
+        pending_result = con.async_query_stream(query_sql)
+
+        pending_result.execute_task while pending_result.state == :not_ready
+        result = pending_result.execute_pending
+        result.each.first
+      end
+    end
+
+    print <<~END_OF_HEAD
+
+
+      Benchmark: Get all records ======================================
+    END_OF_HEAD
+
+    Benchmark.ips do |x|
+      x.report('async_query') do
+        pending_result = con.async_query(query_sql)
+
+        pending_result.execute_task while pending_result.state == :not_ready
+        result = pending_result.execute_pending
+        result.each.to_a
+      end
+      x.report('query') do
+        result = con.query(query_sql)
+        result.each.to_a
+      end
+      x.report('async_query_stream') do
+        pending_result = con.async_query_stream(query_sql)
+
+        pending_result.execute_task while pending_result.state == :not_ready
+        result = pending_result.execute_pending
+        result.each.to_a
+      end
+    end
+  end
+end
+
+__END__
+
+results:
+Benchmark: Get first record ======================================
+Warming up --------------------------------------
+         async_query    70.000  i/100ms
+               query    88.000  i/100ms
+  async_query_stream   188.000  i/100ms
+Calculating -------------------------------------
+         async_query    847.191  (± 4.6%) i/s -      4.270k in   5.051650s
+               query    850.509  (± 3.8%) i/s -      4.312k in   5.078167s
+  async_query_stream      1.757k (± 7.3%) i/s -      8.836k in   5.057142s
+
+
+Benchmark: Get all records ======================================
+Warming up --------------------------------------
+         async_query    40.000  i/100ms
+               query    40.000  i/100ms
+  async_query_stream    39.000  i/100ms
+Calculating -------------------------------------
+         async_query    402.567  (± 0.5%) i/s -      2.040k in   5.067639s
+               query    406.632  (± 0.7%) i/s -      2.040k in   5.017079s
+  async_query_stream    395.532  (± 0.8%) i/s -      1.989k in   5.028955s

data/ext/duckdb/appender.c

@@ -285,7 +285,7 @@ static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE da
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    dt = to_duckdb_date_from_value(year, month, day);
+    dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
     if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append date");
@@ -298,7 +298,7 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    to_duckdb_interval_from_value(&interval, months, days, micros);
+    rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append interval");
@@ -311,7 +311,7 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    time = to_duckdb_time_from_value(hour, min, sec, micros);
+    time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
     if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to append time");
@@ -326,7 +326,7 @@ static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VAL
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    timestamp = rbduckdb_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");
@@ -369,7 +369,7 @@ static VALUE appender_close(VALUE self) {
     return self;
 }
 
-void init_duckdb_appender(void) {
+void rbduckdb_init_duckdb_appender(void) {
     cDuckDBAppender = rb_define_class_under(mDuckDB, "Appender", rb_cObject);
     rb_define_alloc_func(cDuckDBAppender, allocate);
     rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);

data/ext/duckdb/appender.h

@@ -7,6 +7,6 @@ struct _rubyDuckDBAppender {
 
 typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
 
-void init_duckdb_appender(void);
+void rbduckdb_init_duckdb_appender(void);
 
 #endif

data/ext/duckdb/blob.c

@@ -2,6 +2,6 @@
 
 VALUE cDuckDBBlob;
 
-void init_duckdb_blob(void) {
+void rbduckdb_init_duckdb_blob(void) {
     cDuckDBBlob = rb_define_class_under(mDuckDB, "Blob", rb_cString);
 }

data/ext/duckdb/blob.h

@@ -1,10 +1,7 @@
 #ifndef RUBY_DUCKDB_BLOB_H
 #define RUBY_DUCKDB_BLOB_H
 
-/*
- * blob is supported by duckdb v0.2.5 or later
- */
-void init_duckdb_blob(void);
+void rbduckdb_init_duckdb_blob(void);
 
 #endif
 

data/ext/duckdb/column.c

@@ -68,7 +68,7 @@ VALUE duckdb_column_get_name(VALUE oDuckDBColumn) {
     return rb_utf8_str_new_cstr(duckdb_column_name(&(ctxresult->result), ctx->col));
 }
 
-VALUE create_column(VALUE oDuckDBResult, idx_t col) {
+VALUE rbduckdb_create_column(VALUE oDuckDBResult, idx_t col) {
     VALUE obj;
     rubyDuckDBColumn *ctx;
 
@@ -81,7 +81,7 @@ VALUE create_column(VALUE oDuckDBResult, idx_t col) {
     return obj;
 }
 
-void init_duckdb_column(void) {
+void rbduckdb_init_duckdb_column(void) {
     cDuckDBColumn = rb_define_class_under(mDuckDB, "Column", rb_cObject);
     rb_define_alloc_func(cDuckDBColumn, allocate);
 

data/ext/duckdb/column.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBColumn {
 
 typedef struct _rubyDuckDBColumn rubyDuckDBColumn;
 
-void init_duckdb_column(void);
-VALUE create_column(VALUE oDuckDBResult, idx_t col);
+void rbduckdb_init_duckdb_column(void);
+VALUE rbduckdb_create_column(VALUE oDuckDBResult, idx_t col);
 
 #endif

data/ext/duckdb/config.c

@@ -79,7 +79,7 @@ static VALUE config_set_config(VALUE self, VALUE key, VALUE value) {
     return self;
 }
 
-void init_duckdb_config(void) {
+void rbduckdb_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);

data/ext/duckdb/config.h

@@ -9,6 +9,6 @@ typedef struct _rubyDuckDBConfig rubyDuckDBConfig;
 
 rubyDuckDBConfig *get_struct_config(VALUE obj);
 
-void init_duckdb_config(void);
+void rbduckdb_init_duckdb_config(void);
 
 #endif

data/ext/duckdb/connection.c

@@ -6,6 +6,12 @@ static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE duckdb_connection_disconnect(VALUE self);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_connection_interrupt(VALUE self);
+static VALUE duckdb_connection_query_progress(VALUE self);
+#endif
+
 static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase);
 static VALUE duckdb_connection_query_sql(VALUE self, VALUE str);
 
@@ -37,12 +43,12 @@ rubyDuckDBConnection *get_struct_connection(VALUE obj) {
     return ctx;
 }
 
-VALUE create_connection(VALUE oDuckDBDatabase) {
+VALUE rbduckdb_create_connection(VALUE oDuckDBDatabase) {
     rubyDuckDB *ctxdb;
     rubyDuckDBConnection *ctxcon;
     VALUE obj;
 
-    ctxdb = get_struct_database(oDuckDBDatabase);
+    ctxdb = rbduckdb_get_struct_database(oDuckDBDatabase);
 
     obj = allocate(cDuckDBConnection);
     TypedData_Get_Struct(obj, rubyDuckDBConnection, &connection_data_type, ctxcon);
@@ -51,7 +57,6 @@ VALUE create_connection(VALUE oDuckDBDatabase) {
         rb_raise(eDuckDBError, "connection error");
     }
 
-    // rb_ivar_set(obj, rb_intern("database"), oDuckDBDatabase);
     return obj;
 }
 
@@ -64,6 +69,57 @@ static VALUE duckdb_connection_disconnect(VALUE self) {
     return self;
 }
 
+#ifdef HAVE_DUCKDB_H_GE_V090
+/*
+ * call-seq:
+ *   connection.interrupt -> nil
+ *
+ * Interrupts the currently running query.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  con.query('SET ENABLE_PROGRESS_BAR=true')
+ *  con.query('SET ENABLE_PROGRESS_BAR_PRINT=false')
+ *  pending_result = con.async_query('slow query')
+ *
+ *  pending_result.execute_task
+ *  con.interrupt # => nil
+ */
+static VALUE duckdb_connection_interrupt(VALUE self) {
+    rubyDuckDBConnection *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
+    duckdb_interrupt(ctx->con);
+
+    return Qnil;
+}
+
+/*
+ * Returns the progress of the currently running query.
+ *
+ *  require 'duckdb'
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  con.query('SET ENABLE_PROGRESS_BAR=true')
+ *  con.query('SET ENABLE_PROGRESS_BAR_PRINT=false')
+ *  con.query_progress # => -1.0
+ *  pending_result = con.async_query('slow query')
+ *  con.query_progress # => 0.0
+ *  pending_result.execute_task
+ *  con.query_progress # => Float
+ */
+static VALUE duckdb_connection_query_progress(VALUE self) {
+    rubyDuckDBConnection *ctx;
+    double progress;
+
+    TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
+    progress = duckdb_query_progress(ctx->con);
+
+    return DBL2NUM(progress);
+}
+#endif
+
 static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     rubyDuckDBConnection *ctx;
     rubyDuckDB *ctxdb;
@@ -71,7 +127,7 @@ static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     if (!rb_obj_is_kind_of(oDuckDBDatabase, cDuckDBDatabase)) {
         rb_raise(rb_eTypeError, "The first argument must be DuckDB::Database object.");
     }
-    ctxdb = get_struct_database(oDuckDBDatabase);
+    ctxdb = rbduckdb_get_struct_database(oDuckDBDatabase);
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
 
     if (duckdb_connect(ctxdb->db, &(ctx->con)) == DuckDBError) {
@@ -85,7 +141,7 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     rubyDuckDBConnection *ctx;
     rubyDuckDBResult *ctxr;
 
-    VALUE result = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -100,11 +156,15 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     return result;
 }
 
-void init_duckdb_connection(void) {
+void rbduckdb_init_duckdb_connection(void) {
     cDuckDBConnection = rb_define_class_under(mDuckDB, "Connection", rb_cObject);
     rb_define_alloc_func(cDuckDBConnection, allocate);
 
     rb_define_method(cDuckDBConnection, "disconnect", duckdb_connection_disconnect, 0);
+#ifdef HAVE_DUCKDB_H_GE_V090
+    rb_define_method(cDuckDBConnection, "interrupt", duckdb_connection_interrupt, 0);
+    rb_define_method(cDuckDBConnection, "query_progress", duckdb_connection_query_progress, 0);
+#endif
     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

@@ -8,7 +8,7 @@ struct _rubyDuckDBConnection {
 typedef struct _rubyDuckDBConnection rubyDuckDBConnection;
 
 rubyDuckDBConnection *get_struct_connection(VALUE obj);
-void init_duckdb_connection(void);
-VALUE create_connection(VALUE oDuckDBDatabase);
+void rbduckdb_init_duckdb_connection(void);
+VALUE rbduckdb_create_connection(VALUE oDuckDBDatabase);
 
 #endif

data/ext/duckdb/converter.h

@@ -1,6 +1,6 @@
 #ifndef RUBY_DUCKDB_CONVERTER_H
 #define RUBY_DUCKDB_CONVERTER_H
 
-void init_duckdb_converter(void);
+void rbduckdb_init_duckdb_converter(void);
 
 #endif

data/ext/duckdb/conveter.c

@@ -2,6 +2,6 @@
 
 VALUE mDuckDBConverter;
 
-void init_duckdb_converter(void) {
+void rbduckdb_init_duckdb_converter(void) {
     mDuckDBConverter = rb_define_module_under(mDuckDB, "Converter");
 }

data/ext/duckdb/database.c

@@ -37,7 +37,7 @@ static VALUE allocate(VALUE klass) {
     return TypedData_Wrap_Struct(klass, &database_data_type, ctx);
 }
 
-rubyDuckDB *get_struct_database(VALUE obj) {
+rubyDuckDB *rbduckdb_get_struct_database(VALUE obj) {
     rubyDuckDB *ctx;
     TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
     return ctx;
@@ -99,7 +99,7 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
 }
 
 static VALUE duckdb_database_connect(VALUE self) {
-    return create_connection(self);
+    return rbduckdb_create_connection(self);
 }
 
 /*
@@ -115,7 +115,7 @@ static VALUE duckdb_database_close(VALUE self) {
     return self;
 }
 
-void init_duckdb_database(void) {
+void rbduckdb_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);

data/ext/duckdb/database.h

@@ -7,7 +7,7 @@ struct _rubyDuckDB {
 
 typedef struct _rubyDuckDB rubyDuckDB;
 
-rubyDuckDB *get_struct_database(VALUE obj);
-void init_duckdb_database(void);
+rubyDuckDB *rbduckdb_get_struct_database(VALUE obj);
+void rbduckdb_init_duckdb_database(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -22,15 +22,15 @@ Init_duckdb_native(void) {
 
     rb_define_singleton_method(mDuckDB, "library_version", duckdb_s_library_version, 0);
 
-    init_duckdb_error();
-    init_duckdb_database();
-    init_duckdb_connection();
-    init_duckdb_result();
-    init_duckdb_column();
-    init_duckdb_prepared_statement();
-    init_duckdb_pending_result();
-    init_duckdb_blob();
-    init_duckdb_appender();
-    init_duckdb_config();
-    init_duckdb_converter();
+    rbduckdb_init_duckdb_error();
+    rbduckdb_init_duckdb_database();
+    rbduckdb_init_duckdb_connection();
+    rbduckdb_init_duckdb_result();
+    rbduckdb_init_duckdb_column();
+    rbduckdb_init_duckdb_prepared_statement();
+    rbduckdb_init_duckdb_pending_result();
+    rbduckdb_init_duckdb_blob();
+    rbduckdb_init_duckdb_appender();
+    rbduckdb_init_duckdb_config();
+    rbduckdb_init_duckdb_converter();
 }

data/ext/duckdb/error.c

@@ -2,6 +2,6 @@
 
 VALUE eDuckDBError;
 
-void init_duckdb_error(void) {
+void rbduckdb_init_duckdb_error(void) {
     eDuckDBError = rb_define_class_under(mDuckDB, "Error", rb_eStandardError);
 }

data/ext/duckdb/error.h

@@ -1,7 +1,7 @@
 #ifndef RUBY_DUCKDB_ERROR_H
 #define RUBY_DUCKDB_ERROR_H
 
-void init_duckdb_error(void);
+void rbduckdb_init_duckdb_error(void);
 
 #endif