Arrow 数据集#

Arrow C++ 提供了Datasets的概念和实现，用于处理碎片化数据，这些数据可能大于内存，这可能是由于生成大量数据、从流中读取或磁盘上的大型文件所致。在本文中，您将

读取多文件分区数据集并将其放入表中，
从表中写出分区数据集。

先决条件#

在继续之前，请确保您拥有

Arrow 安装，您可以在此处设置：在您自己的项目中使用 Arrow C++
对基本 Arrow 数据结构的理解

为了见证差异，阅读Arrow 文件 I/O可能会有所帮助。但是，这不是必需的。

设置#

在运行一些计算之前，我们需要填补几个空白

我们需要包含必要的头文件。
需要一个main() 将所有内容粘合在一起。
我们需要磁盘上的数据来进行操作。

包含#

在编写 C++ 代码之前，我们需要一些包含语句。我们将获取iostream 用于输出，然后导入 Arrow 的计算功能，用于我们将在这篇文章中使用的每种文件类型

#include <arrow/api.h>
#include <arrow/dataset/api.h>
// We use Parquet headers for setting up examples; they are not required for using
// datasets.
#include <parquet/arrow/reader.h>
#include <parquet/arrow/writer.h>

#include <unistd.h>
#include <iostream>

Main()#

对于我们的粘合剂，我们将使用之前数据结构教程中的main() 模式

int main() {
  arrow::Status st = RunMain();
  if (!st.ok()) {
    std::cerr << st << std::endl;
    return 1;
  }
  return 0;
}

它，就像我们之前使用它时一样，与RunMain() 配对

