duckdb 2.0.0.0 → 2.0.0.1

data/ext/duckdb/function_vector.h

@@ -24,4 +24,22 @@ void rbduckdb_vector_set_value_at(duckdb_vector vector,
                                   idx_t index,
                                   VALUE value);
 
+/*
+ * Load the vector and logical type of each of the `n` columns of `input`.
+ * Allocates both arrays with ALLOC_N; release them with
+ * rbduckdb_input_columns_free.
+ */
+void rbduckdb_input_columns_load(duckdb_data_chunk input,
+                                 idx_t n,
+                                 duckdb_vector **vectors,
+                                 duckdb_logical_type **types);
+
+/*
+ * Destroy the `n` logical types and free both arrays.  NULL arrays are
+ * tolerated so it is safe to call when the load never happened.
+ */
+void rbduckdb_input_columns_free(duckdb_vector *vectors,
+                                 duckdb_logical_type *types,
+                                 idx_t n);
+
 #endif

data/ext/duckdb/logical_type.c

@@ -59,6 +59,42 @@ static VALUE allocate(VALUE klass) {
     return TypedData_Wrap_Struct(klass, &logical_type_data_type, ctx);
 }
 
+static duckdb_logical_type logical_type_of(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return ctx->logical_type;
+}
+
+static VALUE string_at(VALUE self, VALUE vidx, char *(*getter)(duckdb_logical_type, idx_t), const char *error_format, int utf8) {
+    VALUE str;
+    const char *cstr;
+    idx_t idx = NUM2ULL(vidx);
+
+    cstr = getter(logical_type_of(self), idx);
+    if (cstr == NULL) {
+        rb_raise(eDuckDBError, error_format, (unsigned long long)idx);
+    }
+    str = utf8 ? rb_utf8_str_new_cstr(cstr) : rb_str_new_cstr(cstr);
+    duckdb_free((void *)cstr);
+    return str;
+}
+
+static VALUE logical_type_at(VALUE self, VALUE vidx, duckdb_logical_type (*getter)(duckdb_logical_type, idx_t), const char *error_format) {
+    duckdb_logical_type found;
+    idx_t idx = NUM2ULL(vidx);
+
+    found = getter(logical_type_of(self), idx);
+    if (found == NULL) {
+        rb_raise(eDuckDBError, error_format, (unsigned long long)idx);
+    }
+
+    return rbduckdb_create_logical_type(found);
+}
+
+static VALUE wrapped_logical_type(VALUE self, duckdb_logical_type (*getter)(duckdb_logical_type)) {
+    return rbduckdb_create_logical_type(getter(logical_type_of(self)));
+}
+
 static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBLogicalType);
 }
@@ -90,9 +126,7 @@ static VALUE logical_type_initialize(VALUE self, VALUE type_id_arg) {
 
 /* :nodoc: */
 static VALUE logical_type__type(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_get_type_id(ctx->logical_type));
+    return INT2FIX(duckdb_get_type_id(logical_type_of(self)));
 }
 
 /*
@@ -103,9 +137,7 @@ static VALUE logical_type__type(VALUE self) {
  *
  */
 static VALUE logical_type_width(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_decimal_width(ctx->logical_type));
+    return INT2FIX(duckdb_decimal_width(logical_type_of(self)));
 }
 
 /*
@@ -116,9 +148,7 @@ static VALUE logical_type_width(VALUE self) {
  *
  */
 static VALUE logical_type_scale(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_decimal_scale(ctx->logical_type));
+    return INT2FIX(duckdb_decimal_scale(logical_type_of(self)));
 }
 
 /*
@@ -129,9 +159,7 @@ static VALUE logical_type_scale(VALUE self) {
  *
  */
 static VALUE logical_type_child_count(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_struct_type_child_count(ctx->logical_type));
