Status version FileReader::Make set to deprecated

Author: hiroyuki-sato

cpp/src/arrow/dataset/file_parquet.cc

@@ -509,9 +509,9 @@ Result<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
   std::shared_ptr<parquet::FileMetaData> reader_metadata = reader->metadata();
   auto arrow_properties =
       MakeArrowReaderProperties(*this, *reader_metadata, *options, *parquet_scan_options);
-  std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
-  RETURN_NOT_OK(parquet::arrow::FileReader::Make(
-      options->pool, std::move(reader), std::move(arrow_properties), &arrow_reader));
+  ARROW_ASSIGN_OR_RAISE(auto arrow_reader,
+                        parquet::arrow::FileReader::Make(options->pool, std::move(reader),
+                                                         std::move(arrow_properties)));
   // R build with openSUSE155 requires an explicit shared_ptr construction
   return std::shared_ptr<parquet::arrow::FileReader>(std::move(arrow_reader));
 }
@@ -532,37 +532,37 @@ Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
                                          source.filesystem(), options->pool);
   auto self = checked_pointer_cast<const ParquetFileFormat>(shared_from_this());
 
-  return source.OpenAsync().Then(
-      [self = self, properties = std::move(properties), source = source,
-       options = options, metadata = metadata,
-       parquet_scan_options = parquet_scan_options](
-          const std::shared_ptr<io::RandomAccessFile>& input) mutable {
-        return parquet::ParquetFileReader::OpenAsync(input, properties, metadata)
-            .Then(
-                [=](const std::unique_ptr<parquet::ParquetFileReader>& reader) mutable
-                -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
-                  auto arrow_properties = MakeArrowReaderProperties(
-                      *self, *reader->metadata(), *options, *parquet_scan_options);
-
-                  std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
-                  RETURN_NOT_OK(parquet::arrow::FileReader::Make(
+  return source.OpenAsync().Then([self = self, properties = std::move(properties),
+                                  source = source, options = options, metadata = metadata,
+                                  parquet_scan_options = parquet_scan_options](
+                                     const std::shared_ptr<io::RandomAccessFile>&
+                                         input) mutable {
+    return parquet::ParquetFileReader::OpenAsync(input, properties, metadata)
+        .Then(
+            [=](const std::unique_ptr<parquet::ParquetFileReader>& reader) mutable
+            -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
+              auto arrow_properties = MakeArrowReaderProperties(
+                  *self, *reader->metadata(), *options, *parquet_scan_options);
+
+              ARROW_ASSIGN_OR_RAISE(
+                  auto arrow_reader,
+                  parquet::arrow::FileReader::Make(
                       options->pool,
                       // TODO(ARROW-12259): workaround since we have Future<(move-only
                       // type)> It *wouldn't* be safe to const_cast reader except that
                       // here we know there are no other waiters on the reader.
                       std::move(const_cast<std::unique_ptr<parquet::ParquetFileReader>&>(
                           reader)),
-                      arrow_properties, &arrow_reader));
-
-                  // R build with openSUSE155 requires an explicit shared_ptr construction
-                  return std::shared_ptr<parquet::arrow::FileReader>(
-                      std::move(arrow_reader));
-                },
-                [path = source.path()](const Status& status)
-                    -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
-                  return WrapSourceError(status, path);
-                });
-      });
+                      arrow_properties));
+
+              // R build with openSUSE155 requires an explicit shared_ptr construction
+              return std::shared_ptr<parquet::arrow::FileReader>(std::move(arrow_reader));
+            },
+            [path = source.path()](const Status& status)
+                -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
+              return WrapSourceError(status, path);
+            });
+  });
 }
 
 struct SlicingGenerator {

cpp/src/parquet/arrow/arrow_statistics_test.cc

@@ -202,9 +202,9 @@ ::arrow::Result<std::shared_ptr<::arrow::Array>> StatisticsReadArray(
 
   auto reader =
       ParquetFileReader::Open(std::make_shared<::arrow::io::BufferReader>(buffer));
-  std::unique_ptr<FileReader> file_reader;
-  ARROW_RETURN_NOT_OK(FileReader::Make(::arrow::default_memory_pool(), std::move(reader),
-                                       reader_properties, &file_reader));
+  ARROW_ASSIGN_OR_RAISE(auto file_reader,
+                        FileReader::Make(::arrow::default_memory_pool(),
+                                         std::move(reader), reader_properties));
   std::shared_ptr<::arrow::ChunkedArray> chunked_array;
   ARROW_RETURN_NOT_OK(file_reader->ReadColumn(0, &chunked_array));
   return chunked_array->chunk(0);

cpp/src/parquet/arrow/reader.cc

@@ -1404,13 +1404,13 @@ FileReaderBuilder* FileReaderBuilder::properties(
 }
 
 Status FileReaderBuilder::Build(std::unique_ptr<FileReader>* out) {
-  return FileReader::Make(pool_, std::move(raw_reader_), properties_, out);
+  ARROW_ASSIGN_OR_RAISE(*out,
+                        FileReader::Make(pool_, std::move(raw_reader_), properties_));
+  return Status::OK();
 }
 
 Result<std::unique_ptr<FileReader>> FileReaderBuilder::Build() {
-  std::unique_ptr<FileReader> out;
-  RETURN_NOT_OK(FileReader::Make(pool_, std::move(raw_reader_), properties_, &out));
-  return out;
+  return FileReader::Make(pool_, std::move(raw_reader_), properties_);
 }
 
 Result<std::unique_ptr<FileReader>> OpenFile(
@@ -1581,8 +1581,8 @@ Status FuzzReader(const uint8_t* data, int64_t size) {
     pq_file_reader = ParquetFileReader::Open(file, reader_properties, pq_md);
     END_PARQUET_CATCH_EXCEPTIONS
 
-    std::unique_ptr<FileReader> reader;
-    RETURN_NOT_OK(FileReader::Make(pool, std::move(pq_file_reader), properties, &reader));
+    ARROW_ASSIGN_OR_RAISE(auto reader,
+                          FileReader::Make(pool, std::move(pq_file_reader), properties));
     st &= FuzzReadData(std::move(reader));
   }
   return st;

cpp/src/parquet/arrow/reader.h

@@ -116,12 +116,16 @@ class RowGroupReader;
 class PARQUET_EXPORT FileReader {
  public:
   /// Factory function to create a FileReader from a ParquetFileReader and properties
+  /// \deprecated Deprecated in 23.0.0. Use arrow::Result version instead.
+  ARROW_DEPRECATED("Deprecated in 23.0.0. Use arrow::Result version instead.")
   static ::arrow::Status Make(::arrow::MemoryPool* pool,
                               std::unique_ptr<ParquetFileReader> reader,
                               const ArrowReaderProperties& properties,
                               std::unique_ptr<FileReader>* out);
 
   /// Factory function to create a FileReader from a ParquetFileReader
+  /// \deprecated Deprecated in 23.0.0. Use arrow::Result version instead.
+  ARROW_DEPRECATED("Deprecated in 23.0.0. Use arrow::Result version instead.")
   static ::arrow::Status Make(::arrow::MemoryPool* pool,
                               std::unique_ptr<ParquetFileReader> reader,
                               std::unique_ptr<FileReader>* out);