GH-35419: [GLib] Add GArrowFixedShapeTensorDataType (#46305)

hiroyuki-sato · kou · web-flow · commit 37fbdbc88c30 · 2025-05-07T14:45:57.000+09:00
### Rationale for this change The C++ API implemented FixedShapeTensor Extension DataType. GLib was not yet supported. ### What changes are included in this PR? Implement GArrowFixedShapeTensorDataType. ### Are these changes tested? Yes. ### Are there any user-facing changes? Yes. * GitHub Issue: #35419 Lead-authored-by: Hiroyuki Sato <hiroysato@gmail.com> Co-authored-by: Sutou Kouhei <kou@cozmixng.org> Signed-off-by: Sutou Kouhei <kou@clear-code.com>
diff --git a/c_glib/arrow-glib/basic-data-type.cpp b/c_glib/arrow-glib/basic-data-type.cpp
@@ -26,6 +26,7 @@
 #include <arrow-glib/type.hpp>
 
 #include <arrow/c/bridge.h>
+#include <arrow/extension/fixed_shape_tensor.h>
 
 G_BEGIN_DECLS
 
@@ -131,6 +132,8 @@ G_BEGIN_DECLS
  * #GArrowStringViewDataType is a class for the string view data type.
  *
  * #GArrowBinaryViewDataType is a class for the binary view data type.
+ *
+ * #GArrowFixedShapeTensorDataType is a class for the fixed shape tensor data type.
  */
 
 struct GArrowDataTypePrivate
@@ -2267,6 +2270,83 @@ garrow_string_view_data_type_new(void)
   return data_type;
 }
 
+G_DEFINE_TYPE(GArrowFixedShapeTensorDataType,
+              garrow_fixed_shape_tensor_data_type,
+              GARROW_TYPE_EXTENSION_DATA_TYPE)
+
+static void
+garrow_fixed_shape_tensor_data_type_init(GArrowFixedShapeTensorDataType *object)
+{
+}
+
+static void
+garrow_fixed_shape_tensor_data_type_class_init(GArrowFixedShapeTensorDataTypeClass *klass)
+{
+}
+
+/**
+ * garrow_fixed_shape_tensor_data_type_new:
+ * @value_type: A #GArrowDataType of individual tensor elements.
+ * @shape: (array length=shape_length): A physical shape of the contained tensors as an
+ *   array.
+ * @shape_length: The length of `shape`.
+ * @permutation: (array length=permutation_length) (nullable): An indices of the desired
+ *   ordering of the original dimensions, defined as an array. This must be `NULL` or
+ *   the same length array of `shape`.
+ * @permutation_length: The length of `permutation`.
+ * @dim_names: (array length=n_dim_names) (nullable): Explicit names to tensor dimensions
+ *   as an array. This must be `NULL` or the same length array of `shape`.
+ * @n_dim_names. The length of `dim_names`.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: The newly created fixed shape tensor data type.
+ */
+GArrowFixedShapeTensorDataType *
+garrow_fixed_shape_tensor_data_type_new(GArrowDataType *value_type,
+                                        const gint64 *shape,
+                                        gsize shape_length,
+                                        const gint64 *permutation,
+                                        gsize permutation_length,
+                                        const gchar **dim_names,
+                                        gsize n_dim_names,
+                                        GError **error)
+{
+  std::vector<int64_t> arrow_shape;
+  std::vector<int64_t> arrow_permutation;
+  std::vector<std::string> arrow_dim_names;
+
+  auto arrow_value_type = garrow_data_type_get_raw(value_type);
+
+  for (int i = 0; i < shape_length; i++) {
+    arrow_shape.push_back(shape[i]);
+  }
+
+  for (int i = 0; i < permutation_length; i++) {
+    arrow_permutation.push_back(permutation[i]);
+  }
+
+  for (int i = 0; i < n_dim_names; i++) {
+    arrow_dim_names.push_back(dim_names[i]);
+  }
+
+  auto arrow_data_type_result =
+    arrow::extension::FixedShapeTensorType::Make(arrow_value_type,
+                                                 arrow_shape,
+                                                 arrow_permutation,
+                                                 arrow_dim_names);
+  if (!garrow::check(error, arrow_data_type_result, "[fixed-shape-tensor][new]")) {
+    return NULL;
+  }
+
+  auto arrow_data_type = *arrow_data_type_result;
+  auto data_type = GARROW_FIXED_SHAPE_TENSOR_DATA_TYPE(
+    g_object_new(GARROW_TYPE_FIXED_SHAPE_TENSOR_DATA_TYPE,
+                 "data-type",
+                 &arrow_data_type,
+                 NULL));
+  return data_type;
+}
+
 G_END_DECLS
 
 GArrowDataType *
