diff --git a/c_glib/arrow-glib/array-builder.cpp b/c_glib/arrow-glib/array-builder.cpp index 126986d1fb0..a6fad87ab8f 100644 --- a/c_glib/arrow-glib/array-builder.cpp +++ b/c_glib/arrow-glib/array-builder.cpp @@ -38,6 +38,43 @@ garrow_array_builder_append(GArrowArrayBuilder *builder, return garrow_error_check(error, status, context); } +template +gboolean +garrow_array_builder_append_values(GArrowArrayBuilder *builder, + const VALUE *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error, + const gchar *context) +{ + auto arrow_builder = + static_cast(garrow_array_builder_get_raw(builder)); + arrow::Status status; + if (is_valids_length > 0) { + if (values_length != is_valids_length) { + g_set_error(error, + GARROW_ERROR, + GARROW_ERROR_INVALID, + "%s: values length and is_valids length must be equal: " + "<%" G_GINT64_FORMAT "> != " + "<%" G_GINT64_FORMAT ">", + context, + values_length, + is_valids_length); + return FALSE; + } + uint8_t valid_bytes[is_valids_length]; + for (gint64 i = 0; i < is_valids_length; ++i) { + valid_bytes[i] = is_valids[i]; + } + status = arrow_builder->Append(values, values_length, valid_bytes); + } else { + status = arrow_builder->Append(values, values_length, nullptr); + } + return garrow_error_check(error, status, context); +} + template gboolean garrow_array_builder_append_null(GArrowArrayBuilder *builder, @@ -50,6 +87,35 @@ garrow_array_builder_append_null(GArrowArrayBuilder *builder, return garrow_error_check(error, status, context); } +template +gboolean +garrow_array_builder_append_nulls(GArrowArrayBuilder *builder, + gint64 n, + GError **error, + const gchar *context) +{ + if (n < 0) { + g_set_error(error, + GARROW_ERROR, + GARROW_ERROR_INVALID, + "%s: the number of nulls must be 0 or larger: " + "<%" G_GINT64_FORMAT ">", + context, + n); + return FALSE; + } + if (n == 0) { + return TRUE; + } + + auto arrow_builder = + static_cast(garrow_array_builder_get_raw(builder)); + uint8_t valid_bytes[n]; + memset(valid_bytes, 0, sizeof(uint8_t) * n); + auto status = arrow_builder->AppendNulls(valid_bytes, n); + return garrow_error_check(error, status, context); +} + G_BEGIN_DECLS /** @@ -302,6 +368,47 @@ garrow_boolean_array_builder_append(GArrowBooleanArrayBuilder *builder, "[boolean-array-builder][append]"); } +/** + * garrow_boolean_array_builder_append_values: + * @builder: A #GArrowBooleanArrayBuilder. + * @values: (array length=values_length): The array of boolean. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_boolean_array_builder_append_values(GArrowBooleanArrayBuilder *builder, + const gboolean *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + guint8 arrow_values[values_length]; + for (gint64 i = 0; i < values_length; ++i) { + arrow_values[i] = values[i]; + } + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + arrow_values, + values_length, + is_valids, + is_valids_length, + error, + "[boolean-array-builder][append-values]"); +} + /** * garrow_boolean_array_builder_append_null: * @builder: A #GArrowBooleanArrayBuilder. @@ -319,6 +426,31 @@ garrow_boolean_array_builder_append_null(GArrowBooleanArrayBuilder *builder, "[boolean-array-builder][append-null]"); } +/** + * garrow_boolean_array_builder_append_nulls: + * @builder: A #GArrowBooleanArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_boolean_array_builder_append_nulls(GArrowBooleanArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[boolean-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowIntArrayBuilder, garrow_int_array_builder, @@ -373,6 +505,43 @@ garrow_int_array_builder_append(GArrowIntArrayBuilder *builder, "[int-array-builder][append]"); } +/** + * garrow_int_array_builder_append_values: + * @builder: A #GArrowIntArrayBuilder. + * @values: (array length=values_length): The array of int. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int_array_builder_append_values(GArrowIntArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[int-array-builder][append-values]"); +} + /** * garrow_int_array_builder_append_null: * @builder: A #GArrowIntArrayBuilder. @@ -392,6 +561,31 @@ garrow_int_array_builder_append_null(GArrowIntArrayBuilder *builder, "[int-array-builder][append-null]"); } +/** + * garrow_int_array_builder_append_nulls: + * @builder: A #GArrowIntArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int_array_builder_append_nulls(GArrowIntArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[int-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowInt8ArrayBuilder, garrow_int8_array_builder, @@ -441,6 +635,43 @@ garrow_int8_array_builder_append(GArrowInt8ArrayBuilder *builder, "[int8-array-builder][append]"); } +/** + * garrow_int8_array_builder_append_values: + * @builder: A #GArrowInt8ArrayBuilder. + * @values: (array length=values_length): The array of int8. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int8_array_builder_append_values(GArrowInt8ArrayBuilder *builder, + const gint8 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[int8-array-builder][append-values]"); +} + /** * garrow_int8_array_builder_append_null: * @builder: A #GArrowInt8ArrayBuilder. @@ -458,6 +689,31 @@ garrow_int8_array_builder_append_null(GArrowInt8ArrayBuilder *builder, "[int8-array-builder][append-null]"); } +/** + * garrow_int8_array_builder_append_nulls: + * @builder: A #GArrowInt8ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int8_array_builder_append_nulls(GArrowInt8ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[int8-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowUInt8ArrayBuilder, garrow_uint8_array_builder, @@ -507,6 +763,43 @@ garrow_uint8_array_builder_append(GArrowUInt8ArrayBuilder *builder, "[uint8-array-builder][append]"); } +/** + * garrow_uint8_array_builder_append_values: + * @builder: A #GArrowUInt8ArrayBuilder. + * @values: (array length=values_length): The array of uint8. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint8_array_builder_append_values(GArrowUInt8ArrayBuilder *builder, + const guint8 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[uint8-array-builder][append-values]"); +} + /** * garrow_uint8_array_builder_append_null: * @builder: A #GArrowUInt8ArrayBuilder. @@ -524,6 +817,31 @@ garrow_uint8_array_builder_append_null(GArrowUInt8ArrayBuilder *builder, "[uint8-array-builder][append-null]"); } +/** + * garrow_uint8_array_builder_append_nulls: + * @builder: A #GArrowUInt8ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint8_array_builder_append_nulls(GArrowUInt8ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[uint8-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowInt16ArrayBuilder, garrow_int16_array_builder, @@ -573,6 +891,43 @@ garrow_int16_array_builder_append(GArrowInt16ArrayBuilder *builder, "[int16-array-builder][append]"); } +/** + * garrow_int16_array_builder_append_values: + * @builder: A #GArrowInt16ArrayBuilder. + * @values: (array length=values_length): The array of int16. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int16_array_builder_append_values(GArrowInt16ArrayBuilder *builder, + const gint16 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[int16-array-builder][append-values]"); +} + /** * garrow_int16_array_builder_append_null: * @builder: A #GArrowInt16ArrayBuilder. @@ -590,6 +945,31 @@ garrow_int16_array_builder_append_null(GArrowInt16ArrayBuilder *builder, "[int16-array-builder][append-null]"); } +/** + * garrow_int16_array_builder_append_nulls: + * @builder: A #GArrowInt16ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int16_array_builder_append_nulls(GArrowInt16ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[int16-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowUInt16ArrayBuilder, garrow_uint16_array_builder, @@ -639,6 +1019,43 @@ garrow_uint16_array_builder_append(GArrowUInt16ArrayBuilder *builder, "[uint16-array-builder][append]"); } +/** + * garrow_uint16_array_builder_append_values: + * @builder: A #GArrowUInt16ArrayBuilder. + * @values: (array length=values_length): The array of uint16. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint16_array_builder_append_values(GArrowUInt16ArrayBuilder *builder, + const guint16 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[uint16-array-builder][append-values]"); +} + /** * garrow_uint16_array_builder_append_null: * @builder: A #GArrowUInt16ArrayBuilder. @@ -656,6 +1073,31 @@ garrow_uint16_array_builder_append_null(GArrowUInt16ArrayBuilder *builder, "[uint16-array-builder][append-null]"); } +/** + * garrow_uint16_array_builder_append_nulls: + * @builder: A #GArrowUInt16ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint16_array_builder_append_nulls(GArrowUInt16ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[uint16-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowInt32ArrayBuilder, garrow_int32_array_builder, @@ -705,6 +1147,43 @@ garrow_int32_array_builder_append(GArrowInt32ArrayBuilder *builder, "[int32-array-builder][append]"); } +/** + * garrow_int32_array_builder_append_values: + * @builder: A #GArrowInt32ArrayBuilder. + * @values: (array length=values_length): The array of int32. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int32_array_builder_append_values(GArrowInt32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[int32-array-builder][append-values]"); +} + /** * garrow_int32_array_builder_append_null: * @builder: A #GArrowInt32ArrayBuilder. @@ -714,7 +1193,7 @@ garrow_int32_array_builder_append(GArrowInt32ArrayBuilder *builder, */ gboolean garrow_int32_array_builder_append_null(GArrowInt32ArrayBuilder *builder, - GError **error) + GError **error) { return garrow_array_builder_append_null (GARROW_ARRAY_BUILDER(builder), @@ -722,6 +1201,31 @@ garrow_int32_array_builder_append_null(GArrowInt32ArrayBuilder *builder, "[int32-array-builder][append-null]"); } +/** + * garrow_int32_array_builder_append_nulls: + * @builder: A #GArrowInt32ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int32_array_builder_append_nulls(GArrowInt32ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[int32-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowUInt32ArrayBuilder, garrow_uint32_array_builder, @@ -771,6 +1275,43 @@ garrow_uint32_array_builder_append(GArrowUInt32ArrayBuilder *builder, "[uint32-array-builder][append]"); } +/** + * garrow_uint32_array_builder_append_values: + * @builder: A #GArrowUInt32ArrayBuilder. + * @values: (array length=values_length): The array of uint32. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint32_array_builder_append_values(GArrowUInt32ArrayBuilder *builder, + const guint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[uint32-array-builder][append-values]"); +} + /** * garrow_uint32_array_builder_append_null: * @builder: A #GArrowUInt32ArrayBuilder. @@ -788,13 +1329,38 @@ garrow_uint32_array_builder_append_null(GArrowUInt32ArrayBuilder *builder, "[uint32-array-builder][append-null]"); } - -G_DEFINE_TYPE(GArrowInt64ArrayBuilder, - garrow_int64_array_builder, - GARROW_TYPE_ARRAY_BUILDER) - -static void -garrow_int64_array_builder_init(GArrowInt64ArrayBuilder *builder) +/** + * garrow_uint32_array_builder_append_nulls: + * @builder: A #GArrowUInt32ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint32_array_builder_append_nulls(GArrowUInt32ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[uint32-array-builder][append-nulls]"); +} + + +G_DEFINE_TYPE(GArrowInt64ArrayBuilder, + garrow_int64_array_builder, + GARROW_TYPE_ARRAY_BUILDER) + +static void +garrow_int64_array_builder_init(GArrowInt64ArrayBuilder *builder) { } @@ -837,6 +1403,43 @@ garrow_int64_array_builder_append(GArrowInt64ArrayBuilder *builder, "[int64-array-builder][append]"); } +/** + * garrow_int64_array_builder_append_values: + * @builder: A #GArrowInt64ArrayBuilder. + * @values: (array length=values_length): The array of int64. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int64_array_builder_append_values(GArrowInt64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[int64-array-builder][append-values]"); +} + /** * garrow_int64_array_builder_append_null: * @builder: A #GArrowInt64ArrayBuilder. @@ -854,6 +1457,31 @@ garrow_int64_array_builder_append_null(GArrowInt64ArrayBuilder *builder, "[int64-array-builder][append-null]"); } +/** + * garrow_int64_array_builder_append_nulls: + * @builder: A #GArrowInt64ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_int64_array_builder_append_nulls(GArrowInt64ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[int64-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowUInt64ArrayBuilder, garrow_uint64_array_builder, @@ -903,6 +1531,43 @@ garrow_uint64_array_builder_append(GArrowUInt64ArrayBuilder *builder, "[uint64-array-builder][append]"); } +/** + * garrow_uint64_array_builder_append_values: + * @builder: A #GArrowUInt64ArrayBuilder. + * @values: (array length=values_length): The array of uint64. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint64_array_builder_append_values(GArrowUInt64ArrayBuilder *builder, + const guint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[uint64-array-builder][append-values]"); +} + /** * garrow_uint64_array_builder_append_null: * @builder: A #GArrowUInt64ArrayBuilder. @@ -912,7 +1577,7 @@ garrow_uint64_array_builder_append(GArrowUInt64ArrayBuilder *builder, */ gboolean garrow_uint64_array_builder_append_null(GArrowUInt64ArrayBuilder *builder, - GError **error) + GError **error) { return garrow_array_builder_append_null (GARROW_ARRAY_BUILDER(builder), @@ -920,6 +1585,31 @@ garrow_uint64_array_builder_append_null(GArrowUInt64ArrayBuilder *builder, "[uint64-array-builder][append-null]"); } +/** + * garrow_uint64_array_builder_append_nulls: + * @builder: A #GArrowUInt64ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_uint64_array_builder_append_nulls(GArrowUInt64ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[uint64-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowFloatArrayBuilder, garrow_float_array_builder, @@ -969,6 +1659,43 @@ garrow_float_array_builder_append(GArrowFloatArrayBuilder *builder, "[float-array-builder][append]"); } +/** + * garrow_float_array_builder_append_values: + * @builder: A #GArrowFloatArrayBuilder. + * @values: (array length=values_length): The array of float. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_float_array_builder_append_values(GArrowFloatArrayBuilder *builder, + const gfloat *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[float-array-builder][append-values]"); +} + /** * garrow_float_array_builder_append_null: * @builder: A #GArrowFloatArrayBuilder. @@ -986,6 +1713,31 @@ garrow_float_array_builder_append_null(GArrowFloatArrayBuilder *builder, "[float-array-builder][append-null]"); } +/** + * garrow_float_array_builder_append_nulls: + * @builder: A #GArrowFloatArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_float_array_builder_append_nulls(GArrowFloatArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[float-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowDoubleArrayBuilder, garrow_double_array_builder, @@ -1035,6 +1787,43 @@ garrow_double_array_builder_append(GArrowDoubleArrayBuilder *builder, "[double-array-builder][append]"); } +/** + * garrow_double_array_builder_append_values: + * @builder: A #GArrowDoubleArrayBuilder. + * @values: (array length=values_length): The array of double. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_double_array_builder_append_values(GArrowDoubleArrayBuilder *builder, + const gdouble *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[double-array-builder][append-values]"); +} + /** * garrow_double_array_builder_append_null: * @builder: A #GArrowDoubleArrayBuilder. @@ -1052,6 +1841,31 @@ garrow_double_array_builder_append_null(GArrowDoubleArrayBuilder *builder, "[double-array-builder][append-null]"); } +/** + * garrow_double_array_builder_append_nulls: + * @builder: A #GArrowDoubleArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_double_array_builder_append_nulls(GArrowDoubleArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[double-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowBinaryArrayBuilder, garrow_binary_array_builder, @@ -1225,6 +2039,44 @@ garrow_date32_array_builder_append(GArrowDate32ArrayBuilder *builder, "[date32-array-builder][append]"); } +/** + * garrow_date32_array_builder_append_values: + * @builder: A #GArrowDate32ArrayBuilder. + * @values: (array length=values_length): The array of + * the number of days since UNIX epoch in signed 32bit integer. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_date32_array_builder_append_values(GArrowDate32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[date32-array-builder][append-values]"); +} + /** * garrow_date32_array_builder_append_null: * @builder: A #GArrowDate32ArrayBuilder. @@ -1244,6 +2096,31 @@ garrow_date32_array_builder_append_null(GArrowDate32ArrayBuilder *builder, "[date32-array-builder][append-null]"); } +/** + * garrow_date32_array_builder_append_nulls: + * @builder: A #GArrowDate32ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_date32_array_builder_append_nulls(GArrowDate32ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[date32-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowDate64ArrayBuilder, garrow_date64_array_builder, @@ -1297,6 +2174,44 @@ garrow_date64_array_builder_append(GArrowDate64ArrayBuilder *builder, "[date64-array-builder][append]"); } +/** + * garrow_date64_array_builder_append_values: + * @builder: A #GArrowDate64ArrayBuilder. + * @values: (array length=values_length): The array of + * the number of milliseconds since UNIX epoch in signed 64bit integer. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_date64_array_builder_append_values(GArrowDate64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[date64-array-builder][append-values]"); +} + /** * garrow_date64_array_builder_append_null: * @builder: A #GArrowDate64ArrayBuilder. @@ -1316,6 +2231,31 @@ garrow_date64_array_builder_append_null(GArrowDate64ArrayBuilder *builder, "[date64-array-builder][append-null]"); } +/** + * garrow_date64_array_builder_append_nulls: + * @builder: A #GArrowDate64ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_date64_array_builder_append_nulls(GArrowDate64ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[date64-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowTimestampArrayBuilder, garrow_timestamp_array_builder, @@ -1371,6 +2311,44 @@ garrow_timestamp_array_builder_append(GArrowTimestampArrayBuilder *builder, "[timestamp-array-builder][append]"); } +/** + * garrow_timestamp_array_builder_append_values: + * @builder: A #GArrowTimestampArrayBuilder. + * @values: (array length=values_length): The array of + * the number of milliseconds since UNIX epoch in signed 64bit integer. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_timestamp_array_builder_append_values(GArrowTimestampArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[timestamp-array-builder][append-values]"); +} + /** * garrow_timestamp_array_builder_append_null: * @builder: A #GArrowTimestampArrayBuilder. @@ -1390,6 +2368,31 @@ garrow_timestamp_array_builder_append_null(GArrowTimestampArrayBuilder *builder, "[timestamp-array-builder][append-null]"); } +/** + * garrow_timestamp_array_builder_append_nulls: + * @builder: A #GArrowTimestampArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_timestamp_array_builder_append_nulls(GArrowTimestampArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[timestamp-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowTime32ArrayBuilder, garrow_time32_array_builder, @@ -1445,6 +2448,44 @@ garrow_time32_array_builder_append(GArrowTime32ArrayBuilder *builder, "[time32-array-builder][append]"); } +/** + * garrow_time32_array_builder_append_values: + * @builder: A #GArrowTime32ArrayBuilder. + * @values: (array length=values_length): The array of + * the number of days since UNIX epoch in signed 32bit integer. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_time32_array_builder_append_values(GArrowTime32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + values, + values_length, + is_valids, + is_valids_length, + error, + "[time32-array-builder][append-values]"); +} + /** * garrow_time32_array_builder_append_null: * @builder: A #GArrowTime32ArrayBuilder. @@ -1464,6 +2505,31 @@ garrow_time32_array_builder_append_null(GArrowTime32ArrayBuilder *builder, "[time32-array-builder][append-null]"); } +/** + * garrow_time32_array_builder_append_nulls: + * @builder: A #GArrowTime32ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_time32_array_builder_append_nulls(GArrowTime32ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[time32-array-builder][append-nulls]"); +} + G_DEFINE_TYPE(GArrowTime64ArrayBuilder, garrow_time64_array_builder, @@ -1519,6 +2585,44 @@ garrow_time64_array_builder_append(GArrowTime64ArrayBuilder *builder, "[time64-array-builder][append]"); } +/** + * garrow_time64_array_builder_append_values: + * @builder: A #GArrowTime64ArrayBuilder. + * @values: (array length=values_length): The array of + * the number of milliseconds since UNIX epoch in signed 64bit integer. + * @values_length: The length of `values`. + * @is_valids: (nullable) (array length=is_valids_length): The array of + * boolean that shows whether the Nth value is valid or not. If the + * Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise + * the Nth value is null value. + * @is_valids_length: The length of `is_valids`. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple values at once. It's efficient than multiple + * `append()` and `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_time64_array_builder_append_values(GArrowTime64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error) +{ + return garrow_array_builder_append_values + (GARROW_ARRAY_BUILDER(builder), + reinterpret_cast(values), + values_length, + is_valids, + is_valids_length, + error, + "[time64-array-builder][append-values]"); +} + /** * garrow_time64_array_builder_append_null: * @builder: A #GArrowTime64ArrayBuilder. @@ -1538,6 +2642,31 @@ garrow_time64_array_builder_append_null(GArrowTime64ArrayBuilder *builder, "[time64-array-builder][append-null]"); } +/** + * garrow_time64_array_builder_append_nulls: + * @builder: A #GArrowTime64ArrayBuilder. + * @n: The number of null values to be appended. + * @error: (nullable): Return location for a #GError or %NULL. + * + * Append multiple nulls at once. It's efficient than multiple + * `append_null()` calls. + * + * Returns: %TRUE on success, %FALSE if there was an error. + * + * Since: 0.8.0 + */ +gboolean +garrow_time64_array_builder_append_nulls(GArrowTime64ArrayBuilder *builder, + gint64 n, + GError **error) +{ + return garrow_array_builder_append_nulls + (GARROW_ARRAY_BUILDER(builder), + n, + error, + "[time64-array-builder][append-nulls]"); +} + typedef struct GArrowListArrayBuilderPrivate_ { GArrowArrayBuilder *value_builder; diff --git a/c_glib/arrow-glib/array-builder.h b/c_glib/arrow-glib/array-builder.h index f28959ffb5f..87808549afa 100644 --- a/c_glib/arrow-glib/array-builder.h +++ b/c_glib/arrow-glib/array-builder.h @@ -116,8 +116,17 @@ GArrowBooleanArrayBuilder *garrow_boolean_array_builder_new(void); gboolean garrow_boolean_array_builder_append(GArrowBooleanArrayBuilder *builder, gboolean value, GError **error); +gboolean garrow_boolean_array_builder_append_values(GArrowBooleanArrayBuilder *builder, + const gboolean *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_boolean_array_builder_append_null(GArrowBooleanArrayBuilder *builder, GError **error); +gboolean garrow_boolean_array_builder_append_nulls(GArrowBooleanArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_INT_ARRAY_BUILDER \ @@ -167,8 +176,17 @@ GArrowIntArrayBuilder *garrow_int_array_builder_new(void); gboolean garrow_int_array_builder_append(GArrowIntArrayBuilder *builder, gint64 value, GError **error); +gboolean garrow_int_array_builder_append_values(GArrowIntArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_int_array_builder_append_null(GArrowIntArrayBuilder *builder, GError **error); +gboolean garrow_int_array_builder_append_nulls(GArrowIntArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_INT8_ARRAY_BUILDER \ @@ -218,8 +236,17 @@ GArrowInt8ArrayBuilder *garrow_int8_array_builder_new(void); gboolean garrow_int8_array_builder_append(GArrowInt8ArrayBuilder *builder, gint8 value, GError **error); +gboolean garrow_int8_array_builder_append_values(GArrowInt8ArrayBuilder *builder, + const gint8 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_int8_array_builder_append_null(GArrowInt8ArrayBuilder *builder, GError **error); +gboolean garrow_int8_array_builder_append_nulls(GArrowInt8ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_UINT8_ARRAY_BUILDER \ @@ -269,8 +296,17 @@ GArrowUInt8ArrayBuilder *garrow_uint8_array_builder_new(void); gboolean garrow_uint8_array_builder_append(GArrowUInt8ArrayBuilder *builder, guint8 value, GError **error); +gboolean garrow_uint8_array_builder_append_values(GArrowUInt8ArrayBuilder *builder, + const guint8 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_uint8_array_builder_append_null(GArrowUInt8ArrayBuilder *builder, GError **error); +gboolean garrow_uint8_array_builder_append_nulls(GArrowUInt8ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_INT16_ARRAY_BUILDER \ @@ -320,8 +356,17 @@ GArrowInt16ArrayBuilder *garrow_int16_array_builder_new(void); gboolean garrow_int16_array_builder_append(GArrowInt16ArrayBuilder *builder, gint16 value, GError **error); +gboolean garrow_int16_array_builder_append_values(GArrowInt16ArrayBuilder *builder, + const gint16 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_int16_array_builder_append_null(GArrowInt16ArrayBuilder *builder, GError **error); +gboolean garrow_int16_array_builder_append_nulls(GArrowInt16ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_UINT16_ARRAY_BUILDER \ @@ -371,8 +416,17 @@ GArrowUInt16ArrayBuilder *garrow_uint16_array_builder_new(void); gboolean garrow_uint16_array_builder_append(GArrowUInt16ArrayBuilder *builder, guint16 value, GError **error); +gboolean garrow_uint16_array_builder_append_values(GArrowUInt16ArrayBuilder *builder, + const guint16 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_uint16_array_builder_append_null(GArrowUInt16ArrayBuilder *builder, GError **error); +gboolean garrow_uint16_array_builder_append_nulls(GArrowUInt16ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_INT32_ARRAY_BUILDER \ @@ -422,8 +476,17 @@ GArrowInt32ArrayBuilder *garrow_int32_array_builder_new(void); gboolean garrow_int32_array_builder_append(GArrowInt32ArrayBuilder *builder, gint32 value, GError **error); +gboolean garrow_int32_array_builder_append_values(GArrowInt32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_int32_array_builder_append_null(GArrowInt32ArrayBuilder *builder, GError **error); +gboolean garrow_int32_array_builder_append_nulls(GArrowInt32ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_UINT32_ARRAY_BUILDER \ @@ -473,8 +536,17 @@ GArrowUInt32ArrayBuilder *garrow_uint32_array_builder_new(void); gboolean garrow_uint32_array_builder_append(GArrowUInt32ArrayBuilder *builder, guint32 value, GError **error); +gboolean garrow_uint32_array_builder_append_values(GArrowUInt32ArrayBuilder *builder, + const guint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_uint32_array_builder_append_null(GArrowUInt32ArrayBuilder *builder, GError **error); +gboolean garrow_uint32_array_builder_append_nulls(GArrowUInt32ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_INT64_ARRAY_BUILDER \ @@ -524,8 +596,17 @@ GArrowInt64ArrayBuilder *garrow_int64_array_builder_new(void); gboolean garrow_int64_array_builder_append(GArrowInt64ArrayBuilder *builder, gint64 value, GError **error); +gboolean garrow_int64_array_builder_append_values(GArrowInt64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_int64_array_builder_append_null(GArrowInt64ArrayBuilder *builder, GError **error); +gboolean garrow_int64_array_builder_append_nulls(GArrowInt64ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_UINT64_ARRAY_BUILDER \ @@ -575,8 +656,17 @@ GArrowUInt64ArrayBuilder *garrow_uint64_array_builder_new(void); gboolean garrow_uint64_array_builder_append(GArrowUInt64ArrayBuilder *builder, guint64 value, GError **error); +gboolean garrow_uint64_array_builder_append_values(GArrowUInt64ArrayBuilder *builder, + const guint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_uint64_array_builder_append_null(GArrowUInt64ArrayBuilder *builder, GError **error); +gboolean garrow_uint64_array_builder_append_nulls(GArrowUInt64ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_FLOAT_ARRAY_BUILDER \ @@ -626,8 +716,17 @@ GArrowFloatArrayBuilder *garrow_float_array_builder_new(void); gboolean garrow_float_array_builder_append(GArrowFloatArrayBuilder *builder, gfloat value, GError **error); +gboolean garrow_float_array_builder_append_values(GArrowFloatArrayBuilder *builder, + const gfloat *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_float_array_builder_append_null(GArrowFloatArrayBuilder *builder, GError **error); +gboolean garrow_float_array_builder_append_nulls(GArrowFloatArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_DOUBLE_ARRAY_BUILDER \ @@ -677,8 +776,17 @@ GArrowDoubleArrayBuilder *garrow_double_array_builder_new(void); gboolean garrow_double_array_builder_append(GArrowDoubleArrayBuilder *builder, gdouble value, GError **error); +gboolean garrow_double_array_builder_append_values(GArrowDoubleArrayBuilder *builder, + const gdouble *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_double_array_builder_append_null(GArrowDoubleArrayBuilder *builder, GError **error); +gboolean garrow_double_array_builder_append_nulls(GArrowDoubleArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_BINARY_ARRAY_BUILDER \ @@ -829,8 +937,17 @@ GArrowDate32ArrayBuilder *garrow_date32_array_builder_new(void); gboolean garrow_date32_array_builder_append(GArrowDate32ArrayBuilder *builder, gint32 value, GError **error); +gboolean garrow_date32_array_builder_append_values(GArrowDate32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_date32_array_builder_append_null(GArrowDate32ArrayBuilder *builder, GError **error); +gboolean garrow_date32_array_builder_append_nulls(GArrowDate32ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_DATE64_ARRAY_BUILDER \ @@ -880,8 +997,17 @@ GArrowDate64ArrayBuilder *garrow_date64_array_builder_new(void); gboolean garrow_date64_array_builder_append(GArrowDate64ArrayBuilder *builder, gint64 value, GError **error); +gboolean garrow_date64_array_builder_append_values(GArrowDate64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_date64_array_builder_append_null(GArrowDate64ArrayBuilder *builder, GError **error); +gboolean garrow_date64_array_builder_append_nulls(GArrowDate64ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_TIMESTAMP_ARRAY_BUILDER \ @@ -932,8 +1058,17 @@ garrow_timestamp_array_builder_new(GArrowTimestampDataType *data_type); gboolean garrow_timestamp_array_builder_append(GArrowTimestampArrayBuilder *builder, gint64 value, GError **error); +gboolean garrow_timestamp_array_builder_append_values(GArrowTimestampArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_timestamp_array_builder_append_null(GArrowTimestampArrayBuilder *builder, GError **error); +gboolean garrow_timestamp_array_builder_append_nulls(GArrowTimestampArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_TIME32_ARRAY_BUILDER \ @@ -983,8 +1118,17 @@ GArrowTime32ArrayBuilder *garrow_time32_array_builder_new(GArrowTime32DataType * gboolean garrow_time32_array_builder_append(GArrowTime32ArrayBuilder *builder, gint32 value, GError **error); +gboolean garrow_time32_array_builder_append_values(GArrowTime32ArrayBuilder *builder, + const gint32 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_time32_array_builder_append_null(GArrowTime32ArrayBuilder *builder, GError **error); +gboolean garrow_time32_array_builder_append_nulls(GArrowTime32ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_TIME64_ARRAY_BUILDER \ @@ -1034,8 +1178,17 @@ GArrowTime64ArrayBuilder *garrow_time64_array_builder_new(GArrowTime64DataType * gboolean garrow_time64_array_builder_append(GArrowTime64ArrayBuilder *builder, gint64 value, GError **error); +gboolean garrow_time64_array_builder_append_values(GArrowTime64ArrayBuilder *builder, + const gint64 *values, + gint64 values_length, + const gboolean *is_valids, + gint64 is_valids_length, + GError **error); gboolean garrow_time64_array_builder_append_null(GArrowTime64ArrayBuilder *builder, GError **error); +gboolean garrow_time64_array_builder_append_nulls(GArrowTime64ArrayBuilder *builder, + gint64 n, + GError **error); #define GARROW_TYPE_LIST_ARRAY_BUILDER \ diff --git a/c_glib/doc/reference/arrow-glib-docs.sgml b/c_glib/doc/reference/arrow-glib-docs.sgml index 3366fc8ebe5..fc161a5864c 100644 --- a/c_glib/doc/reference/arrow-glib-docs.sgml +++ b/c_glib/doc/reference/arrow-glib-docs.sgml @@ -133,6 +133,10 @@ Index of deprecated API + + Index of new symbols in 0.8.0 + + Index of new symbols in 0.7.0 diff --git a/c_glib/test/test-array-builder.rb b/c_glib/test/test-array-builder.rb new file mode 100644 index 00000000000..6c0f984854d --- /dev/null +++ b/c_glib/test/test-array-builder.rb @@ -0,0 +1,485 @@ +# 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. + +module ArrayBuilderAppendValuesTests + def test_empty + builder = create_builder + builder.append_values([]) + assert_equal(build_array([]), + builder.finish) + end + + def test_values_only + builder = create_builder + builder.append_values(sample_values) + assert_equal(build_array(sample_values), + builder.finish) + end + + def test_with_is_valids + builder = create_builder + builder.append_values(sample_values, [true, true, false]) + sample_values_with_null = sample_values + sample_values_with_null[2] = nil + assert_equal(build_array(sample_values_with_null), + builder.finish) + end + + def test_mismatch_length + builder = create_builder + message = "[#{builder_class_name}][append-values]: " + + "values length and is_valids length must be equal: <3> != <2>" + assert_raise(Arrow::Error::Invalid.new(message)) do + builder.append_values(sample_values, [true, true]) + end + end +end + +module ArrayBuilderAppendNullsTests + def test_zero + builder = create_builder + builder.append_nulls(0) + assert_equal(build_array([]), + builder.finish) + end + + def test_positive + builder = create_builder + builder.append_nulls(3) + assert_equal(build_array([nil, nil, nil]), + builder.finish) + end + + def test_negative + builder = create_builder + message = "[#{builder_class_name}][append-nulls]: " + + "the number of nulls must be 0 or larger: <-1>" + assert_raise(Arrow::Error::Invalid.new(message)) do + builder.append_nulls(-1) + end + end +end + +class TestArrayBuilder < Test::Unit::TestCase + include Helper::Buildable + include Helper::Omittable + + def setup + require_gi_bindings(3, 1, 9) + end + + def build_array(values) + super(create_builder, values) + end + + sub_test_case("BooleanArrayBuilder") do + def create_builder + Arrow::BooleanArrayBuilder.new + end + + def builder_class_name + "boolean-array-builder" + end + + def sample_values + [true, false, true] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("IntArrayBuilder") do + def create_builder + Arrow::IntArrayBuilder.new + end + + def builder_class_name + "int-array-builder" + end + + def sample_values + [1, -2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Int8ArrayBuilder") do + def create_builder + Arrow::Int8ArrayBuilder.new + end + + def builder_class_name + "int8-array-builder" + end + + def sample_values + [1, -2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("UInt8ArrayBuilder") do + def create_builder + Arrow::UInt8ArrayBuilder.new + end + + def builder_class_name + "uint8-array-builder" + end + + def sample_values + [1, 2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Int16ArrayBuilder") do + def create_builder + Arrow::Int16ArrayBuilder.new + end + + def builder_class_name + "int16-array-builder" + end + + def sample_values + [1, -2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("UInt16ArrayBuilder") do + def create_builder + Arrow::UInt16ArrayBuilder.new + end + + def builder_class_name + "uint16-array-builder" + end + + def sample_values + [1, 2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Int32ArrayBuilder") do + def create_builder + Arrow::Int32ArrayBuilder.new + end + + def builder_class_name + "int32-array-builder" + end + + def sample_values + [1, -2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("UInt32ArrayBuilder") do + def create_builder + Arrow::UInt32ArrayBuilder.new + end + + def builder_class_name + "uint32-array-builder" + end + + def sample_values + [1, 2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Int64ArrayBuilder") do + def create_builder + Arrow::Int64ArrayBuilder.new + end + + def builder_class_name + "int64-array-builder" + end + + def sample_values + [1, -2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("UInt64ArrayBuilder") do + def create_builder + Arrow::UInt64ArrayBuilder.new + end + + def builder_class_name + "uint64-array-builder" + end + + def sample_values + [1, 2, 3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("FloatArrayBuilder") do + def create_builder + Arrow::FloatArrayBuilder.new + end + + def builder_class_name + "float-array-builder" + end + + def sample_values + [1.1, -2.2, 3.3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("DoubleArrayBuilder") do + def create_builder + Arrow::DoubleArrayBuilder.new + end + + def builder_class_name + "double-array-builder" + end + + def sample_values + [1.1, -2.2, 3.3] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Date32ArrayBuilder") do + def create_builder + Arrow::Date32ArrayBuilder.new + end + + def builder_class_name + "date32-array-builder" + end + + def sample_values + [ + 0, # epoch + 17406, # 2017-08-28 + 17427, # 2017-09-18 + ] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Date64ArrayBuilder") do + def create_builder + Arrow::Date64ArrayBuilder.new + end + + def builder_class_name + "date64-array-builder" + end + + def sample_values + [ + -315619200, # 1960-01-01T00:00:00Z + 0, # epoch + 1503878400000, # 2017-08-28T00:00:00Z + ] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("TimestampArrayBuilder") do + def create_builder + data_type = Arrow::TimestampDataType.new(:milli) + Arrow::TimestampArrayBuilder.new(data_type) + end + + def builder_class_name + "timestamp-array-builder" + end + + def sample_values + [ + 0, # epoch + 1504953190854, # 2017-09-09T10:33:10.854Z + 1505660812942, # 2017-09-17T15:06:52.942Z + ] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Time32ArrayBuilder") do + def create_builder + data_type = Arrow::Time32DataType.new(:second) + Arrow::Time32ArrayBuilder.new(data_type) + end + + def builder_class_name + "time32-array-builder" + end + + def sample_values + [ + 0, # midnight + 60 * 10, # 00:10:00 + 60 * 60 * 2 + 30, # 02:00:30 + ] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end + + sub_test_case("Time64ArrayBuilder") do + def create_builder + data_type = Arrow::Time64DataType.new(:micro) + Arrow::Time64ArrayBuilder.new(data_type) + end + + def builder_class_name + "time64-array-builder" + end + + def sample_values + [ + 0, # midnight + 60 * 10 * 1000 * 1000, # 00:10:00.000000 + (60 * 60 * 2 + 30) * 1000 * 1000, # 02:00:30.000000 + ] + end + + sub_test_case("#append_values") do + include ArrayBuilderAppendValuesTests + end + + sub_test_case("#append_nulls") do + include ArrayBuilderAppendNullsTests + end + end +end