arrow-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From w...@apache.org
Subject [3/3] arrow git commit: ARROW-876: [GLib] Unify ArrayBuilder files
Date Sat, 22 Apr 2017 14:43:10 GMT
ARROW-876: [GLib] Unify ArrayBuilder files

Author: Kouhei Sutou <kou@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 <kou@clear-code.com>
Authored: Sat Apr 22 10:43:01 2017 -0400
Committer: Wes McKinney <wes.mckinney@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


Mime
View raw message