Class: Nanoarrow::CSchemaBuilder

Inherits:
Object
  • Object
show all
Defined in:
ext/nanoarrow/schema_builder.c

Instance Method Summary collapse

Instance Method Details

#allocate_children(n) ⇒ Object 



186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'ext/nanoarrow/schema_builder.c', line 186

static VALUE schema_builder_allocate_children(VALUE self, VALUE n)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code = ArrowSchemaAllocateChildren(builder->ptr, NUM2LL(n));
    raise_error_not_ok("ArrowSchemaAllocateChildren()", code);

    return self;
}

#append_metadata(metadata) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'ext/nanoarrow/schema_builder.c', line 69

static VALUE schema_builder_append_metadata(VALUE self, VALUE metadata)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    Check_Type(metadata, T_HASH);

    if (RHASH_SIZE(metadata) > 0)
    {
        VALUE buffer = rb_funcall(cCBuffer, rb_intern("empty"), 0);
        buffer_t* buffer_ptr;
        GetBuffer(buffer, buffer_ptr);

        schema_t* c_schema;
        GetSchema(builder->c_schema, c_schema);

        const char* existing_metadata = c_schema->ptr->metadata;
        int code = ArrowMetadataBuilderInit(buffer_ptr->ptr, existing_metadata);
        raise_error_not_ok("ArrowMetadataBuilderInit()", code);

        rb_hash_foreach(metadata, foreach_metadata, buffer);

        code = ArrowSchemaSetMetadata(c_schema->ptr, (const char*) buffer_ptr->ptr->data);
        raise_error_not_ok("ArrowSchemaSetMetadata()", code);
    }

    return self;
}

#finish ⇒ Object 



311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'ext/nanoarrow/schema_builder.c', line 311

static VALUE schema_builder_finish(VALUE self)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    VALUE out = rb_funcall(cCSchema, rb_intern("allocate"), 0);

    schema_t* c_schema_ptr;
    GetSchema(builder->c_schema, c_schema_ptr);

    schema_t* out_ptr;
    GetSchema(out, out_ptr);

    ArrowSchemaMove(c_schema_ptr->ptr, out_ptr->ptr);
    ArrowSchemaInit(c_schema_ptr->ptr);
    return out;
}

#set_child(idx, name, child_src) ⇒ Object 



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'ext/nanoarrow/schema_builder.c', line 199

static VALUE schema_builder_set_child(VALUE self, VALUE idx, VALUE name, VALUE child_src)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int64_t i = NUM2LL(idx);
    if (i < 0 || i >= builder->ptr->n_children)
        rb_raise(rb_eIndexError, "Index out of range");

    if (builder->ptr->children[i]->release != NULL)
        ArrowSchemaRelease(builder->ptr->children[i]);

    schema_t* child_src_ptr;
    GetSchema(child_src, child_src_ptr);

    int code = ArrowSchemaDeepCopy(child_src_ptr->ptr, builder->ptr->children[i]);
    raise_error_not_ok("ArrowSchemaDeepCopy()", code);

    if (!NIL_P(name))
    {
        Check_Type(name, T_STRING);
        code = ArrowSchemaSetName(builder->ptr->children[i], StringValueCStr(name));
        raise_error_not_ok("ArrowSchemaSetName()", code);
    }

    return self;
}

#set_dictionary(dictionary) ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'ext/nanoarrow/schema_builder.c', line 229

static VALUE schema_builder_set_dictionary(VALUE self, VALUE dictionary)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code;
    if (builder->ptr->dictionary == NULL)
    {
        code = ArrowSchemaAllocateDictionary(builder->ptr);
        raise_error_not_ok("ArrowSchemaAllocateDictionary()", code);
    }

    if (builder->ptr->dictionary->release != NULL)
        ArrowSchemaRelease(builder->ptr->dictionary);

    schema_t* dictionary_ptr;
    GetSchema(dictionary, dictionary_ptr);

    code = ArrowSchemaDeepCopy(dictionary_ptr->ptr, builder->ptr->dictionary);
    raise_error_not_ok("ArrowSchemaDeepCopy()", code);

    return self;
}

#set_dictionary_ordered(dictionary_ordered) ⇒ Object 



277
278
279
280
281
282
283
284
285
286
287
288
 
# File 'ext/nanoarrow/schema_builder.c', line 277

static VALUE schema_builder_set_dictionary_ordered(VALUE self, VALUE dictionary_ordered)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    if (RTEST(dictionary_ordered))
        builder->ptr->flags |= ARROW_FLAG_DICTIONARY_ORDERED;
    else
        builder->ptr->flags &= ~ARROW_FLAG_DICTIONARY_ORDERED;

    return self;
}

