| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include <config.h> |
| #endif |
| |
| #include <arrow-glib/array.hpp> |
| #include <arrow-glib/buffer.hpp> |
| #include <arrow-glib/compute.hpp> |
| #include <arrow-glib/data-type.hpp> |
| #include <arrow-glib/error.hpp> |
| #include <arrow-glib/type.hpp> |
| |
| G_BEGIN_DECLS |
| |
| /** |
| * SECTION: composite-array |
| * @section_id: composite-array-classes |
| * @title: Composite array classes |
| * @include: arrow-glib/arrow-glib.h |
| * |
| * #GArrowListArray is a class for list array. It can store zero or |
| * more list data. If you don't have Arrow format data, you need to |
| * use #GArrowListArrayBuilder to create a new array. |
| * |
| * #GArrowLargeListArray is a class for 64-bit offsets list array. |
| * It can store zero or more list data. If you don't have Arrow format data, |
| * you need to use #GArrowLargeListArrayBuilder to create a new array. |
| * |
| * #GArrowStructArray is a class for struct array. It can store zero |
| * or more structs. One struct has one or more fields. If you don't |
| * have Arrow format data, you need to use #GArrowStructArrayBuilder |
| * to create a new array. |
| * |
| * #GArrowMapArray is a class for map array. It can store |
| * data with keys and items. |
| * |
| * #GArrowUnionArray is a base class for union array. It can store |
| * zero or more unions. One union has one or more fields but one union |
| * can store only one field value. |
| * |
| * #GArrowDenseUnionArray is a class for dense union array. |
| * |
| * #GArrowSparseUnionArray is a class for sparse union array. |
| * |
| * #GArrowDictionaryArray is a class for dictionary array. It can |
| * store data with dictionary and indices. It's space effective than |
| * normal array when the array has many same values. You can convert a |
| * normal array to dictionary array by garrow_array_dictionary_encode(). |
| */ |
| |
| typedef struct GArrowListArrayPrivate_ { |
| GArrowArray *raw_values; |
| } GArrowListArrayPrivate; |
| |
| enum { |
| PROP_RAW_VALUES = 1, |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowListArray, |
| garrow_list_array, |
| GARROW_TYPE_ARRAY) |
| |
| #define GARROW_LIST_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowListArrayPrivate *>( \ |
| garrow_list_array_get_instance_private( \ |
| GARROW_LIST_ARRAY(obj))) |
| |
| G_END_DECLS |
| template <typename LIST_ARRAY_CLASS> |
| GArrowArray * |
| garrow_base_list_array_new(GArrowDataType *data_type, |
| gint64 length, |
| GArrowBuffer *value_offsets, |
| GArrowArray *values, |
| GArrowBuffer *null_bitmap, |
| gint64 n_nulls) |
| { |
| const auto arrow_data_type = garrow_data_type_get_raw(data_type); |
| const auto arrow_value_offsets = garrow_buffer_get_raw(value_offsets); |
| const auto arrow_values = garrow_array_get_raw(values); |
| const auto arrow_null_bitmap = garrow_buffer_get_raw(null_bitmap); |
| auto arrow_list_array = |
| std::make_shared<LIST_ARRAY_CLASS>(arrow_data_type, |
| length, |
| arrow_value_offsets, |
| arrow_values, |
| arrow_null_bitmap, |
| n_nulls); |
| auto arrow_array = |
| std::static_pointer_cast<arrow::Array>(arrow_list_array); |
| return garrow_array_new_raw(&arrow_array, |
| "array", &arrow_array, |
| "value-data-type", data_type, |
| "null-bitmap", null_bitmap, |
| "buffer1", value_offsets, |
| "raw-values", values, |
| NULL); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| GArrowDataType * |
| garrow_base_list_array_get_value_type(GArrowArray *array) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| auto arrow_value_type = arrow_list_array->value_type(); |
| return garrow_data_type_new_raw(&arrow_value_type); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| GArrowArray * |
| garrow_base_list_array_get_value(GArrowArray *array, |
| gint64 i) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| auto arrow_list = arrow_list_array->value_slice(i); |
| return garrow_array_new_raw(&arrow_list, |
| "array", &arrow_list, |
| "parent", array, |
| NULL); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| GArrowArray * |
| garrow_base_list_array_get_values(GArrowArray *array) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| auto arrow_values = arrow_list_array->values(); |
| return garrow_array_new_raw(&arrow_values, |
| "array", &arrow_values, |
| "parent", array, |
| NULL); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| typename LIST_ARRAY_CLASS::offset_type |
| garrow_base_list_array_get_value_offset(GArrowArray *array, gint64 i) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| return arrow_list_array->value_offset(i); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| typename LIST_ARRAY_CLASS::offset_type |
| garrow_base_list_array_get_value_length(GArrowArray *array, gint64 i) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| return arrow_list_array->value_length(i); |
| }; |
| |
| template <typename LIST_ARRAY_CLASS> |
| const typename LIST_ARRAY_CLASS::offset_type * |
| garrow_base_list_array_get_value_offsets(GArrowArray *array, gint64 *n_offsets) |
| { |
| auto arrow_array = garrow_array_get_raw(array); |
| *n_offsets = arrow_array->length() + 1; |
| auto arrow_list_array = |
| std::static_pointer_cast<LIST_ARRAY_CLASS>(arrow_array); |
| return arrow_list_array->raw_value_offsets(); |
| }; |
| |
| |
| G_BEGIN_DECLS |
| |
| static void |
| garrow_list_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_LIST_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->raw_values) { |
| g_object_unref(priv->raw_values); |
| priv->raw_values = NULL; |
| } |
| |
| |
| G_OBJECT_CLASS(garrow_list_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_list_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_LIST_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_RAW_VALUES: |
| priv->raw_values = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_list_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_LIST_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_RAW_VALUES: |
| g_value_set_object(value, priv->raw_values); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_list_array_init(GArrowListArray *object) |
| { |
| } |
| |
| static void |
| garrow_list_array_class_init(GArrowListArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_list_array_dispose; |
| gobject_class->set_property = garrow_list_array_set_property; |
| gobject_class->get_property = garrow_list_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("raw-values", |
| "Raw values", |
| "The raw values", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_RAW_VALUES, spec); |
| } |
| |
| /** |
| * garrow_list_array_new: |
| * @data_type: The data type of the list. |
| * @length: The number of elements. |
| * @value_offsets: The offsets of @values in Arrow format. |
| * @values: The values as #GArrowArray. |
| * @null_bitmap: (nullable): The bitmap that shows null elements. The |
| * N-th element is null when the N-th bit is 0, not null otherwise. |
| * If the array has no null elements, the bitmap must be %NULL and |
| * @n_nulls is 0. |
| * @n_nulls: The number of null elements. If -1 is specified, the |
| * number of nulls are computed from @null_bitmap. |
| * |
| * Returns: A newly created #GArrowListArray. |
| * |
| * Since: 0.4.0 |
| */ |
| GArrowListArray * |
| garrow_list_array_new(GArrowDataType *data_type, |
| gint64 length, |
| GArrowBuffer *value_offsets, |
| GArrowArray *values, |
| GArrowBuffer *null_bitmap, |
| gint64 n_nulls) |
| { |
| auto list_array = garrow_base_list_array_new<arrow::ListArray>( |
| data_type, |
| length, |
| value_offsets, |
| values, |
| null_bitmap, |
| n_nulls); |
| return GARROW_LIST_ARRAY(list_array); |
| } |
| |
| /** |
| * garrow_list_array_get_value_type: |
| * @array: A #GArrowListArray. |
| * |
| * Returns: (transfer full): The data type of value in each list. |
| */ |
| GArrowDataType * |
| garrow_list_array_get_value_type(GArrowListArray *array) |
| { |
| return garrow_base_list_array_get_value_type<arrow::ListArray>( |
| GARROW_ARRAY(array)); |
| } |
| |
| /** |
| * garrow_list_array_get_value: |
| * @array: A #GArrowListArray. |
| * @i: The index of the target value. |
| * |
| * Returns: (transfer full): The i-th list. |
| */ |
| GArrowArray * |
| garrow_list_array_get_value(GArrowListArray *array, |
| gint64 i) |
| { |
| return garrow_base_list_array_get_value<arrow::ListArray>( |
| GARROW_ARRAY(array), i); |
| } |
| |
| /** |
| * garrow_list_array_get_values: |
| * @array: A #GArrowListArray. |
| * |
| * Returns: (transfer full): The array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| GArrowArray * |
| garrow_list_array_get_values(GArrowListArray *array) |
| { |
| return garrow_base_list_array_get_values<arrow::ListArray>( |
| GARROW_ARRAY(array)); |
| } |
| |
| /** |
| * garrow_list_array_get_offset: |
| * @array: A #GArrowListArray. |
| * @i: The index of the offset of the target value. |
| * |
| * Returns: The target offset in the array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| gint32 |
| garrow_list_array_get_value_offset(GArrowListArray *array, gint64 i) |
| { |
| return garrow_base_list_array_get_value_offset<arrow::ListArray>( |
| GARROW_ARRAY(array), i); |
| } |
| |
| /** |
| * garrow_list_array_get_value_length: |
| * @array: A #GArrowListArray. |
| * @i: The index of the length of the target value. |
| * |
| * Returns: The target length in the array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| gint32 |
| garrow_list_array_get_value_length(GArrowListArray *array, gint64 i) |
| { |
| return garrow_base_list_array_get_value_length<arrow::ListArray>( |
| GARROW_ARRAY(array), i); |
| } |
| |
| /** |
| * garrow_list_array_get_value_offsets: |
| * @array: A #GArrowListArray. |
| * @n_offsets: The number of offsets to be returned. |
| * |
| * Returns: (array length=n_offsets): The target offsets in the array |
| * containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| const gint32 * |
| garrow_list_array_get_value_offsets(GArrowListArray *array, gint64 *n_offsets) |
| { |
| return garrow_base_list_array_get_value_offsets<arrow::ListArray>( |
| GARROW_ARRAY(array), n_offsets); |
| } |
| |
| |
| typedef struct GArrowLargeListArrayPrivate_ { |
| GArrowArray *raw_values; |
| } GArrowLargeListArrayPrivate; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowLargeListArray, |
| garrow_large_list_array, |
| GARROW_TYPE_ARRAY) |
| |
| #define GARROW_LARGE_LIST_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowLargeListArrayPrivate *>( \ |
| garrow_large_list_array_get_instance_private( \ |
| GARROW_LARGE_LIST_ARRAY(obj))) |
| |
| static void |
| garrow_large_list_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_LARGE_LIST_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->raw_values) { |
| g_object_unref(priv->raw_values); |
| priv->raw_values = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_large_list_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_large_list_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_LARGE_LIST_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_RAW_VALUES: |
| priv->raw_values = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_large_list_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_LARGE_LIST_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_RAW_VALUES: |
| g_value_set_object(value, priv->raw_values); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_large_list_array_init(GArrowLargeListArray *object) |
| { |
| } |
| |
| static void |
| garrow_large_list_array_class_init(GArrowLargeListArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_large_list_array_dispose; |
| gobject_class->set_property = garrow_large_list_array_set_property; |
| gobject_class->get_property = garrow_large_list_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("raw-values", |
| "Raw values", |
| "The raw values", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_RAW_VALUES, spec); |
| } |
| |
| /** |
| * garrow_large_list_array_new: |
| * @data_type: The data type of the list. |
| * @length: The number of elements. |
| * @value_offsets: The offsets of @values in Arrow format. |
| * @values: The values as #GArrowArray. |
| * @null_bitmap: (nullable): The bitmap that shows null elements. The |
| * N-th element is null when the N-th bit is 0, not null otherwise. |
| * If the array has no null elements, the bitmap must be %NULL and |
| * @n_nulls is 0. |
| * @n_nulls: The number of null elements. If -1 is specified, the |
| * number of nulls are computed from @null_bitmap. |
| * |
| * Returns: A newly created #GArrowLargeListArray. |
| * |
| * Since: 0.16.0 |
| */ |
| GArrowLargeListArray * |
| garrow_large_list_array_new(GArrowDataType *data_type, |
| gint64 length, |
| GArrowBuffer *value_offsets, |
| GArrowArray *values, |
| GArrowBuffer *null_bitmap, |
| gint64 n_nulls) |
| { |
| auto large_list_array = garrow_base_list_array_new<arrow::LargeListArray>( |
| data_type, |
| length, |
| value_offsets, |
| values, |
| null_bitmap, |
| n_nulls); |
| return GARROW_LARGE_LIST_ARRAY(large_list_array); |
| } |
| |
| /** |
| * garrow_large_list_array_get_value_type: |
| * @array: A #GArrowLargeListArray. |
| * |
| * Returns: (transfer full): The data type of value in each list. |
| * |
| * Since: 0.16.0 |
| */ |
| GArrowDataType * |
| garrow_large_list_array_get_value_type(GArrowLargeListArray *array) |
| { |
| return garrow_base_list_array_get_value_type<arrow::LargeListArray>( |
| GARROW_ARRAY(array)); |
| } |
| |
| /** |
| * garrow_large_list_array_get_value: |
| * @array: A #GArrowLargeListArray. |
| * @i: The index of the target value. |
| * |
| * Returns: (transfer full): The @i-th list. |
| * |
| * Since: 0.16.0 |
| */ |
| GArrowArray * |
| garrow_large_list_array_get_value(GArrowLargeListArray *array, |
| gint64 i) |
| { |
| return garrow_base_list_array_get_value<arrow::LargeListArray>( |
| GARROW_ARRAY(array), |
| i); |
| } |
| |
| /** |
| * garrow_large_list_array_get_values: |
| * @array: A #GArrowLargeListArray. |
| * |
| * Returns: (transfer full): The array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| GArrowArray * |
| garrow_large_list_array_get_values(GArrowLargeListArray *array) |
| { |
| return garrow_base_list_array_get_values<arrow::LargeListArray>( |
| GARROW_ARRAY(array)); |
| } |
| |
| /** |
| * garrow_large_list_array_get_value_offset: |
| * @array: A #GArrowLargeListArray. |
| * @i: The index of the offset of the target value. |
| * |
| * Returns: The target offset in the array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| gint64 |
| garrow_large_list_array_get_value_offset(GArrowLargeListArray *array, gint64 i) |
| { |
| return garrow_base_list_array_get_value_offset<arrow::LargeListArray>( |
| GARROW_ARRAY(array), i); |
| } |
| |
| /** |
| * garrow_large_list_array_get_length: |
| * @array: A #GArrowLargeListArray. |
| * @i: The index of the length of the target value. |
| * |
| * Returns: The target length in the array containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| gint64 |
| garrow_large_list_array_get_value_length(GArrowLargeListArray *array, gint64 i) |
| { |
| return garrow_base_list_array_get_value_length<arrow::LargeListArray>( |
| GARROW_ARRAY(array), i); |
| } |
| |
| /** |
| * garrow_large_list_array_get_value_offsets: |
| * @array: A #GArrowLargeListArray. |
| * @n_offsets: The number of offsets to be returned. |
| * |
| * Returns: (array length=n_offsets): The target offsets in the array |
| * containing the list's values. |
| * |
| * Since: 2.0.0 |
| */ |
| const gint64 * |
| garrow_large_list_array_get_value_offsets(GArrowLargeListArray *array, |
| gint64 *n_offsets) |
| { |
| return garrow_base_list_array_get_value_offsets<arrow::LargeListArray>( |
| GARROW_ARRAY(array), n_offsets); |
| } |
| |
| |
| typedef struct GArrowStructArrayPrivate_ { |
| GPtrArray *fields; |
| } GArrowStructArrayPrivate; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowStructArray, |
| garrow_struct_array, |
| GARROW_TYPE_ARRAY) |
| |
| #define GARROW_STRUCT_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowStructArrayPrivate *>( \ |
| garrow_struct_array_get_instance_private( \ |
| GARROW_STRUCT_ARRAY(obj))) |
| |
| static void |
| garrow_struct_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_STRUCT_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->fields) { |
| g_ptr_array_free(priv->fields, TRUE); |
| priv->fields = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_struct_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_struct_array_init(GArrowStructArray *object) |
| { |
| } |
| |
| static void |
| garrow_struct_array_class_init(GArrowStructArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| gobject_class->dispose = garrow_struct_array_dispose; |
| } |
| |
| /** |
| * garrow_struct_array_new: |
| * @data_type: The data type of the struct. |
| * @length: The number of elements. |
| * @fields: (element-type GArrowArray): The arrays for each field |
| * as #GList of #GArrowArray. |
| * @null_bitmap: (nullable): The bitmap that shows null elements. The |
| * N-th element is null when the N-th bit is 0, not null otherwise. |
| * If the array has no null elements, the bitmap must be %NULL and |
| * @n_nulls is 0. |
| * @n_nulls: The number of null elements. If -1 is specified, the |
| * number of nulls are computed from @null_bitmap. |
| * |
| * Returns: A newly created #GArrowStructArray. |
| * |
| * Since: 0.4.0 |
| */ |
| GArrowStructArray * |
| garrow_struct_array_new(GArrowDataType *data_type, |
| gint64 length, |
| GList *fields, |
| GArrowBuffer *null_bitmap, |
| gint64 n_nulls) |
| { |
| const auto arrow_data_type = garrow_data_type_get_raw(data_type); |
| std::vector<std::shared_ptr<arrow::Array>> arrow_fields; |
| for (auto node = fields; node; node = node->next) { |
| auto field = GARROW_ARRAY(node->data); |
| arrow_fields.push_back(garrow_array_get_raw(field)); |
| } |
| const auto arrow_null_bitmap = garrow_buffer_get_raw(null_bitmap); |
| auto arrow_struct_array = |
| std::make_shared<arrow::StructArray>(arrow_data_type, |
| length, |
| arrow_fields, |
| arrow_null_bitmap, |
| n_nulls); |
| auto arrow_array = |
| std::static_pointer_cast<arrow::Array>(arrow_struct_array); |
| auto struct_array = |
| garrow_array_new_raw(&arrow_array, |
| "array", &arrow_array, |
| "null-bitmap", null_bitmap, |
| NULL); |
| auto priv = GARROW_STRUCT_ARRAY_GET_PRIVATE(struct_array); |
| priv->fields = g_ptr_array_sized_new(arrow_fields.size()); |
| g_ptr_array_set_free_func(priv->fields, g_object_unref); |
| for (auto node = fields; node; node = node->next) { |
| auto field = GARROW_ARRAY(node->data); |
| g_ptr_array_add(priv->fields, g_object_ref(field)); |
| } |
| return GARROW_STRUCT_ARRAY(struct_array); |
| } |
| |
| static GPtrArray * |
| garrow_struct_array_get_fields_internal(GArrowStructArray *array) |
| { |
| auto priv = GARROW_STRUCT_ARRAY_GET_PRIVATE(array); |
| if (!priv->fields) { |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_struct_array = |
| std::static_pointer_cast<arrow::StructArray>(arrow_array); |
| auto arrow_fields = arrow_struct_array->fields(); |
| priv->fields = g_ptr_array_sized_new(arrow_fields.size()); |
| g_ptr_array_set_free_func(priv->fields, g_object_unref); |
| for (auto &arrow_field : arrow_fields) { |
| g_ptr_array_add(priv->fields, garrow_array_new_raw(&arrow_field)); |
| } |
| } |
| return priv->fields; |
| } |
| |
| /** |
| * garrow_struct_array_get_field |
| * @array: A #GArrowStructArray. |
| * @i: The index of the field in the struct. |
| * |
| * Returns: (transfer full): The i-th field. |
| */ |
| GArrowArray * |
| garrow_struct_array_get_field(GArrowStructArray *array, |
| gint i) |
| { |
| auto fields = garrow_struct_array_get_fields_internal(array); |
| if (i < 0) { |
| i += fields->len; |
| } |
| if (i < 0) { |
| return NULL; |
| } |
| if (i >= static_cast<gint>(fields->len)) { |
| return NULL; |
| } |
| auto field = static_cast<GArrowArray *>(g_ptr_array_index(fields, i)); |
| g_object_ref(field); |
| return field; |
| } |
| |
| /** |
| * garrow_struct_array_get_fields |
| * @array: A #GArrowStructArray. |
| * |
| * Returns: (element-type GArrowArray) (transfer full): |
| * The fields in the struct. |
| */ |
| GList * |
| garrow_struct_array_get_fields(GArrowStructArray *array) |
| { |
| auto fields = garrow_struct_array_get_fields_internal(array); |
| |
| GList *field_list = NULL; |
| for (guint i = 0; i < fields->len; ++i) { |
| auto field = static_cast<GArrowArray *>(g_ptr_array_index(fields, i)); |
| field_list = g_list_prepend(field_list, g_object_ref(field)); |
| } |
| return g_list_reverse(field_list); |
| } |
| |
| /** |
| * garrow_struct_array_flatten |
| * @array: A #GArrowStructArray. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (element-type GArrowArray) (transfer full): |
| * The fields in the struct. |
| * |
| * Since: 0.10.0 |
| */ |
| GList * |
| garrow_struct_array_flatten(GArrowStructArray *array, GError **error) |
| { |
| const auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_struct_array = |
| std::static_pointer_cast<arrow::StructArray>(arrow_array); |
| |
| auto memory_pool = arrow::default_memory_pool(); |
| auto arrow_arrays = arrow_struct_array->Flatten(memory_pool); |
| if (!garrow::check(error, arrow_arrays, "[struct-array][flatten]")) { |
| return NULL; |
| } |
| |
| GList *arrays = NULL; |
| for (auto arrow_array : *arrow_arrays) { |
| auto array = garrow_array_new_raw(&arrow_array); |
| arrays = g_list_prepend(arrays, array); |
| } |
| |
| return g_list_reverse(arrays); |
| } |
| |
| |
| typedef struct GArrowMapArrayPrivate_ { |
| GArrowArray *offsets; |
| GArrowArray *keys; |
| GArrowArray *items; |
| } GArrowMapArrayPrivate; |
| |
| enum { |
| PROP_OFFSETS = 1, |
| PROP_KEYS, |
| PROP_ITEMS, |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowMapArray, |
| garrow_map_array, |
| GARROW_TYPE_LIST_ARRAY) |
| |
| #define GARROW_MAP_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowMapArrayPrivate *>( \ |
| garrow_map_array_get_instance_private( \ |
| GARROW_MAP_ARRAY(obj))) |
| |
| static void |
| garrow_map_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_MAP_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->offsets) { |
| g_object_unref(priv->offsets); |
| priv->offsets = NULL; |
| } |
| |
| if (priv->keys) { |
| g_object_unref(priv->keys); |
| priv->keys = NULL; |
| } |
| |
| if (priv->items) { |
| g_object_unref(priv->items); |
| priv->items = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_map_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_map_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_MAP_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_OFFSETS: |
| priv->offsets = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| case PROP_KEYS: |
| priv->keys = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| case PROP_ITEMS: |
| priv->items = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_map_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_MAP_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_OFFSETS: |
| g_value_set_object(value, priv->offsets); |
| break; |
| case PROP_KEYS: |
| g_value_set_object(value, priv->keys); |
| break; |
| case PROP_ITEMS: |
| g_value_set_object(value, priv->items); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_map_array_init(GArrowMapArray *object) |
| { |
| } |
| |
| static void |
| garrow_map_array_class_init(GArrowMapArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_map_array_dispose; |
| gobject_class->set_property = garrow_map_array_set_property; |
| gobject_class->get_property = garrow_map_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("offsets", |
| "Offsets", |
| "The GArrowArray for offsets", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_OFFSETS, spec); |
| |
| spec = g_param_spec_object("keys", |
| "Keys", |
| "The GArrowArray for keys", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_KEYS, spec); |
| |
| spec = g_param_spec_object("items", |
| "Items", |
| "The GArrowArray for items", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_ITEMS, spec); |
| } |
| |
| /** |
| * garrow_map_array_new: |
| * @offsets: The offsets Array containing n + 1 offsets encoding length and size. |
| * @keys: The Array containing key values. |
| * @items: The items Array containing item values. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowMapArray |
| * or %NULL on error. |
| * |
| * Since: 0.17.0 |
| */ |
| GArrowMapArray * |
| garrow_map_array_new(GArrowArray *offsets, |
| GArrowArray *keys, |
| GArrowArray *items, |
| GError **error) |
| { |
| const auto arrow_offsets = garrow_array_get_raw(offsets); |
| const auto arrow_keys = garrow_array_get_raw(keys); |
| const auto arrow_items = garrow_array_get_raw(items); |
| auto arrow_memory_pool = arrow::default_memory_pool(); |
| auto arrow_array_result = arrow::MapArray::FromArrays(arrow_offsets, |
| arrow_keys, |
| arrow_items, |
| arrow_memory_pool); |
| if (garrow::check(error, arrow_array_result, "[map-array][new]")) { |
| auto arrow_array = *arrow_array_result; |
| return GARROW_MAP_ARRAY(garrow_array_new_raw(&arrow_array, |
| "array", &arrow_array, |
| "offsets", offsets, |
| "keys", keys, |
| "items", items, |
| NULL)); |
| } else { |
| return NULL; |
| } |
| } |
| |
| /** |
| * garrow_map_array_get_keys: |
| * @array: A #GArrowMapArray. |
| * |
| * Returns: (transfer full): The Array containing key values. |
| * |
| * Since: 0.17.0 |
| */ |
| GArrowArray * |
| garrow_map_array_get_keys(GArrowMapArray *array) |
| { |
| auto priv = GARROW_MAP_ARRAY_GET_PRIVATE(array); |
| if (priv->keys) { |
| g_object_ref(priv->keys); |
| return priv->keys; |
| } |
| |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_map_array = |
| std::static_pointer_cast<arrow::MapArray>(arrow_array); |
| auto arrow_keys = arrow_map_array->keys(); |
| return garrow_array_new_raw(&arrow_keys); |
| } |
| |
| /** |
| * garrow_map_array_get_items: |
| * @array: A #GArrowMapArray. |
| * |
| * Returns: (transfer full): The items Array containing item values. |
| * |
| * Since: 0.17.0 |
| */ |
| GArrowArray * |
| garrow_map_array_get_items(GArrowMapArray *array) |
| { |
| auto priv = GARROW_MAP_ARRAY_GET_PRIVATE(array); |
| if (priv->items) { |
| g_object_ref(priv->items); |
| return priv->items; |
| } |
| |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_map_array = |
| std::static_pointer_cast<arrow::MapArray>(arrow_array); |
| auto arrow_items = arrow_map_array->items(); |
| return garrow_array_new_raw(&arrow_items); |
| } |
| |
| |
| typedef struct GArrowUnionArrayPrivate_ { |
| GArrowInt8Array *type_ids; |
| GPtrArray *fields; |
| } GArrowUnionArrayPrivate; |
| |
| enum { |
| PROP_TYPE_IDS = 1, |
| PROP_FIELDS, |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowUnionArray, |
| garrow_union_array, |
| GARROW_TYPE_ARRAY) |
| |
| #define GARROW_UNION_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowUnionArrayPrivate *>( \ |
| garrow_union_array_get_instance_private( \ |
| GARROW_UNION_ARRAY(obj))) |
| |
| static void |
| garrow_union_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->type_ids) { |
| g_object_unref(priv->type_ids); |
| priv->type_ids = NULL; |
| } |
| |
| if (priv->fields) { |
| g_ptr_array_free(priv->fields, TRUE); |
| priv->fields = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_union_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_union_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_TYPE_IDS: |
| priv->type_ids = GARROW_INT8_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_union_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_TYPE_IDS: |
| g_value_set_object(value, priv->type_ids); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_union_array_init(GArrowUnionArray *object) |
| { |
| } |
| |
| static void |
| garrow_union_array_class_init(GArrowUnionArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_union_array_dispose; |
| gobject_class->set_property = garrow_union_array_set_property; |
| gobject_class->get_property = garrow_union_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("type-ids", |
| "Type IDs", |
| "The GArrowInt8Array for type IDs", |
| GARROW_TYPE_INT8_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_TYPE_IDS, spec); |
| } |
| |
| /** |
| * garrow_union_array_get_field |
| * @array: A #GArrowUnionArray. |
| * @i: The index of the field in the union. |
| * |
| * Returns: (nullable) (transfer full): The i-th field values as a |
| * #GArrowArray or %NULL on out of range. |
| */ |
| GArrowArray * |
| garrow_union_array_get_field(GArrowUnionArray *array, |
| gint i) |
| { |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(array); |
| if (!priv->fields) { |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_union_array = |
| std::static_pointer_cast<arrow::UnionArray>(arrow_array); |
| auto n_fields = arrow_union_array->num_fields(); |
| priv->fields = g_ptr_array_sized_new(n_fields); |
| g_ptr_array_set_free_func(priv->fields, g_object_unref); |
| for (int i = 0; i < n_fields; ++i) { |
| auto arrow_field = arrow_union_array->field(i); |
| g_ptr_array_add(priv->fields, garrow_array_new_raw(&arrow_field)); |
| } |
| } |
| |
| if (i < 0) { |
| i += priv->fields->len; |
| } |
| if (i < 0) { |
| return NULL; |
| } |
| if (i >= static_cast<gint>(priv->fields->len)) { |
| return NULL; |
| } |
| auto field = static_cast<GArrowArray *>(g_ptr_array_index(priv->fields, i)); |
| g_object_ref(field); |
| return field; |
| } |
| |
| |
| G_DEFINE_TYPE(GArrowSparseUnionArray, |
| garrow_sparse_union_array, |
| GARROW_TYPE_UNION_ARRAY) |
| |
| static void |
| garrow_sparse_union_array_init(GArrowSparseUnionArray *object) |
| { |
| } |
| |
| static void |
| garrow_sparse_union_array_class_init(GArrowSparseUnionArrayClass *klass) |
| { |
| } |
| |
| static GArrowSparseUnionArray * |
| garrow_sparse_union_array_new_internal(GArrowSparseUnionDataType *data_type, |
| GArrowInt8Array *type_ids, |
| GList *fields, |
| GError **error, |
| const char *context) |
| { |
| auto arrow_type_ids = garrow_array_get_raw(GARROW_ARRAY(type_ids)); |
| std::vector<std::shared_ptr<arrow::Array>> arrow_fields; |
| for (auto node = fields; node; node = node->next) { |
| auto *field = GARROW_ARRAY(node->data); |
| arrow_fields.push_back(garrow_array_get_raw(field)); |
| } |
| arrow::Result<std::shared_ptr<arrow::Array>> arrow_sparse_union_array_result; |
| if (data_type) { |
| auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type)); |
| auto arrow_union_data_type = |
| std::static_pointer_cast<arrow::UnionType>(arrow_data_type); |
| std::vector<std::string> arrow_field_names; |
| for (const auto &arrow_field : arrow_union_data_type->fields()) { |
| arrow_field_names.push_back(arrow_field->name()); |
| } |
| arrow_sparse_union_array_result = |
| arrow::SparseUnionArray::Make(*arrow_type_ids, |
| arrow_fields, |
| arrow_field_names, |
| arrow_union_data_type->type_codes()); |
| } else { |
| arrow_sparse_union_array_result = |
| arrow::SparseUnionArray::Make(*arrow_type_ids, arrow_fields); |
| } |
| if (garrow::check(error, |
| arrow_sparse_union_array_result, |
| context)) { |
| auto arrow_sparse_union_array = *arrow_sparse_union_array_result; |
| auto sparse_union_array = |
| garrow_array_new_raw(&arrow_sparse_union_array, |
| "array", &arrow_sparse_union_array, |
| "value-data-type", data_type, |
| "type-ids", type_ids, |
| NULL); |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(sparse_union_array); |
| priv->fields = g_ptr_array_sized_new(arrow_fields.size()); |
| g_ptr_array_set_free_func(priv->fields, g_object_unref); |
| for (auto node = fields; node; node = node->next) { |
| auto field = GARROW_ARRAY(node->data); |
| g_ptr_array_add(priv->fields, g_object_ref(field)); |
| } |
| return GARROW_SPARSE_UNION_ARRAY(sparse_union_array); |
| } else { |
| return NULL; |
| } |
| } |
| |
| /** |
| * garrow_sparse_union_array_new: |
| * @type_ids: The field type IDs for each value as #GArrowInt8Array. |
| * @fields: (element-type GArrowArray): The arrays for each field |
| * as #GList of #GArrowArray. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowSparseUnionArray |
| * or %NULL on error. |
| * |
| * Since: 0.12.0 |
| */ |
| GArrowSparseUnionArray * |
| garrow_sparse_union_array_new(GArrowInt8Array *type_ids, |
| GList *fields, |
| GError **error) |
| { |
| return garrow_sparse_union_array_new_internal(NULL, |
| type_ids, |
| fields, |
| error, |
| "[sparse-union-array][new]"); |
| } |
| |
| /** |
| * garrow_sparse_union_array_new_data_type: |
| * @data_type: The data type for the sparse array. |
| * @type_ids: The field type IDs for each value as #GArrowInt8Array. |
| * @fields: (element-type GArrowArray): The arrays for each field |
| * as #GList of #GArrowArray. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowSparseUnionArray |
| * or %NULL on error. |
| * |
| * Since: 0.14.0 |
| */ |
| GArrowSparseUnionArray * |
| garrow_sparse_union_array_new_data_type(GArrowSparseUnionDataType *data_type, |
| GArrowInt8Array *type_ids, |
| GList *fields, |
| GError **error) |
| { |
| return garrow_sparse_union_array_new_internal( |
| data_type, |
| type_ids, |
| fields, |
| error, |
| "[sparse-union-array][new][data-type]"); |
| } |
| |
| |
| typedef struct GArrowDenseUnionArrayPrivate_ { |
| GArrowInt32Array *value_offsets; |
| } GArrowDenseUnionArrayPrivate; |
| |
| enum { |
| PROP_VALUE_OFFSETS = 1, |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowDenseUnionArray, |
| garrow_dense_union_array, |
| GARROW_TYPE_UNION_ARRAY) |
| |
| #define GARROW_DENSE_UNION_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowDenseUnionArrayPrivate *>( \ |
| garrow_dense_union_array_get_instance_private( \ |
| GARROW_DENSE_UNION_ARRAY(obj))) |
| |
| static void |
| garrow_dense_union_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_DENSE_UNION_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->value_offsets) { |
| g_object_unref(priv->value_offsets); |
| priv->value_offsets = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_dense_union_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_dense_union_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_DENSE_UNION_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_VALUE_OFFSETS: |
| priv->value_offsets = GARROW_INT32_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_dense_union_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_DENSE_UNION_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_VALUE_OFFSETS: |
| g_value_set_object(value, priv->value_offsets); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_dense_union_array_init(GArrowDenseUnionArray *object) |
| { |
| } |
| |
| static void |
| garrow_dense_union_array_class_init(GArrowDenseUnionArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_dense_union_array_dispose; |
| gobject_class->set_property = garrow_dense_union_array_set_property; |
| gobject_class->get_property = garrow_dense_union_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("value-offsets", |
| "Value offsets", |
| "The GArrowInt32Array for value offsets", |
| GARROW_TYPE_INT32_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_VALUE_OFFSETS, spec); |
| } |
| |
| static GArrowDenseUnionArray * |
| garrow_dense_union_array_new_internal(GArrowDenseUnionDataType *data_type, |
| GArrowInt8Array *type_ids, |
| GArrowInt32Array *value_offsets, |
| GList *fields, |
| GError **error, |
| const gchar *context) |
| { |
| auto arrow_type_ids = garrow_array_get_raw(GARROW_ARRAY(type_ids)); |
| auto arrow_value_offsets = garrow_array_get_raw(GARROW_ARRAY(value_offsets)); |
| std::vector<std::shared_ptr<arrow::Array>> arrow_fields; |
| for (auto node = fields; node; node = node->next) { |
| auto *field = GARROW_ARRAY(node->data); |
| arrow_fields.push_back(garrow_array_get_raw(field)); |
| } |
| arrow::Result<std::shared_ptr<arrow::Array>> arrow_dense_union_array_result; |
| if (data_type) { |
| auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type)); |
| auto arrow_union_data_type = |
| std::static_pointer_cast<arrow::UnionType>(arrow_data_type); |
| std::vector<std::string> arrow_field_names; |
| for (const auto &arrow_field : arrow_union_data_type->fields()) { |
| arrow_field_names.push_back(arrow_field->name()); |
| } |
| arrow_dense_union_array_result = |
| arrow::DenseUnionArray::Make(*arrow_type_ids, |
| *arrow_value_offsets, |
| arrow_fields, |
| arrow_field_names, |
| arrow_union_data_type->type_codes()); |
| } else { |
| arrow_dense_union_array_result = |
| arrow::DenseUnionArray::Make(*arrow_type_ids, |
| *arrow_value_offsets, |
| arrow_fields); |
| } |
| if (garrow::check(error, |
| arrow_dense_union_array_result, |
| context)) { |
| auto arrow_dense_union_array = *arrow_dense_union_array_result; |
| auto dense_union_array = |
| garrow_array_new_raw(&arrow_dense_union_array, |
| "array", &arrow_dense_union_array, |
| "value-data-type", data_type, |
| "type-ids", type_ids, |
| "value-offsets", value_offsets, |
| NULL); |
| auto priv = GARROW_UNION_ARRAY_GET_PRIVATE(dense_union_array); |
| priv->fields = g_ptr_array_sized_new(arrow_fields.size()); |
| g_ptr_array_set_free_func(priv->fields, g_object_unref); |
| for (auto node = fields; node; node = node->next) { |
| auto field = GARROW_ARRAY(node->data); |
| g_ptr_array_add(priv->fields, g_object_ref(field)); |
| } |
| return GARROW_DENSE_UNION_ARRAY(dense_union_array); |
| } else { |
| return NULL; |
| } |
| } |
| |
| /** |
| * garrow_dense_union_array_new: |
| * @type_ids: The field type IDs for each value as #GArrowInt8Array. |
| * @value_offsets: The value offsets for each value as #GArrowInt32Array. |
| * Each offset is counted for each type. |
| * @fields: (element-type GArrowArray): The arrays for each field |
| * as #GList of #GArrowArray. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowDenseUnionArray |
| * or %NULL on error. |
| * |
| * Since: 0.12.0 |
| */ |
| GArrowDenseUnionArray * |
| garrow_dense_union_array_new(GArrowInt8Array *type_ids, |
| GArrowInt32Array *value_offsets, |
| GList *fields, |
| GError **error) |
| { |
| return garrow_dense_union_array_new_internal(NULL, |
| type_ids, |
| value_offsets, |
| fields, |
| error, |
| "[dense-union-array][new]"); |
| } |
| |
| /** |
| * garrow_dense_union_array_new_data_type: |
| * @data_type: The data type for the dense array. |
| * @type_ids: The field type IDs for each value as #GArrowInt8Array. |
| * @value_offsets: The value offsets for each value as #GArrowInt32Array. |
| * Each offset is counted for each type. |
| * @fields: (element-type GArrowArray): The arrays for each field |
| * as #GList of #GArrowArray. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowSparseUnionArray |
| * or %NULL on error. |
| * |
| * Since: 0.14.0 |
| */ |
| GArrowDenseUnionArray * |
| garrow_dense_union_array_new_data_type(GArrowDenseUnionDataType *data_type, |
| GArrowInt8Array *type_ids, |
| GArrowInt32Array *value_offsets, |
| GList *fields, |
| GError **error) |
| { |
| return garrow_dense_union_array_new_internal( |
| data_type, |
| type_ids, |
| value_offsets, |
| fields, |
| error, |
| "[dense-union-array][new][data-type]"); |
| } |
| |
| |
| typedef struct GArrowDictionaryArrayPrivate_ { |
| GArrowArray *indices; |
| GArrowArray *dictionary; |
| } GArrowDictionaryArrayPrivate; |
| |
| enum { |
| PROP_INDICES = 1, |
| PROP_DICTIONARY, |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE(GArrowDictionaryArray, |
| garrow_dictionary_array, |
| GARROW_TYPE_ARRAY) |
| |
| #define GARROW_DICTIONARY_ARRAY_GET_PRIVATE(obj) \ |
| static_cast<GArrowDictionaryArrayPrivate *>( \ |
| garrow_dictionary_array_get_instance_private( \ |
| GARROW_DICTIONARY_ARRAY(obj))) |
| |
| static void |
| garrow_dictionary_array_dispose(GObject *object) |
| { |
| auto priv = GARROW_DICTIONARY_ARRAY_GET_PRIVATE(object); |
| |
| if (priv->indices) { |
| g_object_unref(priv->indices); |
| priv->indices = NULL; |
| } |
| |
| if (priv->dictionary) { |
| g_object_unref(priv->dictionary); |
| priv->dictionary = NULL; |
| } |
| |
| G_OBJECT_CLASS(garrow_dictionary_array_parent_class)->dispose(object); |
| } |
| |
| static void |
| garrow_dictionary_array_set_property(GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_DICTIONARY_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_INDICES: |
| priv->indices = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| case PROP_DICTIONARY: |
| priv->dictionary = GARROW_ARRAY(g_value_dup_object(value)); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_dictionary_array_get_property(GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| auto priv = GARROW_DICTIONARY_ARRAY_GET_PRIVATE(object); |
| |
| switch (prop_id) { |
| case PROP_INDICES: |
| g_value_set_object(value, priv->indices); |
| break; |
| case PROP_DICTIONARY: |
| g_value_set_object(value, priv->dictionary); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| garrow_dictionary_array_init(GArrowDictionaryArray *object) |
| { |
| } |
| |
| static void |
| garrow_dictionary_array_class_init(GArrowDictionaryArrayClass *klass) |
| { |
| auto gobject_class = G_OBJECT_CLASS(klass); |
| |
| gobject_class->dispose = garrow_dictionary_array_dispose; |
| gobject_class->set_property = garrow_dictionary_array_set_property; |
| gobject_class->get_property = garrow_dictionary_array_get_property; |
| |
| GParamSpec *spec; |
| spec = g_param_spec_object("indices", |
| "The indices", |
| "The GArrowArray for indices", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_INDICES, spec); |
| |
| spec = g_param_spec_object("dictionary", |
| "The dictionary", |
| "The GArrowArray for dictionary", |
| GARROW_TYPE_ARRAY, |
| static_cast<GParamFlags>(G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY)); |
| g_object_class_install_property(gobject_class, PROP_DICTIONARY, spec); |
| } |
| |
| /** |
| * garrow_dictionary_array_new: |
| * @data_type: The data type of the dictionary array. |
| * @indices: The indices of values in dictionary. |
| * @dictionary: The dictionary of the dictionary array. |
| * @error: (nullable): Return location for a #GError or %NULL. |
| * |
| * Returns: (nullable): A newly created #GArrowDictionaryArray |
| * or %NULL on error. |
| * |
| * Since: 0.8.0 |
| */ |
| GArrowDictionaryArray * |
| garrow_dictionary_array_new(GArrowDataType *data_type, |
| GArrowArray *indices, |
| GArrowArray *dictionary, |
| GError **error) |
| { |
| const auto arrow_data_type = garrow_data_type_get_raw(data_type); |
| const auto arrow_indices = garrow_array_get_raw(indices); |
| const auto arrow_dictionary = garrow_array_get_raw(dictionary); |
| auto arrow_dictionary_array_result = |
| arrow::DictionaryArray::FromArrays( |
| arrow_data_type, |
| arrow_indices, |
| arrow_dictionary); |
| if (garrow::check(error, |
| arrow_dictionary_array_result, |
| "[dictionary-array][new]")) { |
| auto arrow_array = |
| std::static_pointer_cast<arrow::Array>(*arrow_dictionary_array_result); |
| auto dictionary_array = garrow_array_new_raw(&arrow_array, |
| "array", &arrow_array, |
| "value-data-type", data_type, |
| "indices", indices, |
| "dictionary", dictionary, |
| NULL); |
| return GARROW_DICTIONARY_ARRAY(dictionary_array); |
| } else { |
| return NULL; |
| } |
| } |
| |
| /** |
| * garrow_dictionary_array_get_indices: |
| * @array: A #GArrowDictionaryArray. |
| * |
| * Returns: (transfer full): The indices of values in dictionary. |
| * |
| * Since: 0.8.0 |
| */ |
| GArrowArray * |
| garrow_dictionary_array_get_indices(GArrowDictionaryArray *array) |
| { |
| auto priv = GARROW_DICTIONARY_ARRAY_GET_PRIVATE(array); |
| if (priv->indices) { |
| g_object_ref(priv->indices); |
| return priv->indices; |
| } |
| |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_dictionary_array = |
| std::static_pointer_cast<arrow::DictionaryArray>(arrow_array); |
| auto arrow_indices = arrow_dictionary_array->indices(); |
| return garrow_array_new_raw(&arrow_indices); |
| } |
| |
| /** |
| * garrow_dictionary_array_get_dictionary: |
| * @array: A #GArrowDictionaryArray. |
| * |
| * Returns: (transfer full): The dictionary of this array. |
| * |
| * Since: 0.8.0 |
| */ |
| GArrowArray * |
| garrow_dictionary_array_get_dictionary(GArrowDictionaryArray *array) |
| { |
| auto priv = GARROW_DICTIONARY_ARRAY_GET_PRIVATE(array); |
| if (priv->dictionary) { |
| g_object_ref(priv->dictionary); |
| return priv->dictionary; |
| } |
| |
| auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array)); |
| auto arrow_dictionary_array = |
| std::static_pointer_cast<arrow::DictionaryArray>(arrow_array); |
| auto arrow_dictionary = arrow_dictionary_array->dictionary(); |
| return garrow_array_new_raw(&arrow_dictionary); |
| } |
| |
| /** |
| * garrow_dictionary_array_get_dictionary_data_type: |
| * @array: A #GArrowDictionaryArray. |
| * |
| * Returns: (transfer full): The dictionary data type of this array. |
| * |
| * Since: 0.8.0 |
| * |
| * Deprecated: 1.0.0: Use garrow_array_get_value_data_type() instead. |
| */ |
| GArrowDictionaryDataType * |
| garrow_dictionary_array_get_dictionary_data_type(GArrowDictionaryArray *array) |
| { |
| auto data_type = garrow_array_get_value_data_type(GARROW_ARRAY(array)); |
| return GARROW_DICTIONARY_DATA_TYPE(data_type); |
| } |
| |
| G_END_DECLS |
