duckdb 1.5.2.0 → 1.5.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (56) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +9 -0
  3. data/duckdb.gemspec +37 -0
  4. data/ext/duckdb/aggregate_function.c +61 -100
  5. data/ext/duckdb/aggregate_function.h +2 -2
  6. data/ext/duckdb/appender.c +76 -35
  7. data/ext/duckdb/appender.h +1 -1
  8. data/ext/duckdb/client_context.c +5 -5
  9. data/ext/duckdb/client_context.h +2 -2
  10. data/ext/duckdb/column.c +13 -13
  11. data/ext/duckdb/column.h +1 -1
  12. data/ext/duckdb/connection.c +40 -41
  13. data/ext/duckdb/connection.h +2 -2
  14. data/ext/duckdb/converter.h +1 -7
  15. data/ext/duckdb/conveter.c +6 -6
  16. data/ext/duckdb/data_chunk.c +22 -22
  17. data/ext/duckdb/data_chunk.h +2 -2
  18. data/ext/duckdb/database.c +10 -10
  19. data/ext/duckdb/database.h +1 -1
  20. data/ext/duckdb/duckdb.c +17 -17
  21. data/ext/duckdb/expression.c +8 -8
  22. data/ext/duckdb/expression.h +1 -1
  23. data/ext/duckdb/extconf.rb +4 -3
  24. data/ext/duckdb/extracted_statements.c +15 -15
  25. data/ext/duckdb/extracted_statements.h +1 -1
  26. data/ext/duckdb/instance_cache.c +10 -10
  27. data/ext/duckdb/instance_cache.h +1 -1
  28. data/ext/duckdb/logical_type.c +94 -133
  29. data/ext/duckdb/logical_type.h +2 -2
  30. data/ext/duckdb/memory_helper.c +28 -28
  31. data/ext/duckdb/pending_result.c +27 -27
  32. data/ext/duckdb/pending_result.h +2 -2
  33. data/ext/duckdb/prepared_statement.c +103 -103
  34. data/ext/duckdb/prepared_statement.h +2 -2
  35. data/ext/duckdb/result.c +33 -33
  36. data/ext/duckdb/result.h +2 -3
  37. data/ext/duckdb/ruby-duckdb.h +4 -0
  38. data/ext/duckdb/scalar_function.c +3 -3
  39. data/ext/duckdb/table_description.c +1 -1
  40. data/ext/duckdb/table_function.c +3 -3
  41. data/ext/duckdb/table_function_bind_info.c +1 -1
  42. data/ext/duckdb/value.c +62 -50
  43. data/ext/duckdb/value.h +2 -2
  44. data/ext/duckdb/vector.c +20 -20
  45. data/ext/duckdb/vector.h +2 -2
  46. data/lib/duckdb/aggregate_function.rb +202 -3
  47. data/lib/duckdb/appender.rb +74 -0
  48. data/lib/duckdb/connection.rb +1 -16
  49. data/lib/duckdb/converter.rb +5 -0
  50. data/lib/duckdb/logical_type.rb +1 -3
  51. data/lib/duckdb/prepared_statement.rb +1 -1
  52. data/lib/duckdb/table_function.rb +0 -1
  53. data/lib/duckdb/value.rb +19 -0
  54. data/lib/duckdb/version.rb +1 -1
  55. metadata +2 -2
  56. data/lib/duckdb/duckdb_native.so +0 -0
data/ext/duckdb/extracted_statements.c CHANGED
@@ -16,10 +16,10 @@ static void deallocate(void *ctx);
16
16
  static VALUE allocate(VALUE klass);
17
17
  static size_t memsize(const void *p);
18
18
 
19
- static VALUE duckdb_extracted_statements__initialize(VALUE self, VALUE con, VALUE query);
20
- static VALUE duckdb_extracted_statements_destroy(VALUE self);
21
- static VALUE duckdb_extracted_statements_size(VALUE self);
22
- static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index);
19
+ static VALUE extracted_statements__initialize(VALUE self, VALUE con, VALUE query);
20
+ static VALUE extracted_statements_destroy(VALUE self);
21
+ static VALUE extracted_statements_size(VALUE self);
22
+ static VALUE extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index);
23
23
 
