duckdb 1.5.3.0 → 1.5.5.0

data/ext/duckdb/table_function_function_info.h

@@ -7,7 +7,7 @@ struct _rubyDuckDBFunctionInfo {
 
 typedef struct _rubyDuckDBFunctionInfo rubyDuckDBFunctionInfo;
 
-rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj);
-void rbduckdb_init_duckdb_table_function_function_info(void);
+rubyDuckDBFunctionInfo *rbduckdb_get_struct_function_info(VALUE obj);
+void rbduckdb_init_table_function_function_info(void);
 
 #endif

data/ext/duckdb/table_function_init_info.c

@@ -5,7 +5,10 @@ VALUE cDuckDBTableFunctionInitInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_init_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_init_info_set_max_threads(VALUE self, VALUE max_threads);
+static VALUE table_function_init_info_column_count(VALUE self);
+static VALUE table_function_init_info_column_index(VALUE self, VALUE index);
 
 static const rb_data_type_t init_info_data_type = {
     "DuckDB/TableFunctionInitInfo",
@@ -27,7 +30,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBInitInfo);
 }
 
-rubyDuckDBInitInfo *get_struct_init_info(VALUE obj) {
+rubyDuckDBInitInfo *rbduckdb_get_struct_init_info(VALUE obj) {
     rubyDuckDBInitInfo *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBInitInfo, &init_info_data_type, ctx);
     return ctx;
@@ -42,7 +45,7 @@ rubyDuckDBInitInfo *get_struct_init_info(VALUE obj) {
  *
  *   init_info.set_error('Invalid initialization')
  */
-static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error) {
+static VALUE table_function_init_info_set_error(VALUE self, VALUE error) {
     rubyDuckDBInitInfo *ctx;
     const char *error_msg;
 
@@ -54,12 +57,74 @@ static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error) {
     return self;
 }
 
-void rbduckdb_init_duckdb_table_function_init_info(void) {
+/*
+ * call-seq:
+ *   init_info.set_max_threads(max_threads) -> self
+ *   init_info.max_threads = max_threads
+ *
+ * Sets the maximum number of threads that can execute the table function concurrently.
+ * This is a hint to DuckDB's scheduler; the actual number of threads is also bounded
+ * by the configured worker pool size (e.g., +SET threads+).
+ *
+ *   init_info.max_threads = 4
+ */
+static VALUE table_function_init_info_set_max_threads(VALUE self, VALUE max_threads) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    duckdb_init_set_max_threads(ctx->info, NUM2ULL(max_threads));
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   init_info.column_count -> Integer
+ *
+ * Returns the number of projected result columns for this scan.
+ * Without projection pushdown this equals the number of result columns
+ * added in the bind callback.
+ *
+ *   init_info.column_count # => 2
+ */
+static VALUE table_function_init_info_column_count(VALUE self) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    return ULL2NUM(duckdb_init_get_column_count(ctx->info));
+}
+
+/*
+ * call-seq:
+ *   init_info.column_index(index) -> Integer
+ *
+ * Returns the column index of the projected result column at +index+
+ * (0 <= +index+ < column_count). Without projection pushdown the projected
+ * columns mirror the columns added in the bind callback, so this returns
+ * +index+ itself.
+ *
+ *   init_info.column_index(0) # => 0
+ */
+static VALUE table_function_init_info_column_index(VALUE self, VALUE index) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    return ULL2NUM(duckdb_init_get_column_index(ctx->info, NUM2ULL(index)));
+}
+
+void rbduckdb_init_table_function_init_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableFunctionInitInfo = rb_define_class_under(cDuckDBTableFunction, "InitInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunctionInitInfo, allocate);
 
-    rb_define_method(cDuckDBTableFunctionInitInfo, "set_error", rbduckdb_init_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "set_error", table_function_init_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "set_max_threads", table_function_init_info_set_max_threads, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "max_threads=", table_function_init_info_set_max_threads, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "column_count", table_function_init_info_column_count, 0);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "column_index", table_function_init_info_column_index, 1);
 }

data/ext/duckdb/table_function_init_info.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBInitInfo {
 typedef struct _rubyDuckDBInitInfo rubyDuckDBInitInfo;
 
 extern VALUE cDuckDBTableFunctionInitInfo;
-rubyDuckDBInitInfo *get_struct_init_info(VALUE obj);
-void rbduckdb_init_duckdb_table_function_init_info(void);
+rubyDuckDBInitInfo *rbduckdb_get_struct_init_info(VALUE obj);
+void rbduckdb_init_table_function_init_info(void);
 
 #endif

data/ext/duckdb/util.c

@@ -21,6 +21,14 @@ duckdb_time rbduckdb_to_duckdb_time_from_value(VALUE hour, VALUE min, VALUE sec,
     return duckdb_to_time(time_st);
 }
 
+duckdb_time_ns rbduckdb_to_duckdb_time_ns_from_value(VALUE hour, VALUE min, VALUE sec, VALUE nanos) {
+    duckdb_time_ns time_ns;
+
+    time_ns.nanos = ((NUM2LL(hour) * 60 + NUM2LL(min)) * 60 + NUM2LL(sec)) * 1000000000LL + NUM2LL(nanos);
+
+    return time_ns;
+}
+
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj) {
     if (!rb_obj_is_kind_of(time_obj, rb_cTime)) {
         rb_raise(rb_eTypeError, "Expected Time object");

data/ext/duckdb/util.h

@@ -3,6 +3,7 @@
 
 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_time_ns rbduckdb_to_duckdb_time_ns_from_value(VALUE hour, VALUE min, VALUE sec, VALUE nanos);
 duckdb_timestamp rbduckdb_to_duckdb_timestamp_from_time_value(VALUE time_obj);
 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);