diff --git a/c_glib/arrow-glib/basic-data-type.h b/c_glib/arrow-glib/basic-data-type.h
@@ -802,4 +802,28 @@ GARROW_AVAILABLE_IN_19_0
 GArrowStringViewDataType *
 garrow_string_view_data_type_new(void);
 
+#define GARROW_TYPE_FIXED_SHAPE_TENSOR_DATA_TYPE                                         \
+  (garrow_fixed_shape_tensor_data_type_get_type())
+GARROW_AVAILABLE_IN_21_0
+G_DECLARE_DERIVABLE_TYPE(GArrowFixedShapeTensorDataType,
+                         garrow_fixed_shape_tensor_data_type,
+                         GARROW,
+                         FIXED_SHAPE_TENSOR_DATA_TYPE,
+                         GArrowExtensionDataType)
+struct _GArrowFixedShapeTensorDataTypeClass
+{
+  GArrowExtensionDataTypeClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_21_0
+GArrowFixedShapeTensorDataType *
+garrow_fixed_shape_tensor_data_type_new(GArrowDataType *value_type,
+                                        const gint64 *shape,
+                                        gsize shape_length,
+                                        const gint64 *permutation,
+                                        gsize permutation_length,
+                                        const gchar **dim_names,
+                                        gsize n_dim_names,
+                                        GError **error);
+
 G_END_DECLS
diff --git a/c_glib/test/test-fixed-shape-tensor-data-type.rb b/c_glib/test/test-fixed-shape-tensor-data-type.rb
@@ -0,0 +1,93 @@
+# 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.
+
+class TestFixedShapeTensorDataType < Test::Unit::TestCase
+  def test_id
+    data_type = Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                                    [3, 4],
+                                                    [1, 0],
+                                                    ["x", "y"])
+    assert_equal(Arrow::Type::EXTENSION, data_type.id)
+  end
+
+  def test_name
+    data_type = Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                                    [3, 4],
+                                                    [1, 0],
+                                                    ["x", "y"])
+    assert_equal(["extension", "arrow.fixed_shape_tensor"],
+                 [data_type.name, data_type.extension_name])
+  end
+
+  def test_to_s
+    data_type = Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                                    [3, 4],
+                                                    [1, 0],
+                                                    ["x", "y"])
+    assert do
+      data_type.to_s.start_with?("extension<arrow.fixed_shape_tensor")
+    end
+  end
+
+  def test_nil_permutation
+    data_type = Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                                    [3, 4],
+                                                    nil,
+                                                    ["x", "y"])
+    # TODO: Use Arrow::FixedShapeTensorDataType#permutation
+    assert_equal(Arrow::Type::EXTENSION, data_type.id)
+  end
+
+  def test_nil_dim_names
+    data_type = Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                                    [3, 4],
+                                                    [0, 1],
+                                                    nil)
+    # TODO: Use Arrow::FixedShapeTensorDataType#dim_names
+    assert_equal(Arrow::Type::EXTENSION, data_type.id)
+  end
+
+  def test_mismatch_permutation_size
+    message =
+      "[fixed-shape-tensor][new]: Invalid: " +
+      "permutation size must match shape size. " +
+      "Expected: 2 Got: 1"
+    error = assert_raise(Arrow::Error::Invalid) do
+      Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                          [3, 4],
+                                          [1],
+                                          ["x", "y"])
+    end
+    assert_equal(message,
+                 error.message.lines.first.chomp)
+  end
+
+  def test_mismatch_dim_names_size
+    message =
+      "[fixed-shape-tensor][new]: Invalid: " +
+      "dim_names size must match shape size. " +
+      "Expected: 2 Got: 1"
+    error = assert_raise(Arrow::Error::Invalid) do
+      Arrow::FixedShapeTensorDataType.new(Arrow::UInt64DataType.new,
+                                          [3, 4],
+                                          [],
+                                          ["x"])
+    end
+    assert_equal(message,
+                 error.message.lines.first.chomp)
+  end
+end