24
24
  static void deallocate(void *ctx) {
25
25
  rubyDuckDBExtractedStatements *p = (rubyDuckDBExtractedStatements *)ctx;
@@ -39,7 +39,7 @@ static size_t memsize(const void *p) {
39
39
  return sizeof(rubyDuckDBExtractedStatements);
40
40
  }
41
41
 
42
- static VALUE duckdb_extracted_statements__initialize(VALUE self, VALUE con, VALUE query) {
42
+ static VALUE extracted_statements__initialize(VALUE self, VALUE con, VALUE query) {
43
43
  rubyDuckDBConnection *pcon;
44
44
  rubyDuckDBExtractedStatements *ctx;
45
45
  char *pquery;
@@ -50,7 +50,7 @@ static VALUE duckdb_extracted_statements__initialize(VALUE self, VALUE con, VALU
50
50
  }
51
51
 
52
52
  pquery = StringValuePtr(query);
53
- pcon = get_struct_connection(con);
53
+ pcon = rbduckdb_get_struct_connection(con);
54
54
  TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
55
55
 
56
56
  ctx->num_statements = duckdb_extract_statements(pcon->con, pquery, &(ctx->extracted_statements));
@@ -63,7 +63,7 @@ static VALUE duckdb_extracted_statements__initialize(VALUE self, VALUE con, VALU
63
63
  return self;
64
64
  }
65
65
 
66
- static VALUE duckdb_extracted_statements_destroy(VALUE self) {
66
+ static VALUE extracted_statements_destroy(VALUE self) {
67
67
  rubyDuckDBExtractedStatements *ctx;
68
68
 
69
69
  TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
@@ -73,7 +73,7 @@ static VALUE duckdb_extracted_statements_destroy(VALUE self) {
73
73
  return Qnil;
74
74
  }
75
75
 
76
- static VALUE duckdb_extracted_statements_size(VALUE self) {
76
+ static VALUE extracted_statements_size(VALUE self) {
77
77
  rubyDuckDBExtractedStatements *ctx;
78
78
 
79
79
  TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
@@ -81,28 +81,28 @@ static VALUE duckdb_extracted_statements_size(VALUE self) {
81
81
  return ULL2NUM(ctx->num_statements);
82
82
  }
83
83
 
84
- static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index) {
84
+ static VALUE extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index) {
85
85
  rubyDuckDBConnection *pcon;
86
86
  rubyDuckDBExtractedStatements *ctx;
87
87
 
88
88
  if (rb_obj_is_kind_of(con, cDuckDBConnection) != Qtrue) {
89
89
  rb_raise(rb_eTypeError, "1st argument must be DuckDB::Connection");
90
90
  }
91
- pcon = get_struct_connection(con);
91
+ pcon = rbduckdb_get_struct_connection(con);
92
92
  TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
93
93
 
94
94
  return rbduckdb_prepared_statement_new(pcon->con, ctx->extracted_statements, NUM2ULL(index));
95
95
  }
96
96
 
97
- void rbduckdb_init_duckdb_extracted_statements(void) {
97
+ void rbduckdb_init_extracted_statements(void) {
98
98
  #if 0
99
99
  VALUE mDuckDB = rb_define_module("DuckDB");
100
100
  #endif
101
101
  cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatements", rb_cObject);
102
102
 
103
103
  rb_define_alloc_func(cDuckDBExtractedStatements, allocate);
104
- rb_define_private_method(cDuckDBExtractedStatements, "_initialize", duckdb_extracted_statements__initialize, 2);
105
- rb_define_method(cDuckDBExtractedStatements, "destroy", duckdb_extracted_statements_destroy, 0);
106
- rb_define_method(cDuckDBExtractedStatements, "size", duckdb_extracted_statements_size, 0);
107
- rb_define_method(cDuckDBExtractedStatements, "prepared_statement", duckdb_extracted_statements_prepared_statement, 2);
104
+ rb_define_private_method(cDuckDBExtractedStatements, "_initialize", extracted_statements__initialize, 2);
105
+ rb_define_method(cDuckDBExtractedStatements, "destroy", extracted_statements_destroy, 0);
106
+ rb_define_method(cDuckDBExtractedStatements, "size", extracted_statements_size, 0);
107
+ rb_define_method(cDuckDBExtractedStatements, "prepared_statement", extracted_statements_prepared_statement, 2);
108
108
  }
data/ext/duckdb/extracted_statements.h CHANGED
@@ -8,5 +8,5 @@ struct _rubyDuckDBExtractedStatements {
8
8
 
9
9
  typedef struct _rubyDuckDBExtractedStatements rubyDuckDBExtractedStatements;
10
10
 
11
- void rbduckdb_init_duckdb_extracted_statements(void);
11
+ void rbduckdb_init_extracted_statements(void);
12
12
  #endif
data/ext/duckdb/instance_cache.c CHANGED
@@ -5,9 +5,9 @@ VALUE cDuckDBInstanceCache;
5
5
  static void deallocate(void * ctx);
6
6
  static VALUE allocate(VALUE klass);
7
7
  static size_t memsize(const void *p);
8
- static VALUE duckdb_instance_cache_initialize(VALUE self);
9
- static VALUE duckdb_instance_cache_get_or_create(int argc, VALUE *argv, VALUE self);
10
- static VALUE duckdb_instance_cache_destroy(VALUE self);
8
+ static VALUE instance_cache_initialize(VALUE self);
9
+ static VALUE instance_cache_get_or_create(int argc, VALUE *argv, VALUE self);
10
+ static VALUE instance_cache_destroy(VALUE self);
11
11
 
12
12
  static const rb_data_type_t instance_cache_data_type = {
13
13
  "DuckDB/InstanceCache",
@@ -33,7 +33,7 @@ static VALUE allocate(VALUE klass) {
33
33
  return TypedData_Wrap_Struct(klass, &instance_cache_data_type, ctx);
34
34
  }
35
35
 
36
- static VALUE duckdb_instance_cache_initialize(VALUE self) {
36
+ static VALUE instance_cache_initialize(VALUE self) {
37
37
  rubyDuckDBInstanceCache *ctx;
38
38
 
39
39
  TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
@@ -47,7 +47,7 @@ static VALUE duckdb_instance_cache_initialize(VALUE self) {
47
47
  }
48
48
 
49
49
  /* :nodoc: */
50
- static VALUE duckdb_instance_cache_get_or_create(int argc, VALUE *argv, VALUE self) {
50
+ static VALUE instance_cache_get_or_create(int argc, VALUE *argv, VALUE self) {
51
51
  VALUE vpath = Qnil;
52
52
  VALUE vconfig = Qnil;
53
53
  const char *path = NULL;
@@ -82,7 +82,7 @@ static VALUE duckdb_instance_cache_get_or_create(int argc, VALUE *argv, VALUE se
82
82
  return rbduckdb_create_database_obj(db);
83
83
  }
84
84
 
85
- static VALUE duckdb_instance_cache_destroy(VALUE self) {
85
+ static VALUE instance_cache_destroy(VALUE self) {
86
86
  rubyDuckDBInstanceCache *ctx;
87
87
  TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
88
88
 
@@ -94,13 +94,13 @@ static VALUE duckdb_instance_cache_destroy(VALUE self) {
94
94
  return Qnil;
95
95
  }
96
96
 
97
- void rbduckdb_init_duckdb_instance_cache(void) {
97
+ void rbduckdb_init_instance_cache(void) {
98
98
  #if 0
99
99
  VALUE mDuckDB = rb_define_module("DuckDB");
100
100
  #endif
101
101
  cDuckDBInstanceCache = rb_define_class_under(mDuckDB, "InstanceCache", rb_cObject);
102
- rb_define_method(cDuckDBInstanceCache, "initialize", duckdb_instance_cache_initialize, 0);
103
- rb_define_method(cDuckDBInstanceCache, "get_or_create", duckdb_instance_cache_get_or_create, -1);
104
- rb_define_method(cDuckDBInstanceCache, "destroy", duckdb_instance_cache_destroy, 0);
102
+ rb_define_method(cDuckDBInstanceCache, "initialize", instance_cache_initialize, 0);
103
+ rb_define_method(cDuckDBInstanceCache, "get_or_create", instance_cache_get_or_create, -1);
104
+ rb_define_method(cDuckDBInstanceCache, "destroy", instance_cache_destroy, 0);
105
105
  rb_define_alloc_func(cDuckDBInstanceCache, allocate);
106
106
  }
data/ext/duckdb/instance_cache.h CHANGED
@@ -7,6 +7,6 @@ struct _rubyDuckDBInstanceCache {
7
7
 
8
8
  typedef struct _rubyDuckDBInstanceCache rubyDuckDBInstanceCache;
9
9
 
10
- void rbduckdb_init_duckdb_instance_cache(void);
10
+ void rbduckdb_init_instance_cache(void);
11
11
 
12
12
  #endif
data/ext/duckdb/logical_type.c CHANGED
@@ -5,30 +5,32 @@ static VALUE cDuckDBLogicalType;
5
5
  static void deallocate(void *ctx);
6
6
  static VALUE allocate(VALUE klass);
7
7
  static size_t memsize(const void *p);
8
- static VALUE duckdb_logical_type__type(VALUE self);
9
- static VALUE duckdb_logical_type_width(VALUE self);
10
- static VALUE duckdb_logical_type_scale(VALUE self);
11
- static VALUE duckdb_logical_type_child_count(VALUE self);
12
- static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx);
13
- static VALUE duckdb_logical_type_child_type(VALUE self);
14
- static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx);
15
- static VALUE duckdb_logical_type_size(VALUE self);
16
- static VALUE duckdb_logical_type_key_type(VALUE self);
17
- static VALUE duckdb_logical_type_value_type(VALUE self);
18
- static VALUE duckdb_logical_type_member_count(VALUE self);
19
- static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx);
20
- static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx);
21
- static VALUE duckdb_logical_type__internal_type(VALUE self);
22
- static VALUE duckdb_logical_type_dictionary_size(VALUE self);
23
- static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx);
24
- static VALUE duckdb_logical_type__get_alias(VALUE self);
25
- static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
26
- static VALUE duckdb_logical_type_s_create_array_type(VALUE klass, VALUE child, VALUE array_size);
27
- static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child);
28
- static VALUE duckdb_logical_type_s_create_map_type(VALUE klass, VALUE key, VALUE value);
29
- static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members);
30
- static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members);
31
- static VALUE initialize(VALUE self, VALUE type_id_arg);
8
+ static VALUE logical_type__type(VALUE self);
9
+ static VALUE logical_type_width(VALUE self);
10
+ static VALUE logical_type_scale(VALUE self);
11
+ static VALUE logical_type_child_count(VALUE self);
12
+ static VALUE logical_type_child_name_at(VALUE self, VALUE cidx);
13
+ static VALUE logical_type_child_type(VALUE self);
14
+ static VALUE logical_type_child_type_at(VALUE self, VALUE cidx);
15
+ static VALUE logical_type_size(VALUE self);
16
+ static VALUE logical_type_key_type(VALUE self);
17
+ static VALUE logical_type_value_type(VALUE self);
18
+ static VALUE logical_type_member_count(VALUE self);
19
+ static VALUE logical_type_member_name_at(VALUE self, VALUE midx);
20
+ static VALUE logical_type_member_type_at(VALUE self, VALUE midx);
21
+ static VALUE logical_type__internal_type(VALUE self);
22
+ static VALUE logical_type_dictionary_size(VALUE self);
23
+ static VALUE logical_type_dictionary_value_at(VALUE self, VALUE didx);
24
+ static VALUE logical_type_get_alias(VALUE self);
25
+ static VALUE logical_type_set_alias(VALUE self, VALUE aname);
26
+ static VALUE logical_type_s__create_array_type(VALUE klass, VALUE child, VALUE array_size);
27
+ static VALUE logical_type_s__create_list_type(VALUE klass, VALUE child);
28
+ static VALUE logical_type_s__create_map_type(VALUE klass, VALUE key, VALUE value);
29
+ static VALUE logical_type_s__create_union_type(VALUE klass, VALUE members);
30
+ static VALUE logical_type_s__create_struct_type(VALUE klass, VALUE members);
31
+ static VALUE logical_type_s__create_enum_type(VALUE klass, VALUE members);
32
+ static VALUE logical_type_s__create_decimal_type(VALUE klass, VALUE width, VALUE scale);
33
+ static VALUE logical_type_initialize(VALUE self, VALUE type_id_arg);
32
34
 
33
35
  static const rb_data_type_t logical_type_data_type = {
34
36
  "DuckDB/LogicalType",
@@ -46,7 +48,7 @@ static void deallocate(void *ctx) {
46
48
  xfree(p);
47
49
  }
48
50
 
49
- rubyDuckDBLogicalType *get_struct_logical_type(VALUE obj) {
51
+ rubyDuckDBLogicalType *rbduckdb_get_struct_logical_type(VALUE obj) {
50
52
  rubyDuckDBLogicalType *ctx;
51
53
  TypedData_Get_Struct(obj, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
52
54
  return ctx;
@@ -61,7 +63,7 @@ static size_t memsize(const void *p) {
61
63
  return sizeof(rubyDuckDBLogicalType);
62
64
  }
63
65
 
64
- static VALUE initialize(VALUE self, VALUE type_id_arg) {
66
+ static VALUE logical_type_initialize(VALUE self, VALUE type_id_arg) {
65
67
  rubyDuckDBLogicalType *ctx;
66
68
  duckdb_type type = (duckdb_type)NUM2INT(type_id_arg);
67
69
  duckdb_logical_type new_logical_type;
@@ -86,14 +88,8 @@ static VALUE initialize(VALUE self, VALUE type_id_arg) {
86
88
  return self;
87
89
  }
88
90
 
89
- /*
90
- * call-seq:
91
- * decimal_col.logical_type.type -> Symbol
92
- *
93
- * Returns the logical type's type symbol.
94
- *
95
- */
96
- static VALUE duckdb_logical_type__type(VALUE self) {
91
+ /* :nodoc: */
92
+ static VALUE logical_type__type(VALUE self) {
97
93
  rubyDuckDBLogicalType *ctx;
98
94
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
99
95
  return INT2FIX(duckdb_get_type_id(ctx->logical_type));
@@ -106,7 +102,7 @@ static VALUE duckdb_logical_type__type(VALUE self) {
106
102
  * Returns the width of the decimal column.
107
103
  *
108
104
  */
109
- static VALUE duckdb_logical_type_width(VALUE self) {
105
+ static VALUE logical_type_width(VALUE self) {
110
106
  rubyDuckDBLogicalType *ctx;
111
107
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
112
108
  return INT2FIX(duckdb_decimal_width(ctx->logical_type));
@@ -119,7 +115,7 @@ static VALUE duckdb_logical_type_width(VALUE self) {
119
115
  * Returns the scale of the decimal column.
120
116
  *
121
117
  */
122
- static VALUE duckdb_logical_type_scale(VALUE self) {
118
+ static VALUE logical_type_scale(VALUE self) {
123
119
  rubyDuckDBLogicalType *ctx;
124
120
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
125
121
  return INT2FIX(duckdb_decimal_scale(ctx->logical_type));
@@ -132,7 +128,7 @@ static VALUE duckdb_logical_type_scale(VALUE self) {
132
128
  * Returns the number of children of a struct type, otherwise 0.
133
129
  *
134
130
  */
135
- static VALUE duckdb_logical_type_child_count(VALUE self) {
131
+ static VALUE logical_type_child_count(VALUE self) {
136
132
  rubyDuckDBLogicalType *ctx;
137
133
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
138
134
  return INT2FIX(duckdb_struct_type_child_count(ctx->logical_type));
@@ -145,7 +141,7 @@ static VALUE duckdb_logical_type_child_count(VALUE self) {
145
141
  * Returns the name of the struct child at the specified index.
146
142
  *
147
143
  */
148
- static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx) {
144
+ static VALUE logical_type_child_name_at(VALUE self, VALUE cidx) {
149
145
  rubyDuckDBLogicalType *ctx;
150
146
  VALUE cname;
151
147
  const char *child_name;
@@ -169,7 +165,7 @@ static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx) {
169
165
  * Returns the child logical type for list and map types, otherwise nil.
170
166
  *
171
167
  */
172
- static VALUE duckdb_logical_type_child_type(VALUE self) {
168
+ static VALUE logical_type_child_type(VALUE self) {
173
169
  rubyDuckDBLogicalType *ctx;
174
170
  duckdb_type type_id;
175
171
  duckdb_logical_type child_logical_type;
@@ -202,7 +198,7 @@ static VALUE duckdb_logical_type_child_type(VALUE self) {
202
198
  * DuckDB::LogicalType object.
203
199
  *
204
200
  */
205
- static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx) {
201
+ static VALUE logical_type_child_type_at(VALUE self, VALUE cidx) {
206
202
  rubyDuckDBLogicalType *ctx;
207
203
  duckdb_logical_type struct_child_type;
208
204
  idx_t idx = NUM2ULL(cidx);
@@ -226,7 +222,7 @@ static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx) {
226
222
  * Returns the size of the array column, otherwise 0.
227
223
  *
228
224
  */
229
- static VALUE duckdb_logical_type_size(VALUE self) {
225
+ static VALUE logical_type_size(VALUE self) {
230
226
  rubyDuckDBLogicalType *ctx;
231
227
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
232
228
  return INT2FIX(duckdb_array_type_array_size(ctx->logical_type));
@@ -239,7 +235,7 @@ static VALUE duckdb_logical_type_size(VALUE self) {
239
235
  * Returns the key logical type for map type, otherwise nil.
240
236
  *
241
237
  */
242
- static VALUE duckdb_logical_type_key_type(VALUE self) {
238
+ static VALUE logical_type_key_type(VALUE self) {
243
239
  rubyDuckDBLogicalType *ctx;
244
240
  duckdb_logical_type key_logical_type;
245
241
  VALUE logical_type = Qnil;
@@ -257,7 +253,7 @@ static VALUE duckdb_logical_type_key_type(VALUE self) {
257
253
  * Returns the value logical type for map type, otherwise nil.
258
254
  *
259
255
  */
260
- static VALUE duckdb_logical_type_value_type(VALUE self) {
256
+ static VALUE logical_type_value_type(VALUE self) {
261
257
  rubyDuckDBLogicalType *ctx;
262
258
  duckdb_logical_type value_logical_type;
263
259
  VALUE logical_type = Qnil;
@@ -275,7 +271,7 @@ static VALUE duckdb_logical_type_value_type(VALUE self) {
275
271
  * Returns the member count of union type, otherwise 0.
276
272
  *
277
273
  */
278
- static VALUE duckdb_logical_type_member_count(VALUE self) {
274
+ static VALUE logical_type_member_count(VALUE self) {
279
275
  rubyDuckDBLogicalType *ctx;
280
276
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
281
277
  return INT2FIX(duckdb_union_type_member_count(ctx->logical_type));
@@ -288,7 +284,7 @@ static VALUE duckdb_logical_type_member_count(VALUE self) {
288
284
  * Returns the name of the union member at the specified index.
289
285
  *
290
286
  */
291
- static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx) {
287
+ static VALUE logical_type_member_name_at(VALUE self, VALUE midx) {
292
288
  rubyDuckDBLogicalType *ctx;
293
289
  VALUE mname;
294
290
  const char *member_name;
@@ -313,7 +309,7 @@ static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx) {
313
309
  * DuckDB::LogicalType object.
314
310
  *
315
311
  */
316
- static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx) {
312
+ static VALUE logical_type_member_type_at(VALUE self, VALUE midx) {
317
313
  rubyDuckDBLogicalType *ctx;
318
314
  duckdb_logical_type union_member_type;
319
315
  idx_t idx = NUM2ULL(midx);
@@ -337,7 +333,7 @@ static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx) {
337
333
  * Returns the logical type's internal type.
338
334
  *
339
335
  */
340
- static VALUE duckdb_logical_type__internal_type(VALUE self) {
336
+ static VALUE logical_type__internal_type(VALUE self) {
341
337
  rubyDuckDBLogicalType *ctx;
342
338
  duckdb_type type_id;
343
339
  duckdb_type internal_type_id;
@@ -366,7 +362,7 @@ static VALUE duckdb_logical_type__internal_type(VALUE self) {
366
362
  * Returns the dictionary size of the enum type.
367
363
  *
368
364
  */
369
- static VALUE duckdb_logical_type_dictionary_size(VALUE self) {
365
+ static VALUE logical_type_dictionary_size(VALUE self) {
370
366
  rubyDuckDBLogicalType *ctx;
371
367
  TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
372
368
  return INT2FIX(duckdb_enum_dictionary_size(ctx->logical_type));
@@ -379,7 +375,7 @@ static VALUE duckdb_logical_type_dictionary_size(VALUE self) {
379
375
  * Returns the dictionary value at the specified index.
380
376
  *
381
377
  */
382
- static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx) {
378
+ static VALUE logical_type_dictionary_value_at(VALUE self, VALUE didx) {
383
379
  rubyDuckDBLogicalType *ctx;
384
380
  VALUE dvalue;
385
381
  const char *dict_value;
@@ -403,7 +399,7 @@ static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx) {
403
399
  * Returns the alias of the logical type.
404
400
  *
405
401
  */
406
- static VALUE duckdb_logical_type__get_alias(VALUE self) {
402
+ static VALUE logical_type_get_alias(VALUE self) {
407
403
  rubyDuckDBLogicalType *ctx;
408
404
  VALUE alias = Qnil;
409
405
  const char *_alias;
@@ -425,7 +421,7 @@ static VALUE duckdb_logical_type__get_alias(VALUE self) {
425
421
  * Return the set alias of the logical type.
426
422
  *
427
423
  */
428
- static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
424
+ static VALUE logical_type_set_alias(VALUE self, VALUE aname) {
429
425
  rubyDuckDBLogicalType *ctx;
430
426
  VALUE alias = Qnil;
431
427
  const char *_alias = StringValuePtr(aname);
@@ -439,14 +435,9 @@ static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
439
435
  return alias;
440
436
  }
441
437
 
442
- /*
443
- * call-seq:
444
- * DuckDB::LogicalType._create_array_type(logical_type, size) -> DuckDB::LogicalType
445
- *
446
- * Return an array logical type from the given child logical type and size.
447
- */
448
- static VALUE duckdb_logical_type_s_create_array_type(VALUE klass, VALUE child, VALUE array_size) {
449
- rubyDuckDBLogicalType *child_ctx = get_struct_logical_type(child);
438
+ /* :nodoc: */
439
+ static VALUE logical_type_s__create_array_type(VALUE klass, VALUE child, VALUE array_size) {
440
+ rubyDuckDBLogicalType *child_ctx = rbduckdb_get_struct_logical_type(child);
450
441
  idx_t size = NUM2ULL(array_size);
451
442
  duckdb_logical_type new_type = duckdb_create_array_type(child_ctx->logical_type, size);
452
443
 
@@ -457,14 +448,9 @@ static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
457
448
  return rbduckdb_create_logical_type(new_type);
458
449
  }
459
450
 
460
- /*
461
- * call-seq:
462
- * DuckDB::LogicalType._create_list_type(logical_type) -> DuckDB::LogicalType
463
- *
464
- * Return a list logical type from the given child logical type.
465
- */
466
- static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child) {
467
- rubyDuckDBLogicalType *child_ctx = get_struct_logical_type(child);
451
+ /* :nodoc: */
452
+ static VALUE logical_type_s__create_list_type(VALUE klass, VALUE child) {
453
+ rubyDuckDBLogicalType *child_ctx = rbduckdb_get_struct_logical_type(child);
468
454
  duckdb_logical_type new_type = duckdb_create_list_type(child_ctx->logical_type);
469
455
 
470
456
  if (!new_type) {
@@ -474,15 +460,10 @@ static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child) {
474
460
  return rbduckdb_create_logical_type(new_type);
475
461
  }
476
462
 
477
- /*
478
- * call-seq:
479
- * DuckDB::LogicalType._create_map_type(key_type, value_type) -> DuckDB::LogicalType
480
- *
481
- * Return a map logical type from the given key and value logical types.
482
- */
483
- static VALUE duckdb_logical_type_s_create_map_type(VALUE klass, VALUE key, VALUE value) {
484
- rubyDuckDBLogicalType *key_ctx = get_struct_logical_type(key);
485
- rubyDuckDBLogicalType *value_ctx = get_struct_logical_type(value);
463
+ /* :nodoc: */
464
+ static VALUE logical_type_s__create_map_type(VALUE klass, VALUE key, VALUE value) {
465
+ rubyDuckDBLogicalType *key_ctx = rbduckdb_get_struct_logical_type(key);
466
+ rubyDuckDBLogicalType *value_ctx = rbduckdb_get_struct_logical_type(value);
486
467
  duckdb_logical_type new_type = duckdb_create_map_type(key_ctx->logical_type, value_ctx->logical_type);
487
468
 
488
469
  if (!new_type) {
@@ -492,13 +473,8 @@ static VALUE duckdb_logical_type_s_create_map_type(VALUE klass, VALUE key, VALUE
492
473
  return rbduckdb_create_logical_type(new_type);
493
474
  }
494
475
 
495
- /*
496
- * call-seq:
497
- * DuckDB::LogicalType._create_union_type(members) -> DuckDB::LogicalType
498
- *
499
- * Return a union logical type from the given member hash.
500
- */
501
- static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members) {
476
+ /* :nodoc: */
477
+ static VALUE logical_type_s__create_union_type(VALUE klass, VALUE members) {
502
478
  idx_t member_size = RHASH_SIZE(members);
503
479
  duckdb_logical_type *member_types = NULL;
504
480
  const char **member_names = NULL;
@@ -517,7 +493,7 @@ static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members)
517
493
  for (idx_t i = 0; i < member_size; i++) {
518
494
  VALUE key = rb_ary_entry(keys, (long)i);
519
495
  VALUE val = rb_hash_aref(members, key);
520
- rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(val);
496
+ rubyDuckDBLogicalType *type_ctx = rbduckdb_get_struct_logical_type(val);
521
497
 
522
498
  member_names[i] = rb_id2name(SYM2ID(key));
523
499
  member_types[i] = type_ctx->logical_type;
@@ -535,13 +511,8 @@ static VALUE duckdb_logical_type_s_create_union_type(VALUE klass, VALUE members)
535
511
  return rbduckdb_create_logical_type(new_type);
536
512
  }
537
513
 
538
- /*
539
- * call-seq:
540
- * DuckDB::LogicalType._create_struct_type(members) -> DuckDB::LogicalType
541
- *
542
- * Return a struct logical type from the given member hash.
543
- */
544
- static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members) {
514
+ /* :nodoc: */
515
+ static VALUE logical_type_s__create_struct_type(VALUE klass, VALUE members) {
545
516
  idx_t member_size = RHASH_SIZE(members);
546
517
  duckdb_logical_type *member_types = NULL;
547
518
  const char **member_names = NULL;
@@ -560,7 +531,7 @@ static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members
560
531
  for (idx_t i = 0; i < member_size; i++) {
561
532
  VALUE key = rb_ary_entry(keys, (long)i);
562
533
  VALUE val = rb_hash_aref(members, key);
563
- rubyDuckDBLogicalType *type_ctx = get_struct_logical_type(val);
534
+ rubyDuckDBLogicalType *type_ctx = rbduckdb_get_struct_logical_type(val);
564
535
 
565
536
  member_names[i] = rb_id2name(SYM2ID(key));
566
537
  member_types[i] = type_ctx->logical_type;
@@ -578,13 +549,8 @@ static VALUE duckdb_logical_type_s_create_struct_type(VALUE klass, VALUE members
578
549
  return rbduckdb_create_logical_type(new_type);
579
550
  }
580
551
 
581
- /*
582
- * call-seq:
583
- * DuckDB::LogicalType._create_enum_type(members) -> DuckDB::LogicalType
584
- *
585
- * Return an enum logical type from the given array of strings.
586
- */
587
- static VALUE duckdb_logical_type_s_create_enum_type(VALUE klass, VALUE members) {
552
+ /* :nodoc: */
553
+ static VALUE logical_type_s__create_enum_type(VALUE klass, VALUE members) {
588
554
  idx_t member_size = RARRAY_LEN(members);
589
555
  const char **member_names = NULL;
590
556
  duckdb_logical_type new_type;
@@ -611,13 +577,8 @@ static VALUE duckdb_logical_type_s_create_enum_type(VALUE klass, VALUE members)
611
577
  return rbduckdb_create_logical_type(new_type);
612
578
  }
613
579
 
614
- /*
615
- * call-seq:
616
- * DuckDB::LogicalType._create_decimal_type(width, scale) -> DuckDB::LogicalType
617
- *
618
- * Return a decimal logical type with the given width and scale.
619
- */
620
- static VALUE duckdb_logical_type_s_create_decimal_type(VALUE klass, VALUE width, VALUE scale) {
580
+ /* :nodoc: */
581
+ static VALUE logical_type_s__create_decimal_type(VALUE klass, VALUE width, VALUE scale) {
621
582
  duckdb_logical_type new_type;
622
583
 
623
584
  new_type = duckdb_create_decimal_type((uint8_t)NUM2UINT(width), (uint8_t)NUM2UINT(scale));
@@ -641,46 +602,46 @@ VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
641
602
  return obj;
642
603
  }
643
604
 
644
- void rbduckdb_init_duckdb_logical_type(void) {
605
+ void rbduckdb_init_logical_type(void) {
645
606
  #if 0
646
607
  VALUE mDuckDB = rb_define_module("DuckDB");
647
608
  #endif
648
609
  cDuckDBLogicalType = rb_define_class_under(mDuckDB, "LogicalType", rb_cObject);
649
610
  rb_define_alloc_func(cDuckDBLogicalType, allocate);
650
611
 
651
- rb_define_private_method(cDuckDBLogicalType, "_type", duckdb_logical_type__type, 0);
652
- rb_define_method(cDuckDBLogicalType, "width", duckdb_logical_type_width, 0);
653
- rb_define_method(cDuckDBLogicalType, "scale", duckdb_logical_type_scale, 0);
654
- rb_define_method(cDuckDBLogicalType, "child_count", duckdb_logical_type_child_count, 0);
655
- rb_define_method(cDuckDBLogicalType, "child_name_at", duckdb_logical_type_child_name_at, 1);
656
- rb_define_method(cDuckDBLogicalType, "child_type", duckdb_logical_type_child_type, 0);
657
- rb_define_method(cDuckDBLogicalType, "child_type_at", duckdb_logical_type_child_type_at, 1);
658
- rb_define_method(cDuckDBLogicalType, "size", duckdb_logical_type_size, 0);
659
- rb_define_method(cDuckDBLogicalType, "key_type", duckdb_logical_type_key_type, 0);
660
- rb_define_method(cDuckDBLogicalType, "value_type", duckdb_logical_type_value_type, 0);
661
- rb_define_method(cDuckDBLogicalType, "member_count", duckdb_logical_type_member_count, 0);
662
- rb_define_method(cDuckDBLogicalType, "member_name_at", duckdb_logical_type_member_name_at, 1);
663
- rb_define_method(cDuckDBLogicalType, "member_type_at", duckdb_logical_type_member_type_at, 1);
664
- rb_define_method(cDuckDBLogicalType, "_internal_type", duckdb_logical_type__internal_type, 0);
665
- rb_define_method(cDuckDBLogicalType, "dictionary_size", duckdb_logical_type_dictionary_size, 0);
666
- rb_define_method(cDuckDBLogicalType, "dictionary_value_at", duckdb_logical_type_dictionary_value_at, 1);
667
- rb_define_method(cDuckDBLogicalType, "get_alias", duckdb_logical_type__get_alias, 0);
668
- rb_define_method(cDuckDBLogicalType, "set_alias", duckdb_logical_type__set_alias, 1);
612
+ rb_define_private_method(cDuckDBLogicalType, "_type", logical_type__type, 0);
613
+ rb_define_method(cDuckDBLogicalType, "width", logical_type_width, 0);
614
+ rb_define_method(cDuckDBLogicalType, "scale", logical_type_scale, 0);
615
+ rb_define_method(cDuckDBLogicalType, "child_count", logical_type_child_count, 0);
616
+ rb_define_method(cDuckDBLogicalType, "child_name_at", logical_type_child_name_at, 1);
617
+ rb_define_method(cDuckDBLogicalType, "child_type", logical_type_child_type, 0);
618
+ rb_define_method(cDuckDBLogicalType, "child_type_at", logical_type_child_type_at, 1);
619
+ rb_define_method(cDuckDBLogicalType, "size", logical_type_size, 0);
620
+ rb_define_method(cDuckDBLogicalType, "key_type", logical_type_key_type, 0);
621
+ rb_define_method(cDuckDBLogicalType, "value_type", logical_type_value_type, 0);
622
+ rb_define_method(cDuckDBLogicalType, "member_count", logical_type_member_count, 0);
623
+ rb_define_method(cDuckDBLogicalType, "member_name_at", logical_type_member_name_at, 1);
624
+ rb_define_method(cDuckDBLogicalType, "member_type_at", logical_type_member_type_at, 1);
625
+ rb_define_private_method(cDuckDBLogicalType, "_internal_type", logical_type__internal_type, 0);
626
+ rb_define_method(cDuckDBLogicalType, "dictionary_size", logical_type_dictionary_size, 0);
627
+ rb_define_method(cDuckDBLogicalType, "dictionary_value_at", logical_type_dictionary_value_at, 1);
628
+ rb_define_method(cDuckDBLogicalType, "get_alias", logical_type_get_alias, 0);
629
+ rb_define_method(cDuckDBLogicalType, "set_alias", logical_type_set_alias, 1);
669
630
 
670
631
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_array_type",
671
- duckdb_logical_type_s_create_array_type, 2);
632
+ logical_type_s__create_array_type, 2);
672
633
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_list_type",
673
- duckdb_logical_type_s_create_list_type, 1);
634
+ logical_type_s__create_list_type, 1);
674
635
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_map_type",
675
- duckdb_logical_type_s_create_map_type, 2);
636
+ logical_type_s__create_map_type, 2);
676
637
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_union_type",
677
- duckdb_logical_type_s_create_union_type, 1);
638
+ logical_type_s__create_union_type, 1);
678
639
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_struct_type",
679
- duckdb_logical_type_s_create_struct_type, 1);
640
+ logical_type_s__create_struct_type, 1);
680
641
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_enum_type",
681
- duckdb_logical_type_s_create_enum_type, 1);
642
+ logical_type_s__create_enum_type, 1);
682
643
  rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_decimal_type",
683
- duckdb_logical_type_s_create_decimal_type, 2);
644
+ logical_type_s__create_decimal_type, 2);
684
645
 
685
- rb_define_method(cDuckDBLogicalType, "initialize", initialize, 1);
646
+ rb_define_method(cDuckDBLogicalType, "initialize", logical_type_initialize, 1);
686
647
  }
data/ext/duckdb/logical_type.h CHANGED
@@ -7,7 +7,7 @@ struct _rubyDuckDBLogicalType {
7
7
 
8
8
  typedef struct _rubyDuckDBLogicalType rubyDuckDBLogicalType;
9
9
 
10
- void rbduckdb_init_duckdb_logical_type(void);
10
+ void rbduckdb_init_logical_type(void);
11
11
  VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type);
12
- rubyDuckDBLogicalType *get_struct_logical_type(VALUE obj);
12
+ rubyDuckDBLogicalType *rbduckdb_get_struct_logical_type(VALUE obj);
13
13
  #endif