duckdb 0.9.1 → 0.9.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2948812978266d6ca2040d2071479f0484fe39719be860282e238b1e786a53e7
-  data.tar.gz: 3a3d10a5dd8e318b7a6274e6e32f0fc4850eeafada95673b42ed6c6121a36af5
+  metadata.gz: b492788be53be66a956ad49e4cd8a82ffa6273c12f037b2c0abd51253321802f
+  data.tar.gz: 50571029b1d1160a7abb6ac223bd4cda4f3791b29d26cdebac6b795f160a2a14
 SHA512:
-  metadata.gz: f4bf27bf6c3e378650584e9226bd0c2e16a76a2d5e68c96451f5abafb4dfe6fbb4df705ceb754ac8df30ed36bc6fe67299f61861fa882ef11acac79dea1e80cf
-  data.tar.gz: 71f42787f8368ab322c5d8c9a9a74227117dbf0454601d9ac3ec407188497c34e437fd5de14bec2038d6f3df3233098b580a8e116f8590dedd8004b7ba934f5a
+  metadata.gz: d80355e181599217574191f3acba24d6dbcb37e4a73b774689590f42fc9b92032d4a4285962ee65100d3a3186825b29f09066d9fd0f8f24ce46aaec85cba4701
+  data.tar.gz: b126f7e0057c77cae338f7c6b76d4b775c52b06f84936ebd6208a3357148ababa8c8c3aaca727dacf4b7ed05b5f5da2bedc74d8b1d46f170ddc418d4c9e125fa

data/.github/workflows/test_on_macos.yml

@@ -3,7 +3,7 @@ name: MacOS
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/.github/workflows/test_on_ubuntu.yml

@@ -3,7 +3,7 @@ name: Ubuntu
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/.github/workflows/test_on_windows.yml

@@ -3,7 +3,7 @@ name: Windows
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     types:
       - opened

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # ChangeLog
 
+# 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.
+- add DuckDB::PendingResult#state.
+- add DuckDB::PendingResult#execute_task.
+- add DuckDB::PendingResult#execute_pending.
+- add DuckDB::PreparedStatement#pending_prepared.
+
+## Breaking Changes
+- drop duckdb v0.7.x.
+
 # 0.9.1
 - add `DuckDB::PreparedStatement#parameter_name`.
 - bump duckdb to 0.9.1.
@@ -11,7 +26,7 @@
 # 0.9.0
 - bump duckdb to 0.9.0.
 
-## Breaking Change
+## Breaking Changes
 - deprecation warning when DuckDB::Result.each calling with `DuckDB::Result.use_chunk_each` is false.
   The `each` behavior will be same as `DuckDB::Result.chunk_each` in the future.
   set `DuckDB::Result.use_chunk_each = true` to suppress the warning.
@@ -54,7 +69,7 @@
 - support enum type in DuckDB::Result#chunk_each.
 - support uuid type in DuckDB::Result#chunk_each.
 
-## Breaking Change
+## Breaking Changes
 
 - DuckDB::Config.set_config does not raise exception when invalid key specified.
   Instead, DuckDB::Database.open raises DuckDB::Error with invalid key configuration.
@@ -64,7 +79,7 @@
 - add DuckDB::Result#_to_decimal_internal
 - add DuckDB::Result#_to_hugeint_internal
 
-## Breaking Change
+## Breaking Changes
 - DuckDB::Result returns BigDecimal object instead of String object if the column type is DECIMAL.
 
 # 0.7.1
@@ -81,7 +96,7 @@
 - add DuckDB::Result#__to_decimal_internal
 - add Ruby 3.2.1 on CI test
 - add Ruby mswin on CI test
-## Breaking Change
+## Breaking Changes
 - drop Ruby 2.6
 
 # 0.6.1
@@ -95,7 +110,7 @@
 - bump Ruby to 3.2.0rc1
 - bump duckdb to 0.6.0
 
-## Breaking Change
+## Breaking Changes
 - drop duckdb <= 0.4.x. ruby-duckdb supports duckdb >= 0.5.0
 
 # 0.5.1.1
@@ -114,7 +129,7 @@
 - add DuckDB::Result#row_count, DuckDB::Result#row_size(alias of row_count).
 - add DuckDB::Result#column_count, DuckDB::Result#column_size(alias of column_count).
 
-## Breaking Change
+## Breaking Changes
 - bind_varchar does not raised DuckDB::Error when the binding column is date or datetime.
 
 # 0.3.4.0

data/Gemfile.lock

@@ -1,21 +1,21 @@
 PATH
   remote: .
   specs:
-    duckdb (0.9.1)
+    duckdb (0.9.1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.12.0)
-    mini_portile2 (2.8.4)
+    mini_portile2 (2.8.5)
     minitest (5.20.0)
     nokogiri (1.15.4)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     nokogiri (1.15.4-x86_64-linux)
       racc (~> 1.4)