#set_flags(flags) ⇒ Object 



255
256
257
258
259
260
261
262
 
# File 'ext/nanoarrow/schema_builder.c', line 255

static VALUE schema_builder_set_flags(VALUE self, VALUE flags)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    builder->ptr->flags = NUM2LL(flags);
    return self;
}

#set_format(format) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'ext/nanoarrow/schema_builder.c', line 155

static VALUE schema_builder_set_format(VALUE self, VALUE format)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code = ArrowSchemaSetFormat(builder->ptr, StringValueCStr(format));
    raise_error_not_ok("ArrowSchemaSetFormat()", code);

    return self;
}

#set_map_keys_sorted(map_keys_sorted) ⇒ Object 



290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'ext/nanoarrow/schema_builder.c', line 290

static VALUE schema_builder_set_map_keys_sorted(VALUE self, VALUE map_keys_sorted)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    if (RTEST(map_keys_sorted))
        builder->ptr->flags |= ARROW_FLAG_MAP_KEYS_SORTED;
    else
        builder->ptr->flags &= ~ARROW_FLAG_MAP_KEYS_SORTED;

    return self;
}

#set_name(name) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'ext/nanoarrow/schema_builder.c', line 168

static VALUE schema_builder_set_name(VALUE self, VALUE name)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code;
    if (NIL_P(name))
        code = ArrowSchemaSetName(builder->ptr, NULL);
    else
        code = ArrowSchemaSetName(builder->ptr, StringValueCStr(name));

    raise_error_not_ok("ArrowSchemaSetName()", code);

    return self;
}

#set_nullable(nullable) ⇒ Object 



264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'ext/nanoarrow/schema_builder.c', line 264

static VALUE schema_builder_set_nullable(VALUE self, VALUE nullable)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    if (RTEST(nullable))
        builder->ptr->flags |= ARROW_FLAG_NULLABLE;
    else
        builder->ptr->flags &= ~ARROW_FLAG_NULLABLE;

    return self;
}

#set_type(type_id) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'ext/nanoarrow/schema_builder.c', line 98

static VALUE schema_builder_set_type(VALUE self, VALUE type_id)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code = ArrowSchemaSetType(builder->ptr, NUM2INT(type_id));
    raise_error_not_ok("ArrowSchemaSetType()", code);

    return self;
}

#set_type_date_time(type_id, time_unit, timezone) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'ext/nanoarrow/schema_builder.c', line 137

static VALUE schema_builder_set_type_date_time(VALUE self, VALUE type_id, VALUE time_unit, VALUE timezone)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code;
    if (NIL_P(timezone))
        code = ArrowSchemaSetTypeDateTime(builder->ptr, NUM2INT(type_id), NUM2INT(time_unit), NULL);
    else
        code = ArrowSchemaSetTypeDateTime(builder->ptr, NUM2INT(type_id), NUM2INT(time_unit), StringValueCStr(timezone));

    raise_error_not_ok("ArrowSchemaSetTypeDateTime()", code);

    return self;
}

#set_type_decimal(type_id, precision, scale) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'ext/nanoarrow/schema_builder.c', line 111

static VALUE schema_builder_set_type_decimal(VALUE self, VALUE type_id, VALUE precision, VALUE scale)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code = ArrowSchemaSetTypeDecimal(builder->ptr, NUM2INT(type_id), NUM2INT(precision), NUM2INT(scale));
    raise_error_not_ok("ArrowSchemaSetTypeDecimal()", code);

    return self;
}

#set_type_fixed_size(type_id, fixed_size) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'ext/nanoarrow/schema_builder.c', line 124

static VALUE schema_builder_set_type_fixed_size(VALUE self, VALUE type_id, VALUE fixed_size)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    schema_assert_valid(builder->c_schema);

    int code = ArrowSchemaSetTypeFixedSize(builder->ptr, NUM2INT(type_id), NUM2INT(fixed_size));
    raise_error_not_ok("ArrowSchemaSetTypeFixedSize()", code);

    return self;
}

#validate ⇒ Object 



303
304
305
306
307
308
309
 
# File 'ext/nanoarrow/schema_builder.c', line 303

static VALUE schema_builder_validate(VALUE self)
{
    schema_builder_t* builder;
    GetSchemaBuilder(self, builder);

    return rb_funcall(cCSchemaView, rb_intern("new"), 1, builder->c_schema);
}