You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by we...@apache.org on 2017/04/22 14:43:10 UTC
[3/3] arrow git commit: ARROW-876: [GLib] Unify ArrayBuilder files
ARROW-876: [GLib] Unify ArrayBuilder files
Author: Kouhei Sutou <ko...@clear-code.com>
Closes #581 from kou/glib-array-builder-unify-file and squashes the following commits:
5449d50 [Kouhei Sutou] [GLib] Unify ArrayBuilder files
Project: http://git-wip-us.apache.org/repos/asf/arrow/repo
Commit: http://git-wip-us.apache.org/repos/asf/arrow/commit/76dfd987
Tree: http://git-wip-us.apache.org/repos/asf/arrow/tree/76dfd987
Diff: http://git-wip-us.apache.org/repos/asf/arrow/diff/76dfd987
Branch: refs/heads/master
Commit: 76dfd9878529c010b43726058ef3e913a78501f0
Parents: 423235c
Author: Kouhei Sutou <ko...@clear-code.com>
Authored: Sat Apr 22 10:43:01 2017 -0400
Committer: Wes McKinney <we...@twosigma.com>
Committed: Sat Apr 22 10:43:01 2017 -0400
----------------------------------------------------------------------
c_glib/arrow-glib/Makefile.am | 32 +-
c_glib/arrow-glib/array-builder.cpp | 1381 +++++++++++++++++++++-
c_glib/arrow-glib/array-builder.h | 769 ++++++++++++
c_glib/arrow-glib/arrow-glib.h | 15 -
c_glib/arrow-glib/binary-array-builder.cpp | 122 --
c_glib/arrow-glib/binary-array-builder.h | 77 --
c_glib/arrow-glib/boolean-array-builder.cpp | 120 --
c_glib/arrow-glib/boolean-array-builder.h | 76 --
c_glib/arrow-glib/double-array-builder.cpp | 120 --
c_glib/arrow-glib/double-array-builder.h | 76 --
c_glib/arrow-glib/float-array-builder.cpp | 120 --
c_glib/arrow-glib/float-array-builder.h | 76 --
c_glib/arrow-glib/int16-array-builder.cpp | 120 --
c_glib/arrow-glib/int16-array-builder.h | 76 --
c_glib/arrow-glib/int32-array-builder.cpp | 120 --
c_glib/arrow-glib/int32-array-builder.h | 76 --
c_glib/arrow-glib/int64-array-builder.cpp | 120 --
c_glib/arrow-glib/int64-array-builder.h | 76 --
c_glib/arrow-glib/int8-array-builder.cpp | 120 --
c_glib/arrow-glib/int8-array-builder.h | 76 --
c_glib/arrow-glib/list-array-builder.cpp | 173 ---
c_glib/arrow-glib/list-array-builder.h | 77 --
c_glib/arrow-glib/string-array-builder.cpp | 97 --
c_glib/arrow-glib/string-array-builder.h | 74 --
c_glib/arrow-glib/struct-array-builder.cpp | 187 ---
c_glib/arrow-glib/struct-array-builder.h | 81 --
c_glib/arrow-glib/uint16-array-builder.cpp | 120 --
c_glib/arrow-glib/uint16-array-builder.h | 76 --
c_glib/arrow-glib/uint32-array-builder.cpp | 120 --
c_glib/arrow-glib/uint32-array-builder.h | 76 --
c_glib/arrow-glib/uint64-array-builder.cpp | 120 --
c_glib/arrow-glib/uint64-array-builder.h | 76 --
c_glib/arrow-glib/uint8-array-builder.cpp | 120 --
c_glib/arrow-glib/uint8-array-builder.h | 76 --
c_glib/doc/reference/arrow-glib-docs.sgml | 15 -
35 files changed, 2135 insertions(+), 3121 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/arrow/blob/76dfd987/c_glib/arrow-glib/Makefile.am
----------------------------------------------------------------------
diff --git a/c_glib/arrow-glib/Makefile.am b/c_glib/arrow-glib/Makefile.am
index d0c8c79..bbc1101 100644
--- a/c_glib/arrow-glib/Makefile.am
+++ b/c_glib/arrow-glib/Makefile.am
@@ -44,32 +44,17 @@ libarrow_glib_la_headers = \
array.h \
array-builder.h \
arrow-glib.h \
- binary-array-builder.h \
- boolean-array-builder.h \
buffer.h \
chunked-array.h \
column.h \
data-type.h \
- double-array-builder.h \
error.h \
field.h \
- float-array-builder.h \
- int8-array-builder.h \
- int16-array-builder.h \
- int32-array-builder.h \
- int64-array-builder.h \
- list-array-builder.h \
record-batch.h \
schema.h \
- string-array-builder.h \
- struct-array-builder.h \
table.h \
tensor.h \
- type.h \
- uint8-array-builder.h \
- uint16-array-builder.h \
- uint32-array-builder.h \
- uint64-array-builder.h
+ type.h
libarrow_glib_la_headers += \
file.h \
@@ -100,32 +85,17 @@ libarrow_glib_la_generated_sources = \
libarrow_glib_la_sources = \
array.cpp \
array-builder.cpp \
- binary-array-builder.cpp \
- boolean-array-builder.cpp \
buffer.cpp \
chunked-array.cpp \
column.cpp \
data-type.cpp \
- double-array-builder.cpp \
error.cpp \
field.cpp \
- float-array-builder.cpp \
- int8-array-builder.cpp \
- int16-array-builder.cpp \
- int32-array-builder.cpp \
- int64-array-builder.cpp \
- list-array-builder.cpp \
record-batch.cpp \
schema.cpp \
- string-array-builder.cpp \
- struct-array-builder.cpp \
table.cpp \
tensor.cpp \
type.cpp \
- uint8-array-builder.cpp \
- uint16-array-builder.cpp \
- uint32-array-builder.cpp \
- uint64-array-builder.cpp \
$(libarrow_glib_la_headers) \
$(libarrow_glib_la_generated_sources)
http://git-wip-us.apache.org/repos/asf/arrow/blob/76dfd987/c_glib/arrow-glib/array-builder.cpp
----------------------------------------------------------------------
diff --git a/c_glib/arrow-glib/array-builder.cpp b/c_glib/arrow-glib/array-builder.cpp
index aea93d0..97d43e1 100644
--- a/c_glib/arrow-glib/array-builder.cpp
+++ b/c_glib/arrow-glib/array-builder.cpp
@@ -22,32 +22,66 @@
#endif
#include <arrow-glib/array-builder.hpp>
-#include <arrow-glib/binary-array-builder.h>
-#include <arrow-glib/boolean-array-builder.h>
-#include <arrow-glib/double-array-builder.h>
-#include <arrow-glib/float-array-builder.h>
-#include <arrow-glib/int8-array-builder.h>
-#include <arrow-glib/int16-array-builder.h>
-#include <arrow-glib/int32-array-builder.h>
-#include <arrow-glib/int64-array-builder.h>
-#include <arrow-glib/list-array-builder.h>
-#include <arrow-glib/string-array-builder.h>
-#include <arrow-glib/struct-array-builder.h>
-#include <arrow-glib/uint8-array-builder.h>
-#include <arrow-glib/uint16-array-builder.h>
-#include <arrow-glib/uint32-array-builder.h>
-#include <arrow-glib/uint64-array-builder.h>
+#include <arrow-glib/data-type.hpp>
+#include <arrow-glib/error.hpp>
G_BEGIN_DECLS
/**
* SECTION: array-builder
- * @short_description: Base class for all array builder classes.
+ * @section_id: array-builder-classes
+ * @title: Array builder classes
+ * @include: arrow-glib/arrow-glib.h
*
* #GArrowArrayBuilder is a base class for all array builder classes
* such as #GArrowBooleanArrayBuilder.
*
* You need to use array builder class to create a new array.
+ *
+ * #GArrowBooleanArrayBuilder is the class to create a new
+ * #GArrowBooleanArray.
+ *
+ * #GArrowInt8ArrayBuilder is the class to create a new
+ * #GArrowInt8Array.
+ *
+ * #GArrowUInt8ArrayBuilder is the class to create a new
+ * #GArrowUInt8Array.
+ *
+ * #GArrowInt16ArrayBuilder is the class to create a new
+ * #GArrowInt16Array.
+ *
+ * #GArrowUInt16ArrayBuilder is the class to create a new
+ * #GArrowUInt16Array.
+ *
+ * #GArrowInt32ArrayBuilder is the class to create a new
+ * #GArrowInt32Array.
+ *
+ * #GArrowUInt32ArrayBuilder is the class to create a new
+ * #GArrowUInt32Array.
+ *
+ * #GArrowInt64ArrayBuilder is the class to create a new
+ * #GArrowInt64Array.
+ *
+ * #GArrowUInt64ArrayBuilder is the class to create a new
+ * #GArrowUInt64Array.
+ *
+ * #GArrowFloatArrayBuilder is the class to creating a new
+ * #GArrowFloatArray.
+ *
+ * #GArrowDoubleArrayBuilder is the class to create a new
+ * #GArrowDoubleArray.
+ *
+ * #GArrowBinaryArrayBuilder is the class to create a new
+ * #GArrowBinaryArray.
+ *
+ * #GArrowStringArrayBuilder is the class to create a new
+ * #GArrowStringArray.
+ *
+ * #GArrowListArrayBuilder is the class to create a new
+ * #GArrowListArray.
+ *
+ * #GArrowStructArrayBuilder is the class to create a new
+ * #GArrowStructArray.
*/
typedef struct GArrowArrayBuilderPrivate_ {
@@ -154,6 +188,1321 @@ garrow_array_builder_finish(GArrowArrayBuilder *builder)
return garrow_array_new_raw(&arrow_array);
}
+
+G_DEFINE_TYPE(GArrowBooleanArrayBuilder,
+ garrow_boolean_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_boolean_array_builder_init(GArrowBooleanArrayBuilder *builder)
+{
+}
+
+static void
+garrow_boolean_array_builder_class_init(GArrowBooleanArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_boolean_array_builder_new:
+ *
+ * Returns: A newly created #GArrowBooleanArrayBuilder.
+ */
+GArrowBooleanArrayBuilder *
+garrow_boolean_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_boolean_builder =
+ std::make_shared<arrow::BooleanBuilder>(memory_pool);
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_boolean_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_BOOLEAN_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_boolean_array_builder_append:
+ * @builder: A #GArrowBooleanArrayBuilder.
+ * @value: A boolean value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_boolean_array_builder_append(GArrowBooleanArrayBuilder *builder,
+ gboolean value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::BooleanBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(static_cast<bool>(value));
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[boolean-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_boolean_array_builder_append_null:
+ * @builder: A #GArrowBooleanArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_boolean_array_builder_append_null(GArrowBooleanArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::BooleanBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[boolean-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowInt8ArrayBuilder,
+ garrow_int8_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_int8_array_builder_init(GArrowInt8ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_int8_array_builder_class_init(GArrowInt8ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_int8_array_builder_new:
+ *
+ * Returns: A newly created #GArrowInt8ArrayBuilder.
+ */
+GArrowInt8ArrayBuilder *
+garrow_int8_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_int8_builder =
+ std::make_shared<arrow::Int8Builder>(memory_pool, arrow::int8());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_int8_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_INT8_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_int8_array_builder_append:
+ * @builder: A #GArrowInt8ArrayBuilder.
+ * @value: A int8 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int8_array_builder_append(GArrowInt8ArrayBuilder *builder,
+ gint8 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int8Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int8-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_int8_array_builder_append_null:
+ * @builder: A #GArrowInt8ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int8_array_builder_append_null(GArrowInt8ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int8Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int8-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowUInt8ArrayBuilder,
+ garrow_uint8_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_uint8_array_builder_init(GArrowUInt8ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_uint8_array_builder_class_init(GArrowUInt8ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_uint8_array_builder_new:
+ *
+ * Returns: A newly created #GArrowUInt8ArrayBuilder.
+ */
+GArrowUInt8ArrayBuilder *
+garrow_uint8_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_uint8_builder =
+ std::make_shared<arrow::UInt8Builder>(memory_pool, arrow::uint8());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_uint8_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_UINT8_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_uint8_array_builder_append:
+ * @builder: A #GArrowUInt8ArrayBuilder.
+ * @value: An uint8 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint8_array_builder_append(GArrowUInt8ArrayBuilder *builder,
+ guint8 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt8Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint8-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_uint8_array_builder_append_null:
+ * @builder: A #GArrowUInt8ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint8_array_builder_append_null(GArrowUInt8ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt8Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint8-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowInt16ArrayBuilder,
+ garrow_int16_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_int16_array_builder_init(GArrowInt16ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_int16_array_builder_class_init(GArrowInt16ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_int16_array_builder_new:
+ *
+ * Returns: A newly created #GArrowInt16ArrayBuilder.
+ */
+GArrowInt16ArrayBuilder *
+garrow_int16_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_int16_builder =
+ std::make_shared<arrow::Int16Builder>(memory_pool, arrow::int16());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_int16_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_INT16_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_int16_array_builder_append:
+ * @builder: A #GArrowInt16ArrayBuilder.
+ * @value: A int16 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int16_array_builder_append(GArrowInt16ArrayBuilder *builder,
+ gint16 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int16Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int16-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_int16_array_builder_append_null:
+ * @builder: A #GArrowInt16ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int16_array_builder_append_null(GArrowInt16ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int16Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int16-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowUInt16ArrayBuilder,
+ garrow_uint16_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_uint16_array_builder_init(GArrowUInt16ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_uint16_array_builder_class_init(GArrowUInt16ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_uint16_array_builder_new:
+ *
+ * Returns: A newly created #GArrowUInt16ArrayBuilder.
+ */
+GArrowUInt16ArrayBuilder *
+garrow_uint16_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_uint16_builder =
+ std::make_shared<arrow::UInt16Builder>(memory_pool, arrow::uint16());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_uint16_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_UINT16_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_uint16_array_builder_append:
+ * @builder: A #GArrowUInt16ArrayBuilder.
+ * @value: An uint16 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint16_array_builder_append(GArrowUInt16ArrayBuilder *builder,
+ guint16 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt16Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint16-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_uint16_array_builder_append_null:
+ * @builder: A #GArrowUInt16ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint16_array_builder_append_null(GArrowUInt16ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt16Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint16-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowInt32ArrayBuilder,
+ garrow_int32_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_int32_array_builder_init(GArrowInt32ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_int32_array_builder_class_init(GArrowInt32ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_int32_array_builder_new:
+ *
+ * Returns: A newly created #GArrowInt32ArrayBuilder.
+ */
+GArrowInt32ArrayBuilder *
+garrow_int32_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_int32_builder =
+ std::make_shared<arrow::Int32Builder>(memory_pool, arrow::int32());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_int32_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_INT32_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_int32_array_builder_append:
+ * @builder: A #GArrowInt32ArrayBuilder.
+ * @value: A int32 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int32_array_builder_append(GArrowInt32ArrayBuilder *builder,
+ gint32 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int32Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int32-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_int32_array_builder_append_null:
+ * @builder: A #GArrowInt32ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int32_array_builder_append_null(GArrowInt32ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int32Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int32-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowUInt32ArrayBuilder,
+ garrow_uint32_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_uint32_array_builder_init(GArrowUInt32ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_uint32_array_builder_class_init(GArrowUInt32ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_uint32_array_builder_new:
+ *
+ * Returns: A newly created #GArrowUInt32ArrayBuilder.
+ */
+GArrowUInt32ArrayBuilder *
+garrow_uint32_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_uint32_builder =
+ std::make_shared<arrow::UInt32Builder>(memory_pool, arrow::uint32());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_uint32_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_UINT32_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_uint32_array_builder_append:
+ * @builder: A #GArrowUInt32ArrayBuilder.
+ * @value: An uint32 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint32_array_builder_append(GArrowUInt32ArrayBuilder *builder,
+ guint32 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt32Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint32-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_uint32_array_builder_append_null:
+ * @builder: A #GArrowUInt32ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint32_array_builder_append_null(GArrowUInt32ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt32Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint32-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowInt64ArrayBuilder,
+ garrow_int64_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_int64_array_builder_init(GArrowInt64ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_int64_array_builder_class_init(GArrowInt64ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_int64_array_builder_new:
+ *
+ * Returns: A newly created #GArrowInt64ArrayBuilder.
+ */
+GArrowInt64ArrayBuilder *
+garrow_int64_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_int64_builder =
+ std::make_shared<arrow::Int64Builder>(memory_pool, arrow::int64());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_int64_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_INT64_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_int64_array_builder_append:
+ * @builder: A #GArrowInt64ArrayBuilder.
+ * @value: A int64 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int64_array_builder_append(GArrowInt64ArrayBuilder *builder,
+ gint64 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int64Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int64-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_int64_array_builder_append_null:
+ * @builder: A #GArrowInt64ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_int64_array_builder_append_null(GArrowInt64ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::Int64Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[int64-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowUInt64ArrayBuilder,
+ garrow_uint64_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_uint64_array_builder_init(GArrowUInt64ArrayBuilder *builder)
+{
+}
+
+static void
+garrow_uint64_array_builder_class_init(GArrowUInt64ArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_uint64_array_builder_new:
+ *
+ * Returns: A newly created #GArrowUInt64ArrayBuilder.
+ */
+GArrowUInt64ArrayBuilder *
+garrow_uint64_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_uint64_builder =
+ std::make_shared<arrow::UInt64Builder>(memory_pool, arrow::uint64());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_uint64_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_UINT64_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_uint64_array_builder_append:
+ * @builder: A #GArrowUInt64ArrayBuilder.
+ * @value: An uint64 value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint64_array_builder_append(GArrowUInt64ArrayBuilder *builder,
+ guint64 value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt64Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint64-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_uint64_array_builder_append_null:
+ * @builder: A #GArrowUInt64ArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_uint64_array_builder_append_null(GArrowUInt64ArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::UInt64Builder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[uint64-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowFloatArrayBuilder,
+ garrow_float_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_float_array_builder_init(GArrowFloatArrayBuilder *builder)
+{
+}
+
+static void
+garrow_float_array_builder_class_init(GArrowFloatArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_float_array_builder_new:
+ *
+ * Returns: A newly created #GArrowFloatArrayBuilder.
+ */
+GArrowFloatArrayBuilder *
+garrow_float_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_float_builder =
+ std::make_shared<arrow::FloatBuilder>(memory_pool, arrow::float32());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_float_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_FLOAT_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_float_array_builder_append:
+ * @builder: A #GArrowFloatArrayBuilder.
+ * @value: A float value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_float_array_builder_append(GArrowFloatArrayBuilder *builder,
+ gfloat value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::FloatBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[float-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_float_array_builder_append_null:
+ * @builder: A #GArrowFloatArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_float_array_builder_append_null(GArrowFloatArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::FloatBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[float-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowDoubleArrayBuilder,
+ garrow_double_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_double_array_builder_init(GArrowDoubleArrayBuilder *builder)
+{
+}
+
+static void
+garrow_double_array_builder_class_init(GArrowDoubleArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_double_array_builder_new:
+ *
+ * Returns: A newly created #GArrowDoubleArrayBuilder.
+ */
+GArrowDoubleArrayBuilder *
+garrow_double_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_double_builder =
+ std::make_shared<arrow::DoubleBuilder>(memory_pool, arrow::float64());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_double_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_DOUBLE_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_double_array_builder_append:
+ * @builder: A #GArrowDoubleArrayBuilder.
+ * @value: A double value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_double_array_builder_append(GArrowDoubleArrayBuilder *builder,
+ gdouble value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::DoubleBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[double-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_double_array_builder_append_null:
+ * @builder: A #GArrowDoubleArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_double_array_builder_append_null(GArrowDoubleArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::DoubleBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[double-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowBinaryArrayBuilder,
+ garrow_binary_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_binary_array_builder_init(GArrowBinaryArrayBuilder *builder)
+{
+}
+
+static void
+garrow_binary_array_builder_class_init(GArrowBinaryArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_binary_array_builder_new:
+ *
+ * Returns: A newly created #GArrowBinaryArrayBuilder.
+ */
+GArrowBinaryArrayBuilder *
+garrow_binary_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_binary_builder =
+ std::make_shared<arrow::BinaryBuilder>(memory_pool, arrow::binary());
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_binary_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_BINARY_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_binary_array_builder_append:
+ * @builder: A #GArrowBinaryArrayBuilder.
+ * @value: (array length=length): A binary value.
+ * @length: A value length.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_binary_array_builder_append(GArrowBinaryArrayBuilder *builder,
+ const guint8 *value,
+ gint32 length,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::BinaryBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value, length);
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[binary-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_binary_array_builder_append_null:
+ * @builder: A #GArrowBinaryArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_binary_array_builder_append_null(GArrowBinaryArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::BinaryBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[binary-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowStringArrayBuilder,
+ garrow_string_array_builder,
+ GARROW_TYPE_BINARY_ARRAY_BUILDER)
+
+static void
+garrow_string_array_builder_init(GArrowStringArrayBuilder *builder)
+{
+}
+
+static void
+garrow_string_array_builder_class_init(GArrowStringArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_string_array_builder_new:
+ *
+ * Returns: A newly created #GArrowStringArrayBuilder.
+ */
+GArrowStringArrayBuilder *
+garrow_string_array_builder_new(void)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_string_builder =
+ std::make_shared<arrow::StringBuilder>(memory_pool);
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_string_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_STRING_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_string_array_builder_append:
+ * @builder: A #GArrowStringArrayBuilder.
+ * @value: A string value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ */
+gboolean
+garrow_string_array_builder_append(GArrowStringArrayBuilder *builder,
+ const gchar *value,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::StringBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append(value,
+ static_cast<gint32>(strlen(value)));
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[string-array-builder][append]");
+ return FALSE;
+ }
+}
+
+
+G_DEFINE_TYPE(GArrowListArrayBuilder,
+ garrow_list_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_list_array_builder_init(GArrowListArrayBuilder *builder)
+{
+}
+
+static void
+garrow_list_array_builder_class_init(GArrowListArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_list_array_builder_new:
+ * @value_builder: A #GArrowArrayBuilder for value array.
+ *
+ * Returns: A newly created #GArrowListArrayBuilder.
+ */
+GArrowListArrayBuilder *
+garrow_list_array_builder_new(GArrowArrayBuilder *value_builder)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_value_builder = garrow_array_builder_get_raw(value_builder);
+ auto arrow_list_builder =
+ std::make_shared<arrow::ListBuilder>(memory_pool, arrow_value_builder);
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_list_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_LIST_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_list_array_builder_append:
+ * @builder: A #GArrowListArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * It appends a new list element. To append a new list element, you
+ * need to call this function then append list element values to
+ * `value_builder`. `value_builder` is the #GArrowArrayBuilder
+ * specified to constructor. You can get `value_builder` by
+ * garrow_list_array_builder_get_value_builder().
+ *
+ * |[<!-- language="C" -->
+ * GArrowInt8ArrayBuilder *value_builder;
+ * GArrowListArrayBuilder *builder;
+ *
+ * value_builder = garrow_int8_array_builder_new();
+ * builder = garrow_list_array_builder_new(value_builder, NULL);
+ *
+ * // Start 0th list element: [1, 0, -1]
+ * garrow_list_array_builder_append(builder, NULL);
+ * garrow_int8_array_builder_append(value_builder, 1);
+ * garrow_int8_array_builder_append(value_builder, 0);
+ * garrow_int8_array_builder_append(value_builder, -1);
+ *
+ * // Start 1st list element: [-29, 29]
+ * garrow_list_array_builder_append(builder, NULL);
+ * garrow_int8_array_builder_append(value_builder, -29);
+ * garrow_int8_array_builder_append(value_builder, 29);
+ *
+ * {
+ * // [[1, 0, -1], [-29, 29]]
+ * GArrowArray *array = garrow_array_builder_finish(builder);
+ * // Now, builder is needless.
+ * g_object_unref(builder);
+ * g_object_unref(value_builder);
+ *
+ * // Use array...
+ * g_object_unref(array);
+ * }
+ * ]|
+ */
+gboolean
+garrow_list_array_builder_append(GArrowListArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::ListBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[list-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_list_array_builder_append_null:
+ * @builder: A #GArrowListArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * It appends a new NULL element.
+ */
+gboolean
+garrow_list_array_builder_append_null(GArrowListArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::ListBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[list-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_list_array_builder_get_value_builder:
+ * @builder: A #GArrowListArrayBuilder.
+ *
+ * Returns: (transfer full): The #GArrowArrayBuilder for values.
+ */
+GArrowArrayBuilder *
+garrow_list_array_builder_get_value_builder(GArrowListArrayBuilder *builder)
+{
+ auto arrow_builder =
+ static_cast<arrow::ListBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+ auto arrow_value_builder = arrow_builder->value_builder();
+ return garrow_array_builder_new_raw(&arrow_value_builder);
+}
+
+
+G_DEFINE_TYPE(GArrowStructArrayBuilder,
+ garrow_struct_array_builder,
+ GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_struct_array_builder_init(GArrowStructArrayBuilder *builder)
+{
+}
+
+static void
+garrow_struct_array_builder_class_init(GArrowStructArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_struct_array_builder_new:
+ * @data_type: #GArrowStructDataType for the struct.
+ * @field_builders: (element-type GArrowArray): #GArrowArrayBuilders
+ * for fields.
+ *
+ * Returns: A newly created #GArrowStructArrayBuilder.
+ */
+GArrowStructArrayBuilder *
+garrow_struct_array_builder_new(GArrowStructDataType *data_type,
+ GList *field_builders)
+{
+ auto memory_pool = arrow::default_memory_pool();
+ auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+ std::vector<std::shared_ptr<arrow::ArrayBuilder>> arrow_field_builders;
+ for (GList *node = field_builders; node; node = g_list_next(node)) {
+ auto field_builder = static_cast<GArrowArrayBuilder *>(node->data);
+ auto arrow_field_builder = garrow_array_builder_get_raw(field_builder);
+ arrow_field_builders.push_back(arrow_field_builder);
+ }
+
+ auto arrow_struct_builder =
+ std::make_shared<arrow::StructBuilder>(memory_pool,
+ arrow_data_type,
+ arrow_field_builders);
+ std::shared_ptr<arrow::ArrayBuilder> arrow_builder = arrow_struct_builder;
+ auto builder = garrow_array_builder_new_raw(&arrow_builder);
+ return GARROW_STRUCT_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_struct_array_builder_append:
+ * @builder: A #GArrowStructArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * It appends a new struct element. To append a new struct element,
+ * you need to call this function then append struct element field
+ * values to all `field_builder`s. `field_value`s are the
+ * #GArrowArrayBuilder specified to constructor. You can get
+ * `field_builder` by garrow_struct_array_builder_get_field_builder()
+ * or garrow_struct_array_builder_get_field_builders().
+ *
+ * |[<!-- language="C" -->
+ * // TODO
+ * ]|
+ */
+gboolean
+garrow_struct_array_builder_append(GArrowStructArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::StructBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->Append();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[struct-array-builder][append]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_struct_array_builder_append_null:
+ * @builder: A #GArrowStructArrayBuilder.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * It appends a new NULL element.
+ */
+gboolean
+garrow_struct_array_builder_append_null(GArrowStructArrayBuilder *builder,
+ GError **error)
+{
+ auto arrow_builder =
+ static_cast<arrow::StructBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ auto status = arrow_builder->AppendNull();
+ if (status.ok()) {
+ return TRUE;
+ } else {
+ garrow_error_set(error, status, "[struct-array-builder][append-null]");
+ return FALSE;
+ }
+}
+
+/**
+ * garrow_struct_array_builder_get_field_builder:
+ * @builder: A #GArrowStructArrayBuilder.
+ * @i: The index of the field in the struct.
+ *
+ * Returns: (transfer full): The #GArrowArrayBuilder for the i-th field.
+ */
+GArrowArrayBuilder *
+garrow_struct_array_builder_get_field_builder(GArrowStructArrayBuilder *builder,
+ gint i)
+{
+ auto arrow_builder =
+ static_cast<arrow::StructBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+ auto arrow_field_builder = arrow_builder->field_builder(i);
+ return garrow_array_builder_new_raw(&arrow_field_builder);
+}
+
+/**
+ * garrow_struct_array_builder_get_field_builders:
+ * @builder: A #GArrowStructArrayBuilder.
+ *
+ * Returns: (element-type GArrowArray) (transfer full):
+ * The #GArrowArrayBuilder for all fields.
+ */
+GList *
+garrow_struct_array_builder_get_field_builders(GArrowStructArrayBuilder *builder)
+{
+ auto arrow_struct_builder =
+ static_cast<arrow::StructBuilder *>(
+ garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
+
+ GList *field_builders = NULL;
+ for (auto arrow_field_builder : arrow_struct_builder->field_builders()) {
+ auto field_builder = garrow_array_builder_new_raw(&arrow_field_builder);
+ field_builders = g_list_prepend(field_builders, field_builder);
+ }
+
+ return g_list_reverse(field_builders);
+}
+
+
G_END_DECLS
GArrowArrayBuilder *
http://git-wip-us.apache.org/repos/asf/arrow/blob/76dfd987/c_glib/arrow-glib/array-builder.h
----------------------------------------------------------------------
diff --git a/c_glib/arrow-glib/array-builder.h b/c_glib/arrow-glib/array-builder.h
index 3717aef..ad72f9a 100644
--- a/c_glib/arrow-glib/array-builder.h
+++ b/c_glib/arrow-glib/array-builder.h
@@ -67,4 +67,773 @@ GType garrow_array_builder_get_type (void) G_GNUC_CONST;
GArrowArray *garrow_array_builder_finish (GArrowArrayBuilder *builder);
+
+#define GARROW_TYPE_BOOLEAN_ARRAY_BUILDER \
+ (garrow_boolean_array_builder_get_type())
+#define GARROW_BOOLEAN_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_BOOLEAN_ARRAY_BUILDER, \
+ GArrowBooleanArrayBuilder))
+#define GARROW_BOOLEAN_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_BOOLEAN_ARRAY_BUILDER, \
+ GArrowBooleanArrayBuilderClass))
+#define GARROW_IS_BOOLEAN_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_BOOLEAN_ARRAY_BUILDER))
+#define GARROW_IS_BOOLEAN_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_BOOLEAN_ARRAY_BUILDER))
+#define GARROW_BOOLEAN_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_BOOLEAN_ARRAY_BUILDER, \
+ GArrowBooleanArrayBuilderClass))
+
+typedef struct _GArrowBooleanArrayBuilder GArrowBooleanArrayBuilder;
+typedef struct _GArrowBooleanArrayBuilderClass GArrowBooleanArrayBuilderClass;
+
+/**
+ * GArrowBooleanArrayBuilder:
+ *
+ * It wraps `arrow::BooleanBuilder`.
+ */
+struct _GArrowBooleanArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowBooleanArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_boolean_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowBooleanArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_INT8_ARRAY_BUILDER \
+ (garrow_int8_array_builder_get_type())
+#define GARROW_INT8_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_INT8_ARRAY_BUILDER, \
+ GArrowInt8ArrayBuilder))
+#define GARROW_INT8_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_INT8_ARRAY_BUILDER, \
+ GArrowInt8ArrayBuilderClass))
+#define GARROW_IS_INT8_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_INT8_ARRAY_BUILDER))
+#define GARROW_IS_INT8_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_INT8_ARRAY_BUILDER))
+#define GARROW_INT8_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_INT8_ARRAY_BUILDER, \
+ GArrowInt8ArrayBuilderClass))
+
+typedef struct _GArrowInt8ArrayBuilder GArrowInt8ArrayBuilder;
+typedef struct _GArrowInt8ArrayBuilderClass GArrowInt8ArrayBuilderClass;
+
+/**
+ * GArrowInt8ArrayBuilder:
+ *
+ * It wraps `arrow::Int8Builder`.
+ */
+struct _GArrowInt8ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowInt8ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_int8_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowInt8ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_UINT8_ARRAY_BUILDER \
+ (garrow_uint8_array_builder_get_type())
+#define GARROW_UINT8_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_UINT8_ARRAY_BUILDER, \
+ GArrowUInt8ArrayBuilder))
+#define GARROW_UINT8_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_UINT8_ARRAY_BUILDER, \
+ GArrowUInt8ArrayBuilderClass))
+#define GARROW_IS_UINT8_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_UINT8_ARRAY_BUILDER))
+#define GARROW_IS_UINT8_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_UINT8_ARRAY_BUILDER))
+#define GARROW_UINT8_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_UINT8_ARRAY_BUILDER, \
+ GArrowUInt8ArrayBuilderClass))
+
+typedef struct _GArrowUInt8ArrayBuilder GArrowUInt8ArrayBuilder;
+typedef struct _GArrowUInt8ArrayBuilderClass GArrowUInt8ArrayBuilderClass;
+
+/**
+ * GArrowUInt8ArrayBuilder:
+ *
+ * It wraps `arrow::UInt8Builder`.
+ */
+struct _GArrowUInt8ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowUInt8ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_uint8_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowUInt8ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_INT16_ARRAY_BUILDER \
+ (garrow_int16_array_builder_get_type())
+#define GARROW_INT16_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_INT16_ARRAY_BUILDER, \
+ GArrowInt16ArrayBuilder))
+#define GARROW_INT16_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_INT16_ARRAY_BUILDER, \
+ GArrowInt16ArrayBuilderClass))
+#define GARROW_IS_INT16_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_INT16_ARRAY_BUILDER))
+#define GARROW_IS_INT16_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_INT16_ARRAY_BUILDER))
+#define GARROW_INT16_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_INT16_ARRAY_BUILDER, \
+ GArrowInt16ArrayBuilderClass))
+
+typedef struct _GArrowInt16ArrayBuilder GArrowInt16ArrayBuilder;
+typedef struct _GArrowInt16ArrayBuilderClass GArrowInt16ArrayBuilderClass;
+
+/**
+ * GArrowInt16ArrayBuilder:
+ *
+ * It wraps `arrow::Int16Builder`.
+ */
+struct _GArrowInt16ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowInt16ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_int16_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowInt16ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_UINT16_ARRAY_BUILDER \
+ (garrow_uint16_array_builder_get_type())
+#define GARROW_UINT16_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_UINT16_ARRAY_BUILDER, \
+ GArrowUInt16ArrayBuilder))
+#define GARROW_UINT16_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_UINT16_ARRAY_BUILDER, \
+ GArrowUInt16ArrayBuilderClass))
+#define GARROW_IS_UINT16_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_UINT16_ARRAY_BUILDER))
+#define GARROW_IS_UINT16_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_UINT16_ARRAY_BUILDER))
+#define GARROW_UINT16_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_UINT16_ARRAY_BUILDER, \
+ GArrowUInt16ArrayBuilderClass))
+
+typedef struct _GArrowUInt16ArrayBuilder GArrowUInt16ArrayBuilder;
+typedef struct _GArrowUInt16ArrayBuilderClass GArrowUInt16ArrayBuilderClass;
+
+/**
+ * GArrowUInt16ArrayBuilder:
+ *
+ * It wraps `arrow::UInt16Builder`.
+ */
+struct _GArrowUInt16ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowUInt16ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_uint16_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowUInt16ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_INT32_ARRAY_BUILDER \
+ (garrow_int32_array_builder_get_type())
+#define GARROW_INT32_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_INT32_ARRAY_BUILDER, \
+ GArrowInt32ArrayBuilder))
+#define GARROW_INT32_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_INT32_ARRAY_BUILDER, \
+ GArrowInt32ArrayBuilderClass))
+#define GARROW_IS_INT32_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_INT32_ARRAY_BUILDER))
+#define GARROW_IS_INT32_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_INT32_ARRAY_BUILDER))
+#define GARROW_INT32_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_INT32_ARRAY_BUILDER, \
+ GArrowInt32ArrayBuilderClass))
+
+typedef struct _GArrowInt32ArrayBuilder GArrowInt32ArrayBuilder;
+typedef struct _GArrowInt32ArrayBuilderClass GArrowInt32ArrayBuilderClass;
+
+/**
+ * GArrowInt32ArrayBuilder:
+ *
+ * It wraps `arrow::Int32Builder`.
+ */
+struct _GArrowInt32ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowInt32ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_int32_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowInt32ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_UINT32_ARRAY_BUILDER \
+ (garrow_uint32_array_builder_get_type())
+#define GARROW_UINT32_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_UINT32_ARRAY_BUILDER, \
+ GArrowUInt32ArrayBuilder))
+#define GARROW_UINT32_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_UINT32_ARRAY_BUILDER, \
+ GArrowUInt32ArrayBuilderClass))
+#define GARROW_IS_UINT32_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_UINT32_ARRAY_BUILDER))
+#define GARROW_IS_UINT32_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_UINT32_ARRAY_BUILDER))
+#define GARROW_UINT32_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_UINT32_ARRAY_BUILDER, \
+ GArrowUInt32ArrayBuilderClass))
+
+typedef struct _GArrowUInt32ArrayBuilder GArrowUInt32ArrayBuilder;
+typedef struct _GArrowUInt32ArrayBuilderClass GArrowUInt32ArrayBuilderClass;
+
+/**
+ * GArrowUInt32ArrayBuilder:
+ *
+ * It wraps `arrow::UInt32Builder`.
+ */
+struct _GArrowUInt32ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowUInt32ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_uint32_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowUInt32ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_INT64_ARRAY_BUILDER \
+ (garrow_int64_array_builder_get_type())
+#define GARROW_INT64_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_INT64_ARRAY_BUILDER, \
+ GArrowInt64ArrayBuilder))
+#define GARROW_INT64_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_INT64_ARRAY_BUILDER, \
+ GArrowInt64ArrayBuilderClass))
+#define GARROW_IS_INT64_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_INT64_ARRAY_BUILDER))
+#define GARROW_IS_INT64_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_INT64_ARRAY_BUILDER))
+#define GARROW_INT64_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_INT64_ARRAY_BUILDER, \
+ GArrowInt64ArrayBuilderClass))
+
+typedef struct _GArrowInt64ArrayBuilder GArrowInt64ArrayBuilder;
+typedef struct _GArrowInt64ArrayBuilderClass GArrowInt64ArrayBuilderClass;
+
+/**
+ * GArrowInt64ArrayBuilder:
+ *
+ * It wraps `arrow::Int64Builder`.
+ */
+struct _GArrowInt64ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowInt64ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_int64_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowInt64ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_UINT64_ARRAY_BUILDER \
+ (garrow_uint64_array_builder_get_type())
+#define GARROW_UINT64_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_UINT64_ARRAY_BUILDER, \
+ GArrowUInt64ArrayBuilder))
+#define GARROW_UINT64_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_UINT64_ARRAY_BUILDER, \
+ GArrowUInt64ArrayBuilderClass))
+#define GARROW_IS_UINT64_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_UINT64_ARRAY_BUILDER))
+#define GARROW_IS_UINT64_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_UINT64_ARRAY_BUILDER))
+#define GARROW_UINT64_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_UINT64_ARRAY_BUILDER, \
+ GArrowUInt64ArrayBuilderClass))
+
+typedef struct _GArrowUInt64ArrayBuilder GArrowUInt64ArrayBuilder;
+typedef struct _GArrowUInt64ArrayBuilderClass GArrowUInt64ArrayBuilderClass;
+
+/**
+ * GArrowUInt64ArrayBuilder:
+ *
+ * It wraps `arrow::UInt64Builder`.
+ */
+struct _GArrowUInt64ArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowUInt64ArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_uint64_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowUInt64ArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_FLOAT_ARRAY_BUILDER \
+ (garrow_float_array_builder_get_type())
+#define GARROW_FLOAT_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_FLOAT_ARRAY_BUILDER, \
+ GArrowFloatArrayBuilder))
+#define GARROW_FLOAT_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_FLOAT_ARRAY_BUILDER, \
+ GArrowFloatArrayBuilderClass))
+#define GARROW_IS_FLOAT_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_FLOAT_ARRAY_BUILDER))
+#define GARROW_IS_FLOAT_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_FLOAT_ARRAY_BUILDER))
+#define GARROW_FLOAT_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_FLOAT_ARRAY_BUILDER, \
+ GArrowFloatArrayBuilderClass))
+
+typedef struct _GArrowFloatArrayBuilder GArrowFloatArrayBuilder;
+typedef struct _GArrowFloatArrayBuilderClass GArrowFloatArrayBuilderClass;
+
+/**
+ * GArrowFloatArrayBuilder:
+ *
+ * It wraps `arrow::FloatBuilder`.
+ */
+struct _GArrowFloatArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowFloatArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_float_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowFloatArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_DOUBLE_ARRAY_BUILDER \
+ (garrow_double_array_builder_get_type())
+#define GARROW_DOUBLE_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_DOUBLE_ARRAY_BUILDER, \
+ GArrowDoubleArrayBuilder))
+#define GARROW_DOUBLE_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_DOUBLE_ARRAY_BUILDER, \
+ GArrowDoubleArrayBuilderClass))
+#define GARROW_IS_DOUBLE_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_DOUBLE_ARRAY_BUILDER))
+#define GARROW_IS_DOUBLE_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_DOUBLE_ARRAY_BUILDER))
+#define GARROW_DOUBLE_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_DOUBLE_ARRAY_BUILDER, \
+ GArrowDoubleArrayBuilderClass))
+
+typedef struct _GArrowDoubleArrayBuilder GArrowDoubleArrayBuilder;
+typedef struct _GArrowDoubleArrayBuilderClass GArrowDoubleArrayBuilderClass;
+
+/**
+ * GArrowDoubleArrayBuilder:
+ *
+ * It wraps `arrow::DoubleBuilder`.
+ */
+struct _GArrowDoubleArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowDoubleArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_double_array_builder_get_type(void) G_GNUC_CONST;
+
+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_null(GArrowDoubleArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_BINARY_ARRAY_BUILDER \
+ (garrow_binary_array_builder_get_type())
+#define GARROW_BINARY_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_BINARY_ARRAY_BUILDER, \
+ GArrowBinaryArrayBuilder))
+#define GARROW_BINARY_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_BINARY_ARRAY_BUILDER, \
+ GArrowBinaryArrayBuilderClass))
+#define GARROW_IS_BINARY_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_BINARY_ARRAY_BUILDER))
+#define GARROW_IS_BINARY_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_BINARY_ARRAY_BUILDER))
+#define GARROW_BINARY_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_BINARY_ARRAY_BUILDER, \
+ GArrowBinaryArrayBuilderClass))
+
+typedef struct _GArrowBinaryArrayBuilder GArrowBinaryArrayBuilder;
+typedef struct _GArrowBinaryArrayBuilderClass GArrowBinaryArrayBuilderClass;
+
+/**
+ * GArrowBinaryArrayBuilder:
+ *
+ * It wraps `arrow::BinaryBuilder`.
+ */
+struct _GArrowBinaryArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowBinaryArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_binary_array_builder_get_type(void) G_GNUC_CONST;
+
+GArrowBinaryArrayBuilder *garrow_binary_array_builder_new(void);
+
+gboolean garrow_binary_array_builder_append(GArrowBinaryArrayBuilder *builder,
+ const guint8 *value,
+ gint32 length,
+ GError **error);
+gboolean garrow_binary_array_builder_append_null(GArrowBinaryArrayBuilder *builder,
+ GError **error);
+
+
+#define GARROW_TYPE_STRING_ARRAY_BUILDER \
+ (garrow_string_array_builder_get_type())
+#define GARROW_STRING_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_STRING_ARRAY_BUILDER, \
+ GArrowStringArrayBuilder))
+#define GARROW_STRING_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_STRING_ARRAY_BUILDER, \
+ GArrowStringArrayBuilderClass))
+#define GARROW_IS_STRING_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_STRING_ARRAY_BUILDER))
+#define GARROW_IS_STRING_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_STRING_ARRAY_BUILDER))
+#define GARROW_STRING_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_STRING_ARRAY_BUILDER, \
+ GArrowStringArrayBuilderClass))
+
+typedef struct _GArrowStringArrayBuilder GArrowStringArrayBuilder;
+typedef struct _GArrowStringArrayBuilderClass GArrowStringArrayBuilderClass;
+
+/**
+ * GArrowStringArrayBuilder:
+ *
+ * It wraps `arrow::StringBuilder`.
+ */
+struct _GArrowStringArrayBuilder
+{
+ /*< private >*/
+ GArrowBinaryArrayBuilder parent_instance;
+};
+
+struct _GArrowStringArrayBuilderClass
+{
+ GArrowBinaryArrayBuilderClass parent_class;
+};
+
+GType garrow_string_array_builder_get_type(void) G_GNUC_CONST;
+
+GArrowStringArrayBuilder *garrow_string_array_builder_new(void);
+
+gboolean garrow_string_array_builder_append(GArrowStringArrayBuilder *builder,
+ const gchar *value,
+ GError **error);
+
+
+#define GARROW_TYPE_LIST_ARRAY_BUILDER \
+ (garrow_list_array_builder_get_type())
+#define GARROW_LIST_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_LIST_ARRAY_BUILDER, \
+ GArrowListArrayBuilder))
+#define GARROW_LIST_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_LIST_ARRAY_BUILDER, \
+ GArrowListArrayBuilderClass))
+#define GARROW_IS_LIST_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_LIST_ARRAY_BUILDER))
+#define GARROW_IS_LIST_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_LIST_ARRAY_BUILDER))
+#define GARROW_LIST_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_LIST_ARRAY_BUILDER, \
+ GArrowListArrayBuilderClass))
+
+typedef struct _GArrowListArrayBuilder GArrowListArrayBuilder;
+typedef struct _GArrowListArrayBuilderClass GArrowListArrayBuilderClass;
+
+/**
+ * GArrowListArrayBuilder:
+ *
+ * It wraps `arrow::ListBuilder`.
+ */
+struct _GArrowListArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowListArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_list_array_builder_get_type(void) G_GNUC_CONST;
+
+GArrowListArrayBuilder *garrow_list_array_builder_new(GArrowArrayBuilder *value_builder);
+
+gboolean garrow_list_array_builder_append(GArrowListArrayBuilder *builder,
+ GError **error);
+gboolean garrow_list_array_builder_append_null(GArrowListArrayBuilder *builder,
+ GError **error);
+
+GArrowArrayBuilder *garrow_list_array_builder_get_value_builder(GArrowListArrayBuilder *builder);
+
+
+#define GARROW_TYPE_STRUCT_ARRAY_BUILDER \
+ (garrow_struct_array_builder_get_type())
+#define GARROW_STRUCT_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+ GARROW_TYPE_STRUCT_ARRAY_BUILDER, \
+ GArrowStructArrayBuilder))
+#define GARROW_STRUCT_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), \
+ GARROW_TYPE_STRUCT_ARRAY_BUILDER, \
+ GArrowStructArrayBuilderClass))
+#define GARROW_IS_STRUCT_ARRAY_BUILDER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+ GARROW_TYPE_STRUCT_ARRAY_BUILDER))
+#define GARROW_IS_STRUCT_ARRAY_BUILDER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), \
+ GARROW_TYPE_STRUCT_ARRAY_BUILDER))
+#define GARROW_STRUCT_ARRAY_BUILDER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS((obj), \
+ GARROW_TYPE_STRUCT_ARRAY_BUILDER, \
+ GArrowStructArrayBuilderClass))
+
+typedef struct _GArrowStructArrayBuilder GArrowStructArrayBuilder;
+typedef struct _GArrowStructArrayBuilderClass GArrowStructArrayBuilderClass;
+
+/**
+ * GArrowStructArrayBuilder:
+ *
+ * It wraps `arrow::StructBuilder`.
+ */
+struct _GArrowStructArrayBuilder
+{
+ /*< private >*/
+ GArrowArrayBuilder parent_instance;
+};
+
+struct _GArrowStructArrayBuilderClass
+{
+ GArrowArrayBuilderClass parent_class;
+};
+
+GType garrow_struct_array_builder_get_type(void) G_GNUC_CONST;
+
+GArrowStructArrayBuilder *garrow_struct_array_builder_new(GArrowStructDataType *data_type,
+ GList *field_builders);
+
+gboolean garrow_struct_array_builder_append(GArrowStructArrayBuilder *builder,
+ GError **error);
+gboolean garrow_struct_array_builder_append_null(GArrowStructArrayBuilder *builder,
+ GError **error);
+
+GArrowArrayBuilder *garrow_struct_array_builder_get_field_builder(GArrowStructArrayBuilder *builder,
+ gint i);
+GList *garrow_struct_array_builder_get_field_builders(GArrowStructArrayBuilder *builder);
+
G_END_DECLS
http://git-wip-us.apache.org/repos/asf/arrow/blob/76dfd987/c_glib/arrow-glib/arrow-glib.h
----------------------------------------------------------------------
diff --git a/c_glib/arrow-glib/arrow-glib.h b/c_glib/arrow-glib/arrow-glib.h
index 46e98d2..efff571 100644
--- a/c_glib/arrow-glib/arrow-glib.h
+++ b/c_glib/arrow-glib/arrow-glib.h
@@ -21,32 +21,17 @@
#include <arrow-glib/array.h>
#include <arrow-glib/array-builder.h>
-#include <arrow-glib/binary-array-builder.h>
-#include <arrow-glib/boolean-array-builder.h>
#include <arrow-glib/chunked-array.h>
#include <arrow-glib/column.h>
#include <arrow-glib/data-type.h>
-#include <arrow-glib/double-array-builder.h>
#include <arrow-glib/enums.h>
#include <arrow-glib/error.h>
#include <arrow-glib/field.h>
-#include <arrow-glib/float-array-builder.h>
-#include <arrow-glib/int8-array-builder.h>
-#include <arrow-glib/int16-array-builder.h>
-#include <arrow-glib/int32-array-builder.h>
-#include <arrow-glib/int64-array-builder.h>
-#include <arrow-glib/list-array-builder.h>
#include <arrow-glib/record-batch.h>
#include <arrow-glib/schema.h>
-#include <arrow-glib/string-array-builder.h>
-#include <arrow-glib/struct-array-builder.h>
#include <arrow-glib/table.h>
#include <arrow-glib/tensor.h>
#include <arrow-glib/type.h>
-#include <arrow-glib/uint8-array-builder.h>
-#include <arrow-glib/uint16-array-builder.h>
-#include <arrow-glib/uint32-array-builder.h>
-#include <arrow-glib/uint64-array-builder.h>
#include <arrow-glib/file.h>
#include <arrow-glib/file-mode.h>
http://git-wip-us.apache.org/repos/asf/arrow/blob/76dfd987/c_glib/arrow-glib/binary-array-builder.cpp
----------------------------------------------------------------------
diff --git a/c_glib/arrow-glib/binary-array-builder.cpp b/c_glib/arrow-glib/binary-array-builder.cpp
deleted file mode 100644
index ab11535..0000000
--- a/c_glib/arrow-glib/binary-array-builder.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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-builder.hpp>
-#include <arrow-glib/binary-array-builder.h>
-#include <arrow-glib/error.hpp>
-
-G_BEGIN_DECLS
-
-/**
- * SECTION: binary-array-builder
- * @short_description: Binary array builder class
- *
- * #GArrowBinaryArrayBuilder is the class to create a new
- * #GArrowBinaryArray.
- */
-
-G_DEFINE_TYPE(GArrowBinaryArrayBuilder,
- garrow_binary_array_builder,
- GARROW_TYPE_ARRAY_BUILDER)
-
-static void
-garrow_binary_array_builder_init(GArrowBinaryArrayBuilder *builder)
-{
-}
-
-static void
-garrow_binary_array_builder_class_init(GArrowBinaryArrayBuilderClass *klass)
-{
-}
-
-/**
- * garrow_binary_array_builder_new:
- *
- * Returns: A newly created #GArrowBinaryArrayBuilder.
- */
-GArrowBinaryArrayBuilder *
-garrow_binary_array_builder_new(void)
-{
- auto memory_pool = arrow::default_memory_pool();
- auto arrow_builder =
- std::make_shared<arrow::BinaryBuilder>(memory_pool, arrow::binary());
- auto builder =
- GARROW_BINARY_ARRAY_BUILDER(g_object_new(GARROW_TYPE_BINARY_ARRAY_BUILDER,
- "array-builder", &arrow_builder,
- NULL));
- return builder;
-}
-
-/**
- * garrow_binary_array_builder_append:
- * @builder: A #GArrowBinaryArrayBuilder.
- * @value: (array length=length): A binary value.
- * @length: A value length.
- * @error: (nullable): Return location for a #GError or %NULL.
- *
- * Returns: %TRUE on success, %FALSE if there was an error.
- */
-gboolean
-garrow_binary_array_builder_append(GArrowBinaryArrayBuilder *builder,
- const guint8 *value,
- gint32 length,
- GError **error)
-{
- auto arrow_builder =
- static_cast<arrow::BinaryBuilder *>(
- garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
-
- auto status = arrow_builder->Append(value, length);
- if (status.ok()) {
- return TRUE;
- } else {
- garrow_error_set(error, status, "[binary-array-builder][append]");
- return FALSE;
- }
-}
-
-/**
- * garrow_binary_array_builder_append_null:
- * @builder: A #GArrowBinaryArrayBuilder.
- * @error: (nullable): Return location for a #GError or %NULL.
- *
- * Returns: %TRUE on success, %FALSE if there was an error.
- */
-gboolean
-garrow_binary_array_builder_append_null(GArrowBinaryArrayBuilder *builder,
- GError **error)
-{
- auto arrow_builder =
- static_cast<arrow::BinaryBuilder *>(
- garrow_array_builder_get_raw(GARROW_ARRAY_BUILDER(builder)).get());
-
- auto status = arrow_builder->AppendNull();
- if (status.ok()) {
- return TRUE;
- } else {
- garrow_error_set(error, status, "[binary-array-builder][append-null]");
- return FALSE;
- }
-}
-
-G_END_DECLS