-    racc (1.7.1)
-    rake (13.0.6)
+    racc (1.7.3)
+    rake (13.1.0)
     rake-compiler (1.2.5)
       rake
     ruby_memcheck (2.2.0)

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,14 +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_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
 

data/ext/duckdb/extconf.rb

@@ -20,13 +20,8 @@ end
 
 dir_config('duckdb')
 
-check_duckdb_library('duckdb_extract_statements', '0.7.0')
-
-# check duckdb >= 0.7.0
-have_func('duckdb_extract_statements', 'duckdb.h')
-
 # check duckdb >= 0.8.0
-have_func('duckdb_string_is_inlined', 'duckdb.h')
+check_duckdb_library('duckdb_string_is_inlined', '0.8.0')
 
 # check duckdb >= 0.9.0
 have_func('duckdb_bind_parameter_index', 'duckdb.h')

data/ext/duckdb/pending_result.c

@@ -0,0 +1,123 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBPendingResult;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement);
+static VALUE duckdb_pending_result_execute_task(VALUE self);
+static VALUE duckdb_pending_result_execute_pending(VALUE self);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_pending_result_execution_finished_p(VALUE self);
+#endif
+
+static VALUE duckdb_pending_result__state(VALUE self);
+
+static const rb_data_type_t pending_result_data_type = {
+    "DuckDB/PendingResult",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBPendingResult *p = (rubyDuckDBPendingResult *)ctx;
+
+    duckdb_destroy_pending(&(p->pending_result));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBPendingResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPendingResult));
+    ctx->state = DUCKDB_PENDING_RESULT_NOT_READY;
+    return TypedData_Wrap_Struct(klass, &pending_result_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBPendingResult);
+}
+
+static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedStatement) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
+
+    if (duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result)) == DuckDBError) {
+        rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
+    }
+    return self;
+}
+
+/*
+ * call-seq:
+ *   pending_result.execute_task -> nil
+ *
+ * Executes the task in the pending result.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  pending_result = conn.async_query("slow query")
+ *  pending_result.execute_task
+ */
+static VALUE duckdb_pending_result_execute_task(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    ctx->state = duckdb_pending_execute_task(ctx->pending_result);
+    return Qnil;
+}
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    return duckdb_pending_execution_is_finished(ctx->state) ? Qtrue : Qfalse;
+}
+#endif
+
+/*
+ * call-seq:
+ *   pending_result.execute_pending -> DuckDB::Result
+ *
+ * Get DuckDB::Result object after query execution finished.
+ *
+ *  db = DuckDB::Database.open
+ *  conn = db.connect
+ *  pending_result = conn.async_query("slow query")
+ *  pending_result.execute_task while pending_result.state != :ready
+ *  result = pending_result.execute_pending # => DuckDB::Result
+ */
+static VALUE duckdb_pending_result_execute_pending(VALUE self) {
+    rubyDuckDBPendingResult *ctx;
+    rubyDuckDBResult *ctxr;
+    VALUE result = rbduckdb_create_result();
+
+    TypedData_Get_Struct(self, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
+    ctxr = get_struct_result(result);
+    if (duckdb_execute_pending(ctx->pending_result, &(ctxr->result)) == DuckDBError) {
+        rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
+    }
+    return result;
+}
+
+static VALUE duckdb_pending_result__state(VALUE self) {
+    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+    return INT2FIX(ctx->state);
+}
+
+rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
+    rubyDuckDBPendingResult *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
+    return ctx;
+}
+
+void rbduckdb_init_duckdb_pending_result(void) {
+    cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
+    rb_define_alloc_func(cDuckDBPendingResult, allocate);
+
+    rb_define_method(cDuckDBPendingResult, "initialize", duckdb_pending_result_initialize, 1);
+    rb_define_method(cDuckDBPendingResult, "execute_task", duckdb_pending_result_execute_task, 0);
+    rb_define_method(cDuckDBPendingResult, "execute_pending", duckdb_pending_result_execute_pending, 0);
+
+#ifdef HAVE_DUCKDB_H_GE_V090
+    rb_define_method(cDuckDBPendingResult, "execution_finished?", duckdb_pending_result_execution_finished_p, 0);
+#endif
+    rb_define_private_method(cDuckDBPendingResult, "_state", duckdb_pending_result__state, 0);
+}

data/ext/duckdb/pending_result.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_PENDING_RESULT_H
+#define RUBY_DUCKDB_PENDING_RESULT_H
+
+struct _rubyDuckDBPendingResult {
+    duckdb_pending_result pending_result;
+    duckdb_pending_state state;
+};
+
+typedef struct _rubyDuckDBPendingResult rubyDuckDBPendingResult;
+
+rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj);
+void rbduckdb_init_duckdb_pending_result(void);
+#endif