Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2405 insertions, 0 deletions

diff --git a/src/arrow/c_glib/arrow-glib/scalar.cpp b/src/arrow/c_glib/arrow-glib/scalar.cpp
new file mode 100644
index 000000000..847b48620
--- /dev/null
+++ b/src/arrow/c_glib/arrow-glib/scalar.cpp
@@ -0,0 +1,2405 @@
+/*
+ * 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.
+ */
+
+#include <arrow-glib/basic-array.hpp>
+#include <arrow-glib/buffer.hpp>
+#include <arrow-glib/data-type.hpp>
+#include <arrow-glib/decimal.hpp>
+#include <arrow-glib/error.hpp>
+#include <arrow-glib/scalar.hpp>
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION: scalar
+ * @section_id: scalar-classes
+ * @title: Scalar classes
+ * @include: arrow-glib/arrow-glib.h
+ *
+ * #GArrowScalar is a base class for all scalar classes such as
+ * #GArrowBooleanScalar.
+ *
+ * #GArrowNullScalar is a class for a null scalar.
+ *
+ * #GArrowBooleanScalar is a class for a boolean scalar.
+ *
+ * #GArrowInt8Scalar is a class for a 8-bit integer scalar.
+ *
+ * #GArrowInt16Scalar is a class for a 16-bit integer scalar.
+ *
+ * #GArrowInt32Scalar is a class for a 32-bit integer scalar.
+ *
+ * #GArrowInt64Scalar is a class for a 64-bit integer scalar.
+ *
+ * #GArrowUInt8Scalar is a class for a 8-bit unsigned integer scalar.
+ *
+ * #GArrowUInt16Scalar is a class for a 16-bit unsigned integer scalar.
+ *
+ * #GArrowUInt32Scalar is a class for a 32-bit unsigned integer scalar.
+ *
+ * #GArrowUInt64Scalar is a class for a 64-bit unsigned integer scalar.
+ *
+ * #GArrowFloatScalar is a class for a 32-bit floating point scalar.
+ *
+ * #GArrowDoubleScalar is a class for a 64-bit floating point scalar.
+ *
+ * #GArrowBaseBinaryScalar is a base class for all binary and string
+ * scalar classes such as #GArrowBinaryScalar.
+ *
+ * #GArrowBinaryScalar is a class for a binary scalar.
+ *
+ * #GArrowStringScalar is a class for an UTF-8 encoded string scalar.
+ *
+ * #GArrowLargeBinaryScalar is a class for a 64-bit offsets binary
+ * scalar.
+ *
+ * #GArrowLargeStringScalar is a class for a 64-bit offsets UTF-8
+ * encoded string scalar.
+ *
+ * #GArrowFixedSizeBinaryScalar is a class for a fixed-size binary
+ * scalar.
+ *
+ * #GArrowDate32Scalar is a class for the number of days since UNIX
+ * epoch in a 32-bit signed integer scalar.
+ *
+ * #GArrowDate64Scalar is a class for the number of milliseconds
+ * since UNIX epoch in a 64-bit signed integer scalar.
+ *
+ * #GArrowTime32Scalar is a class for the number of seconds or
+ * milliseconds since midnight in a 32-bit signed integer scalar.
+ *
+ * #GArrowTime64Scalar is a class for the number of microseconds or
+ * nanoseconds since midnight in a 64-bit signed integer scalar.
+ *
+ * #GArrowTimestampScalar is a class for the number of
+ * seconds/milliseconds/microseconds/nanoseconds since UNIX epoch in
+ * a 64-bit signed integer scalar.
+ *
+ * #GArrowDecimal128Scalar is a class for a 128-bit decimal scalar.
+ *
+ * #GArrowDecimal256Scalar is a class for a 256-bit decimal scalar.
+ *
+ * #GArrowBaseListScalar is a base class for all list scalar classes
+ * such as #GArrowListScalar.
+ *
+ * #GArrowListScalar is a class for a list scalar.
+ *
+ * #GArrowLargeListScalar is a class for a large list scalar.
+ *
+ * #GArrowMapScalar is a class for a map list scalar.
+ *
+ * #GArrowStructScalar is a class for a struct list scalar.
+ *
+ * #GArrowUnionScalar is a base class for all union scalar classes
+ * such as #GArrowSparseUnionScalar.
+ *
+ * #GArrowSparseUnionScalar is a class for a sparse union scalar.
+ *
+ * #GArrowDenseUnionScalar is a class for a dense union scalar.
+ *
+ * #GArrowExtensionScalar is a base class for user-defined extension
+ * scalar.
+ */
+
+typedef struct GArrowScalarPrivate_ {
+  std::shared_ptr<arrow::Scalar> scalar;
+  GArrowDataType *data_type;
+} GArrowScalarPrivate;
+
+enum {
+  PROP_SCALAR = 1,
+  PROP_DATA_TYPE,
+};
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(GArrowScalar,
+                                    garrow_scalar,
+                                    G_TYPE_OBJECT)
+
+#define GARROW_SCALAR_GET_PRIVATE(obj)            \
+  static_cast<GArrowScalarPrivate *>(             \
+    garrow_scalar_get_instance_private(           \
+      GARROW_SCALAR(obj)))
+
+static void
+garrow_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(object);
+
+  if (priv->data_type) {
+    g_object_unref(priv->data_type);
+    priv->data_type = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_scalar_finalize(GObject *object)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(object);
+
+  priv->scalar.~shared_ptr();
+
+  G_OBJECT_CLASS(garrow_scalar_parent_class)->finalize(object);
+}
+
+static void
+garrow_scalar_set_property(GObject *object,
+                           guint prop_id,
+                           const GValue *value,
+                           GParamSpec *pspec)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_SCALAR:
+    priv->scalar =
+      *static_cast<std::shared_ptr<arrow::Scalar> *>(g_value_get_pointer(value));
+    break;
+  case PROP_DATA_TYPE:
+    priv->data_type = GARROW_DATA_TYPE(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_scalar_init(GArrowScalar *object)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(object);
+  new(&priv->scalar) std::shared_ptr<arrow::Scalar>;
+}
+
+static void
+garrow_scalar_class_init(GArrowScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+
+  gobject_class->dispose      = garrow_scalar_dispose;
+  gobject_class->finalize     = garrow_scalar_finalize;
+  gobject_class->set_property = garrow_scalar_set_property;
+
+  GParamSpec *spec;
+  spec = g_param_spec_pointer("scalar",
+                              "Scalar",
+                              "The raw std::shared<arrow::Scalar> *",
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_SCALAR, spec);
+
+  /**
+   * GArrowScalar:data-type:
+   *
+   * The data type of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("data-type",
+                             "Data type",
+                             "The data type of the scalar",
+                             GARROW_TYPE_DATA_TYPE,
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_DATA_TYPE, spec);
+}
+
+/**
+ * garrow_scalar_parse:
+ * @data_type: A #GArrowDataType for the parsed scalar.
+ * @data: (array length=size): Data to be parsed.
+ * @size: The number of bytes of the data.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: (nullable) (transfer full):
+ *   A newly created #GArrowScalar if the data is parsed successfully,
+ *   %NULL otherwise.
+ *
+ * Since: 5.0.0
+ */
+GArrowScalar *
+garrow_scalar_parse(GArrowDataType *data_type,
+                    const guint8 *data,
+                    gsize size,
+                    GError **error)
+{
+  const auto arrow_data_type = garrow_data_type_get_raw(data_type);
+  auto arrow_data =
+    arrow::util::string_view(reinterpret_cast<const char *>(data),
+                             size);
+  auto arrow_scalar_result = arrow::Scalar::Parse(arrow_data_type, arrow_data);
+  if (garrow::check(error, arrow_scalar_result, "[scalar][parse]")) {
+    auto arrow_scalar = *arrow_scalar_result;
+    return garrow_scalar_new_raw(&arrow_scalar,
+                                 "scalar", &arrow_scalar,
+                                 "data-type", data_type,
+                                 NULL);
+  } else {
+    return NULL;
+  }
+}
+
+/**
+ * garrow_scalar_get_data_type:
+ * @scalar: A #GArrowScalar.
+ *
+ * Returns: (transfer none): The #GArrowDataType for the scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDataType *
+garrow_scalar_get_data_type(GArrowScalar *scalar)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(scalar);
+  if (!priv->data_type) {
+    priv->data_type = garrow_data_type_new_raw(&(priv->scalar->type));
+  }
+  return priv->data_type;
+}
+
+/**
+ * garrow_scalar_is_valid:
+ * @scalar: A #GArrowScalar.
+ *
+ * Returns: %TRUE if the scalar is valid, %FALSE otherwise.
+ *
+ * Since: 5.0.0
+ */
+gboolean
+garrow_scalar_is_valid(GArrowScalar *scalar)
+{
+  const auto arrow_scalar = garrow_scalar_get_raw(scalar);
+  return arrow_scalar->is_valid;
+}
+
+/**
+ * garrow_scalar_equal:
+ * @scalar: A #GArrowScalar.
+ * @other_scalar: A #GArrowScalar to be compared.
+ *
+ * Returns: %TRUE if both of them have the same data, %FALSE
+ *   otherwise.
+ *
+ * Since: 5.0.0
+ */
+gboolean
+garrow_scalar_equal(GArrowScalar *scalar,
+                    GArrowScalar *other_scalar)
+{
+  return garrow_scalar_equal_options(scalar, other_scalar, NULL);
+}
+
+/**
+ * garrow_scalar_equal_options:
+ * @scalar: A #GArrowScalar.
+ * @other_scalar: A #GArrowScalar to be compared.
+ * @options: (nullable): A #GArrowEqualOptions.
+ *
+ * Returns: %TRUE if both of them have the same data, %FALSE
+ *   otherwise.
+ *
+ * Since: 5.0.0
+ */
+gboolean
+garrow_scalar_equal_options(GArrowScalar *scalar,
+                            GArrowScalar *other_scalar,
+                            GArrowEqualOptions *options)
+{
+  const auto arrow_scalar = garrow_scalar_get_raw(scalar);
+  const auto arrow_other_scalar = garrow_scalar_get_raw(other_scalar);
+  if (options) {
+    auto is_approx = garrow_equal_options_is_approx(options);
+    const auto arrow_options = garrow_equal_options_get_raw(options);
+    if (is_approx) {
+      return arrow_scalar->ApproxEquals(*arrow_other_scalar, *arrow_options);
+    } else {
+      return arrow_scalar->Equals(arrow_other_scalar, *arrow_options);
+    }
+  } else {
+    return arrow_scalar->Equals(arrow_other_scalar);
+  }
+}
+
+/**
+ * garrow_scalar_to_string:
+ * @scalar: A #GArrowScalar.
+ *
+ * Returns: The string representation of the scalar.
+ *
+ *   It should be freed with g_free() when no longer needed.
+ *
+ * Since: 5.0.0
+ */
+gchar *
+garrow_scalar_to_string(GArrowScalar *scalar)
+{
+  const auto arrow_scalar = garrow_scalar_get_raw(scalar);
+  return g_strdup(arrow_scalar->ToString().c_str());
+}
+
+/**
+ * garrow_scalar_cast:
+ * @scalar: A #GArrowScalar.
+ * @data_type: A #GArrowDataType of the casted scalar.
+ * @options: (nullable): A #GArrowCastOptions.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: (nullable) (transfer full):
+ *   A newly created casted scalar on success, %NULL on error.
+ *
+ * Since: 5.0.0
+ */
+GArrowScalar *
+garrow_scalar_cast(GArrowScalar *scalar,
+                   GArrowDataType *data_type,
+                   GArrowCastOptions *options,
+                   GError **error)
+{
+  const auto arrow_scalar = garrow_scalar_get_raw(scalar);
+  const auto arrow_data_type = garrow_data_type_get_raw(data_type);
+  auto arrow_casted_scalar_result = arrow_scalar->CastTo(arrow_data_type);
+  if (garrow::check(error, arrow_casted_scalar_result, "[scalar][cast]")) {
+    auto arrow_casted_scalar = *arrow_casted_scalar_result;
+    return garrow_scalar_new_raw(&arrow_casted_scalar,
+                                 "scalar", &arrow_casted_scalar,
+                                 "data-type", data_type,
+                                 NULL);
+  } else {
+    return NULL;
+  }
+}
+
+
+G_DEFINE_TYPE(GArrowNullScalar,
+              garrow_null_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_null_scalar_init(GArrowNullScalar *object)
+{
+}
+
+static void
+garrow_null_scalar_class_init(GArrowNullScalarClass *klass)
+{
+}
+
+/**
+ * garrow_null_scalar_new:
+ *
+ * Returns: A newly created #GArrowNullScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowNullScalar *
+garrow_null_scalar_new(void)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::NullScalar>());
+  return GARROW_NULL_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+
+G_DEFINE_TYPE(GArrowBooleanScalar,
+              garrow_boolean_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_boolean_scalar_init(GArrowBooleanScalar *object)
+{
+}
+
+static void
+garrow_boolean_scalar_class_init(GArrowBooleanScalarClass *klass)
+{
+}
+
+/**
+ * garrow_boolean_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowBooleanScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowBooleanScalar *
+garrow_boolean_scalar_new(gboolean value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::BooleanScalar>(value));
+  return GARROW_BOOLEAN_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_boolean_scalar_get_value:
+ * @scalar: A #GArrowBooleanScalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gboolean
+garrow_boolean_scalar_get_value(GArrowBooleanScalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::BooleanScalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowInt8Scalar,
+              garrow_int8_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_int8_scalar_init(GArrowInt8Scalar *object)
+{
+}
+
+static void
+garrow_int8_scalar_class_init(GArrowInt8ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_int8_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowInt8Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowInt8Scalar *
+garrow_int8_scalar_new(gint8 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Int8Scalar>(value));
+  return GARROW_INT8_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_int8_scalar_get_value:
+ * @scalar: A #GArrowInt8Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint8
+garrow_int8_scalar_get_value(GArrowInt8Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Int8Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowInt16Scalar,
+              garrow_int16_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_int16_scalar_init(GArrowInt16Scalar *object)
+{
+}
+
+static void
+garrow_int16_scalar_class_init(GArrowInt16ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_int16_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowInt16Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowInt16Scalar *
+garrow_int16_scalar_new(gint16 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Int16Scalar>(value));
+  return GARROW_INT16_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_int16_scalar_get_value:
+ * @scalar: A #GArrowInt16Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint16
+garrow_int16_scalar_get_value(GArrowInt16Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Int16Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowInt32Scalar,
+              garrow_int32_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_int32_scalar_init(GArrowInt32Scalar *object)
+{
+}
+
+static void
+garrow_int32_scalar_class_init(GArrowInt32ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_int32_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowInt32Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowInt32Scalar *
+garrow_int32_scalar_new(gint32 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Int32Scalar>(value));
+  return GARROW_INT32_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_int32_scalar_get_value:
+ * @scalar: A #GArrowInt32Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint32
+garrow_int32_scalar_get_value(GArrowInt32Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Int32Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowInt64Scalar,
+              garrow_int64_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_int64_scalar_init(GArrowInt64Scalar *object)
+{
+}
+
+static void
+garrow_int64_scalar_class_init(GArrowInt64ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_int64_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowInt64Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowInt64Scalar *
+garrow_int64_scalar_new(gint64 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Int64Scalar>(value));
+  return GARROW_INT64_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_int64_scalar_get_value:
+ * @scalar: A #GArrowInt64Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint64
+garrow_int64_scalar_get_value(GArrowInt64Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Int64Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowUInt8Scalar,
+              garrow_uint8_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_uint8_scalar_init(GArrowUInt8Scalar *object)
+{
+}
+
+static void
+garrow_uint8_scalar_class_init(GArrowUInt8ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_uint8_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowUInt8Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowUInt8Scalar *
+garrow_uint8_scalar_new(guint8 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::UInt8Scalar>(value));
+  return GARROW_UINT8_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_uint8_scalar_get_value:
+ * @scalar: A #GArrowUInt8Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+guint8
+garrow_uint8_scalar_get_value(GArrowUInt8Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::UInt8Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowUInt16Scalar,
+              garrow_uint16_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_uint16_scalar_init(GArrowUInt16Scalar *object)
+{
+}
+
+static void
+garrow_uint16_scalar_class_init(GArrowUInt16ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_uint16_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowUInt16Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowUInt16Scalar *
+garrow_uint16_scalar_new(guint16 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::UInt16Scalar>(value));
+  return GARROW_UINT16_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_uint16_scalar_get_value:
+ * @scalar: A #GArrowUInt16Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+guint16
+garrow_uint16_scalar_get_value(GArrowUInt16Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::UInt16Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowUInt32Scalar,
+              garrow_uint32_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_uint32_scalar_init(GArrowUInt32Scalar *object)
+{
+}
+
+static void
+garrow_uint32_scalar_class_init(GArrowUInt32ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_uint32_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowUInt32Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowUInt32Scalar *
+garrow_uint32_scalar_new(guint32 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::UInt32Scalar>(value));
+  return GARROW_UINT32_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_uint32_scalar_get_value:
+ * @scalar: A #GArrowUInt32Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+guint32
+garrow_uint32_scalar_get_value(GArrowUInt32Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::UInt32Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowUInt64Scalar,
+              garrow_uint64_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_uint64_scalar_init(GArrowUInt64Scalar *object)
+{
+}
+
+static void
+garrow_uint64_scalar_class_init(GArrowUInt64ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_uint64_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowUInt64Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowUInt64Scalar *
+garrow_uint64_scalar_new(guint64 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::UInt64Scalar>(value));
+  return GARROW_UINT64_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_uint64_scalar_get_value:
+ * @scalar: A #GArrowUInt64Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+guint64
+garrow_uint64_scalar_get_value(GArrowUInt64Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::UInt64Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowFloatScalar,
+              garrow_float_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_float_scalar_init(GArrowFloatScalar *object)
+{
+}
+
+static void
+garrow_float_scalar_class_init(GArrowFloatScalarClass *klass)
+{
+}
+
+/**
+ * garrow_float_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowFloatScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowFloatScalar *
+garrow_float_scalar_new(gfloat value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::FloatScalar>(value));
+  return GARROW_FLOAT_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_float_scalar_get_value:
+ * @scalar: A #GArrowFloatScalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gfloat
+garrow_float_scalar_get_value(GArrowFloatScalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::FloatScalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowDoubleScalar,
+              garrow_double_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_double_scalar_init(GArrowDoubleScalar *object)
+{
+}
+
+static void
+garrow_double_scalar_class_init(GArrowDoubleScalarClass *klass)
+{
+}
+
+/**
+ * garrow_double_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDoubleScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDoubleScalar *
+garrow_double_scalar_new(gdouble value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::DoubleScalar>(value));
+  return GARROW_DOUBLE_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_double_scalar_get_value:
+ * @scalar: A #GArrowDoubleScalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gdouble
+garrow_double_scalar_get_value(GArrowDoubleScalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::DoubleScalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+typedef struct GArrowBaseBinaryScalarPrivate_ {
+  GArrowBuffer *value;
+} GArrowBaseBinaryScalarPrivate;
+
+enum {
+  PROP_VALUE = 1,
+};
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(GArrowBaseBinaryScalar,
+                                    garrow_base_binary_scalar,
+                                    GARROW_TYPE_SCALAR)
+
+#define GARROW_BASE_BINARY_SCALAR_GET_PRIVATE(obj)            \
+  static_cast<GArrowBaseBinaryScalarPrivate *>(               \
+    garrow_base_binary_scalar_get_instance_private(           \
+      GARROW_BASE_BINARY_SCALAR(obj)))
+
+static void
+garrow_base_binary_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_BASE_BINARY_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_object_unref(priv->value);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_base_binary_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_base_binary_scalar_set_property(GObject *object,
+                                       guint prop_id,
+                                       const GValue *value,
+                                       GParamSpec *pspec)
+{
+  auto priv = GARROW_BASE_BINARY_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_VALUE:
+    priv->value = GARROW_BUFFER(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_base_binary_scalar_init(GArrowBaseBinaryScalar *object)
+{
+}
+
+static void
+garrow_base_binary_scalar_class_init(GArrowBaseBinaryScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->dispose      = garrow_base_binary_scalar_dispose;
+  gobject_class->set_property = garrow_base_binary_scalar_set_property;
+
+  GParamSpec *spec;
+  /**
+   * GArrowBaseBinaryScalar:value:
+   *
+   * The value of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("value",
+                             "Value",
+                             "The value of the scalar",
+                             GARROW_TYPE_BUFFER,
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_VALUE, spec);
+}
+
+G_END_DECLS
+template<typename ArrowBinaryScalarType>
+GArrowScalar *
+garrow_base_binary_scalar_new(GArrowBuffer *value)
+{
+  auto arrow_value = garrow_buffer_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<ArrowBinaryScalarType>(arrow_value));
+  return garrow_scalar_new_raw(&arrow_scalar,
+                               "scalar", &arrow_scalar,
+                               "value", value,
+                               NULL);
+}
+G_BEGIN_DECLS
+
+/**
+ * garrow_base_binary_scalar_get_value:
+ * @scalar: A #GArrowBaseBinaryScalar.
+ *
+ * Returns: (transfer none): The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowBuffer *
+garrow_base_binary_scalar_get_value(GArrowBaseBinaryScalar *scalar)
+{
+  auto priv = GARROW_BASE_BINARY_SCALAR_GET_PRIVATE(scalar);
+  if (!priv->value) {
+    const auto arrow_scalar =
+      std::static_pointer_cast<arrow::BaseBinaryScalar>(
+        garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+    priv->value = garrow_buffer_new_raw(&(arrow_scalar->value));
+  }
+  return priv->value;
+}
+
+
+G_DEFINE_TYPE(GArrowBinaryScalar,
+              garrow_binary_scalar,
+              GARROW_TYPE_BASE_BINARY_SCALAR)
+
+static void
+garrow_binary_scalar_init(GArrowBinaryScalar *object)
+{
+}
+
+static void
+garrow_binary_scalar_class_init(GArrowBinaryScalarClass *klass)
+{
+}
+
+/**
+ * garrow_binary_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowBinaryScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowBinaryScalar *
+garrow_binary_scalar_new(GArrowBuffer *value)
+{
+  return GARROW_BINARY_SCALAR(
+    garrow_base_binary_scalar_new<arrow::BinaryScalar>(value));
+}
+
+
+G_DEFINE_TYPE(GArrowStringScalar,
+              garrow_string_scalar,
+              GARROW_TYPE_BASE_BINARY_SCALAR)
+
+static void
+garrow_string_scalar_init(GArrowStringScalar *object)
+{
+}
+
+static void
+garrow_string_scalar_class_init(GArrowStringScalarClass *klass)
+{
+}
+
+/**
+ * garrow_string_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowStringScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowStringScalar *
+garrow_string_scalar_new(GArrowBuffer *value)
+{
+  return GARROW_STRING_SCALAR(
+    garrow_base_binary_scalar_new<arrow::StringScalar>(value));
+}
+
+
+G_DEFINE_TYPE(GArrowLargeBinaryScalar,
+              garrow_large_binary_scalar,
+              GARROW_TYPE_BASE_BINARY_SCALAR)
+
+static void
+garrow_large_binary_scalar_init(GArrowLargeBinaryScalar *object)
+{
+}
+
+static void
+garrow_large_binary_scalar_class_init(GArrowLargeBinaryScalarClass *klass)
+{
+}
+
+/**
+ * garrow_large_binary_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowLargeBinaryScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowLargeBinaryScalar *
+garrow_large_binary_scalar_new(GArrowBuffer *value)
+{
+  return GARROW_LARGE_BINARY_SCALAR(
+    garrow_base_binary_scalar_new<arrow::LargeBinaryScalar>(value));
+}
+
+
+G_DEFINE_TYPE(GArrowLargeStringScalar,
+              garrow_large_string_scalar,
+              GARROW_TYPE_BASE_BINARY_SCALAR)
+
+static void
+garrow_large_string_scalar_init(GArrowLargeStringScalar *object)
+{
+}
+
+static void
+garrow_large_string_scalar_class_init(GArrowLargeStringScalarClass *klass)
+{
+}
+
+/**
+ * garrow_large_string_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowLargeStringScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowLargeStringScalar *
+garrow_large_string_scalar_new(GArrowBuffer *value)
+{
+  return GARROW_LARGE_STRING_SCALAR(
+    garrow_base_binary_scalar_new<arrow::LargeStringScalar>(value));
+}
+
+
+G_DEFINE_TYPE(GArrowFixedSizeBinaryScalar,
+              garrow_fixed_size_binary_scalar,
+              GARROW_TYPE_BASE_BINARY_SCALAR)
+
+static void
+garrow_fixed_size_binary_scalar_init(GArrowFixedSizeBinaryScalar *object)
+{
+}
+
+static void
+garrow_fixed_size_binary_scalar_class_init(
+  GArrowFixedSizeBinaryScalarClass *klass)
+{
+}
+
+/**
+ * garrow_fixed_size_binary_scalar_new:
+ * @data_type: A #GArrowFixedSizeBinaryDataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowFixedSizeBinaryScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowFixedSizeBinaryScalar *
+garrow_fixed_size_binary_scalar_new(GArrowFixedSizeBinaryDataType *data_type,
+                                    GArrowBuffer *value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_value = garrow_buffer_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::FixedSizeBinaryScalar>(
+        arrow_value, arrow_data_type));
+  return GARROW_FIXED_SIZE_BINARY_SCALAR(
+    garrow_scalar_new_raw(&arrow_scalar,
+                          "scalar", &arrow_scalar,
+                          "data-type", data_type,
+                          "value", value,
+                          NULL));
+}
+
+
+G_DEFINE_TYPE(GArrowDate32Scalar,
+              garrow_date32_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_date32_scalar_init(GArrowDate32Scalar *object)
+{
+}
+
+static void
+garrow_date32_scalar_class_init(GArrowDate32ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_date32_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDate32Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDate32Scalar *
+garrow_date32_scalar_new(gint32 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Date32Scalar>(value));
+  return GARROW_DATE32_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_date32_scalar_get_value:
+ * @scalar: A #GArrowDate32Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint32
+garrow_date32_scalar_get_value(GArrowDate32Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Date32Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowDate64Scalar,
+              garrow_date64_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_date64_scalar_init(GArrowDate64Scalar *object)
+{
+}
+
+static void
+garrow_date64_scalar_class_init(GArrowDate64ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_date64_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDate64Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDate64Scalar *
+garrow_date64_scalar_new(gint64 value)
+{
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Date64Scalar>(value));
+  return GARROW_DATE64_SCALAR(garrow_scalar_new_raw(&arrow_scalar));
+}
+
+/**
+ * garrow_date64_scalar_get_value:
+ * @scalar: A #GArrowDate64Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint64
+garrow_date64_scalar_get_value(GArrowDate64Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Date64Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowTime32Scalar,
+              garrow_time32_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_time32_scalar_init(GArrowTime32Scalar *object)
+{
+}
+
+static void
+garrow_time32_scalar_class_init(GArrowTime32ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_time32_scalar_new:
+ * @data_type: A #GArrowTime32DataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowTime32Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowTime32Scalar *
+garrow_time32_scalar_new(GArrowTime32DataType *data_type,
+                         gint32 value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Time32Scalar>(value, arrow_data_type));
+  return GARROW_TIME32_SCALAR(
+    garrow_scalar_new_raw(&arrow_scalar,
+                          "scalar", &arrow_scalar,
+                          "data-type", data_type,
+                          NULL));
+}
+
+/**
+ * garrow_time32_scalar_get_value:
+ * @scalar: A #GArrowTime32Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint32
+garrow_time32_scalar_get_value(GArrowTime32Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Time32Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowTime64Scalar,
+              garrow_time64_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_time64_scalar_init(GArrowTime64Scalar *object)
+{
+}
+
+static void
+garrow_time64_scalar_class_init(GArrowTime64ScalarClass *klass)
+{
+}
+
+/**
+ * garrow_time64_scalar_new:
+ * @data_type: A #GArrowTime64DataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowTime64Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowTime64Scalar *
+garrow_time64_scalar_new(GArrowTime64DataType *data_type,
+                         gint64 value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Time64Scalar>(value, arrow_data_type));
+  return GARROW_TIME64_SCALAR(
+    garrow_scalar_new_raw(&arrow_scalar,
+                          "scalar", &arrow_scalar,
+                          "data-type", data_type,
+                          NULL));
+}
+
+/**
+ * garrow_time64_scalar_get_value:
+ * @scalar: A #GArrowTime64Scalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint64
+garrow_time64_scalar_get_value(GArrowTime64Scalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::Time64Scalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+G_DEFINE_TYPE(GArrowTimestampScalar,
+              garrow_timestamp_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_timestamp_scalar_init(GArrowTimestampScalar *object)
+{
+}
+
+static void
+garrow_timestamp_scalar_class_init(GArrowTimestampScalarClass *klass)
+{
+}
+
+/**
+ * garrow_timestamp_scalar_new:
+ * @data_type: A #GArrowTimestampDataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowTimestampScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowTimestampScalar *
+garrow_timestamp_scalar_new(GArrowTimestampDataType *data_type,
+                            gint64 value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::TimestampScalar>(value, arrow_data_type));
+  return GARROW_TIMESTAMP_SCALAR(
+    garrow_scalar_new_raw(&arrow_scalar,
+                          "scalar", &arrow_scalar,
+                          "data-type", data_type,
+                          NULL));
+}
+
+/**
+ * garrow_timestamp_scalar_get_value:
+ * @scalar: A #GArrowTimestampScalar.
+ *
+ * Returns: The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+gint64
+garrow_timestamp_scalar_get_value(GArrowTimestampScalar *scalar)
+{
+  const auto arrow_scalar =
+    std::static_pointer_cast<arrow::TimestampScalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->value;
+}
+
+
+typedef struct GArrowDecimal128ScalarPrivate_ {
+  GArrowDecimal128 *value;
+} GArrowDecimal128ScalarPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE(GArrowDecimal128Scalar,
+                           garrow_decimal128_scalar,
+                           GARROW_TYPE_SCALAR)
+
+#define GARROW_DECIMAL128_SCALAR_GET_PRIVATE(obj)            \
+  static_cast<GArrowDecimal128ScalarPrivate *>(              \
+    garrow_decimal128_scalar_get_instance_private(           \
+      GARROW_DECIMAL128_SCALAR(obj)))
+
+static void
+garrow_decimal128_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_DECIMAL128_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_object_unref(priv->value);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_decimal128_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_decimal128_scalar_set_property(GObject *object,
+                                      guint prop_id,
+                                      const GValue *value,
+                                      GParamSpec *pspec)
+{
+  auto priv = GARROW_DECIMAL128_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_VALUE:
+    priv->value = GARROW_DECIMAL128(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_decimal128_scalar_init(GArrowDecimal128Scalar *object)
+{
+}
+
+static void
+garrow_decimal128_scalar_class_init(GArrowDecimal128ScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+
+  gobject_class->dispose      = garrow_decimal128_scalar_dispose;
+  gobject_class->set_property = garrow_decimal128_scalar_set_property;
+
+  GParamSpec *spec;
+  /**
+   * GArrowDecimal128Scalar:value:
+   *
+   * The value of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("value",
+                             "Value",
+                             "The value of the scalar",
+                             garrow_decimal128_get_type(),
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_VALUE, spec);
+}
+
+/**
+ * garrow_decimal128_scalar_new:
+ * @data_type: A #GArrowDecimal128DataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDecimal128Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDecimal128Scalar *
+garrow_decimal128_scalar_new(GArrowDecimal128DataType *data_type,
+                             GArrowDecimal128 *value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_value = garrow_decimal128_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Decimal128Scalar>(*arrow_value, arrow_data_type));
+  return GARROW_DECIMAL128_SCALAR(
+    garrow_scalar_new_raw(&arrow_scalar,
+                          "scalar", &arrow_scalar,
+                          "data-type", data_type,
+                          "value", value,
+                          NULL));
+}
+
+/**
+ * garrow_decimal128_scalar_get_value:
+ * @scalar: A #GArrowDecimal128Scalar.
+ *
+ * Returns: (transfer none): The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDecimal128 *
+garrow_decimal128_scalar_get_value(GArrowDecimal128Scalar *scalar)
+{
+  auto priv = GARROW_DECIMAL128_SCALAR_GET_PRIVATE(scalar);
+  if (!priv->value) {
+    auto arrow_scalar =
+      std::static_pointer_cast<arrow::Decimal128Scalar>(
+        garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+    auto arrow_value = std::make_shared<arrow::Decimal128>(arrow_scalar->value);
+    priv->value = garrow_decimal128_new_raw(&arrow_value);
+  }
+  return priv->value;
+}
+
+
+typedef struct GArrowDecimal256ScalarPrivate_ {
+  GArrowDecimal256 *value;
+} GArrowDecimal256ScalarPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE(GArrowDecimal256Scalar,
+                           garrow_decimal256_scalar,
+                           GARROW_TYPE_SCALAR)
+
+#define GARROW_DECIMAL256_SCALAR_GET_PRIVATE(obj)            \
+  static_cast<GArrowDecimal256ScalarPrivate *>(              \
+    garrow_decimal256_scalar_get_instance_private(           \
+      GARROW_DECIMAL256_SCALAR(obj)))
+
+static void
+garrow_decimal256_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_DECIMAL256_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_object_unref(priv->value);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_decimal256_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_decimal256_scalar_set_property(GObject *object,
+                                      guint prop_id,
+                                      const GValue *value,
+                                      GParamSpec *pspec)
+{
+  auto priv = GARROW_DECIMAL256_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_VALUE:
+    priv->value = GARROW_DECIMAL256(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_decimal256_scalar_init(GArrowDecimal256Scalar *object)
+{
+}
+
+static void
+garrow_decimal256_scalar_class_init(GArrowDecimal256ScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+
+  gobject_class->dispose      = garrow_decimal256_scalar_dispose;
+  gobject_class->set_property = garrow_decimal256_scalar_set_property;
+
+  GParamSpec *spec;
+  /**
+   * GArrowDecimal256Scalar:value:
+   *
+   * The value of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("value",
+                             "Value",
+                             "The value of the scalar",
+                             garrow_decimal256_get_type(),
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_VALUE, spec);
+}
+
+/**
+ * garrow_decimal256_scalar_new:
+ * @data_type: A #GArrowDecimal256DataType for this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDecimal256Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDecimal256Scalar *
+garrow_decimal256_scalar_new(GArrowDecimal256DataType *data_type,
+                             GArrowDecimal256 *value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  auto arrow_value = garrow_decimal256_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::Decimal256Scalar>(*arrow_value, arrow_data_type));
+  return GARROW_DECIMAL256_SCALAR(garrow_scalar_new_raw(&arrow_scalar,
+                                                        "scalar", &arrow_scalar,
+                                                        "data-type", data_type,
+                                                        "value", value,
+                                                        NULL));
+}
+
+/**
+ * garrow_decimal256_scalar_get_value:
+ * @scalar: A #GArrowDecimal256Scalar.
+ *
+ * Returns: (transfer none): The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDecimal256 *
+garrow_decimal256_scalar_get_value(GArrowDecimal256Scalar *scalar)
+{
+  auto priv = GARROW_DECIMAL256_SCALAR_GET_PRIVATE(scalar);
+  if (!priv->value) {
+    auto arrow_scalar =
+      std::static_pointer_cast<arrow::Decimal256Scalar>(
+        garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+    auto arrow_value = std::make_shared<arrow::Decimal256>(arrow_scalar->value);
+    priv->value = garrow_decimal256_new_raw(&arrow_value);
+  }
+  return priv->value;
+}
+
+
+typedef struct GArrowBaseListScalarPrivate_ {
+  GArrowArray *value;
+} GArrowBaseListScalarPrivate;
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(GArrowBaseListScalar,
+                                    garrow_base_list_scalar,
+                                    GARROW_TYPE_SCALAR)
+
+#define GARROW_BASE_LIST_SCALAR_GET_PRIVATE(obj)            \
+  static_cast<GArrowBaseListScalarPrivate *>(               \
+    garrow_base_list_scalar_get_instance_private(           \
+      GARROW_BASE_LIST_SCALAR(obj)))
+
+static void
+garrow_base_list_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_BASE_LIST_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_object_unref(priv->value);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_base_list_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_base_list_scalar_set_property(GObject *object,
+                                     guint prop_id,
+                                     const GValue *value,
+                                     GParamSpec *pspec)
+{
+  auto priv = GARROW_BASE_LIST_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_VALUE:
+    priv->value = GARROW_ARRAY(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_base_list_scalar_init(GArrowBaseListScalar *object)
+{
+}
+
+static void
+garrow_base_list_scalar_class_init(GArrowBaseListScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+
+  gobject_class->dispose      = garrow_base_list_scalar_dispose;
+  gobject_class->set_property = garrow_base_list_scalar_set_property;
+
+  GParamSpec *spec;
+  /**
+   * GArrowBaseListScalar:value:
+   *
+   * The value of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("value",
+                             "Value",
+                             "The value of the scalar",
+                             GARROW_TYPE_ARRAY,
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_VALUE, spec);
+}
+
+G_END_DECLS
+template<typename ArrowListScalarType>
+GArrowScalar *
+garrow_base_list_scalar_new(GArrowArray *value)
+{
+  auto arrow_value = garrow_array_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<ArrowListScalarType>(arrow_value));
+  auto data_type = garrow_array_get_value_data_type(value);
+  auto scalar = garrow_scalar_new_raw(&arrow_scalar,
+                                      "scalar", &arrow_scalar,
+                                      "data-type", data_type,
+                                      "value", value,
+                                      NULL);
+  g_object_unref(data_type);
+  return scalar;
+}
+G_BEGIN_DECLS
+
+/**
+ * garrow_base_list_scalar_get_value:
+ * @scalar: A #GArrowBaseListScalar.
+ *
+ * Returns: (transfer none): The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowArray *
+garrow_base_list_scalar_get_value(GArrowBaseListScalar *scalar)
+{
+  auto priv = GARROW_BASE_LIST_SCALAR_GET_PRIVATE(scalar);
+  if (!priv->value) {
+    const auto arrow_scalar =
+      std::static_pointer_cast<arrow::BaseListScalar>(
+        garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+    priv->value = garrow_array_new_raw(&(arrow_scalar->value));
+  }
+  return priv->value;
+}
+
+
+G_DEFINE_TYPE(GArrowListScalar,
+              garrow_list_scalar,
+              GARROW_TYPE_BASE_LIST_SCALAR)
+
+static void
+garrow_list_scalar_init(GArrowListScalar *object)
+{
+}
+
+static void
+garrow_list_scalar_class_init(GArrowListScalarClass *klass)
+{
+}
+
+/**
+ * garrow_list_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowListScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowListScalar *
+garrow_list_scalar_new(GArrowListArray *value)
+{
+  return GARROW_LIST_SCALAR(
+    garrow_base_list_scalar_new<arrow::ListScalar>(GARROW_ARRAY(value)));
+}
+
+
+G_DEFINE_TYPE(GArrowLargeListScalar,
+              garrow_large_list_scalar,
+              GARROW_TYPE_BASE_LIST_SCALAR)
+
+static void
+garrow_large_list_scalar_init(GArrowLargeListScalar *object)
+{
+}
+
+static void
+garrow_large_list_scalar_class_init(GArrowLargeListScalarClass *klass)
+{
+}
+
+/**
+ * garrow_large_list_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowLargeListScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowLargeListScalar *
+garrow_large_list_scalar_new(GArrowLargeListArray *value)
+{
+  return GARROW_LARGE_LIST_SCALAR(
+    garrow_base_list_scalar_new<arrow::LargeListScalar>(GARROW_ARRAY(value)));
+}
+
+
+G_DEFINE_TYPE(GArrowMapScalar,
+              garrow_map_scalar,
+              GARROW_TYPE_BASE_LIST_SCALAR)
+
+static void
+garrow_map_scalar_init(GArrowMapScalar *object)
+{
+}
+
+static void
+garrow_map_scalar_class_init(GArrowMapScalarClass *klass)
+{
+}
+
+/**
+ * garrow_map_scalar_new:
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowMapScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowMapScalar *
+garrow_map_scalar_new(GArrowStructArray *value)
+{
+  return GARROW_MAP_SCALAR(
+    garrow_base_list_scalar_new<arrow::MapScalar>(GARROW_ARRAY(value)));
+}
+
+
+typedef struct GArrowStructScalarPrivate_ {
+  GList *value;
+} GArrowStructScalarPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE(GArrowStructScalar,
+                           garrow_struct_scalar,
+                           GARROW_TYPE_SCALAR)
+
+#define GARROW_STRUCT_SCALAR_GET_PRIVATE(obj)             \
+  static_cast<GArrowStructScalarPrivate *>(               \
+    garrow_struct_scalar_get_instance_private(            \
+      GARROW_STRUCT_SCALAR(obj)))
+
+static void
+garrow_struct_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_STRUCT_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_list_free_full(priv->value, g_object_unref);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_struct_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_struct_scalar_init(GArrowStructScalar *object)
+{
+}
+
+static void
+garrow_struct_scalar_class_init(GArrowStructScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->dispose = garrow_struct_scalar_dispose;
+}
+
+/**
+ * garrow_struct_scalar_new:
+ * @data_type: A #GArrowStructDataType for this scalar.
+ * @value: (element-type GArrowScalar): The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDecimal256Scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowStructScalar *
+garrow_struct_scalar_new(GArrowStructDataType *data_type,
+                         GList *value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(GARROW_DATA_TYPE(data_type));
+  std::vector<std::shared_ptr<arrow::Scalar>> arrow_value;
+  for (GList *node = value; node; node = node->next) {
+    auto field = GARROW_SCALAR(node->data);
+    auto arrow_field = garrow_scalar_get_raw(field);
+    arrow_value.push_back(arrow_field);
+  }
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<arrow::StructScalar>(arrow_value, arrow_data_type));
+  auto scalar =
+    GARROW_STRUCT_SCALAR(
+      garrow_scalar_new_raw(&arrow_scalar,
+                            "scalar", &arrow_scalar,
+                            "data-type", data_type,
+                            NULL));
+  auto priv = GARROW_STRUCT_SCALAR_GET_PRIVATE(scalar);
+  priv->value = g_list_copy_deep(value,
+                                 reinterpret_cast<GCopyFunc>(g_object_ref),
+                                 NULL);
+  return scalar;
+}
+
+/**
+ * garrow_struct_scalar_get_value:
+ * @scalar: A #GArrowStructScalar.
+ *
+ * Returns: (element-type GArrowScalar) (transfer none):
+ *   The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GList *
+garrow_struct_scalar_get_value(GArrowStructScalar *scalar)
+{
+  auto priv = GARROW_STRUCT_SCALAR_GET_PRIVATE(scalar);
+  return priv->value;
+}
+
+
+typedef struct GArrowUnionScalarPrivate_ {
+  GArrowScalar *value;
+} GArrowUnionScalarPrivate;
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(GArrowUnionScalar,
+                                    garrow_union_scalar,
+                                    GARROW_TYPE_SCALAR)
+
+#define GARROW_UNION_SCALAR_GET_PRIVATE(obj)             \
+  static_cast<GArrowUnionScalarPrivate *>(               \
+    garrow_union_scalar_get_instance_private(            \
+      GARROW_UNION_SCALAR(obj)))
+
+static void
+garrow_union_scalar_dispose(GObject *object)
+{
+  auto priv = GARROW_UNION_SCALAR_GET_PRIVATE(object);
+
+  if (priv->value) {
+    g_object_unref(priv->value);
+    priv->value = NULL;
+  }
+
+  G_OBJECT_CLASS(garrow_union_scalar_parent_class)->dispose(object);
+}
+
+static void
+garrow_union_scalar_set_property(GObject *object,
+                                 guint prop_id,
+                                 const GValue *value,
+                                 GParamSpec *pspec)
+{
+  auto priv = GARROW_UNION_SCALAR_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_VALUE:
+    priv->value = GARROW_SCALAR(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+garrow_union_scalar_init(GArrowUnionScalar *object)
+{
+}
+
+static void
+garrow_union_scalar_class_init(GArrowUnionScalarClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->dispose      = garrow_union_scalar_dispose;
+  gobject_class->set_property = garrow_union_scalar_set_property;
+
+  GParamSpec *spec;
+  /**
+   * GArrowUnionScalar:value:
+   *
+   * The value of the scalar.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_object("value",
+                             "Value",
+                             "The value of the scalar",
+                             GARROW_TYPE_SCALAR,
+                             static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_VALUE, spec);
+}
+
+G_END_DECLS
+template<typename ArrowUnionScalarType>
+GArrowScalar *
+garrow_union_scalar_new(GArrowDataType *data_type,
+                        gint8 type_code,
+                        GArrowScalar *value)
+{
+  auto arrow_data_type = garrow_data_type_get_raw(data_type);
+  auto arrow_value = garrow_scalar_get_raw(value);
+  auto arrow_scalar =
+    std::static_pointer_cast<arrow::Scalar>(
+      std::make_shared<ArrowUnionScalarType>(arrow_value, type_code,
+                                             arrow_data_type));
+  auto scalar = garrow_scalar_new_raw(&arrow_scalar,
+                                      "scalar", &arrow_scalar,
+                                      "data-type", data_type,
+                                      "value", value,
+                                      NULL);
+  return scalar;
+}
+G_BEGIN_DECLS
+
+/**
+ * garrow_union_scalar_get_type_code:
+ * @scalar: A #GArrowUnionScalar.
+ *
+ * Returns: The type code of this scalar.
+ *
+ * Since: 6.0.0
+ */
+gint8
+garrow_union_scalar_get_type_code(GArrowUnionScalar *scalar)
+{
+  const auto &arrow_scalar =
+    std::static_pointer_cast<arrow::UnionScalar>(
+      garrow_scalar_get_raw(GARROW_SCALAR(scalar)));
+  return arrow_scalar->type_code;
+}
+
+/**
+ * garrow_union_scalar_get_value:
+ * @scalar: A #GArrowUnionScalar.
+ *
+ * Returns: (transfer none): The value of this scalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowScalar *
+garrow_union_scalar_get_value(GArrowUnionScalar *scalar)
+{
+  auto priv = GARROW_UNION_SCALAR_GET_PRIVATE(scalar);
+  return priv->value;
+}
+
+
+G_DEFINE_TYPE(GArrowSparseUnionScalar,
+              garrow_sparse_union_scalar,
+              GARROW_TYPE_UNION_SCALAR)
+
+static void
+garrow_sparse_union_scalar_init(GArrowSparseUnionScalar *object)
+{
+}
+
+static void
+garrow_sparse_union_scalar_class_init(GArrowSparseUnionScalarClass *klass)
+{
+}
+
+/**
+ * garrow_sparse_union_scalar_new:
+ * @data_type: A #GArrowSparseUnionDataType for this scalar.
+ * @type_code: The type code of this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowSparseUnionScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowSparseUnionScalar *
+garrow_sparse_union_scalar_new(GArrowSparseUnionDataType *data_type,
+                               gint8 type_code,
+                               GArrowScalar *value)
+{
+  return GARROW_SPARSE_UNION_SCALAR(
+    garrow_union_scalar_new<arrow::SparseUnionScalar>(
+      GARROW_DATA_TYPE(data_type), type_code, value));
+}
+
+
+G_DEFINE_TYPE(GArrowDenseUnionScalar,
+              garrow_dense_union_scalar,
+              GARROW_TYPE_UNION_SCALAR)
+
+static void
+garrow_dense_union_scalar_init(GArrowDenseUnionScalar *object)
+{
+}
+
+static void
+garrow_dense_union_scalar_class_init(GArrowDenseUnionScalarClass *klass)
+{
+}
+
+/**
+ * garrow_dense_union_scalar_new:
+ * @data_type: A #GArrowDenseUnionDataType for this scalar.
+ * @type_code: The type code of this scalar.
+ * @value: The value of this scalar.
+ *
+ * Returns: A newly created #GArrowDenseUnionScalar.
+ *
+ * Since: 5.0.0
+ */
+GArrowDenseUnionScalar *
+garrow_dense_union_scalar_new(GArrowDenseUnionDataType *data_type,
+                              gint8 type_code,
+                              GArrowScalar *value)
+{
+  return GARROW_DENSE_UNION_SCALAR(
+    garrow_union_scalar_new<arrow::DenseUnionScalar>(
+      GARROW_DATA_TYPE(data_type), type_code, value));
+}
+
+
+G_DEFINE_TYPE(GArrowExtensionScalar,
+              garrow_extension_scalar,
+              GARROW_TYPE_SCALAR)
+
+static void
+garrow_extension_scalar_init(GArrowExtensionScalar *object)
+{
+}
+
+static void
+garrow_extension_scalar_class_init(GArrowExtensionScalarClass *klass)
+{
+}
+
+
+G_END_DECLS
+
+GArrowScalar *
+garrow_scalar_new_raw(std::shared_ptr<arrow::Scalar> *arrow_scalar)
+{
+  return garrow_scalar_new_raw(arrow_scalar,
+                               "scalar", arrow_scalar,
+                               NULL);
+}
+
+GArrowScalar *
+garrow_scalar_new_raw(std::shared_ptr<arrow::Scalar> *arrow_scalar,
+                      const gchar *first_property_name,
+                      ...)
+{
+  va_list args;
+  va_start(args, first_property_name);
+  auto array = garrow_scalar_new_raw_valist(arrow_scalar,
+                                            first_property_name,
+                                            args);
+  va_end(args);
+  return array;
+}
+
+GArrowScalar *
+garrow_scalar_new_raw_valist(std::shared_ptr<arrow::Scalar> *arrow_scalar,
+                             const gchar *first_property_name,
+                             va_list args)
+{
+  GType type;
+  GArrowScalar *scalar;
+
+  switch ((*arrow_scalar)->type->id()) {
+  case arrow::Type::type::NA:
+    type = GARROW_TYPE_NULL_SCALAR;
+    break;
+  case arrow::Type::type::BOOL:
+    type = GARROW_TYPE_BOOLEAN_SCALAR;
+    break;
+  case arrow::Type::type::INT8:
+    type = GARROW_TYPE_INT8_SCALAR;
+    break;
+  case arrow::Type::type::INT16:
+    type = GARROW_TYPE_INT16_SCALAR;
+    break;
+  case arrow::Type::type::INT32:
+    type = GARROW_TYPE_INT32_SCALAR;
+    break;
+  case arrow::Type::type::INT64:
+    type = GARROW_TYPE_INT64_SCALAR;
+    break;
+  case arrow::Type::type::UINT8:
+    type = GARROW_TYPE_UINT8_SCALAR;
+    break;
+  case arrow::Type::type::UINT16:
+    type = GARROW_TYPE_UINT16_SCALAR;
+    break;
+  case arrow::Type::type::UINT32:
+    type = GARROW_TYPE_UINT32_SCALAR;
+    break;
+  case arrow::Type::type::UINT64:
+    type = GARROW_TYPE_UINT64_SCALAR;
+    break;
+  case arrow::Type::type::FLOAT:
+    type = GARROW_TYPE_FLOAT_SCALAR;
+    break;
+  case arrow::Type::type::DOUBLE:
+    type = GARROW_TYPE_DOUBLE_SCALAR;
+    break;
+  case arrow::Type::type::BINARY:
+    type = GARROW_TYPE_BINARY_SCALAR;
+    break;
+  case arrow::Type::type::STRING:
+    type = GARROW_TYPE_STRING_SCALAR;
+    break;
+  case arrow::Type::type::LARGE_BINARY:
+    type = GARROW_TYPE_LARGE_BINARY_SCALAR;
+    break;
+  case arrow::Type::type::LARGE_STRING:
+    type = GARROW_TYPE_LARGE_STRING_SCALAR;
+    break;
+  case arrow::Type::type::FIXED_SIZE_BINARY:
+    type = GARROW_TYPE_FIXED_SIZE_BINARY_SCALAR;
+    break;
+  case arrow::Type::type::DATE32:
+    type = GARROW_TYPE_DATE32_SCALAR;
+    break;
+  case arrow::Type::type::DATE64:
+    type = GARROW_TYPE_DATE64_SCALAR;
+    break;
+  case arrow::Type::type::TIME32:
+    type = GARROW_TYPE_TIME32_SCALAR;
+    break;
+  case arrow::Type::type::TIME64:
+    type = GARROW_TYPE_TIME64_SCALAR;
+    break;
+  case arrow::Type::type::TIMESTAMP:
+    type = GARROW_TYPE_TIMESTAMP_SCALAR;
+    break;
+  case arrow::Type::type::DECIMAL128:
+    type = GARROW_TYPE_DECIMAL128_SCALAR;
+    break;
+  case arrow::Type::type::DECIMAL256:
+    type = GARROW_TYPE_DECIMAL256_SCALAR;
+    break;
+  case arrow::Type::type::LIST:
+    type = GARROW_TYPE_LIST_SCALAR;
+    break;
+  case arrow::Type::type::LARGE_LIST:
+    type = GARROW_TYPE_LARGE_LIST_SCALAR;
+    break;
+/*
+  case arrow::Type::type::FIXED_SIZE_LIST:
+    type = GARROW_TYPE_FIXED_SIZE_LIST_SCALAR;
+    break;
+*/
+  case arrow::Type::type::MAP:
+    type = GARROW_TYPE_MAP_SCALAR;
+    break;
+  case arrow::Type::type::STRUCT:
+    type = GARROW_TYPE_STRUCT_SCALAR;
+    break;
+  case arrow::Type::type::SPARSE_UNION:
+    type = GARROW_TYPE_SPARSE_UNION_SCALAR;
+    break;
+  case arrow::Type::type::DENSE_UNION:
+    type = GARROW_TYPE_DENSE_UNION_SCALAR;
+    break;
+  case arrow::Type::type::EXTENSION:
+    type = GARROW_TYPE_EXTENSION_SCALAR;
+    break;
+  default:
+    type = GARROW_TYPE_SCALAR;
+    break;
+  }
+  scalar = GARROW_SCALAR(g_object_new_valist(type,
+                                             first_property_name,
+                                             args));
+  return scalar;
+}
+
+std::shared_ptr<arrow::Scalar>
+garrow_scalar_get_raw(GArrowScalar *scalar)
+{
+  auto priv = GARROW_SCALAR_GET_PRIVATE(scalar);
+  return priv->scalar;
+}