GH-41803: [MATLAB] Add C Data Interface format import/export functionality for arrow.tabular.RecordBatch

matlab/src/cpp/arrow/matlab/c/proxy/record_batch_importer.cc

@@ -0,0 +1,66 @@
+// 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/c/bridge.h"
+
+#include "arrow/matlab/c/proxy/record_batch_importer.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/tabular/proxy/record_batch.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::c::proxy {
+
+RecordBatchImporter::RecordBatchImporter() {
+  REGISTER_METHOD(RecordBatchImporter, import);
+}
+
+libmexclass::proxy::MakeResult RecordBatchImporter::make(
+    const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+  return std::make_shared<RecordBatchImporter>();
+}
+
+void RecordBatchImporter::import(libmexclass::proxy::method::Context& context) {
+  namespace mda = ::matlab::data;
+  using namespace libmexclass::proxy;
+  using RecordBatchProxy = arrow::matlab::tabular::proxy::RecordBatch;
+
+  mda::StructArray args = context.inputs[0];
+  const mda::TypedArray<uint64_t> arrow_array_address_mda = args[0]["ArrowArrayAddress"];
+  const mda::TypedArray<uint64_t> arrow_schema_address_mda =
+      args[0]["ArrowSchemaAddress"];
+
+  const auto arrow_array_address = uint64_t(arrow_array_address_mda[0]);
+  const auto arrow_schema_address = uint64_t(arrow_schema_address_mda[0]);
+
+  auto arrow_array = reinterpret_cast<struct ArrowArray*>(arrow_array_address);
+  auto arrow_schema = reinterpret_cast<struct ArrowSchema*>(arrow_schema_address);
+
+  MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto record_batch,
+                                      arrow::ImportRecordBatch(arrow_array, arrow_schema),
+                                      context, error::C_IMPORT_FAILED);
+
+  auto record_batch_proxy = std::make_shared<RecordBatchProxy>(std::move(record_batch));
+
+  mda::ArrayFactory factory;
+  const auto record_batch_proxy_id = ProxyManager::manageProxy(record_batch_proxy);
+  const auto record_batch_proxy_id_mda = factory.createScalar(record_batch_proxy_id);
+
+  context.outputs[0] = record_batch_proxy_id_mda;
+}
+
+}  // namespace arrow::matlab::c::proxy

matlab/src/cpp/arrow/matlab/c/proxy/record_batch_importer.h