+    return INT2FIX(duckdb_struct_type_child_count(logical_type_of(self)));
 }
 
 /*
@@ -142,20 +170,7 @@ static VALUE logical_type_child_count(VALUE self) {
  *
  */
 static VALUE logical_type_child_name_at(VALUE self, VALUE cidx) {
-    rubyDuckDBLogicalType *ctx;
-    VALUE cname;
-    const char *child_name;
-    idx_t idx = NUM2ULL(cidx);
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    child_name = duckdb_struct_type_child_name(ctx->logical_type, idx);
-    if (child_name == NULL) {
-        rb_raise(eDuckDBError, "fail to get name of %llu child", (unsigned long long)idx);
-    }
-    cname = rb_str_new_cstr(child_name);
-    duckdb_free((void *)child_name);
-    return cname;
+    return string_at(self, cidx, duckdb_struct_type_child_name, "fail to get name of %llu child", 0);
 }
 
 /*
@@ -166,22 +181,21 @@ static VALUE logical_type_child_name_at(VALUE self, VALUE cidx) {
  *
  */
 static VALUE logical_type_child_type(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
     duckdb_type type_id;
     duckdb_logical_type child_logical_type;
+    duckdb_logical_type lt = logical_type_of(self);
     VALUE logical_type = Qnil;
 
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    type_id = duckdb_get_type_id(ctx->logical_type);
+    type_id = duckdb_get_type_id(lt);
 
     switch(type_id) {
         case DUCKDB_TYPE_LIST:
         case DUCKDB_TYPE_MAP:
-            child_logical_type = duckdb_list_type_child_type(ctx->logical_type);
+            child_logical_type = duckdb_list_type_child_type(lt);
             logical_type = rbduckdb_create_logical_type(child_logical_type);
             break;
         case DUCKDB_TYPE_ARRAY:
-            child_logical_type = duckdb_array_type_child_type(ctx->logical_type);
+            child_logical_type = duckdb_array_type_child_type(lt);
             logical_type = rbduckdb_create_logical_type(child_logical_type);
             break;
         default:
@@ -199,20 +213,7 @@ static VALUE logical_type_child_type(VALUE self) {
  *
  */
 static VALUE logical_type_child_type_at(VALUE self, VALUE cidx) {
-    rubyDuckDBLogicalType *ctx;
-    duckdb_logical_type struct_child_type;
-    idx_t idx = NUM2ULL(cidx);
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    struct_child_type = duckdb_struct_type_child_type(ctx->logical_type, idx);
-    if (struct_child_type == NULL) {
-        rb_raise(eDuckDBError,
-                 "Failed to get the struct child type at index %llu",
-                 (unsigned long long)idx);
-    }
-
-    return rbduckdb_create_logical_type(struct_child_type);
+    return logical_type_at(self, cidx, duckdb_struct_type_child_type, "Failed to get the struct child type at index %llu");
 }
 
 /*
@@ -223,9 +224,7 @@ static VALUE logical_type_child_type_at(VALUE self, VALUE cidx) {
  *
  */
 static VALUE logical_type_size(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_array_type_array_size(ctx->logical_type));
+    return INT2FIX(duckdb_array_type_array_size(logical_type_of(self)));
 }
 
 /*
@@ -236,14 +235,7 @@ static VALUE logical_type_size(VALUE self) {
  *
  */
 static VALUE logical_type_key_type(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    duckdb_logical_type key_logical_type;
-    VALUE logical_type = Qnil;
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    key_logical_type = duckdb_map_type_key_type(ctx->logical_type);
-    logical_type = rbduckdb_create_logical_type(key_logical_type);
-    return logical_type;
+    return wrapped_logical_type(self, duckdb_map_type_key_type);
 }
 
 /*
@@ -254,14 +246,7 @@ static VALUE logical_type_key_type(VALUE self) {
  *
  */
 static VALUE logical_type_value_type(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    duckdb_logical_type value_logical_type;
-    VALUE logical_type = Qnil;
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    value_logical_type = duckdb_map_type_value_type(ctx->logical_type);
-    logical_type = rbduckdb_create_logical_type(value_logical_type);
-    return logical_type;
+    return wrapped_logical_type(self, duckdb_map_type_value_type);
 }
 
 /*
@@ -272,9 +257,7 @@ static VALUE logical_type_value_type(VALUE self) {
  *
  */
 static VALUE logical_type_member_count(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_union_type_member_count(ctx->logical_type));
+    return INT2FIX(duckdb_union_type_member_count(logical_type_of(self)));
 }
 
 /*
@@ -285,20 +268,7 @@ static VALUE logical_type_member_count(VALUE self) {
  *
  */
 static VALUE logical_type_member_name_at(VALUE self, VALUE midx) {
-    rubyDuckDBLogicalType *ctx;
-    VALUE mname;
-    const char *member_name;
-    idx_t idx = NUM2ULL(midx);
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    member_name = duckdb_union_type_member_name(ctx->logical_type, idx);
-    if (member_name == NULL) {
-        rb_raise(eDuckDBError, "fail to get name of %llu member", (unsigned long long)idx);
-    }
-    mname = rb_str_new_cstr(member_name);
-    duckdb_free((void *)member_name);
-    return mname;
+    return string_at(self, midx, duckdb_union_type_member_name, "fail to get name of %llu member", 0);
 }
 
 /*
@@ -310,20 +280,7 @@ static VALUE logical_type_member_name_at(VALUE self, VALUE midx) {
  *
  */
 static VALUE logical_type_member_type_at(VALUE self, VALUE midx) {
-    rubyDuckDBLogicalType *ctx;
-    duckdb_logical_type union_member_type;
-    idx_t idx = NUM2ULL(midx);
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    union_member_type = duckdb_union_type_member_type(ctx->logical_type, idx);
-    if (union_member_type == NULL) {
-        rb_raise(eDuckDBError,
-                 "Failed to get the union member type at index %llu",
-                 (unsigned long long)idx);
-    }
-
-    return rbduckdb_create_logical_type(union_member_type);
+    return logical_type_at(self, midx, duckdb_union_type_member_type, "Failed to get the union member type at index %llu");
 }
 
 /*
@@ -334,19 +291,17 @@ static VALUE logical_type_member_type_at(VALUE self, VALUE midx) {
  *
  */
 static VALUE logical_type__internal_type(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
     duckdb_type type_id;
     duckdb_type internal_type_id;
+    duckdb_logical_type lt = logical_type_of(self);
 
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    type_id = duckdb_get_type_id(ctx->logical_type);
+    type_id = duckdb_get_type_id(lt);
     switch (type_id) {
         case DUCKDB_TYPE_DECIMAL:
-            internal_type_id = duckdb_decimal_internal_type(ctx->logical_type);
+            internal_type_id = duckdb_decimal_internal_type(lt);
             break;
         case DUCKDB_TYPE_ENUM:
-            internal_type_id = duckdb_enum_internal_type(ctx->logical_type);
+            internal_type_id = duckdb_enum_internal_type(lt);
             break;
         default:
             internal_type_id = DUCKDB_TYPE_INVALID;
@@ -363,9 +318,7 @@ static VALUE logical_type__internal_type(VALUE self) {
  *
  */
 static VALUE logical_type_dictionary_size(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    return INT2FIX(duckdb_enum_dictionary_size(ctx->logical_type));
+    return INT2FIX(duckdb_enum_dictionary_size(logical_type_of(self)));
 }
 
 /*
@@ -376,20 +329,7 @@ static VALUE logical_type_dictionary_size(VALUE self) {
  *
  */
 static VALUE logical_type_dictionary_value_at(VALUE self, VALUE didx) {
-    rubyDuckDBLogicalType *ctx;
-    VALUE dvalue;
-    const char *dict_value;
-    idx_t idx = NUM2ULL(didx);
-
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    dict_value = duckdb_enum_dictionary_value(ctx->logical_type, idx);
-    if (dict_value == NULL) {
-        rb_raise(eDuckDBError, "fail to get dictionary value of %llu", (unsigned long long)idx);
-    }
-    dvalue = rb_utf8_str_new_cstr(dict_value);
-    duckdb_free((void *)dict_value);
-    return dvalue;
+    return string_at(self, didx, duckdb_enum_dictionary_value, "fail to get dictionary value of %llu", 1);
 }
 
 /*
@@ -400,13 +340,10 @@ static VALUE logical_type_dictionary_value_at(VALUE self, VALUE didx) {
  *
  */
 static VALUE logical_type_get_alias(VALUE self) {
-    rubyDuckDBLogicalType *ctx;
     VALUE alias = Qnil;
     const char *_alias;
 
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-
-    _alias = duckdb_logical_type_get_alias(ctx->logical_type);
+    _alias = duckdb_logical_type_get_alias(logical_type_of(self));
     if (_alias != NULL) {
         alias = rb_utf8_str_new_cstr(_alias);
     }
@@ -422,12 +359,10 @@ static VALUE logical_type_get_alias(VALUE self) {
  *
  */
 static VALUE logical_type_set_alias(VALUE self, VALUE aname) {
-    rubyDuckDBLogicalType *ctx;
     VALUE alias = Qnil;
     const char *_alias = StringValuePtr(aname);
 
-    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
-    duckdb_logical_type_set_alias(ctx->logical_type, _alias);
+    duckdb_logical_type_set_alias(logical_type_of(self), _alias);
     if (_alias != NULL) {
         alias = rb_utf8_str_new_cstr(_alias);
     }
@@ -473,20 +408,27 @@ static VALUE logical_type_s__create_map_type(VALUE klass, VALUE key, VALUE value
     return rbduckdb_create_logical_type(new_type);
 }
 
-/* :nodoc: */
-static VALUE logical_type_s__create_union_type(VALUE klass, VALUE members) {
-    idx_t member_size = RHASH_SIZE(members);
+typedef duckdb_logical_type (*create_members_type_fn)(duckdb_logical_type *types, const char **names, idx_t count);
+
+static VALUE create_members_type(VALUE members, create_members_type_fn create_fn, const char *type_name) {
+    idx_t member_size;
     duckdb_logical_type *member_types = NULL;
     const char **member_names = NULL;
     duckdb_logical_type new_type;
+    VALUE types_buf;
+    VALUE names_buf;
     VALUE keys;
 
+    Check_Type(members, T_HASH);
+    member_size = RHASH_SIZE(members);
+
     if (member_size == 0) {
         rb_raise(rb_eArgError, "members hash must not be empty");
     }
 
-    member_types = (duckdb_logical_type *)xcalloc(member_size, sizeof(duckdb_logical_type));
-    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
+    /* GC-managed buffers are released even if reading a member raises. */
+    member_types = ALLOCV_N(duckdb_logical_type, types_buf, member_size);
+    member_names = ALLOCV_N(const char *, names_buf, member_size);
 
     keys = rb_funcall(members, rb_intern("keys"), 0);
 
@@ -499,54 +441,28 @@ static VALUE logical_type_s__create_union_type(VALUE klass, VALUE members) {
         member_types[i] = type_ctx->logical_type;
     }
 
-    new_type = duckdb_create_union_type(member_types, member_names, member_size);
+    new_type = create_fn(member_types, member_names, member_size);
 
-    xfree(member_types);
-    xfree(member_names);
+    RB_GC_GUARD(members);
+    RB_GC_GUARD(keys);
+    ALLOCV_END(types_buf);
+    ALLOCV_END(names_buf);
 
     if (!new_type) {
-        rb_raise(eDuckDBError, "Failed to create union type");
+        rb_raise(eDuckDBError, "Failed to create %s type", type_name);
     }
 
     return rbduckdb_create_logical_type(new_type);
 }
 
 /* :nodoc: */
-static VALUE logical_type_s__create_struct_type(VALUE klass, VALUE members) {
-    idx_t member_size = RHASH_SIZE(members);
-    duckdb_logical_type *member_types = NULL;
-    const char **member_names = NULL;
-    duckdb_logical_type new_type;
-    VALUE keys;
-
-    if (member_size == 0) {
-        rb_raise(rb_eArgError, "members hash must not be empty");
-    }
-
-    member_types = (duckdb_logical_type *)xcalloc(member_size, sizeof(duckdb_logical_type));
-    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
-
-    keys = rb_funcall(members, rb_intern("keys"), 0);
-
-    for (idx_t i = 0; i < member_size; i++) {
-        VALUE key = rb_ary_entry(keys, (long)i);
-        VALUE val = rb_hash_aref(members, key);
-        rubyDuckDBLogicalType *type_ctx = rbduckdb_get_struct_logical_type(val);
-
-        member_names[i] = rb_id2name(SYM2ID(key));
-        member_types[i] = type_ctx->logical_type;
-    }
-
-    new_type = duckdb_create_struct_type(member_types, member_names, member_size);
-
-    xfree(member_types);
-    xfree(member_names);
-
-    if (!new_type) {
-        rb_raise(eDuckDBError, "Failed to create struct type");
-    }
+static VALUE logical_type_s__create_union_type(VALUE klass, VALUE members) {
+    return create_members_type(members, duckdb_create_union_type, "union");
+}
 
-    return rbduckdb_create_logical_type(new_type);
+/* :nodoc: */
+static VALUE logical_type_s__create_struct_type(VALUE klass, VALUE members) {
+    return create_members_type(members, duckdb_create_struct_type, "struct");
 }
 
 /* :nodoc: */
@@ -554,12 +470,13 @@ static VALUE logical_type_s__create_enum_type(VALUE klass, VALUE members) {
     idx_t member_size = RARRAY_LEN(members);
     const char **member_names = NULL;
     duckdb_logical_type new_type;
+    VALUE names_buf;
 
     if (member_size == 0) {
         rb_raise(rb_eArgError, "members must not be empty");
     }
 
-    member_names = (const char **)xcalloc(member_size, sizeof(const char *));
+    member_names = ALLOCV_N(const char *, names_buf, member_size);
 
     for (idx_t i = 0; i < member_size; i++) {
         VALUE val = rb_ary_entry(members, (long)i);
@@ -568,7 +485,8 @@ static VALUE logical_type_s__create_enum_type(VALUE klass, VALUE members) {
 
     new_type = duckdb_create_enum_type(member_names, member_size);
 
-    xfree(member_names);
+    RB_GC_GUARD(members);
+    ALLOCV_END(names_buf);
 
     if (!new_type) {
         rb_raise(eDuckDBError, "Failed to create enum type");