apache · raulcd · Jun 13, 2025 · Feb 24, 2025 · Apr 29, 2025 · Apr 29, 2025
@@ -36,6 +36,7 @@
 
 #include <arrow/acero/exec_plan.h>
 #include <arrow/acero/options.h>
+#include <arrow/compute/api.h>
 
 template <typename ArrowType, typename GArrowArrayType>
 typename ArrowType::c_type
@@ -160,6 +161,9 @@ G_BEGIN_DECLS
  * @title: Computation on data
  * @include: arrow-glib/arrow-glib.h
  *
+ * You must call garrow_compute_initialize() explicitly before you use
+ * computation related features.
+ *
  * #GArrowExecuteContext is a class to customize how to execute a
  * function.
  *
@@ -250,6 +254,25 @@ G_BEGIN_DECLS
  * There are many functions to compute data on an array.
  */
 
+/**
+ * garrow_compute_initialize:
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * You must call this explicitly before you use computation related
+ * features.
+ *
+ * Returns: %TRUE if initializing the compute module completed successfully,
+ *   %FALSE otherwise.
+ *
+ * Since: 21.0.0
+ */
+gboolean
+garrow_compute_initialize(GError **error)
+{
+  auto status = arrow::compute::Initialize();
+  return garrow::check(error, status, "[compute][initialize]");
+}
+
 typedef struct GArrowExecuteContextPrivate_
 {
   arrow::compute::ExecContext context;

@@ -25,6 +25,10 @@
 
 G_BEGIN_DECLS
 
+GARROW_AVAILABLE_IN_21_0
+gboolean
+garrow_compute_initialize(GError **error);
+
 #define GARROW_TYPE_EXECUTE_CONTEXT (garrow_execute_context_get_type())
 GARROW_AVAILABLE_IN_1_0
 G_DECLARE_DERIVABLE_TYPE(

@@ -223,7 +223,7 @@ gio = cxx.find_library('gio-2.0', dirs: [gobject_libdir], required: false)
 if not gio.found()
     gio = dependency('gio-2.0')
 endif
-dependencies = [arrow, arrow_acero, gobject, gio]
+dependencies = [arrow_acero, arrow_compute, arrow, gobject, gio]
 libarrow_glib = library(
     'arrow-glib',
     sources: sources + enums,

@@ -147,7 +147,13 @@ if arrow_cpp_build_lib_dir == ''
         modules: ['ArrowCUDA::arrow_cuda_shared'],
         required: false,
     )
-    # we do not support compiling GLib without Acero engine
+    # we do not support compiling GLib without Compute and Acero engine
+    arrow_compute = dependency(
+        'arrow-compute',
+        'ArrowCompute',
+        kwargs: common_args,
+        modules: ['ArrowCompute::arrow_compute_shared'],
+    )
     arrow_acero = dependency(
         'arrow-acero',
         'ArrowAcero',
@@ -215,6 +221,11 @@ main(void)
         dirs: [arrow_cpp_build_lib_dir],
         required: false,
     )
+    arrow_compute = cpp_compiler.find_library(
+        'arrow_compute',
+        dirs: [arrow_cpp_build_lib_dir],
+        required: true,
+    )
     arrow_acero = cpp_compiler.find_library(
         'arrow_acero',
         dirs: [arrow_cpp_build_lib_dir],

@@ -31,6 +31,7 @@
 
 Gio = GI.load("Gio")
 Arrow = GI.load("Arrow")
+Arrow.compute_initialize
 module Arrow
   class Buffer
     alias_method :initialize_raw, :initialize

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
@@ -553,6 +553,13 @@ if(ARROW_BUILD_STATIC)
   string(APPEND ARROW_ACERO_PC_CFLAGS_PRIVATE " -DARROW_ACERO_STATIC")
 endif()
 
+# For arrow-compute.pc.
+set(ARROW_COMPUTE_PC_CFLAGS "")
+set(ARROW_COMPUTE_PC_CFLAGS_PRIVATE "")
+if(ARROW_BUILD_STATIC)
+  string(APPEND ARROW_COMPUTE_PC_CFLAGS_PRIVATE " -DARROW_COMPUTE_STATIC")
+endif()
+
 # For arrow-cuda.pc.
 set(ARROW_CUDA_PC_CFLAGS "")
 set(ARROW_CUDA_PC_CFLAGS_PRIVATE "")

diff --git a/cpp/examples/arrow/CMakeLists.txt b/cpp/examples/arrow/CMakeLists.txt
@@ -43,7 +43,13 @@ if(ARROW_SUBSTRAIT)
 endif()
 
 if(ARROW_COMPUTE AND ARROW_CSV)
-  add_arrow_example(compute_and_write_csv_example)
+  if(ARROW_BUILD_SHARED)
+    set(COMPUTE_KERNELS_LINK_LIBS arrow_compute_shared)
+  else()
+    set(COMPUTE_KERNELS_LINK_LIBS arrow_compute_static)
+  endif()
+  add_arrow_example(compute_and_write_csv_example EXTRA_LINK_LIBS
+                    ${COMPUTE_KERNELS_LINK_LIBS})
 endif()
 
 if(ARROW_FLIGHT)

diff --git a/cpp/examples/arrow/compute_and_write_csv_example.cc b/cpp/examples/arrow/compute_and_write_csv_example.cc
@@ -41,6 +41,7 @@
 // in the current directory
 
 arrow::Status RunMain(int argc, char** argv) {
+  ARROW_RETURN_NOT_OK(arrow::compute::Initialize());
   // Make Arrays
   arrow::NumericBuilder<arrow::Int64Type> int64_builder;
   arrow::BooleanBuilder boolean_builder;

diff --git a/cpp/examples/arrow/join_example.cc b/cpp/examples/arrow/join_example.cc
@@ -82,6 +82,7 @@ arrow::Result<std::shared_ptr<arrow::dataset::Dataset>> CreateDataSetFromCSVData
 }
 
 arrow::Status DoHashJoin() {
+  ARROW_RETURN_NOT_OK(arrow::compute::Initialize());
   arrow::dataset::internal::Initialize();
 
   ARROW_ASSIGN_OR_RAISE(auto l_dataset, CreateDataSetFromCSVData(true));

diff --git a/cpp/examples/tutorial_examples/CMakeLists.txt b/cpp/examples/tutorial_examples/CMakeLists.txt
@@ -37,7 +37,7 @@ target_link_libraries(file_access_example PRIVATE Arrow::arrow_shared
                                                   Parquet::parquet_shared)
 
 add_executable(compute_example compute_example.cc)
-target_link_libraries(compute_example PRIVATE Arrow::arrow_shared)
+target_link_libraries(compute_example PRIVATE ArrowCompute::arrow_compute_shared)
 
 add_executable(dataset_example dataset_example.cc)
 target_link_libraries(dataset_example PRIVATE ArrowDataset::arrow_dataset_shared)
diff --git a/cpp/examples/tutorial_examples/compute_example.cc b/cpp/examples/tutorial_examples/compute_example.cc
@@ -49,6 +49,9 @@ arrow::Status RunMain() {
 
   schema = arrow::schema({field_a, field_b});
 
+  // Initialize the compute module to register the required compute kernels.
+  ARROW_RETURN_NOT_OK(arrow::compute::Initialize());
+
   std::shared_ptr<arrow::Table> table;
   table = arrow::Table::Make(schema, {some_nums, more_nums}, 5);
   // (Doc section: Create Tables)

diff --git a/cpp/examples/tutorial_examples/dataset_example.cc b/cpp/examples/tutorial_examples/dataset_example.cc
@@ -19,6 +19,7 @@
 
 // (Doc section: Includes)
 #include <arrow/api.h>
+#include <arrow/compute/api.h>
 #include <arrow/dataset/api.h>
 // We use Parquet headers for setting up examples; they are not required for using
 // datasets.
@@ -75,6 +76,8 @@ arrow::Result<std::string> CreateExampleParquetDataset(
 }
 
 arrow::Status PrepareEnv() {
+  // Initilize the compute module to register the required kernels for Dataset
+  ARROW_RETURN_NOT_OK(arrow::compute::Initialize());
   // Get our environment prepared for reading, by setting up some quick writing.
   ARROW_ASSIGN_OR_RAISE(auto src_table, CreateTable())
   std::shared_ptr<arrow::fs::FileSystem> setup_fs;

diff --git a/cpp/src/arrow/ArrowComputeConfig.cmake.in b/cpp/src/arrow/ArrowComputeConfig.cmake.in
@@ -0,0 +1,38 @@
+# 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.
+#
+# This config sets the following variables in your project::
+#
+#   ArrowCompute_FOUND - true if Arrow Compute found on the system
+#
+# This config sets the following targets in your project::
+#
+#   ArrowCompute::arrow_compute_shared - for linked as shared library if shared library is built
+#   ArrowCompute::arrow_compute_static - for linked as static library if static library is built
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(Arrow CONFIG)
+
+include("${CMAKE_CURRENT_LIST_DIR}/ArrowComputeTargets.cmake")
+
+arrow_keep_backward_compatibility(ArrowCompute arrow_compute)
+
+check_required_components(ArrowCompute)
+
+arrow_show_details(ArrowCompute ARROW_COMPUTE)