duckdb 0.9.1.1 → 0.9.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f3ac463fffc2fc6362c34abbfa5b862a7b8c993052ede087ca4403542c98dc8
-  data.tar.gz: c5ea1236f240a62165b7e371ae48033447868d119261def6c5310d3911e9df91
+  metadata.gz: b492788be53be66a956ad49e4cd8a82ffa6273c12f037b2c0abd51253321802f
+  data.tar.gz: 50571029b1d1160a7abb6ac223bd4cda4f3791b29d26cdebac6b795f160a2a14
 SHA512:
-  metadata.gz: 210fe783740da4b6eb7991de416a7b5581403d8ad3661625110e275c030fe9dc1192d6fe2d73dcb778e53408b0e349eb28f37f2a1308d31ff30b0b783be5e498
-  data.tar.gz: b6fcc8d47c20ff9ce053122d9d9c03f4b19f1a72d9cd56addc1704d862ab7cfda4b3bec88bb3d8580befa006dcfeeee76138e00a2a34f065cca630bde523fb7d
+  metadata.gz: d80355e181599217574191f3acba24d6dbcb37e4a73b774689590f42fc9b92032d4a4285962ee65100d3a3186825b29f09066d9fd0f8f24ce46aaec85cba4701
+  data.tar.gz: b126f7e0057c77cae338f7c6b76d4b775c52b06f84936ebd6208a3357148ababa8c8c3aaca727dacf4b7ed05b5f5da2bedc74d8b1d46f170ddc418d4c9e125fa

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.9.1.1)
+    duckdb (0.9.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -14,7 +14,7 @@ GEM
       racc (~> 1.4)
     nokogiri (1.15.4-x86_64-linux)
       racc (~> 1.4)
-    racc (1.7.1)
+    racc (1.7.3)
     rake (13.1.0)
     rake-compiler (1.2.5)
       rake

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
 

data/ext/duckdb/pending_result.c

@@ -48,6 +48,17 @@ static VALUE duckdb_pending_result_initialize(VALUE self, VALUE oDuckDBPreparedS
     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);
@@ -61,10 +72,22 @@ static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
 }
 #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 = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBPendingResult, &pending_result_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -85,7 +108,7 @@ rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
     return ctx;
 }
 
-void init_duckdb_pending_result(void) {
+void rbduckdb_init_duckdb_pending_result(void) {
     cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
     rb_define_alloc_func(cDuckDBPendingResult, allocate);
 

data/ext/duckdb/pending_result.h

@@ -9,5 +9,5 @@ struct _rubyDuckDBPendingResult {
 typedef struct _rubyDuckDBPendingResult rubyDuckDBPendingResult;
 
 rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj);
-void init_duckdb_pending_result(void);
+void rbduckdb_init_duckdb_pending_result(void);
 #endif

data/ext/duckdb/prepared_statement.c

@@ -83,7 +83,7 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
 static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
-    VALUE result = create_result();
+    VALUE result = rbduckdb_create_result();
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -268,7 +268,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     duckdb_date dt;
     idx_t idx = check_index(vidx);
 
-    dt = to_duckdb_date_from_value(year, month, day);
+    dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -285,7 +285,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 
     idx_t idx = check_index(vidx);
 
-    time = to_duckdb_time_from_value(hour, min, sec, micros);
+    time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
@@ -301,7 +301,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    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);
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
     if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
@@ -317,7 +317,7 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    to_duckdb_interval_from_value(&interval, months, days, micros);
+    rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
     if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
@@ -347,7 +347,7 @@ rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
     return ctx;
 }
 
-void init_duckdb_prepared_statement(void) {
+void rbduckdb_init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);

data/ext/duckdb/prepared_statement.h

@@ -9,6 +9,6 @@ struct _rubyDuckDBPreparedStatement {
 typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
 
 rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
-void init_duckdb_prepared_statement(void);
+void rbduckdb_init_duckdb_prepared_statement(void);
 
 #endif

data/ext/duckdb/result.c

@@ -229,7 +229,7 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
 
     VALUE ary = rb_ary_new2(column_count);
     for(col_idx = 0; col_idx < column_count; col_idx++) {
-        VALUE column = create_column(oDuckDBResult, col_idx);
+        VALUE column = rbduckdb_create_column(oDuckDBResult, col_idx);
         rb_ary_store(ary, col_idx, column);
     }
     return ary;
@@ -397,7 +397,7 @@ static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col
     return value;
 }
 
-VALUE create_result(void) {
+VALUE rbduckdb_create_result(void) {
     return allocate(cDuckDBResult);
 }
 
@@ -717,7 +717,7 @@ static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
     return Qnil;
 }
 