@@ -0,0 +1,37 @@
+// 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.
+
+#pragma once
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::c::proxy {
+
+class RecordBatchImporter : public libmexclass::proxy::Proxy {
+ public:
+  RecordBatchImporter();
+
+  ~RecordBatchImporter() = default;
+
+  static libmexclass::proxy::MakeResult make(
+      const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+ protected:
+  void import(libmexclass::proxy::method::Context& context);
+};
+
+}  // namespace arrow::matlab::c::proxy

matlab/src/cpp/arrow/matlab/proxy/factory.cc

@@ -27,6 +27,7 @@
 #include "arrow/matlab/buffer/proxy/buffer.h"
 #include "arrow/matlab/c/proxy/array.h"
 #include "arrow/matlab/c/proxy/array_importer.h"
+#include "arrow/matlab/c/proxy/record_batch_importer.h"
 #include "arrow/matlab/c/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/io/csv/proxy/table_reader.h"
@@ -54,57 +55,58 @@ namespace arrow::matlab::proxy {
 libmexclass::proxy::MakeResult Factory::make_proxy(
     const ClassName& class_name, const FunctionArguments& constructor_arguments) {
   // clang-format off
-  REGISTER_PROXY(arrow.array.proxy.Float32Array  , arrow::matlab::array::proxy::NumericArray<arrow::FloatType>);
-  REGISTER_PROXY(arrow.array.proxy.Float64Array  , arrow::matlab::array::proxy::NumericArray<arrow::DoubleType>);
-  REGISTER_PROXY(arrow.array.proxy.UInt8Array    , arrow::matlab::array::proxy::NumericArray<arrow::UInt8Type>);
-  REGISTER_PROXY(arrow.array.proxy.UInt16Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt16Type>);
-  REGISTER_PROXY(arrow.array.proxy.UInt32Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt32Type>);
-  REGISTER_PROXY(arrow.array.proxy.UInt64Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt64Type>);
-  REGISTER_PROXY(arrow.array.proxy.Int8Array     , arrow::matlab::array::proxy::NumericArray<arrow::Int8Type>);
-  REGISTER_PROXY(arrow.array.proxy.Int16Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int16Type>);
-  REGISTER_PROXY(arrow.array.proxy.Int32Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int32Type>);
-  REGISTER_PROXY(arrow.array.proxy.Int64Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int64Type>);
-  REGISTER_PROXY(arrow.array.proxy.BooleanArray  , arrow::matlab::array::proxy::BooleanArray);
-  REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
-  REGISTER_PROXY(arrow.array.proxy.StructArray   , arrow::matlab::array::proxy::StructArray);
-  REGISTER_PROXY(arrow.array.proxy.ListArray     , arrow::matlab::array::proxy::ListArray);
-  REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
-  REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
-  REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
-  REGISTER_PROXY(arrow.array.proxy.Date32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
-  REGISTER_PROXY(arrow.array.proxy.Date64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date64Type>);
-  REGISTER_PROXY(arrow.array.proxy.ChunkedArray  , arrow::matlab::array::proxy::ChunkedArray);
-  REGISTER_PROXY(arrow.buffer.proxy.Buffer       , arrow::matlab::buffer::proxy::Buffer);
-  REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
-  REGISTER_PROXY(arrow.tabular.proxy.Table       , arrow::matlab::tabular::proxy::Table);
-  REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
-  REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
-  REGISTER_PROXY(arrow.type.proxy.Float32Type    , arrow::matlab::type::proxy::PrimitiveCType<float>);
-  REGISTER_PROXY(arrow.type.proxy.Float64Type    , arrow::matlab::type::proxy::PrimitiveCType<double>);
-  REGISTER_PROXY(arrow.type.proxy.UInt8Type      , arrow::matlab::type::proxy::PrimitiveCType<uint8_t>);
-  REGISTER_PROXY(arrow.type.proxy.UInt16Type     , arrow::matlab::type::proxy::PrimitiveCType<uint16_t>);
-  REGISTER_PROXY(arrow.type.proxy.UInt32Type     , arrow::matlab::type::proxy::PrimitiveCType<uint32_t>);
-  REGISTER_PROXY(arrow.type.proxy.UInt64Type     , arrow::matlab::type::proxy::PrimitiveCType<uint64_t>);
-  REGISTER_PROXY(arrow.type.proxy.Int8Type       , arrow::matlab::type::proxy::PrimitiveCType<int8_t>);
-  REGISTER_PROXY(arrow.type.proxy.Int16Type      , arrow::matlab::type::proxy::PrimitiveCType<int16_t>);
-  REGISTER_PROXY(arrow.type.proxy.Int32Type      , arrow::matlab::type::proxy::PrimitiveCType<int32_t>);
-  REGISTER_PROXY(arrow.type.proxy.Int64Type      , arrow::matlab::type::proxy::PrimitiveCType<int64_t>);
-  REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
-  REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
-  REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
-  REGISTER_PROXY(arrow.type.proxy.Time32Type     , arrow::matlab::type::proxy::Time32Type);
-  REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
-  REGISTER_PROXY(arrow.type.proxy.Date32Type     , arrow::matlab::type::proxy::Date32Type);
-  REGISTER_PROXY(arrow.type.proxy.Date64Type     , arrow::matlab::type::proxy::Date64Type);
-  REGISTER_PROXY(arrow.type.proxy.StructType     , arrow::matlab::type::proxy::StructType);
-  REGISTER_PROXY(arrow.type.proxy.ListType       , arrow::matlab::type::proxy::ListType);
-  REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
-  REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
-  REGISTER_PROXY(arrow.io.csv.proxy.TableWriter  , arrow::matlab::io::csv::proxy::TableWriter);
-  REGISTER_PROXY(arrow.io.csv.proxy.TableReader  , arrow::matlab::io::csv::proxy::TableReader);
-  REGISTER_PROXY(arrow.c.proxy.Array             , arrow::matlab::c::proxy::Array);
-  REGISTER_PROXY(arrow.c.proxy.ArrayImporter     , arrow::matlab::c::proxy::ArrayImporter);
-  REGISTER_PROXY(arrow.c.proxy.Schema            , arrow::matlab::c::proxy::Schema);
+  REGISTER_PROXY(arrow.array.proxy.Float32Array    , arrow::matlab::array::proxy::NumericArray<arrow::FloatType>);
+  REGISTER_PROXY(arrow.array.proxy.Float64Array    , arrow::matlab::array::proxy::NumericArray<arrow::DoubleType>);
+  REGISTER_PROXY(arrow.array.proxy.UInt8Array      , arrow::matlab::array::proxy::NumericArray<arrow::UInt8Type>);
+  REGISTER_PROXY(arrow.array.proxy.UInt16Array     , arrow::matlab::array::proxy::NumericArray<arrow::UInt16Type>);
+  REGISTER_PROXY(arrow.array.proxy.UInt32Array     , arrow::matlab::array::proxy::NumericArray<arrow::UInt32Type>);
+  REGISTER_PROXY(arrow.array.proxy.UInt64Array     , arrow::matlab::array::proxy::NumericArray<arrow::UInt64Type>);
+  REGISTER_PROXY(arrow.array.proxy.Int8Array       , arrow::matlab::array::proxy::NumericArray<arrow::Int8Type>);
+  REGISTER_PROXY(arrow.array.proxy.Int16Array      , arrow::matlab::array::proxy::NumericArray<arrow::Int16Type>);
+  REGISTER_PROXY(arrow.array.proxy.Int32Array      , arrow::matlab::array::proxy::NumericArray<arrow::Int32Type>);
+  REGISTER_PROXY(arrow.array.proxy.Int64Array      , arrow::matlab::array::proxy::NumericArray<arrow::Int64Type>);
+  REGISTER_PROXY(arrow.array.proxy.BooleanArray    , arrow::matlab::array::proxy::BooleanArray);
+  REGISTER_PROXY(arrow.array.proxy.StringArray     , arrow::matlab::array::proxy::StringArray);
+  REGISTER_PROXY(arrow.array.proxy.StructArray     , arrow::matlab::array::proxy::StructArray);
+  REGISTER_PROXY(arrow.array.proxy.ListArray       , arrow::matlab::array::proxy::ListArray);
+  REGISTER_PROXY(arrow.array.proxy.TimestampArray  , arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
+  REGISTER_PROXY(arrow.array.proxy.Time32Array     , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
+  REGISTER_PROXY(arrow.array.proxy.Time64Array     , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
+  REGISTER_PROXY(arrow.array.proxy.Date32Array     , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
+  REGISTER_PROXY(arrow.array.proxy.Date64Array     , arrow::matlab::array::proxy::NumericArray<arrow::Date64Type>);
+  REGISTER_PROXY(arrow.array.proxy.ChunkedArray    , arrow::matlab::array::proxy::ChunkedArray);
+  REGISTER_PROXY(arrow.buffer.proxy.Buffer         , arrow::matlab::buffer::proxy::Buffer);
+  REGISTER_PROXY(arrow.tabular.proxy.RecordBatch   , arrow::matlab::tabular::proxy::RecordBatch);
+  REGISTER_PROXY(arrow.tabular.proxy.Table         , arrow::matlab::tabular::proxy::Table);
+  REGISTER_PROXY(arrow.tabular.proxy.Schema        , arrow::matlab::tabular::proxy::Schema);
+  REGISTER_PROXY(arrow.type.proxy.Field            , arrow::matlab::type::proxy::Field);
+  REGISTER_PROXY(arrow.type.proxy.Float32Type      , arrow::matlab::type::proxy::PrimitiveCType<float>);
+  REGISTER_PROXY(arrow.type.proxy.Float64Type      , arrow::matlab::type::proxy::PrimitiveCType<double>);
+  REGISTER_PROXY(arrow.type.proxy.UInt8Type        , arrow::matlab::type::proxy::PrimitiveCType<uint8_t>);
+  REGISTER_PROXY(arrow.type.proxy.UInt16Type       , arrow::matlab::type::proxy::PrimitiveCType<uint16_t>);
+  REGISTER_PROXY(arrow.type.proxy.UInt32Type       , arrow::matlab::type::proxy::PrimitiveCType<uint32_t>);
+  REGISTER_PROXY(arrow.type.proxy.UInt64Type       , arrow::matlab::type::proxy::PrimitiveCType<uint64_t>);
+  REGISTER_PROXY(arrow.type.proxy.Int8Type         , arrow::matlab::type::proxy::PrimitiveCType<int8_t>);
+  REGISTER_PROXY(arrow.type.proxy.Int16Type        , arrow::matlab::type::proxy::PrimitiveCType<int16_t>);
+  REGISTER_PROXY(arrow.type.proxy.Int32Type        , arrow::matlab::type::proxy::PrimitiveCType<int32_t>);
+  REGISTER_PROXY(arrow.type.proxy.Int64Type        , arrow::matlab::type::proxy::PrimitiveCType<int64_t>);
+  REGISTER_PROXY(arrow.type.proxy.BooleanType      , arrow::matlab::type::proxy::PrimitiveCType<bool>);
+  REGISTER_PROXY(arrow.type.proxy.StringType       , arrow::matlab::type::proxy::StringType);
+  REGISTER_PROXY(arrow.type.proxy.TimestampType    , arrow::matlab::type::proxy::TimestampType);
+  REGISTER_PROXY(arrow.type.proxy.Time32Type       , arrow::matlab::type::proxy::Time32Type);
+  REGISTER_PROXY(arrow.type.proxy.Time64Type       , arrow::matlab::type::proxy::Time64Type);
+  REGISTER_PROXY(arrow.type.proxy.Date32Type       , arrow::matlab::type::proxy::Date32Type);
+  REGISTER_PROXY(arrow.type.proxy.Date64Type       , arrow::matlab::type::proxy::Date64Type);
+  REGISTER_PROXY(arrow.type.proxy.StructType       , arrow::matlab::type::proxy::StructType);
+  REGISTER_PROXY(arrow.type.proxy.ListType         , arrow::matlab::type::proxy::ListType);
+  REGISTER_PROXY(arrow.io.feather.proxy.Writer     , arrow::matlab::io::feather::proxy::Writer);
+  REGISTER_PROXY(arrow.io.feather.proxy.Reader     , arrow::matlab::io::feather::proxy::Reader);
+  REGISTER_PROXY(arrow.io.csv.proxy.TableWriter    , arrow::matlab::io::csv::proxy::TableWriter);
+  REGISTER_PROXY(arrow.io.csv.proxy.TableReader    , arrow::matlab::io::csv::proxy::TableReader);
+  REGISTER_PROXY(arrow.c.proxy.Array               , arrow::matlab::c::proxy::Array);
+  REGISTER_PROXY(arrow.c.proxy.ArrayImporter       , arrow::matlab::c::proxy::ArrayImporter);
+  REGISTER_PROXY(arrow.c.proxy.Schema              , arrow::matlab::c::proxy::Schema);
+  REGISTER_PROXY(arrow.c.proxy.RecordBatchImporter , arrow::matlab::c::proxy::RecordBatchImporter);
   // clang-format on
 
   return libmexclass::error::Error{error::UNKNOWN_PROXY_ERROR_ID,

matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc

@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "libmexclass/proxy/ProxyManager.h"
-
+#include "arrow/c/bridge.h"
 #include "arrow/matlab/array/proxy/array.h"
 #include "arrow/matlab/array/proxy/wrap.h"
 
@@ -66,6 +65,7 @@ RecordBatch::RecordBatch(std::shared_ptr<arrow::RecordBatch> record_batch)
   REGISTER_METHOD(RecordBatch, getColumnByName);
   REGISTER_METHOD(RecordBatch, getSchema);
   REGISTER_METHOD(RecordBatch, getRowAsString);
+  REGISTER_METHOD(RecordBatch, exportToC);
 }
 
 std::shared_ptr<arrow::RecordBatch> RecordBatch::unwrap() { return record_batch; }
@@ -259,4 +259,19 @@ void RecordBatch::getRowAsString(libmexclass::proxy::method::Context& context) {
   context.outputs[0] = factory.createScalar(row_str_utf16);
 }
 
+void RecordBatch::exportToC(libmexclass::proxy::method::Context& context) {
+  namespace mda = ::matlab::data;
+  mda::StructArray opts = context.inputs[0];
+  const mda::TypedArray<uint64_t> array_address_mda = opts[0]["ArrowArrayAddress"];
+  const mda::TypedArray<uint64_t> schema_address_mda = opts[0]["ArrowSchemaAddress"];
+
+  auto arrow_array = reinterpret_cast<struct ArrowArray*>(uint64_t(array_address_mda[0]));
+  auto arrow_schema =
+      reinterpret_cast<struct ArrowSchema*>(uint64_t(schema_address_mda[0]));
+
+  MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+      arrow::ExportRecordBatch(*record_batch, arrow_array, arrow_schema), context,
+      error::C_EXPORT_FAILED);
+}
+
 }  // namespace arrow::matlab::tabular::proxy

matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h

@@ -43,6 +43,7 @@ class RecordBatch : public libmexclass::proxy::Proxy {
   void getColumnByName(libmexclass::proxy::method::Context& context);
   void getSchema(libmexclass::proxy::method::Context& context);
   void getRowAsString(libmexclass::proxy::method::Context& context);
+  void exportToC(libmexclass::proxy::method::Context& context);
 
   std::shared_ptr<arrow::RecordBatch> record_batch;
 };

matlab/src/matlab/+arrow/+c/+internal/RecordBatchImporter.m

@@ -0,0 +1,52 @@
+%RECORDBATCHIMPORTER Imports Arrow RecordBatch using the C Data Interface
+% Format.
+
+% 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.
+
+classdef RecordBatchImporter
+
+    properties (Hidden, SetAccess=private, GetAccess=public)
+        Proxy
+    end
+
+    methods
+
+        function obj = RecordBatchImporter()
+            proxyName = "arrow.c.proxy.RecordBatchImporter";
+            proxy = arrow.internal.proxy.create(proxyName, struct());
+            obj.Proxy = proxy;
+        end
+
+        function recordBatch = import(obj, cArray, cSchema)
+            arguments
+                obj(1, 1) arrow.c.internal.RecordBatchImporter
+                cArray(1, 1) arrow.c.Array
+                cSchema(1, 1) arrow.c.Schema
+            end
+            args = struct(...
+                ArrowArrayAddress=cArray.Address,...
+                ArrowSchemaAddress=cSchema.Address...
+            );
+            proxyID = obj.Proxy.import(args);
+            proxyName = "arrow.tabular.proxy.RecordBatch";
+            proxy = libmexclass.proxy.Proxy(Name=proxyName, ID=proxyID);
+            recordBatch = arrow.tabular.RecordBatch(proxy);
+        end
+
+    end
+
+end
+