From bdbc88559ed66a37253c568318e5ff4b7f38d7bb Mon Sep 17 00:00:00 2001 From: Wes McKinney Date: Thu, 26 Mar 2020 19:06:30 -0500 Subject: [PATCH 1/2] Remove APIs deprecated prior to 0.16.0 --- cpp/src/arrow/array.h | 6 --- cpp/src/arrow/csv/reader.cc | 14 ------- cpp/src/arrow/csv/reader.h | 8 ---- cpp/src/arrow/io/buffered.cc | 17 --------- cpp/src/arrow/io/buffered.h | 14 ------- cpp/src/arrow/io/compressed.cc | 23 ------------ cpp/src/arrow/io/compressed.h | 16 -------- cpp/src/arrow/io/file.cc | 61 ------------------------------- cpp/src/arrow/io/file.h | 39 -------------------- cpp/src/arrow/io/hdfs.cc | 14 ------- cpp/src/arrow/io/hdfs.h | 37 ++++++++++++++----- cpp/src/arrow/io/interfaces.cc | 26 ------------- cpp/src/arrow/io/interfaces.h | 57 ----------------------------- cpp/src/arrow/io/memory.cc | 9 ----- cpp/src/arrow/io/memory.h | 7 ---- cpp/src/arrow/ipc/reader.h | 26 ++++++------- cpp/src/arrow/sparse_tensor.h | 31 ---------------- cpp/src/arrow/type.cc | 21 ----------- cpp/src/arrow/type.h | 14 ------- cpp/src/arrow/util/compression.cc | 30 --------------- cpp/src/arrow/util/compression.h | 29 --------------- cpp/src/arrow/util/decimal.cc | 12 ------ cpp/src/arrow/util/decimal.h | 42 --------------------- cpp/src/parquet/arrow/reader.cc | 18 --------- cpp/src/parquet/arrow/reader.h | 15 -------- cpp/src/parquet/types.h | 4 -- 26 files changed, 41 insertions(+), 549 deletions(-) diff --git a/cpp/src/arrow/array.h b/cpp/src/arrow/array.h index 60ad599284a7..69f7e4e02e74 100644 --- a/cpp/src/arrow/array.h +++ b/cpp/src/arrow/array.h @@ -1224,12 +1224,6 @@ class ARROW_EXPORT UnionArray : public Array { const type_code_t* raw_type_codes() const { return raw_type_codes_ + data_->offset; } - ARROW_DEPRECATED("Use UnionArray::type_codes") - std::shared_ptr type_ids() const { return type_codes(); } - - ARROW_DEPRECATED("Use UnionArray::raw_type_codes") - const type_code_t* raw_type_ids() const { return raw_type_codes(); } - /// The physical child id containing value at index. int child_id(int64_t i) const { return union_type_->child_ids()[raw_type_codes_[i + data_->offset]]; diff --git a/cpp/src/arrow/csv/reader.cc b/cpp/src/arrow/csv/reader.cc index 27c7d7623737..fed4cf4fe903 100644 --- a/cpp/src/arrow/csv/reader.cc +++ b/cpp/src/arrow/csv/reader.cc @@ -504,19 +504,5 @@ Result> TableReader::Make( return reader; } -///////////////////////////////////////////////////////////////////////// -// Deprecated API(s) - -Status TableReader::Make(MemoryPool* pool, std::shared_ptr input, - const ReadOptions& read_options, - const ParseOptions& parse_options, - const ConvertOptions& convert_options, - std::shared_ptr* out) { - return Make(pool, std::move(input), read_options, parse_options, convert_options) - .Value(out); -} - -Status TableReader::Read(std::shared_ptr* out) { return Read().Value(out); } - } // namespace csv } // namespace arrow diff --git a/cpp/src/arrow/csv/reader.h b/cpp/src/arrow/csv/reader.h index f41c79975a14..eabdb7132c88 100644 --- a/cpp/src/arrow/csv/reader.h +++ b/cpp/src/arrow/csv/reader.h @@ -39,20 +39,12 @@ class ARROW_EXPORT TableReader { /// Read the entire CSV file and convert it to a Arrow Table virtual Result> Read() = 0; - ARROW_DEPRECATED("Use Result-returning overload") - virtual Status Read(std::shared_ptr
* out); - /// Create a TableReader instance static Result> Make(MemoryPool* pool, std::shared_ptr input, const ReadOptions&, const ParseOptions&, const ConvertOptions&); - - ARROW_DEPRECATED("Use Result-returning overload") - static Status Make(MemoryPool* pool, std::shared_ptr input, - const ReadOptions&, const ParseOptions&, const ConvertOptions&, - std::shared_ptr* out); }; } // namespace csv diff --git a/cpp/src/arrow/io/buffered.cc b/cpp/src/arrow/io/buffered.cc index 36bebc4e9bb1..cd436daa2696 100644 --- a/cpp/src/arrow/io/buffered.cc +++ b/cpp/src/arrow/io/buffered.cc @@ -209,12 +209,6 @@ Result> BufferedOutputStream::Create( return result; } -Status BufferedOutputStream::Create(int64_t buffer_size, MemoryPool* pool, - std::shared_ptr raw, - std::shared_ptr* out) { - return Create(buffer_size, pool, std::move(raw)).Value(out); -} - BufferedOutputStream::~BufferedOutputStream() { internal::CloseFromDestructor(this); } Status BufferedOutputStream::SetBufferSize(int64_t new_buffer_size) { @@ -229,10 +223,6 @@ Result> BufferedOutputStream::Detach() { return impl_->Detach(); } -Status BufferedOutputStream::Detach(std::shared_ptr* raw) { - return Detach().Value(raw); -} - Status BufferedOutputStream::Close() { return impl_->Close(); } Status BufferedOutputStream::Abort() { return impl_->Abort(); } @@ -453,13 +443,6 @@ Result> BufferedInputStream::Create( return result; } -Status BufferedInputStream::Create(int64_t buffer_size, MemoryPool* pool, - std::shared_ptr raw, - std::shared_ptr* out, - int64_t raw_total_bytes_bound) { - return Create(buffer_size, pool, std::move(raw)).Value(out); -} - Status BufferedInputStream::DoClose() { return impl_->Close(); } Status BufferedInputStream::DoAbort() { return impl_->Abort(); } diff --git a/cpp/src/arrow/io/buffered.h b/cpp/src/arrow/io/buffered.h index 21e01102e677..56c8c390f795 100644 --- a/cpp/src/arrow/io/buffered.h +++ b/cpp/src/arrow/io/buffered.h @@ -47,11 +47,6 @@ class ARROW_EXPORT BufferedOutputStream : public OutputStream { static Result> Create( int64_t buffer_size, MemoryPool* pool, std::shared_ptr raw); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Create(int64_t buffer_size, MemoryPool* pool, - std::shared_ptr raw, - std::shared_ptr* out); - /// \brief Resize internal buffer /// \param[in] new_buffer_size the new buffer size /// \return Status @@ -69,9 +64,6 @@ class ARROW_EXPORT BufferedOutputStream : public OutputStream { /// \return the underlying OutputStream Result> Detach(); - ARROW_DEPRECATED("Use Result-returning overload") - Status Detach(std::shared_ptr* raw); - // OutputStream interface /// \brief Close the buffered output stream. This implicitly closes the @@ -118,12 +110,6 @@ class ARROW_EXPORT BufferedInputStream int64_t buffer_size, MemoryPool* pool, std::shared_ptr raw, int64_t raw_read_bound = -1); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Create(int64_t buffer_size, MemoryPool* pool, - std::shared_ptr raw, - std::shared_ptr* out, - int64_t raw_read_bound = -1); - /// \brief Resize internal read buffer; calls to Read(...) will read at least /// \param[in] new_buffer_size the new read buffer size /// \return Status diff --git a/cpp/src/arrow/io/compressed.cc b/cpp/src/arrow/io/compressed.cc index 99b93c371169..590816983b97 100644 --- a/cpp/src/arrow/io/compressed.cc +++ b/cpp/src/arrow/io/compressed.cc @@ -206,18 +206,6 @@ Result> CompressedOutputStream::Make( return res; } -Status CompressedOutputStream::Make(util::Codec* codec, - const std::shared_ptr& raw, - std::shared_ptr* out) { - return Make(codec, raw).Value(out); -} - -Status CompressedOutputStream::Make(MemoryPool* pool, util::Codec* codec, - const std::shared_ptr& raw, - std::shared_ptr* out) { - return Make(codec, raw, pool).Value(out); -} - CompressedOutputStream::~CompressedOutputStream() { internal::CloseFromDestructor(this); } Status CompressedOutputStream::Close() { return impl_->Close(); } @@ -429,17 +417,6 @@ Result> CompressedInputStream::Make( return Status::OK(); } -Status CompressedInputStream::Make(Codec* codec, const std::shared_ptr& raw, - std::shared_ptr* out) { - return Make(codec, raw).Value(out); -} - -Status CompressedInputStream::Make(MemoryPool* pool, Codec* codec, - const std::shared_ptr& raw, - std::shared_ptr* out) { - return Make(codec, raw, pool).Value(out); -} - CompressedInputStream::~CompressedInputStream() { internal::CloseFromDestructor(this); } Status CompressedInputStream::DoClose() { return impl_->Close(); } diff --git a/cpp/src/arrow/io/compressed.h b/cpp/src/arrow/io/compressed.h index 3761bc2bc1be..677e45c6ff20 100644 --- a/cpp/src/arrow/io/compressed.h +++ b/cpp/src/arrow/io/compressed.h @@ -48,14 +48,6 @@ class ARROW_EXPORT CompressedOutputStream : public OutputStream { util::Codec* codec, const std::shared_ptr& raw, MemoryPool* pool = default_memory_pool()); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Make(util::Codec* codec, const std::shared_ptr& raw, - std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Make(MemoryPool* pool, util::Codec* codec, - const std::shared_ptr& raw, - std::shared_ptr* out); - // OutputStream interface /// \brief Close the compressed output stream. This implicitly closes the @@ -94,14 +86,6 @@ class ARROW_EXPORT CompressedInputStream util::Codec* codec, const std::shared_ptr& raw, MemoryPool* pool = default_memory_pool()); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Make(util::Codec* codec, const std::shared_ptr& raw, - std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Make(MemoryPool* pool, util::Codec* codec, - const std::shared_ptr& raw, - std::shared_ptr* out); - // InputStream interface bool closed() const override; diff --git a/cpp/src/arrow/io/file.cc b/cpp/src/arrow/io/file.cc index 752d5b6bba5d..1300734a6a91 100644 --- a/cpp/src/arrow/io/file.cc +++ b/cpp/src/arrow/io/file.cc @@ -285,23 +285,6 @@ Result> ReadableFile::Open(int fd, MemoryPool* poo return file; } -Status ReadableFile::Open(const std::string& path, std::shared_ptr* file) { - return Open(path).Value(file); -} - -Status ReadableFile::Open(const std::string& path, MemoryPool* pool, - std::shared_ptr* file) { - return Open(path, pool).Value(file); -} - -Status ReadableFile::Open(int fd, std::shared_ptr* file) { - return Open(fd).Value(file); -} - -Status ReadableFile::Open(int fd, MemoryPool* pool, std::shared_ptr* file) { - return Open(fd, pool).Value(file); -} - Status ReadableFile::DoClose() { return impl_->Close(); } bool ReadableFile::closed() const { return !impl_->is_open(); } @@ -359,34 +342,6 @@ Result> FileOutputStream::Open(int fd) { return stream; } -Status FileOutputStream::Open(const std::string& path, - std::shared_ptr* out) { - return Open(path, false).Value(out); -} - -Status FileOutputStream::Open(const std::string& path, bool append, - std::shared_ptr* out) { - return Open(path, append).Value(out); -} - -Status FileOutputStream::Open(int fd, std::shared_ptr* out) { - return Open(fd).Value(out); -} - -Status FileOutputStream::Open(const std::string& path, - std::shared_ptr* out) { - return Open(path, false).Value(out); -} - -Status FileOutputStream::Open(const std::string& path, bool append, - std::shared_ptr* out) { - return Open(path, append).Value(out); -} - -Status FileOutputStream::Open(int fd, std::shared_ptr* out) { - return Open(fd).Value(out); -} - Status FileOutputStream::Close() { return impl_->Close(); } bool FileOutputStream::closed() const { return !impl_->is_open(); } @@ -632,11 +587,6 @@ Result> MemoryMappedFile::Create( return MemoryMappedFile::Open(path, FileMode::READWRITE); } -Status MemoryMappedFile::Create(const std::string& path, int64_t size, - std::shared_ptr* out) { - return Create(path, size).Value(out); -} - Result> MemoryMappedFile::Open(const std::string& path, FileMode::type mode) { std::shared_ptr result(new MemoryMappedFile()); @@ -657,17 +607,6 @@ Result> MemoryMappedFile::Open(const std::stri return result; } -Status MemoryMappedFile::Open(const std::string& path, FileMode::type mode, - std::shared_ptr* out) { - return Open(path, mode).Value(out); -} - -Status MemoryMappedFile::Open(const std::string& path, FileMode::type mode, - const int64_t offset, const int64_t length, - std::shared_ptr* out) { - return Open(path, mode, offset, length).Value(out); -} - Result MemoryMappedFile::GetSize() { RETURN_NOT_OK(memory_map_->CheckClosed()); return memory_map_->size(); diff --git a/cpp/src/arrow/io/file.h b/cpp/src/arrow/io/file.h index 8996d1e1fd19..59c5bfb518b1 100644 --- a/cpp/src/arrow/io/file.h +++ b/cpp/src/arrow/io/file.h @@ -50,17 +50,6 @@ class ARROW_EXPORT FileOutputStream : public OutputStream { static Result> Open(const std::string& path, bool append = false); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, bool append, - std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, std::shared_ptr* file); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, bool append, - std::shared_ptr* file); - /// \brief Open a file descriptor for writing. The underlying file isn't /// truncated. /// \param[in] fd file descriptor @@ -70,11 +59,6 @@ class ARROW_EXPORT FileOutputStream : public OutputStream { /// on Close() or destruction. static Result> Open(int fd); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(int fd, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(int fd, std::shared_ptr* out); - // OutputStream interface Status Close() override; bool closed() const override; @@ -112,12 +96,6 @@ class ARROW_EXPORT ReadableFile static Result> Open( const std::string& path, MemoryPool* pool = default_memory_pool()); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, std::shared_ptr* file); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, MemoryPool* pool, - std::shared_ptr* file); - /// \brief Open a local file for reading /// \param[in] fd file descriptor /// \param[in] pool a MemoryPool for memory allocations @@ -128,11 +106,6 @@ class ARROW_EXPORT ReadableFile static Result> Open( int fd, MemoryPool* pool = default_memory_pool()); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(int fd, std::shared_ptr* file); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(int fd, MemoryPool* pool, std::shared_ptr* file); - bool closed() const override; int file_descriptor() const; @@ -175,28 +148,16 @@ class ARROW_EXPORT MemoryMappedFile : public ReadWriteFileInterface { static Result> Create(const std::string& path, int64_t size); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Create(const std::string& path, int64_t size, - std::shared_ptr* out); - // mmap() with whole file static Result> Open(const std::string& path, FileMode::type mode); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, FileMode::type mode, - std::shared_ptr* out); - // mmap() with a region of file, the offset must be a multiple of the page size static Result> Open(const std::string& path, FileMode::type mode, const int64_t offset, const int64_t length); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Open(const std::string& path, FileMode::type mode, const int64_t offset, - const int64_t length, std::shared_ptr* out); - Status Close() override; bool closed() const override; diff --git a/cpp/src/arrow/io/hdfs.cc b/cpp/src/arrow/io/hdfs.cc index e18553115bb7..75b7a83eebe2 100644 --- a/cpp/src/arrow/io/hdfs.cc +++ b/cpp/src/arrow/io/hdfs.cc @@ -648,20 +648,6 @@ Status HadoopFileSystem::Rename(const std::string& src, const std::string& dst) return impl_->Rename(src, dst); } -// Deprecated in 0.11 - -Status HadoopFileSystem::OpenWriteable(const std::string& path, bool append, - int32_t buffer_size, int16_t replication, - int64_t default_block_size, - std::shared_ptr* file) { - return OpenWritable(path, append, buffer_size, replication, default_block_size, file); -} - -Status HadoopFileSystem::OpenWriteable(const std::string& path, bool append, - std::shared_ptr* file) { - return OpenWritable(path, append, 0, 0, 0, file); -} - // ---------------------------------------------------------------------- // Allow public API users to check whether we are set up correctly diff --git a/cpp/src/arrow/io/hdfs.h b/cpp/src/arrow/io/hdfs.h index a89775ecbe97..3664ac19d935 100644 --- a/cpp/src/arrow/io/hdfs.h +++ b/cpp/src/arrow/io/hdfs.h @@ -38,6 +38,34 @@ namespace io { class HdfsReadableFile; class HdfsOutputStream; +/// DEPRECATED. Use the FileSystem API in arrow::fs instead. +struct ObjectType { + enum type { FILE, DIRECTORY }; +}; + +/// DEPRECATED. Use the FileSystem API in arrow::fs instead. +struct ARROW_EXPORT FileStatistics { + /// Size of file, -1 if finding length is unsupported + int64_t size; + ObjectType::type kind; +}; + +class ARROW_EXPORT FileSystem { + public: + virtual ~FileSystem() = default; + + virtual Status MakeDirectory(const std::string& path) = 0; + + virtual Status DeleteDirectory(const std::string& path) = 0; + + virtual Status GetChildren(const std::string& path, + std::vector* listing) = 0; + + virtual Status Rename(const std::string& src, const std::string& dst) = 0; + + virtual Status Stat(const std::string& path, FileStatistics* stat) = 0; +}; + struct HdfsPathInfo { ObjectType::type kind; @@ -170,15 +198,6 @@ class ARROW_EXPORT HadoopFileSystem : public FileSystem { Status OpenWritable(const std::string& path, bool append, std::shared_ptr* file); - ARROW_DEPRECATED("Use OpenWritable") - Status OpenWriteable(const std::string& path, bool append, int32_t buffer_size, - int16_t replication, int64_t default_block_size, - std::shared_ptr* file); - - ARROW_DEPRECATED("Use OpenWritable") - Status OpenWriteable(const std::string& path, bool append, - std::shared_ptr* file); - private: friend class HdfsReadableFile; friend class HdfsOutputStream; diff --git a/cpp/src/arrow/io/interfaces.cc b/cpp/src/arrow/io/interfaces.cc index d547d3e859e2..fd64eacc746e 100644 --- a/cpp/src/arrow/io/interfaces.cc +++ b/cpp/src/arrow/io/interfaces.cc @@ -48,8 +48,6 @@ FileInterface::~FileInterface() = default; Status FileInterface::Abort() { return Close(); } -Status FileInterface::Tell(int64_t* position) const { return Tell().Value(position); } - class InputStreamBlockIterator { public: InputStreamBlockIterator(std::shared_ptr stream, int64_t block_size) @@ -83,10 +81,6 @@ Result InputStream::Peek(int64_t ARROW_ARG_UNUSED(nbytes)) { return Status::NotImplemented("Peek not implemented"); } -Status InputStream::Peek(int64_t nbytes, util::string_view* out) { - return Peek(nbytes).Value(out); -} - bool InputStream::supports_zero_copy() const { return false; } Result>> MakeInputStreamIterator( @@ -98,14 +92,6 @@ Result>> MakeInputStreamIterator( return Iterator>(InputStreamBlockIterator(stream, block_size)); } -Status Readable::Read(int64_t nbytes, int64_t* bytes_read, void* out) { - return Read(nbytes, out).Value(bytes_read); -} - -Status Readable::Read(int64_t nbytes, std::shared_ptr* out) { - return Read(nbytes).Value(out); -} - struct RandomAccessFile::RandomAccessFileImpl { std::mutex lock_; }; @@ -128,18 +114,6 @@ Result> RandomAccessFile::ReadAt(int64_t position, return Read(nbytes); } -Status RandomAccessFile::ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read, - void* out) { - return ReadAt(position, nbytes, out).Value(bytes_read); -} - -Status RandomAccessFile::ReadAt(int64_t position, int64_t nbytes, - std::shared_ptr* out) { - return ReadAt(position, nbytes).Value(out); -} - -Status RandomAccessFile::GetSize(int64_t* size) { return GetSize().Value(size); } - // Default ReadAsync() implementation: simply issue the read on one of the IO threads Future> RandomAccessFile::ReadAsync(int64_t position, int64_t nbytes) { diff --git a/cpp/src/arrow/io/interfaces.h b/cpp/src/arrow/io/interfaces.h index f3b1db77bf12..de74acae7854 100644 --- a/cpp/src/arrow/io/interfaces.h +++ b/cpp/src/arrow/io/interfaces.h @@ -35,35 +35,6 @@ class Future; namespace io { -/// DEPRECATED. Use the FileSystem API in arrow::fs instead. -struct ObjectType { - enum type { FILE, DIRECTORY }; -}; - -/// DEPRECATED. Use the FileSystem API in arrow::fs instead. -struct ARROW_EXPORT FileStatistics { - /// Size of file, -1 if finding length is unsupported - int64_t size; - ObjectType::type kind; -}; - -/// DEPRECATED. Use the FileSystem API in arrow::fs instead. -class ARROW_EXPORT FileSystem { - public: - virtual ~FileSystem() = default; - - virtual Status MakeDirectory(const std::string& path) = 0; - - virtual Status DeleteDirectory(const std::string& path) = 0; - - virtual Status GetChildren(const std::string& path, - std::vector* listing) = 0; - - virtual Status Rename(const std::string& src, const std::string& dst) = 0; - - virtual Status Stat(const std::string& path, FileStatistics* stat) = 0; -}; - struct ReadRange { int64_t offset; int64_t length; @@ -111,10 +82,6 @@ class ARROW_EXPORT FileInterface { FileMode::type mode() const { return mode_; } - // Deprecated APIs - ARROW_DEPRECATED("Use Result-returning overload") - Status Tell(int64_t* position) const; - protected: FileInterface() : mode_(FileMode::READ) {} FileMode::type mode_; @@ -173,14 +140,6 @@ class ARROW_EXPORT Readable { /// In some cases (e.g. a memory-mapped file), this method may avoid a /// memory copy. virtual Result> Read(int64_t nbytes) = 0; - - // Deprecated APIs - - ARROW_DEPRECATED("Use Result-returning overload") - Status Read(int64_t nbytes, int64_t* bytes_read, void* out); - - ARROW_DEPRECATED("Use Result-returning overload") - Status Read(int64_t nbytes, std::shared_ptr* out); }; class ARROW_EXPORT OutputStream : virtual public FileInterface, public Writable { @@ -211,11 +170,6 @@ class ARROW_EXPORT InputStream : virtual public FileInterface, virtual public Re /// Zero copy reads imply the use of Buffer-returning Read() overloads. virtual bool supports_zero_copy() const; - // Deprecated APIs - - ARROW_DEPRECATED("Use Result-returning overload") - Status Peek(int64_t nbytes, util::string_view* out); - protected: InputStream() = default; }; @@ -274,17 +228,6 @@ class ARROW_EXPORT RandomAccessFile // EXPERIMENTAL virtual Future> ReadAsync(int64_t position, int64_t nbytes); - // Deprecated APIs - - ARROW_DEPRECATED("Use Result-returning overload") - Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read, void* out); - - ARROW_DEPRECATED("Use Result-returning overload") - Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr* out); - - ARROW_DEPRECATED("Use Result-returning overload") - Status GetSize(int64_t* size); - protected: RandomAccessFile(); diff --git a/cpp/src/arrow/io/memory.cc b/cpp/src/arrow/io/memory.cc index dee289b8b4cf..80898005e245 100644 --- a/cpp/src/arrow/io/memory.cc +++ b/cpp/src/arrow/io/memory.cc @@ -58,11 +58,6 @@ Result> BufferOutputStream::Create( return ptr; } -Status BufferOutputStream::Create(int64_t initial_capacity, MemoryPool* pool, - std::shared_ptr* out) { - return Create(initial_capacity, pool).Value(out); -} - Status BufferOutputStream::Reset(int64_t initial_capacity, MemoryPool* pool) { RETURN_NOT_OK(AllocateResizableBuffer(pool, initial_capacity, &buffer_)); is_open_ = true; @@ -97,10 +92,6 @@ Result> BufferOutputStream::Finish() { return std::move(buffer_); } -Status BufferOutputStream::Finish(std::shared_ptr* result) { - return Finish().Value(result); -} - Result BufferOutputStream::Tell() const { return position_; } Status BufferOutputStream::Write(const void* data, int64_t nbytes) { diff --git a/cpp/src/arrow/io/memory.h b/cpp/src/arrow/io/memory.h index e474c4b90d8e..f480aaf4182e 100644 --- a/cpp/src/arrow/io/memory.h +++ b/cpp/src/arrow/io/memory.h @@ -48,10 +48,6 @@ class ARROW_EXPORT BufferOutputStream : public OutputStream { static Result> Create( int64_t initial_capacity = 4096, MemoryPool* pool = default_memory_pool()); - ARROW_DEPRECATED("Use Result-returning overload") - static Status Create(int64_t initial_capacity, MemoryPool* pool, - std::shared_ptr* out); - ~BufferOutputStream() override; // Implement the OutputStream interface @@ -69,9 +65,6 @@ class ARROW_EXPORT BufferOutputStream : public OutputStream { /// Close the stream and return the buffer Result> Finish(); - ARROW_DEPRECATED("Use Result-returning overload") - Status Finish(std::shared_ptr* result); - /// \brief Initialize state of OutputStream with newly allocated memory and /// set position to 0 /// \param[in] initial_capacity the starting allocated capacity diff --git a/cpp/src/arrow/ipc/reader.h b/cpp/src/arrow/ipc/reader.h index 642c3ad02e07..dd2ebd45b15e 100644 --- a/cpp/src/arrow/ipc/reader.h +++ b/cpp/src/arrow/ipc/reader.h @@ -93,15 +93,15 @@ class ARROW_EXPORT RecordBatchStreamReader : public RecordBatchReader { const std::shared_ptr& stream, const IpcReadOptions& options = IpcReadOptions::Defaults()); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(std::unique_ptr message_reader, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(std::unique_ptr message_reader, std::unique_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(io::InputStream* stream, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(const std::shared_ptr& stream, std::shared_ptr* out); }; @@ -155,16 +155,16 @@ class ARROW_EXPORT RecordBatchFileReader { const std::shared_ptr& file, int64_t footer_offset, const IpcReadOptions& options = IpcReadOptions::Defaults()); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(const std::shared_ptr& file, int64_t footer_offset, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(const std::shared_ptr& file, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(io::RandomAccessFile* file, int64_t footer_offset, std::shared_ptr* out); - ARROW_DEPRECATED("Use Result-returning version") + ARROW_DEPRECATED("Deprecated in 0.17.0. Use Result-returning version") static Status Open(io::RandomAccessFile* file, std::shared_ptr* out); @@ -309,29 +309,29 @@ Status FuzzIpcFile(const uint8_t* data, int64_t size); } // namespace internal -ARROW_DEPRECATED("Use version with Result return value") +ARROW_DEPRECATED("Deprecated in 0.17.0. Use version with Result return value") ARROW_EXPORT Status ReadSchema(io::InputStream* stream, DictionaryMemo* dictionary_memo, std::shared_ptr* out); -ARROW_DEPRECATED("Use version with Result return value") +ARROW_DEPRECATED("Deprecated in 0.17.0. Use version with Result return value") ARROW_EXPORT Status ReadSchema(const Message& message, DictionaryMemo* dictionary_memo, std::shared_ptr* out); -ARROW_DEPRECATED("Use version with Result return value") +ARROW_DEPRECATED("Deprecated in 0.17.0. Use version with Result return value") ARROW_EXPORT Status ReadRecordBatch(const std::shared_ptr& schema, const DictionaryMemo* dictionary_memo, io::InputStream* stream, std::shared_ptr* out); -ARROW_DEPRECATED("Use version with Result return value") +ARROW_DEPRECATED("Deprecated in 0.17.0. Use version with Result return value") ARROW_EXPORT Status ReadRecordBatch(const Buffer& metadata, const std::shared_ptr& schema, const DictionaryMemo* dictionary_memo, io::RandomAccessFile* file, std::shared_ptr* out); -ARROW_DEPRECATED("Use version with Result return value") +ARROW_DEPRECATED("Deprecated in 0.17.0. Use version with Result return value") ARROW_EXPORT Status ReadRecordBatch(const Message& message, const std::shared_ptr& schema, const DictionaryMemo* dictionary_memo, diff --git a/cpp/src/arrow/sparse_tensor.h b/cpp/src/arrow/sparse_tensor.h index f01d5c98723c..de2bd89d5d62 100644 --- a/cpp/src/arrow/sparse_tensor.h +++ b/cpp/src/arrow/sparse_tensor.h @@ -558,37 +558,6 @@ class SparseTensorImpl : public SparseTensor { return Make(tensor, int64(), pool); } - /// \brief Create a sparse tensor from a dense tensor - /// - /// The dense tensor is re-encoded as a sparse index and a physical - /// data buffer for the non-zero value. - ARROW_DEPRECATED("Use Result-returning version") - static Status Make(const Tensor& tensor, - const std::shared_ptr& index_value_type, MemoryPool* pool, - std::shared_ptr>* out) { - auto result = Make(tensor, index_value_type, pool); - return std::move(result).Value(out); - } - - ARROW_DEPRECATED("Use Result-returning version") - static Status Make(const Tensor& tensor, - const std::shared_ptr& index_value_type, - std::shared_ptr>* out) { - return Make(tensor, index_value_type, default_memory_pool(), out); - } - - ARROW_DEPRECATED("Use Result-returning version") - static Status Make(const Tensor& tensor, MemoryPool* pool, - std::shared_ptr>* out) { - return Make(tensor, int64(), pool, out); - } - - ARROW_DEPRECATED("Use Result-returning version") - static Status Make(const Tensor& tensor, - std::shared_ptr>* out) { - return Make(tensor, default_memory_pool(), out); - } - private: ARROW_DISALLOW_COPY_AND_ASSIGN(SparseTensorImpl); }; diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc index 9bab4bb4ed29..7bb4428d7633 100644 --- a/cpp/src/arrow/type.cc +++ b/cpp/src/arrow/type.cc @@ -526,21 +526,6 @@ std::vector> StructType::GetAllFieldsByName( return result; } -// Deprecated methods - -std::shared_ptr Field::AddMetadata( - const std::shared_ptr& metadata) const { - return WithMetadata(metadata); -} - -std::shared_ptr StructType::GetChildByName(const std::string& name) const { - return GetFieldByName(name); -} - -int StructType::GetChildIndex(const std::string& name) const { - return GetFieldIndex(name); -} - // ---------------------------------------------------------------------- // Decimal128 type @@ -1179,12 +1164,6 @@ std::shared_ptr Schema::WithMetadata( return std::make_shared(impl_->fields_, metadata); } -// deprecated method -std::shared_ptr Schema::AddMetadata( - const std::shared_ptr& metadata) const { - return WithMetadata(metadata); -} - std::shared_ptr Schema::metadata() const { return impl_->metadata_; } diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index 763f2c75079c..3ef908ca0fae 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -366,10 +366,6 @@ class ARROW_EXPORT Field : public detail::Fingerprintable { std::shared_ptr WithMergedMetadata( const std::shared_ptr& metadata) const; - ARROW_DEPRECATED("Use WithMetadata") - std::shared_ptr AddMetadata( - const std::shared_ptr& metadata) const; - /// \brief Return a copy of this field without any metadata attached to it std::shared_ptr RemoveMetadata() const; @@ -942,12 +938,6 @@ class ARROW_EXPORT StructType : public NestedType { /// Return the indices of all fields having this name std::vector GetAllFieldIndices(const std::string& name) const; - ARROW_DEPRECATED("Use GetFieldByName") - std::shared_ptr GetChildByName(const std::string& name) const; - - ARROW_DEPRECATED("Use GetFieldIndex") - int GetChildIndex(const std::string& name) const; - private: std::string ComputeFingerprint() const override; @@ -1692,10 +1682,6 @@ class ARROW_EXPORT Schema : public detail::Fingerprintable, std::shared_ptr WithMetadata( const std::shared_ptr& metadata) const; - ARROW_DEPRECATED("Use WithMetadata") - std::shared_ptr AddMetadata( - const std::shared_ptr& metadata) const; - /// \brief Return copy of Schema without the KeyValueMetadata std::shared_ptr RemoveMetadata() const; diff --git a/cpp/src/arrow/util/compression.cc b/cpp/src/arrow/util/compression.cc index 8f0ac3fedb98..fff6a5ad604f 100644 --- a/cpp/src/arrow/util/compression.cc +++ b/cpp/src/arrow/util/compression.cc @@ -225,35 +225,5 @@ bool Codec::IsAvailable(Compression::type codec_type) { } } -// Deprecated APIs - -Status Codec::Create(Compression::type codec_type, std::unique_ptr* result) { - return Create(codec_type).Value(result); -} - -Status Codec::Create(Compression::type codec_type, int compression_level, - std::unique_ptr* result) { - return Create(codec_type, compression_level).Value(result); -} - -Status Codec::MakeCompressor(std::shared_ptr* out) { - return MakeCompressor().Value(out); -} - -Status Codec::MakeDecompressor(std::shared_ptr* out) { - return MakeDecompressor().Value(out); -} - -Status Codec::Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len, - uint8_t* output_buffer, int64_t* output_len) { - return Compress(input_len, input, output_buffer_len, output_buffer).Value(output_len); -} - -Status Codec::Decompress(int64_t input_len, const uint8_t* input, - int64_t output_buffer_len, uint8_t* output_buffer, - int64_t* output_len) { - return Decompress(input_len, input, output_buffer_len, output_buffer).Value(output_len); -} - } // namespace util } // namespace arrow diff --git a/cpp/src/arrow/util/compression.h b/cpp/src/arrow/util/compression.h index b6ffc7762d62..b367fb32186e 100644 --- a/cpp/src/arrow/util/compression.h +++ b/cpp/src/arrow/util/compression.h @@ -169,35 +169,6 @@ class ARROW_EXPORT Codec { virtual const char* name() const = 0; - // Deprecated APIs - - /// \brief Create a codec for the given compression algorithm - ARROW_DEPRECATED("Use Result-returning version") - static Status Create(Compression::type codec, std::unique_ptr* out); - - /// \brief Create a codec for the given compression algorithm and level - ARROW_DEPRECATED("Use Result-returning version") - static Status Create(Compression::type codec, int compression_level, - std::unique_ptr* out); - - /// \brief One-shot decompression function - ARROW_DEPRECATED("Use Result-returning version") - Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len, - uint8_t* output_buffer, int64_t* output_len); - - /// \brief One-shot compression function - ARROW_DEPRECATED("Use Result-returning version") - Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len, - uint8_t* output_buffer, int64_t* output_len); - - /// \brief Create a streaming compressor instance - ARROW_DEPRECATED("Use Result-returning version") - virtual Status MakeCompressor(std::shared_ptr* out); - - /// \brief Create a streaming decompressor instance - ARROW_DEPRECATED("Use Result-returning version") - virtual Status MakeDecompressor(std::shared_ptr* out); - private: /// \brief Initializes the codec's resources. virtual Status Init(); diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc index 6174fae49762..af016755a5e7 100644 --- a/cpp/src/arrow/util/decimal.cc +++ b/cpp/src/arrow/util/decimal.cc @@ -361,18 +361,6 @@ Result Decimal128::FromString(const char* s) { return FromString(util::string_view(s)); } -Status Decimal128::FromString(const util::string_view& s, Decimal128* out) { - return FromString(s, out, nullptr, nullptr); -} - -Status Decimal128::FromString(const std::string& s, Decimal128* out) { - return FromString(s, out, nullptr, nullptr); -} - -Status Decimal128::FromString(const char* s, Decimal128* out) { - return FromString(s, out, nullptr, nullptr); -} - // Helper function used by Decimal128::FromBigEndian static inline uint64_t UInt64FromBigEndian(const uint8_t* bytes, int32_t length) { // We don't bounds check the length here because this is called by diff --git a/cpp/src/arrow/util/decimal.h b/cpp/src/arrow/util/decimal.h index 64b724606a96..d4f56f7f69db 100644 --- a/cpp/src/arrow/util/decimal.h +++ b/cpp/src/arrow/util/decimal.h @@ -80,26 +80,6 @@ class ARROW_EXPORT Decimal128 : public BasicDecimal128 { return std::move(result); } - /// Divide this number by right and return the result. - /// - /// This operation is not destructive. - /// The answer rounds to zero. Signs work like: - /// 21 / 5 -> 4, 1 - /// -21 / 5 -> -4, -1 - /// 21 / -5 -> -4, 1 - /// -21 / -5 -> 4, -1 - /// \param[in] divisor the number to divide by - /// \param[out] result the quotient - /// \param[out] remainder the remainder after the division - ARROW_DEPRECATED("Use Result-returning version") - Status Divide(const Decimal128& divisor, Decimal128* result, - Decimal128* remainder) const { - std::pair out; - ARROW_ASSIGN_OR_RAISE(out, Divide(divisor)); - std::tie(*result, *remainder) = out; - return Status::OK(); - } - /// \brief Convert the Decimal128 value to a base 10 decimal string with the given /// scale. std::string ToString(int32_t scale) const; @@ -122,27 +102,11 @@ class ARROW_EXPORT Decimal128 : public BasicDecimal128 { static Result FromString(const std::string& s); static Result FromString(const char* s); - ARROW_DEPRECATED("Use Result-returning version") - static Status FromString(const util::string_view& s, Decimal128* out); - ARROW_DEPRECATED("Use Result-returning version") - static Status FromString(const std::string& s, Decimal128* out); - ARROW_DEPRECATED("Use Result-returning version") - static Status FromString(const char* s, Decimal128* out); - /// \brief Convert from a big-endian byte representation. The length must be /// between 1 and 16. /// \return error status if the length is an invalid value static Result FromBigEndian(const uint8_t* data, int32_t length); - /// \brief Convert from a big-endian byte representation. The length must be - /// between 1 and 16. - /// \return error status if the length is an invalid value - ARROW_DEPRECATED("Use Result-returning version") - static inline Status FromBigEndian(const uint8_t* data, int32_t length, - Decimal128* out) { - return FromBigEndian(data, length).Value(out); - } - /// \brief Convert Decimal128 from one scale to another Result Rescale(int32_t original_scale, int32_t new_scale) const { Decimal128 out; @@ -151,12 +115,6 @@ class ARROW_EXPORT Decimal128 : public BasicDecimal128 { return std::move(out); } - /// \brief Convert Decimal128 from one scale to another - ARROW_DEPRECATED("Use Result-returning version") - Status Rescale(int32_t original_scale, int32_t new_scale, Decimal128* out) const { - return Rescale(original_scale, new_scale).Value(out); - } - /// \brief Convert to a signed integer template > Result ToInteger() const { diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc index b341c620687c..abf1ebb31072 100644 --- a/cpp/src/parquet/arrow/reader.cc +++ b/cpp/src/parquet/arrow/reader.cc @@ -911,24 +911,6 @@ Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile> file, MemoryPool* return builder.memory_pool(pool)->Build(reader); } -Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile> file, MemoryPool* pool, - const ReaderProperties& props, std::shared_ptr metadata, - std::unique_ptr* reader) { - // Deprecated since 0.15.0 - FileReaderBuilder builder; - RETURN_NOT_OK(builder.Open(std::move(file), props, std::move(metadata))); - return builder.memory_pool(pool)->Build(reader); -} - -Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile> file, MemoryPool* pool, - const ArrowReaderProperties& properties, - std::unique_ptr* reader) { - // Deprecated since 0.15.0 - FileReaderBuilder builder; - RETURN_NOT_OK(builder.Open(std::move(file))); - return builder.memory_pool(pool)->properties(properties)->Build(reader); -} - namespace internal { Status FuzzReader(std::unique_ptr reader) { diff --git a/cpp/src/parquet/arrow/reader.h b/cpp/src/parquet/arrow/reader.h index 90d485e65aea..832054854a49 100644 --- a/cpp/src/parquet/arrow/reader.h +++ b/cpp/src/parquet/arrow/reader.h @@ -293,21 +293,6 @@ ::arrow::Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile>, ::arrow::MemoryPool* allocator, std::unique_ptr* reader); -ARROW_DEPRECATED("Deprecated since 0.15.0. Use FileReaderBuilder") -PARQUET_EXPORT -::arrow::Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile> file, - ::arrow::MemoryPool* allocator, - const ReaderProperties& properties, - std::shared_ptr metadata, - std::unique_ptr* reader); - -ARROW_DEPRECATED("Deprecated since 0.15.0. Use FileReaderBuilder") -PARQUET_EXPORT -::arrow::Status OpenFile(std::shared_ptr<::arrow::io::RandomAccessFile> file, - ::arrow::MemoryPool* allocator, - const ArrowReaderProperties& properties, - std::unique_ptr* reader); - /// @} PARQUET_EXPORT diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h index 3a9270bd6abb..ed08af9d8a86 100644 --- a/cpp/src/parquet/types.h +++ b/cpp/src/parquet/types.h @@ -693,10 +693,6 @@ PARQUET_EXPORT std::string TypeToString(Type::type t); PARQUET_EXPORT std::string FormatStatValue(Type::type parquet_type, const std::string& val); -/// \deprecated Since 1.5.0 -ARROW_DEPRECATED("Use std::string instead of char* as input") -PARQUET_EXPORT std::string FormatStatValue(Type::type parquet_type, const char* val); - PARQUET_EXPORT int GetTypeByteSize(Type::type t); PARQUET_EXPORT SortOrder::type DefaultSortOrder(Type::type primitive); From 05aba5f8d0c0c2fe786dd06e6ca4138d9de8a6bc Mon Sep 17 00:00:00 2001 From: Wes McKinney Date: Fri, 27 Mar 2020 16:16:25 -0500 Subject: [PATCH 2/2] Fix Parquet unit test broken by removal of deprecated function --- cpp/src/parquet/types.cc | 56 +++++++---------------------------- cpp/src/parquet/types.h | 3 +- cpp/src/parquet/types_test.cc | 18 ----------- 3 files changed, 12 insertions(+), 65 deletions(-) diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc index 014cec7eea6f..7e22da4c7c1b 100644 --- a/cpp/src/parquet/types.cc +++ b/cpp/src/parquet/types.cc @@ -66,72 +66,36 @@ std::unique_ptr GetCodec(Compression::type codec, int compression_level) return result; } -std::string FormatStatValue(Type::type parquet_type, const std::string& val) { +std::string FormatStatValue(Type::type parquet_type, ::arrow::util::string_view val) { std::stringstream result; - switch (parquet_type) { - case Type::BOOLEAN: - result << reinterpret_cast(val.c_str())[0]; - break; - case Type::INT32: - result << reinterpret_cast(val.c_str())[0]; - break; - case Type::INT64: - result << reinterpret_cast(val.c_str())[0]; - break; - case Type::DOUBLE: - result << reinterpret_cast(val.c_str())[0]; - break; - case Type::FLOAT: - result << reinterpret_cast(val.c_str())[0]; - break; - case Type::INT96: { - auto const i32_val = reinterpret_cast(val.c_str()); - result << i32_val[0] << " " << i32_val[1] << " " << i32_val[2]; - break; - } - case Type::BYTE_ARRAY: { - return val; - } - case Type::FIXED_LEN_BYTE_ARRAY: { - return val; - } - case Type::UNDEFINED: - default: - break; - } - return result.str(); -} -std::string FormatStatValue(Type::type parquet_type, const char* val) { - std::stringstream result; + const char* bytes = val.data(); switch (parquet_type) { case Type::BOOLEAN: - result << reinterpret_cast(val)[0]; + result << reinterpret_cast(bytes)[0]; break; case Type::INT32: - result << reinterpret_cast(val)[0]; + result << reinterpret_cast(bytes)[0]; break; case Type::INT64: - result << reinterpret_cast(val)[0]; + result << reinterpret_cast(bytes)[0]; break; case Type::DOUBLE: - result << reinterpret_cast(val)[0]; + result << reinterpret_cast(bytes)[0]; break; case Type::FLOAT: - result << reinterpret_cast(val)[0]; + result << reinterpret_cast(bytes)[0]; break; case Type::INT96: { - auto const i32_val = reinterpret_cast(val); + auto const i32_val = reinterpret_cast(bytes); result << i32_val[0] << " " << i32_val[1] << " " << i32_val[2]; break; } case Type::BYTE_ARRAY: { - result << val; - break; + return std::string(val); } case Type::FIXED_LEN_BYTE_ARRAY: { - result << val; - break; + return std::string(val); } case Type::UNDEFINED: default: diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h index ed08af9d8a86..a1586b6af7cd 100644 --- a/cpp/src/parquet/types.h +++ b/cpp/src/parquet/types.h @@ -25,6 +25,7 @@ #include #include "arrow/util/int_util.h" +#include "arrow/util/string_view.h" #include "parquet/platform.h" @@ -691,7 +692,7 @@ PARQUET_EXPORT std::string ConvertedTypeToString(ConvertedType::type t); PARQUET_EXPORT std::string TypeToString(Type::type t); PARQUET_EXPORT std::string FormatStatValue(Type::type parquet_type, - const std::string& val); + ::arrow::util::string_view val); PARQUET_EXPORT int GetTypeByteSize(Type::type t); diff --git a/cpp/src/parquet/types_test.cc b/cpp/src/parquet/types_test.cc index 6bfb080c559f..ccec95f98c4c 100644 --- a/cpp/src/parquet/types_test.cc +++ b/cpp/src/parquet/types_test.cc @@ -79,67 +79,49 @@ TEST(TypePrinter, StatisticsTypes) { smin = std::string(reinterpret_cast(&int_min), sizeof(int32_t)); smax = std::string(reinterpret_cast(&int_max), sizeof(int32_t)); ASSERT_STREQ("1024", FormatStatValue(Type::INT32, smin).c_str()); - ASSERT_STREQ("1024", FormatStatValue(Type::INT32, smin.c_str()).c_str()); ASSERT_STREQ("2048", FormatStatValue(Type::INT32, smax).c_str()); - ASSERT_STREQ("2048", FormatStatValue(Type::INT32, smax.c_str()).c_str()); int64_t int64_min = 10240000000000; int64_t int64_max = 20480000000000; smin = std::string(reinterpret_cast(&int64_min), sizeof(int64_t)); smax = std::string(reinterpret_cast(&int64_max), sizeof(int64_t)); ASSERT_STREQ("10240000000000", FormatStatValue(Type::INT64, smin).c_str()); - ASSERT_STREQ("10240000000000", FormatStatValue(Type::INT64, smin.c_str()).c_str()); ASSERT_STREQ("20480000000000", FormatStatValue(Type::INT64, smax).c_str()); - ASSERT_STREQ("20480000000000", FormatStatValue(Type::INT64, smax.c_str()).c_str()); float float_min = 1.024f; float float_max = 2.048f; smin = std::string(reinterpret_cast(&float_min), sizeof(float)); smax = std::string(reinterpret_cast(&float_max), sizeof(float)); ASSERT_STREQ("1.024", FormatStatValue(Type::FLOAT, smin).c_str()); - ASSERT_STREQ("1.024", FormatStatValue(Type::FLOAT, smin.c_str()).c_str()); ASSERT_STREQ("2.048", FormatStatValue(Type::FLOAT, smax).c_str()); - ASSERT_STREQ("2.048", FormatStatValue(Type::FLOAT, smax.c_str()).c_str()); double double_min = 1.0245; double double_max = 2.0489; smin = std::string(reinterpret_cast(&double_min), sizeof(double)); smax = std::string(reinterpret_cast(&double_max), sizeof(double)); ASSERT_STREQ("1.0245", FormatStatValue(Type::DOUBLE, smin).c_str()); - ASSERT_STREQ("1.0245", FormatStatValue(Type::DOUBLE, smin.c_str()).c_str()); ASSERT_STREQ("2.0489", FormatStatValue(Type::DOUBLE, smax).c_str()); - ASSERT_STREQ("2.0489", FormatStatValue(Type::DOUBLE, smax.c_str()).c_str()); Int96 Int96_min = {{1024, 2048, 4096}}; Int96 Int96_max = {{2048, 4096, 8192}}; smin = std::string(reinterpret_cast(&Int96_min), sizeof(Int96)); smax = std::string(reinterpret_cast(&Int96_max), sizeof(Int96)); ASSERT_STREQ("1024 2048 4096", FormatStatValue(Type::INT96, smin).c_str()); - ASSERT_STREQ("1024 2048 4096", FormatStatValue(Type::INT96, smin.c_str()).c_str()); ASSERT_STREQ("2048 4096 8192", FormatStatValue(Type::INT96, smax).c_str()); - ASSERT_STREQ("2048 4096 8192", FormatStatValue(Type::INT96, smax.c_str()).c_str()); smin = std::string("abcdef"); smax = std::string("ijklmnop"); ASSERT_STREQ("abcdef", FormatStatValue(Type::BYTE_ARRAY, smin).c_str()); - ASSERT_STREQ("abcdef", FormatStatValue(Type::BYTE_ARRAY, smin.c_str()).c_str()); ASSERT_STREQ("ijklmnop", FormatStatValue(Type::BYTE_ARRAY, smax).c_str()); - ASSERT_STREQ("ijklmnop", FormatStatValue(Type::BYTE_ARRAY, smax.c_str()).c_str()); // PARQUET-1357: FormatStatValue truncates binary statistics on zero character smax.push_back('\0'); ASSERT_EQ(smax, FormatStatValue(Type::BYTE_ARRAY, smax)); - // This fails, thus the call to FormatStatValue(.., const char*) was deprecated. - // ASSERT_EQ(smax, FormatStatValue(Type::BYTE_ARRAY, smax.c_str())); smin = std::string("abcdefgh"); smax = std::string("ijklmnop"); ASSERT_STREQ("abcdefgh", FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smin).c_str()); - ASSERT_STREQ("abcdefgh", - FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smin.c_str()).c_str()); ASSERT_STREQ("ijklmnop", FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smax).c_str()); - ASSERT_STREQ("ijklmnop", - FormatStatValue(Type::FIXED_LEN_BYTE_ARRAY, smax.c_str()).c_str()); } TEST(TestInt96Timestamp, Decoding) {