duckdb 1.5.2.0 → 1.5.2.1

data/ext/duckdb/memory_helper.c

@@ -14,7 +14,7 @@ static VALUE mDuckDBMemoryHelper;
  *   DuckDB::MemoryHelper.write_bigint(ptr, 0, 42)  # Write 42 at index 0
  *   DuckDB::MemoryHelper.write_bigint(ptr, 1, 84)  # Write 84 at index 1
  */
-static VALUE rbduckdb_memory_helper_write_bigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_bigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     int64_t *data;
     idx_t idx;
     int64_t val;
@@ -41,7 +41,7 @@ static VALUE rbduckdb_memory_helper_write_bigint(VALUE self, VALUE ptr, VALUE in
  *   ptr = vector.get_data
  *   DuckDB::MemoryHelper.write_double(ptr, 0, 3.14)
  */
-static VALUE rbduckdb_memory_helper_write_double(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_double(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     double *data;
     idx_t idx;
     double val;
@@ -66,7 +66,7 @@ static VALUE rbduckdb_memory_helper_write_double(VALUE self, VALUE ptr, VALUE in
  *   ptr = vector.get_data
  *   DuckDB::MemoryHelper.write_integer(ptr, 0, 42)
  */
-static VALUE rbduckdb_memory_helper_write_integer(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_integer(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     int32_t *data;
     idx_t idx;
     int32_t val;
@@ -88,7 +88,7 @@ static VALUE rbduckdb_memory_helper_write_integer(VALUE self, VALUE ptr, VALUE i
  *
  * Writes a boolean to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_boolean(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_boolean(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     bool *data;
     idx_t idx;
 
@@ -107,7 +107,7 @@ static VALUE rbduckdb_memory_helper_write_boolean(VALUE self, VALUE ptr, VALUE i
  *
  * Writes an 8-bit signed integer (TINYINT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_tinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_tinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     int8_t *data;
     idx_t idx;
 
@@ -126,7 +126,7 @@ static VALUE rbduckdb_memory_helper_write_tinyint(VALUE self, VALUE ptr, VALUE i
  *
  * Writes a 16-bit signed integer (SMALLINT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_smallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_smallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     int16_t *data;
     idx_t idx;
 
@@ -145,7 +145,7 @@ static VALUE rbduckdb_memory_helper_write_smallint(VALUE self, VALUE ptr, VALUE
  *
  * Writes an 8-bit unsigned integer (UTINYINT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_utinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_utinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     uint8_t *data;
     idx_t idx;
 
@@ -164,7 +164,7 @@ static VALUE rbduckdb_memory_helper_write_utinyint(VALUE self, VALUE ptr, VALUE
  *
  * Writes a 16-bit unsigned integer (USMALLINT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_usmallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_usmallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     uint16_t *data;
     idx_t idx;
 
@@ -183,7 +183,7 @@ static VALUE rbduckdb_memory_helper_write_usmallint(VALUE self, VALUE ptr, VALUE
  *
  * Writes a 32-bit unsigned integer (UINTEGER) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_uinteger(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_uinteger(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     uint32_t *data;
     idx_t idx;
 
@@ -202,7 +202,7 @@ static VALUE rbduckdb_memory_helper_write_uinteger(VALUE self, VALUE ptr, VALUE
  *
  * Writes a 64-bit unsigned integer (UBIGINT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_ubigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_ubigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     uint64_t *data;
     idx_t idx;
 
@@ -221,7 +221,7 @@ static VALUE rbduckdb_memory_helper_write_ubigint(VALUE self, VALUE ptr, VALUE i
  *
  * Writes a 32-bit floating point number (FLOAT) to raw memory.
  */
-static VALUE rbduckdb_memory_helper_write_float(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_float(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     float *data;
     idx_t idx;
 
@@ -244,7 +244,7 @@ static VALUE rbduckdb_memory_helper_write_float(VALUE self, VALUE ptr, VALUE ind
  *   ptr = vector.get_data
  *   DuckDB::MemoryHelper.write_timestamp(ptr, 0, Time.new(2024, 3, 15, 10, 30, 45))
  */
-static VALUE rbduckdb_memory_helper_write_timestamp(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_timestamp(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     duckdb_timestamp *data;
     idx_t idx;
 
@@ -273,7 +273,7 @@ static VALUE rbduckdb_memory_helper_write_timestamp(VALUE self, VALUE ptr, VALUE
  *   ptr = vector.get_data
  *   DuckDB::MemoryHelper.write_timestamp_tz(ptr, 0, Time.new(2024, 3, 15, 10, 30, 45, '+00:00'))
  */
-static VALUE rbduckdb_memory_helper_write_timestamp_tz(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_timestamp_tz(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     duckdb_time_tz *data;
     idx_t idx;
     int64_t secs;
@@ -295,7 +295,7 @@ static VALUE rbduckdb_memory_helper_write_timestamp_tz(VALUE self, VALUE ptr, VA
     return Qnil;
 }
 
-static VALUE rbduckdb_memory_helper_write_date(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+static VALUE memory_helper_s_write_date(VALUE self, VALUE ptr, VALUE index, VALUE value) {
     duckdb_date *data;
     idx_t idx;
 
@@ -314,18 +314,18 @@ static VALUE rbduckdb_memory_helper_write_date(VALUE self, VALUE ptr, VALUE inde
 void rbduckdb_init_memory_helper(void) {
     mDuckDBMemoryHelper = rb_define_module_under(mDuckDB, "MemoryHelper");
 
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_bigint", rbduckdb_memory_helper_write_bigint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_double", rbduckdb_memory_helper_write_double, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_integer", rbduckdb_memory_helper_write_integer, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_boolean", rbduckdb_memory_helper_write_boolean, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_tinyint", rbduckdb_memory_helper_write_tinyint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_smallint", rbduckdb_memory_helper_write_smallint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_utinyint", rbduckdb_memory_helper_write_utinyint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_usmallint", rbduckdb_memory_helper_write_usmallint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_uinteger", rbduckdb_memory_helper_write_uinteger, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_ubigint", rbduckdb_memory_helper_write_ubigint, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_float", rbduckdb_memory_helper_write_float, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp", rbduckdb_memory_helper_write_timestamp, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp_tz", rbduckdb_memory_helper_write_timestamp_tz, 3);
-    rb_define_singleton_method(mDuckDBMemoryHelper, "write_date", rbduckdb_memory_helper_write_date, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_bigint", memory_helper_s_write_bigint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_double", memory_helper_s_write_double, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_integer", memory_helper_s_write_integer, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_boolean", memory_helper_s_write_boolean, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_tinyint", memory_helper_s_write_tinyint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_smallint", memory_helper_s_write_smallint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_utinyint", memory_helper_s_write_utinyint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_usmallint", memory_helper_s_write_usmallint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_uinteger", memory_helper_s_write_uinteger, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_ubigint", memory_helper_s_write_ubigint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_float", memory_helper_s_write_float, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp", memory_helper_s_write_timestamp, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp_tz", memory_helper_s_write_timestamp_tz, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_date", memory_helper_s_write_date, 3);
 }

data/ext/duckdb/pending_result.c

@@ -5,12 +5,12 @@ 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(int argc, VALUE *args, VALUE self);
-static VALUE duckdb_pending_result_execute_task(VALUE self);
-static VALUE duckdb_pending_result_execute_pending(VALUE self);
-static VALUE duckdb_pending_result_execution_finished_p(VALUE self);
-static VALUE duckdb_pending_result__state(VALUE self);
-static VALUE duckdb_pending_result__execute_check_state(VALUE self);
+static VALUE pending_result_initialize(int argc, VALUE *args, VALUE self);
+static VALUE pending_result_execute_task(VALUE self);
+static VALUE pending_result_execute_pending(VALUE self);
+static VALUE pending_result_execution_finished_p(VALUE self);
+static VALUE pending_result__state(VALUE self);
+static VALUE pending_result__execute_check_state(VALUE self);
 
 static const rb_data_type_t pending_result_data_type = {
     "DuckDB/PendingResult",
@@ -35,7 +35,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBPendingResult);
 }
 
-static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self) {
+static VALUE pending_result_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE oDuckDBPreparedStatement;
     VALUE streaming_p = Qfalse;
     duckdb_state state;
@@ -49,8 +49,8 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eTypeError, "1st argument must be DuckDB::PreparedStatement");
     }
 
-    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
-    rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
+    rubyDuckDBPreparedStatement *stmt = rbduckdb_get_struct_prepared_statement(oDuckDBPreparedStatement);
 
     state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
 
@@ -71,14 +71,14 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
  *  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);
+static VALUE pending_result_execute_task(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
     ctx->state = duckdb_pending_execute_task(ctx->pending_result);
     return Qnil;
 }
 
-static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
-    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+static VALUE pending_result_execution_finished_p(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
     return duckdb_pending_execution_is_finished(ctx->state) ? Qtrue : Qfalse;
 }
 
@@ -94,13 +94,13 @@ static VALUE duckdb_pending_result_execution_finished_p(VALUE self) {
  *  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) {
+static VALUE 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);
+    ctxr = rbduckdb_get_struct_result(result);
     if (duckdb_execute_pending(ctx->pending_result, &(ctxr->result)) == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));
     }
@@ -108,34 +108,34 @@ static VALUE duckdb_pending_result_execute_pending(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE duckdb_pending_result__state(VALUE self) {
-    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+static VALUE pending_result__state(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
     return INT2FIX(ctx->state);
 }
 
 /* :nodoc: */
-static VALUE duckdb_pending_result__execute_check_state(VALUE self) {
-    rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
+static VALUE pending_result__execute_check_state(VALUE self) {
+    rubyDuckDBPendingResult *ctx = rbduckdb_get_struct_pending_result(self);
     return INT2FIX(duckdb_pending_execute_check_state(ctx->pending_result));
 }
 
-rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
+rubyDuckDBPendingResult *rbduckdb_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) {
+void rbduckdb_init_pending_result(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     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);
-    rb_define_method(cDuckDBPendingResult, "execution_finished?", duckdb_pending_result_execution_finished_p, 0);
-    rb_define_private_method(cDuckDBPendingResult, "_state", duckdb_pending_result__state, 0);
-    rb_define_private_method(cDuckDBPendingResult, "_execute_check_state", duckdb_pending_result__execute_check_state, 0);
+    rb_define_method(cDuckDBPendingResult, "initialize", pending_result_initialize, -1);
+    rb_define_method(cDuckDBPendingResult, "execute_task", pending_result_execute_task, 0);
+    rb_define_method(cDuckDBPendingResult, "execute_pending", pending_result_execute_pending, 0);
+    rb_define_method(cDuckDBPendingResult, "execution_finished?", pending_result_execution_finished_p, 0);
+    rb_define_private_method(cDuckDBPendingResult, "_state", pending_result__state, 0);
+    rb_define_private_method(cDuckDBPendingResult, "_execute_check_state", pending_result__execute_check_state, 0);
 }

data/ext/duckdb/pending_result.h

@@ -8,6 +8,6 @@ struct _rubyDuckDBPendingResult {
 
 typedef struct _rubyDuckDBPendingResult rubyDuckDBPendingResult;
 
-rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj);
-void rbduckdb_init_duckdb_pending_result(void);
+rubyDuckDBPendingResult *rbduckdb_get_struct_pending_result(VALUE obj);
+void rbduckdb_init_pending_result(void);
 #endif