arrow::Status RunMain() {

生成要读取的文件#

我们需要一些文件来实际操作。在实践中，您可能会有自己应用程序的一些输入。但是，在这里，我们希望在不增加提供或查找数据集的开销的情况下进行探索，因此让我们生成一些文件，以使操作易于遵循。随意通读此内容，但本文将正确地介绍这些概念——现在，只需将其复制粘贴进去，并意识到它以磁盘上的分区数据集结束

// Generate some data for the rest of this example.
arrow::Result<std::shared_ptr<arrow::Table>> CreateTable() {
  // This code should look familiar from the basic Arrow example, and is not the
  // focus of this example. However, we need data to work on it, and this makes that!
  auto schema =
      arrow::schema({arrow::field("a", arrow::int64()), arrow::field("b", arrow::int64()),
                     arrow::field("c", arrow::int64())});
  std::shared_ptr<arrow::Array> array_a;
  std::shared_ptr<arrow::Array> array_b;
  std::shared_ptr<arrow::Array> array_c;
  arrow::NumericBuilder<arrow::Int64Type> builder;
  ARROW_RETURN_NOT_OK(builder.AppendValues({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_a));
  builder.Reset();
  ARROW_RETURN_NOT_OK(builder.AppendValues({9, 8, 7, 6, 5, 4, 3, 2, 1, 0}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_b));
  builder.Reset();
  ARROW_RETURN_NOT_OK(builder.AppendValues({1, 2, 1, 2, 1, 2, 1, 2, 1, 2}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_c));
  return arrow::Table::Make(schema, {array_a, array_b, array_c});
}

// Set up a dataset by writing two Parquet files.
arrow::Result<std::string> CreateExampleParquetDataset(
    const std::shared_ptr<arrow::fs::FileSystem>& filesystem,
    const std::string& root_path) {
  // Much like CreateTable(), this is utility that gets us the dataset we'll be reading
  // from. Don't worry, we also write a dataset in the example proper.
  auto base_path = root_path + "parquet_dataset";
  ARROW_RETURN_NOT_OK(filesystem->CreateDir(base_path));
  // Create an Arrow Table
  ARROW_ASSIGN_OR_RAISE(auto table, CreateTable());
  // Write it into two Parquet files
  ARROW_ASSIGN_OR_RAISE(auto output,
                        filesystem->OpenOutputStream(base_path + "/data1.parquet"));
  ARROW_RETURN_NOT_OK(parquet::arrow::WriteTable(
      *table->Slice(0, 5), arrow::default_memory_pool(), output, 2048));
  ARROW_ASSIGN_OR_RAISE(output,
                        filesystem->OpenOutputStream(base_path + "/data2.parquet"));
  ARROW_RETURN_NOT_OK(parquet::arrow::WriteTable(
      *table->Slice(5), arrow::default_memory_pool(), output, 2048));
  return base_path;
}

arrow::Status PrepareEnv() {
  // 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;
  // Note this operates in the directory the executable is built in.
  char setup_path[256];
  char* result = getcwd(setup_path, 256);
  if (result == NULL) {
    return arrow::Status::IOError("Fetching PWD failed.");
  }

  ARROW_ASSIGN_OR_RAISE(setup_fs, arrow::fs::FileSystemFromUriOrPath(setup_path));
  ARROW_ASSIGN_OR_RAISE(auto dset_path, CreateExampleParquetDataset(setup_fs, ""));

  return arrow::Status::OK();
}

为了实际拥有这些文件，请确保在RunMain() 中调用的第一件事是我们的辅助函数PrepareEnv()，它将为我们获取一个磁盘上的数据集来进行操作

  ARROW_RETURN_NOT_OK(PrepareEnv());

读取分区数据集#

读取数据集与读取单个文件是不同的任务。由于需要能够解析多个文件和/或文件夹，因此该任务比读取单个文件需要更多工作。此过程可以分解为以下步骤

获取用于本地文件系统的fs::FileSystem 对象
创建fs::FileSelector 并使用它来准备dataset::FileSystemDatasetFactory
使用dataset::FileSystemDatasetFactory 构建dataset::Dataset
使用dataset::Scanner 读取到Table中

准备文件系统对象#

为了开始，我们需要能够与本地文件系统交互。为此，我们需要一个fs::FileSystem 对象。fs::FileSystem 是一个抽象，它允许我们无论使用 Amazon S3、Google Cloud Storage 还是本地磁盘，都使用相同的接口——我们将使用本地磁盘。因此，让我们声明它

  // First, we need a filesystem object, which lets us interact with our local
  // filesystem starting at a given path. For the sake of simplicity, that'll be
  // the current directory.
  std::shared_ptr<arrow::fs::FileSystem> fs;

在此示例中，我们的FileSystem’s 基本路径存在于与可执行文件相同的目录中。fs::FileSystemFromUriOrPath() 允许我们为任何类型的受支持文件系统获取fs::FileSystem 对象。但是，在这里，我们将只传递我们的路径

  // Get the CWD, use it to make the FileSystem object.
  char init_path[256];
  char* result = getcwd(init_path, 256);
  if (result == NULL) {
    return arrow::Status::IOError("Fetching PWD failed.");
  }
  ARROW_ASSIGN_OR_RAISE(fs, arrow::fs::FileSystemFromUriOrPath(init_path));

另请参阅

fs::FileSystem 以了解其他受支持的文件系统。

创建 FileSystemDatasetFactory#

一个fs::FileSystem 存储了许多元数据，但我们需要能够遍历它并解析这些元数据。在 Arrow 中，我们使用FileSelector 来做到这一点

  // A file selector lets us actually traverse a multi-file dataset.
  arrow::fs::FileSelector selector;

此fs::FileSelector 还没有任何功能。为了使用它，我们需要对其进行配置——我们将让它在“parquet_dataset”中启动任何选择，这是环境准备过程为我们留下数据集的地方，并将 recursive 设置为 true，这允许遍历文件夹。

  selector.base_dir = "parquet_dataset";
  // Recursive is a safe bet if you don't know the nesting of your dataset.
  selector.recursive = true;

要从fs::FileSystem 获取dataset::Dataset，我们需要准备一个dataset::FileSystemDatasetFactory。这是一个很长但描述性的名称——它将为我们创建一个工厂，用于从我们的fs::FileSystem 获取数据。首先，我们通过填充dataset::FileSystemFactoryOptions 结构体来对其进行配置

  // Making an options object lets us configure our dataset reading.
  arrow::dataset::FileSystemFactoryOptions options;
  // We'll use Hive-style partitioning. We'll let Arrow Datasets infer the partition
  // schema. We won't set any other options, defaults are fine.
  options.partitioning = arrow::dataset::HivePartitioning::MakeFactory();

有许多文件格式，我们必须选择一个在实际读取时预期的格式。Parquet 是我们磁盘上的格式，因此当然，我们在读取时会请求它

  auto read_format = std::make_shared<arrow::dataset::ParquetFileFormat>();

在设置fs::FileSystem、fs::FileSelector、选项和文件格式后，我们可以创建dataset::FileSystemDatasetFactory。这只需要传入我们准备的所有内容并将其分配给一个变量

  // Now, we get a factory that will let us get our dataset -- we don't have the
  // dataset yet!
  ARROW_ASSIGN_OR_RAISE(auto factory, arrow::dataset::FileSystemDatasetFactory::Make(
                                          fs, selector, read_format, options));

使用工厂构建数据集#

设置了dataset::FileSystemDatasetFactory 后，我们实际上可以使用dataset::FileSystemDatasetFactory::Finish() 构建我们的dataset::Dataset，就像在基本教程中使用ArrayBuilder 一样

  // Now we build our dataset from the factory.
  ARROW_ASSIGN_OR_RAISE(auto read_dataset, factory->Finish());

现在，我们在内存中有一个dataset::Dataset 对象。这并不意味着整个数据集都已在内存中体现，而是意味着我们现在可以访问允许我们探索和使用磁盘上数据集的工具。例如，我们可以获取构成整个数据集的片段（文件），并打印出来，以及一些少量的信息

  // Print out the fragments
  ARROW_ASSIGN_OR_RAISE(auto fragments, read_dataset->GetFragments());
  for (const auto& fragment : fragments) {
    std::cout << "Found fragment: " << (*fragment)->ToString() << std::endl;
    std::cout << "Partition expression: "
              << (*fragment)->partition_expression().ToString() << std::endl;
  }

将数据集移动到表中#

我们可以对Datasets 执行的一件事是将其放入Table 中，在这里我们可以执行我们已经了解到的对Tables 执行的任何操作到该Table。

另请参阅

Acero：一个 C++ 流式执行引擎用于避免在内存中体现整个数据集的执行。

为了将Dataset’s 内容移动到Table 中，我们需要一个dataset::Scanner，它扫描数据并将其输出到Table 中。首先，我们从dataset::Dataset 获取dataset::ScannerBuilder

  // Scan dataset into a Table -- once this is done, you can do
  // normal table things with it, like computation and printing. However, now you're
  // also dedicated to being in memory.
  ARROW_ASSIGN_OR_RAISE(auto read_scan_builder, read_dataset->NewScan());

当然，Builder 的唯一用途是为我们获取dataset::Scanner，因此让我们使用dataset::ScannerBuilder::Finish()

  ARROW_ASSIGN_OR_RAISE(auto read_scanner, read_scan_builder->Finish());

现在我们有了遍历dataset::Dataset的工具，让我们用它来获取我们的Table。dataset::Scanner::ToTable() 正好提供了我们想要的功能，我们可以打印结果。

  ARROW_ASSIGN_OR_RAISE(std::shared_ptr<arrow::Table> table, read_scanner->ToTable());
  std::cout << table->ToString();

这样我们就得到一个普通的Table。同样，如果想要在不转换为Table的情况下处理Datasets，可以考虑使用 Acero。

从 Table 将 Dataset 写入磁盘#

写入dataset::Dataset 与写入单个文件是不同的任务。由于需要能够解析跨多个文件和文件夹的分区方案，因此这项任务比写入单个文件需要更多的工作。这个过程可以分解成以下步骤

准备一个TableBatchReader
创建一个dataset::Scanner 从TableBatchReader中提取数据
准备模式、分区和文件格式选项
设置dataset::FileSystemDatasetWriteOptions - 一个结构体，用于配置我们的写入函数
将数据集写入磁盘

准备从 Table 写入的数据#

我们有一个Table，并且想要在磁盘上获得一个dataset::Dataset。事实上，为了探索的目的，我们将为数据集使用不同的分区方案 - 与原始片段只是分成两半不同，我们将根据每一行在“a”列中的值进行分区。

要开始这个操作，让我们获取一个TableBatchReader！这使得写入Dataset变得非常容易，并且可以在任何需要将Table分解成RecordBatches流的情况下使用。在这里，我们只需使用TableBatchReader’s 构造函数，以及我们的表格

  // Now, let's get a table out to disk as a dataset!
  // We make a RecordBatchReader from our Table, then set up a scanner, which lets us
  // go to a file.
  std::shared_ptr<arrow::TableBatchReader> write_dataset =
      std::make_shared<arrow::TableBatchReader>(table);

创建用于移动 Table 数据的 Scanner#

一旦数据源可用，写入dataset::Dataset 的过程类似于读取它的逆过程。之前，我们使用dataset::Scanner 扫描到Table - 现在，我们需要一个从我们的TableBatchReader中读取。为了获得该dataset::Scanner，我们将基于我们的TableBatchReader 创建一个dataset::ScannerBuilder，然后使用该 Builder 构建一个dataset::Scanner

  auto write_scanner_builder =
      arrow::dataset::ScannerBuilder::FromRecordBatchReader(write_dataset);
  ARROW_ASSIGN_OR_RAISE(auto write_scanner, write_scanner_builder->Finish())

准备模式、分区和文件格式变量#

由于我们想要根据“a”列进行分区，因此我们需要声明这一点。在定义我们的分区Schema时，我们将只包含一个包含“a”的Field

  // The partition schema determines which fields are used as keys for partitioning.
  auto partition_schema = arrow::schema({arrow::field("a", arrow::utf8())});

此Schema 确定了分区的键是什么，但我们需要选择将对该键执行某些操作的算法。我们将再次使用 Hive 样式，这次将我们的模式作为配置传递给它。

  // We'll use Hive-style partitioning, which creates directories with "key=value"
  // pairs.
  auto partitioning =
      std::make_shared<arrow::dataset::HivePartitioning>(partition_schema);

有多种文件格式可用，但 Parquet 通常与 Arrow 一起使用，因此我们将再次写入该格式。

  // Now, we declare we'll be writing Parquet files.
  auto write_format = std::make_shared<arrow::dataset::ParquetFileFormat>();

配置 FileSystemDatasetWriteOptions#

为了写入磁盘，我们需要一些配置。我们将通过在dataset::FileSystemDatasetWriteOptions 结构体中设置值来实现。我们将尽可能使用默认值进行初始化。

  // This time, we make Options for writing, but do much more configuration.
  arrow::dataset::FileSystemDatasetWriteOptions write_options;
  // Defaults to start.
  write_options.file_write_options = write_format->DefaultWriteOptions();

写入文件的关键步骤之一是拥有一个要定位的fs::FileSystem。幸运的是，我们在设置读取时就有一个。这是一个简单的变量赋值。

  // Use the filesystem we already have.
  write_options.filesystem = fs;

Arrow 可以创建目录，但它确实需要该目录的名称，因此让我们给它一个名称，称之为“write_dataset”。

  // Write to the folder "write_dataset" in current directory.
  write_options.base_dir = "write_dataset";

我们之前创建了一个分区方法，声明我们将使用 Hive 样式 - 这是我们实际将该方法传递给写入函数的地方。

  // Use the partitioning declared above.
  write_options.partitioning = partitioning;

发生的一部分情况是 Arrow 将分解文件，从而防止文件过大而无法处理。这就是数据集最初被分割的原因。为了设置这一点，我们需要在目录中每个片段的基本名称 - 在这种情况下，我们将使用“part{i}.parquet”，这意味着（在同一目录中）第三个文件将被称为“part3.parquet”，例如。

  // Define what the name for the files making up the dataset will be.
  write_options.basename_template = "part{i}.parquet";

有时，数据将被多次写入同一位置，并且将接受覆盖。由于我们可能希望多次运行此应用程序，因此我们将设置 Arrow 以覆盖现有数据 - 如果我们不这样做，Arrow 将由于在第一次运行此应用程序后看到现有数据而中止。

  // Set behavior to overwrite existing data -- specifically, this lets this example
  // be run more than once, and allows whatever code you have to overwrite what's there.
  write_options.existing_data_behavior =
      arrow::dataset::ExistingDataBehavior::kOverwriteOrIgnore;

将 Dataset 写入磁盘#

一旦dataset::FileSystemDatasetWriteOptions 配置完成，并且dataset::Scanner 准备解析数据，我们可以将 Options 和dataset::Scanner 传递给dataset::FileSystemDataset::Write() 以写入磁盘。

  // Write to disk!
  ARROW_RETURN_NOT_OK(
      arrow::dataset::FileSystemDataset::Write(write_options, write_scanner));

您可以查看您的磁盘，以确认您是否已写入一个包含每个“a”值的子文件夹的文件夹，每个子文件夹都有 Parquet 文件！

结束程序#

最后，我们只需返回Status::OK()，以便main() 知道我们已经完成，并且一切正常，就像前面的教程一样。

  return arrow::Status::OK();
}

这样，您就读取和写入分区数据集了！此方法，结合一些配置，将适用于任何受支持的数据集格式。对于此类数据集的示例，NYC 出租车数据集是一个众所周知的数据集，您可以在此处找到它。现在您可以获取大于内存的数据以供使用！

这意味着我们现在必须能够处理这些数据，而无需一次将其全部加载到内存中。为此，请尝试使用 Acero。

另请参阅

Acero：一个 C++ 流式执行引擎以获取有关 Acero 的更多信息。

请参阅以下内容以获取完整代码的副本

// (Doc section: Includes)
#include <arrow/api.h>
#include <arrow/dataset/api.h>
// We use Parquet headers for setting up examples; they are not required for using
// datasets.
#include <parquet/arrow/reader.h>
#include <parquet/arrow/writer.h>

#include <unistd.h>
#include <iostream>
// (Doc section: Includes)

// (Doc section: Helper Functions)
// Generate some data for the rest of this example.
arrow::Result<std::shared_ptr<arrow::Table>> CreateTable() {
  // This code should look familiar from the basic Arrow example, and is not the
  // focus of this example. However, we need data to work on it, and this makes that!
  auto schema =
      arrow::schema({arrow::field("a", arrow::int64()), arrow::field("b", arrow::int64()),
                     arrow::field("c", arrow::int64())});
  std::shared_ptr<arrow::Array> array_a;
  std::shared_ptr<arrow::Array> array_b;
  std::shared_ptr<arrow::Array> array_c;
  arrow::NumericBuilder<arrow::Int64Type> builder;
  ARROW_RETURN_NOT_OK(builder.AppendValues({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_a));
  builder.Reset();
  ARROW_RETURN_NOT_OK(builder.AppendValues({9, 8, 7, 6, 5, 4, 3, 2, 1, 0}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_b));
  builder.Reset();
  ARROW_RETURN_NOT_OK(builder.AppendValues({1, 2, 1, 2, 1, 2, 1, 2, 1, 2}));
  ARROW_RETURN_NOT_OK(builder.Finish(&array_c));
  return arrow::Table::Make(schema, {array_a, array_b, array_c});
}

// Set up a dataset by writing two Parquet files.
arrow::Result<std::string> CreateExampleParquetDataset(
    const std::shared_ptr<arrow::fs::FileSystem>& filesystem,
    const std::string& root_path) {
  // Much like CreateTable(), this is utility that gets us the dataset we'll be reading
  // from. Don't worry, we also write a dataset in the example proper.
  auto base_path = root_path + "parquet_dataset";
  ARROW_RETURN_NOT_OK(filesystem->CreateDir(base_path));
  // Create an Arrow Table
  ARROW_ASSIGN_OR_RAISE(auto table, CreateTable());
  // Write it into two Parquet files
  ARROW_ASSIGN_OR_RAISE(auto output,
                        filesystem->OpenOutputStream(base_path + "/data1.parquet"));
  ARROW_RETURN_NOT_OK(parquet::arrow::WriteTable(
      *table->Slice(0, 5), arrow::default_memory_pool(), output, 2048));
  ARROW_ASSIGN_OR_RAISE(output,
                        filesystem->OpenOutputStream(base_path + "/data2.parquet"));
  ARROW_RETURN_NOT_OK(parquet::arrow::WriteTable(
      *table->Slice(5), arrow::default_memory_pool(), output, 2048));
  return base_path;
}

arrow::Status PrepareEnv() {
  // 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;
  // Note this operates in the directory the executable is built in.
  char setup_path[256];
  char* result = getcwd(setup_path, 256);
  if (result == NULL) {
    return arrow::Status::IOError("Fetching PWD failed.");
  }

  ARROW_ASSIGN_OR_RAISE(setup_fs, arrow::fs::FileSystemFromUriOrPath(setup_path));
  ARROW_ASSIGN_OR_RAISE(auto dset_path, CreateExampleParquetDataset(setup_fs, ""));

  return arrow::Status::OK();
}
// (Doc section: Helper Functions)

// (Doc section: RunMain)
arrow::Status RunMain() {
  // (Doc section: RunMain)
  // (Doc section: PrepareEnv)
  ARROW_RETURN_NOT_OK(PrepareEnv());
  // (Doc section: PrepareEnv)

  // (Doc section: FileSystem Declare)
  // First, we need a filesystem object, which lets us interact with our local
  // filesystem starting at a given path. For the sake of simplicity, that'll be
  // the current directory.
  std::shared_ptr<arrow::fs::FileSystem> fs;
  // (Doc section: FileSystem Declare)

  // (Doc section: FileSystem Init)
  // Get the CWD, use it to make the FileSystem object.
  char init_path[256];
  char* result = getcwd(init_path, 256);
  if (result == NULL) {
    return arrow::Status::IOError("Fetching PWD failed.");
  }
  ARROW_ASSIGN_OR_RAISE(fs, arrow::fs::FileSystemFromUriOrPath(init_path));
  // (Doc section: FileSystem Init)

  // (Doc section: FileSelector Declare)
  // A file selector lets us actually traverse a multi-file dataset.
  arrow::fs::FileSelector selector;
  // (Doc section: FileSelector Declare)
  // (Doc section: FileSelector Config)
  selector.base_dir = "parquet_dataset";
  // Recursive is a safe bet if you don't know the nesting of your dataset.
  selector.recursive = true;
  // (Doc section: FileSelector Config)
  // (Doc section: FileSystemFactoryOptions)
  // Making an options object lets us configure our dataset reading.
  arrow::dataset::FileSystemFactoryOptions options;
  // We'll use Hive-style partitioning. We'll let Arrow Datasets infer the partition
  // schema. We won't set any other options, defaults are fine.
  options.partitioning = arrow::dataset::HivePartitioning::MakeFactory();
  // (Doc section: FileSystemFactoryOptions)
  // (Doc section: File Format Setup)
  auto read_format = std::make_shared<arrow::dataset::ParquetFileFormat>();
  // (Doc section: File Format Setup)
  // (Doc section: FileSystemDatasetFactory Make)
  // Now, we get a factory that will let us get our dataset -- we don't have the
  // dataset yet!
  ARROW_ASSIGN_OR_RAISE(auto factory, arrow::dataset::FileSystemDatasetFactory::Make(
                                          fs, selector, read_format, options));
  // (Doc section: FileSystemDatasetFactory Make)
  // (Doc section: FileSystemDatasetFactory Finish)
  // Now we build our dataset from the factory.
  ARROW_ASSIGN_OR_RAISE(auto read_dataset, factory->Finish());
  // (Doc section: FileSystemDatasetFactory Finish)
  // (Doc section: Dataset Fragments)
  // Print out the fragments
  ARROW_ASSIGN_OR_RAISE(auto fragments, read_dataset->GetFragments());
  for (const auto& fragment : fragments) {
    std::cout << "Found fragment: " << (*fragment)->ToString() << std::endl;
    std::cout << "Partition expression: "
              << (*fragment)->partition_expression().ToString() << std::endl;
  }
  // (Doc section: Dataset Fragments)
  // (Doc section: Read Scan Builder)
  // Scan dataset into a Table -- once this is done, you can do
  // normal table things with it, like computation and printing. However, now you're
  // also dedicated to being in memory.
  ARROW_ASSIGN_OR_RAISE(auto read_scan_builder, read_dataset->NewScan());
  // (Doc section: Read Scan Builder)
  // (Doc section: Read Scanner)
  ARROW_ASSIGN_OR_RAISE(auto read_scanner, read_scan_builder->Finish());
  // (Doc section: Read Scanner)
  // (Doc section: To Table)
  ARROW_ASSIGN_OR_RAISE(std::shared_ptr<arrow::Table> table, read_scanner->ToTable());
  std::cout << table->ToString();
  // (Doc section: To Table)

  // (Doc section: TableBatchReader)
  // Now, let's get a table out to disk as a dataset!
  // We make a RecordBatchReader from our Table, then set up a scanner, which lets us
  // go to a file.
  std::shared_ptr<arrow::TableBatchReader> write_dataset =
      std::make_shared<arrow::TableBatchReader>(table);
  // (Doc section: TableBatchReader)
  // (Doc section: WriteScanner)
  auto write_scanner_builder =
      arrow::dataset::ScannerBuilder::FromRecordBatchReader(write_dataset);
  ARROW_ASSIGN_OR_RAISE(auto write_scanner, write_scanner_builder->Finish())
  // (Doc section: WriteScanner)
  // (Doc section: Partition Schema)
  // The partition schema determines which fields are used as keys for partitioning.
  auto partition_schema = arrow::schema({arrow::field("a", arrow::utf8())});
  // (Doc section: Partition Schema)
  // (Doc section: Partition Create)
  // We'll use Hive-style partitioning, which creates directories with "key=value"
  // pairs.
  auto partitioning =
      std::make_shared<arrow::dataset::HivePartitioning>(partition_schema);
  // (Doc section: Partition Create)
  // (Doc section: Write Format)
  // Now, we declare we'll be writing Parquet files.
  auto write_format = std::make_shared<arrow::dataset::ParquetFileFormat>();
  // (Doc section: Write Format)
  // (Doc section: Write Options)
  // This time, we make Options for writing, but do much more configuration.
  arrow::dataset::FileSystemDatasetWriteOptions write_options;
  // Defaults to start.
  write_options.file_write_options = write_format->DefaultWriteOptions();
  // (Doc section: Write Options)
  // (Doc section: Options FS)
  // Use the filesystem we already have.
  write_options.filesystem = fs;
  // (Doc section: Options FS)
  // (Doc section: Options Target)
  // Write to the folder "write_dataset" in current directory.
  write_options.base_dir = "write_dataset";
  // (Doc section: Options Target)
  // (Doc section: Options Partitioning)
  // Use the partitioning declared above.
  write_options.partitioning = partitioning;
  // (Doc section: Options Partitioning)
  // (Doc section: Options Name Template)
  // Define what the name for the files making up the dataset will be.
  write_options.basename_template = "part{i}.parquet";
  // (Doc section: Options Name Template)
  // (Doc section: Options File Behavior)
  // Set behavior to overwrite existing data -- specifically, this lets this example
  // be run more than once, and allows whatever code you have to overwrite what's there.
  write_options.existing_data_behavior =
      arrow::dataset::ExistingDataBehavior::kOverwriteOrIgnore;
  // (Doc section: Options File Behavior)
  // (Doc section: Write Dataset)
  // Write to disk!
  ARROW_RETURN_NOT_OK(
      arrow::dataset::FileSystemDataset::Write(write_options, write_scanner));
  // (Doc section: Write Dataset)
  // (Doc section: Ret)
  return arrow::Status::OK();
}
// (Doc section: Ret)
// (Doc section: Main)
int main() {
  arrow::Status st = RunMain();
  if (!st.ok()) {
    std::cerr << st << std::endl;
    return 1;
  }
  return 0;
}
// (Doc section: Main)