-void init_duckdb_result(void) {
+void rbduckdb_init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 

data/ext/duckdb/result.h

@@ -8,8 +8,8 @@ struct _rubyDuckDBResult {
 typedef struct _rubyDuckDBResult rubyDuckDBResult;
 
 rubyDuckDBResult *get_struct_result(VALUE obj);
-void init_duckdb_result(void);
-VALUE create_result(void);
+void rbduckdb_init_duckdb_result(void);
+VALUE rbduckdb_create_result(void);
 
 #endif
 

data/ext/duckdb/util.c

@@ -1,6 +1,6 @@
 #include "ruby-duckdb.h"
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     duckdb_date_struct dt_struct;
 
     dt_struct.year = NUM2INT(year);
@@ -10,7 +10,7 @@ duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day) {
     return duckdb_to_date(dt_struct);
 }
 
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_time_struct time_st;
 
     time_st.hour = NUM2INT(hour);
@@ -21,7 +21,7 @@ duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE mi
     return duckdb_to_time(time_st);
 }
 
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp_struct timestamp_st;
 
     timestamp_st.date.year = NUM2INT(year);
@@ -35,7 +35,7 @@ duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE d
     return duckdb_to_timestamp(timestamp_st);
 }
 
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros) {
     interval->months = NUM2INT(months);
     interval->days = NUM2INT(days);
     interval->micros = NUM2LL(micros);

data/ext/duckdb/util.h

@@ -1,9 +1,9 @@
 #ifndef RUBY_DUCKDB_UTIL_H
 #define RUBY_DUCKDB_UTIL_H
 
-duckdb_date to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
-duckdb_time to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
-duckdb_timestamp to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
-void to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
+duckdb_date rbduckdb_to_duckdb_date_from_value(VALUE year, VALUE month, VALUE day);
+duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec, VALUE micros);
+duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_value(VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+void rbduckdb_to_duckdb_interval_from_value(duckdb_interval* interval, VALUE months, VALUE days, VALUE micros);
 
 #endif

data/lib/duckdb/appender.rb

@@ -86,16 +86,7 @@ module DuckDB
     #   appender.flush
     #
     def append_time(value)
-      time = case value
-             when Time
-               value
-             else
-               begin
-                 Time.parse(value)
-               rescue
-                 raise(ArgumentError, "Cannot parse argument `#{value}` to Time.")
-               end
-             end
+      time = _parse_time(value)
 
       _append_time(time.hour, time.min, time.sec, time.usec)
     end

data/lib/duckdb/connection.rb

@@ -25,19 +25,38 @@ module DuckDB
     #   sql = 'SELECT * FROM users WHERE name = $name AND email = $email'
     #   dave = con.query(sql, name: 'Dave', email: 'dave@example.com')
     #
-    def query(sql, *args, **hash)
-      return query_sql(sql) if args.empty? && hash.empty?
+    def query(sql, *args, **kwargs)
+      return query_sql(sql) if args.empty? && kwargs.empty?
 
       stmt = PreparedStatement.new(self, sql)
-      args.each.with_index(1) do |arg, i|
-        stmt.bind(i, arg)
-      end
-      hash.each do |key, value|
-        stmt.bind(key, value)
-      end
+      stmt.bind_args(*args, **kwargs)
       stmt.execute
     end
 
+    #
+    # executes sql with args asynchronously.
+    # The first argument sql must be SQL string.
+    # The rest arguments are parameters of SQL string.
+    # This method returns DuckDB::PendingResult object.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_file')
+    #   con = db.connect
+    #   pending_result = con.async_query('SELECT * FROM users')
+    #   sql = 'SELECT * FROM users WHERE name = ? AND email = ?'
+    #   pending_result = con.async_query(sql, 'Dave', 'dave@example.com')
+    #
+    #   # or You can use named parameter.
+    #
+    #   sql = 'SELECT * FROM users WHERE name = $name AND email = $email'
+    #   pending_result = con.async_query(sql, name: 'Dave', email: 'dave@example.com')
+    #
+    def async_query(sql, *args, **kwargs)
+      stmt = PreparedStatement.new(self, sql)
+      stmt.bind_args(*args, **kwargs)
+      stmt.pending_prepared
+    end
+
     #
     # connects DuckDB database
     # The first argument is DuckDB::Database object
@@ -83,6 +102,7 @@ module DuckDB
     end
 
     alias execute query
+    alias async_execute async_query
     alias open connect
     alias close disconnect
   end

data/lib/duckdb/converter.rb

@@ -42,6 +42,32 @@ module DuckDB
       "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20, 12]}"
     end
 
+    def _parse_date(value)
+      case value
+      when Date, Time
+        value
+      else
+        begin
+          Date.parse(value)
+        rescue StandardError => e
+          raise(ArgumentError, "Cannot parse `#{value.inspect}` to Date object. #{e.message}")
+        end
+      end
+    end
+
+    def _parse_time(value)
+      case value
+      when Time
+        value
+      else
+        begin
+          Time.parse(value)
+        rescue StandardError => e
+          raise(ArgumentError, "Cannot parse `#{value.inspect}` to Time object. #{e.message}")
+        end
+      end
+    end
+
     private
 
     def integer_to_hugeint(value)
@@ -51,7 +77,7 @@ module DuckDB
         lower = value - (upper << HALF_HUGEINT_BIT)
         [lower, upper]
       else
-        raise(ArgumentError, "The argument `#{value}` must be Integer.")
+        raise(ArgumentError, "The argument `#{value.inspect}` must be Integer.")
       end
     end
   end

data/lib/duckdb/prepared_statement.rb

@@ -24,21 +24,43 @@ module DuckDB
       PendingResult.new(self)
     end
 
+    # binds all parameters with SQL prepared statement.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE id = ?'
+    #   # or
+    #   # sql ='SELECT name FROM users WHERE id = $id'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind_args([1])
+    #   # or
+    #   # stmt.bind_args(id: 1)
+    def bind_args(*args, **kwargs)
+      args.each.with_index(1) do |arg, i|
+        bind(i, arg)
+      end
+      kwargs.each do |key, value|
+        bind(key, value)
+      end
+    end
+
     # 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 to expected Integer value.
     # This method uses bind_varchar internally.
+    #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_database')
     #   con = db.connect
     #   sql ='SELECT name FROM users WHERE bigint_col = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind_hugeint(1, 1_234_567_890_123_456_789_012_345)
-    def bind_hugeint(i, value)
+    def bind_hugeint(index, value)
       case value
       when Integer
-        bind_varchar(i, value.to_s)
+        bind_varchar(index, value.to_s)
       else
         raise(ArgumentError, "2nd argument `#{value}` must be Integer.")
       end
@@ -49,6 +71,7 @@ module DuckDB
     # The index of first parameter is 1 not 0.
     # The second argument value must be Integer value.
     # This method uses duckdb_bind_hugeint internally.
+    #
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_database')
     #   con = db.connect
@@ -73,19 +96,10 @@ module DuckDB
     #   stmt.bind(1, Date.today)
     #   #  or you can specify date string.
     #   # stmt.bind(1, '2021-02-23')
-    def bind_date(i, value)
-      case value
-      when Date, Time
-        date = value
-      else
-        begin
-          date = Date.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to date. #{e.message}")
-        end
-      end
+    def bind_date(index, value)
+      date = _parse_date(value)
 
-      _bind_date(i, date.year, date.month, date.day)
+      _bind_date(index, date.year, date.month, date.day)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -101,19 +115,10 @@ module DuckDB
     #   stmt.bind(1, Time.now)
     #   #  or you can specify time string.
     #   # stmt.bind(1, '07:39:45')
-    def bind_time(i, value)
-      case value
-      when Time
-        time = value
-      else
-        begin
-          time = Time.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
-        end
-      end
+    def bind_time(index, value)
+      time = _parse_time(value)
 
-      _bind_time(i, time.hour, time.min, time.sec, time.usec)
+      _bind_time(index, time.hour, time.min, time.sec, time.usec)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -129,19 +134,10 @@ module DuckDB
     #   stmt.bind(1, Time.now)
     #   #  or you can specify timestamp string.
     #   # stmt.bind(1, '2022-02-23 07:39:45')
-    def bind_timestamp(i, value)
-      case value
-      when Time
-        time = value
-      else
-        begin
-          time = Time.parse(value)
-        rescue => e
-          raise(ArgumentError, "Cannot parse argument value to time. #{e.message}")
-        end
-      end
+    def bind_timestamp(index, value)
+      time = _parse_time(value)
 
-      _bind_timestamp(i, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
+      _bind_timestamp(index, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
     end
 
     # binds i-th parameter with SQL prepared statement.
@@ -155,9 +151,9 @@ module DuckDB
     #   sql ='SELECT value FROM intervals WHERE interval = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind(1, 'P1Y2D')
-    def bind_interval(i, value)
+    def bind_interval(index, value)
       value = Interval.to_interval(value)
-      _bind_interval(i, value.interval_months, value.interval_days, value.interval_micros)
+      _bind_interval(index, value.interval_months, value.interval_days, value.interval_micros)
     end
 
     # binds i-th parameter with SQL prepared statement.

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '0.9.1.1'
+  VERSION = '0.9.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.9.1.1
+  version: 0.9.1.2
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-28 00:00:00.000000000 Z
+date: 2023-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler