io/types.hpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019-2024, NVIDIA CORPORATION.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
22 #pragma once
23 
24 #include <cudf/table/table.hpp>
25 #include <cudf/types.hpp>
26 #include <cudf/utilities/span.hpp>
27 
28 #include <map>
29 #include <memory>
30 #include <optional>
31 #include <string>
32 #include <unordered_map>
33 #include <utility>
34 #include <vector>
35 
36 namespace CUDF_EXPORT cudf {
38 namespace io {
39 class data_sink;
40 class datasource;
41 } // namespace io
42 } // namespace CUDF_EXPORT cudf
43 
45 namespace CUDF_EXPORT cudf {
47 namespace io {
57 enum class compression_type : int32_t {
58  NONE,
59  AUTO,
60  SNAPPY,
61  GZIP,
62  BZIP2,
63  BROTLI,
64  ZIP,
65  XZ,
66  ZLIB,
67  LZ4,
68  LZO,
69  ZSTD
70 };
71 
75 enum class io_type : int32_t {
76  FILEPATH,
77  HOST_BUFFER,
79  VOID,
81 };
82 
86 enum class quote_style : int32_t {
87  MINIMAL,
88  ALL,
89  NONNUMERIC,
90  NONE
91 };
92 
96 enum statistics_freq : int32_t {
101 };
102 
106 enum class column_encoding : int32_t {
107  // Common encodings:
108  USE_DEFAULT = -1,
109  DICTIONARY,
110  // Parquet encodings:
111  PLAIN,
118  // ORC encodings:
119  DIRECT,
120  DIRECT_V2,
121  DICTIONARY_V2,
122 };
123 
128  public:
133 
142  writer_compression_statistics(size_t num_compressed_bytes,
143  size_t num_failed_bytes,
144  size_t num_skipped_bytes,
145  size_t num_compressed_output_bytes)
146  : _num_compressed_bytes(num_compressed_bytes),
147  _num_failed_bytes(num_failed_bytes),
148  _num_skipped_bytes(num_skipped_bytes),
149  _num_compressed_output_bytes(num_compressed_output_bytes)
150  {
151  }
152 
160  {
161  _num_compressed_bytes += other._num_compressed_bytes;
162  _num_failed_bytes += other._num_failed_bytes;
163  _num_skipped_bytes += other._num_skipped_bytes;
164  _num_compressed_output_bytes += other._num_compressed_output_bytes;
165  return *this;
166  }
167 
176  [[nodiscard]] auto num_compressed_bytes() const noexcept { return _num_compressed_bytes; }
177 
183  [[nodiscard]] auto num_failed_bytes() const noexcept { return _num_failed_bytes; }
184 
190  [[nodiscard]] auto num_skipped_bytes() const noexcept { return _num_skipped_bytes; }
191 
197  [[nodiscard]] auto num_total_input_bytes() const noexcept
198  {
199  return num_compressed_bytes() + num_failed_bytes() + num_skipped_bytes();
200  }
201 
210  [[nodiscard]] auto compression_ratio() const noexcept
211  {
212  return static_cast<double>(num_compressed_bytes()) / _num_compressed_output_bytes;
213  }
214 
215  private:
216  std::size_t _num_compressed_bytes = 0;
217  std::size_t _num_failed_bytes = 0;
218  std::size_t _num_skipped_bytes = 0;
219  std::size_t _num_compressed_output_bytes = 0;
220 };
221 
225 enum dictionary_policy : int32_t {
226  NEVER = 0,
227  ADAPTIVE = 1,
228  ALWAYS = 2
229 };
230 
238  std::string name;
239  std::optional<bool> is_nullable;
240  std::optional<bool> is_binary;
241  std::optional<int32_t> type_length;
242  std::vector<column_name_info> children;
243 
251  column_name_info(std::string _name,
252  std::optional<bool> _is_nullable = std::nullopt,
253  std::optional<bool> _is_binary = std::nullopt)
254  : name(std::move(_name)), is_nullable(_is_nullable), is_binary(_is_binary)
255  {
256  }
257 
258  column_name_info() = default;
259 
266  bool operator==(column_name_info const& rhs) const
267  {
268  return ((name == rhs.name) && (is_nullable == rhs.is_nullable) &&
269  (is_binary == rhs.is_binary) && (type_length == rhs.type_length) &&
270  (children == rhs.children));
271  };
272 };
273 
278  std::vector<column_name_info>
280  std::vector<size_t> num_rows_per_source;
283  std::map<std::string, std::string> user_data;
285  std::vector<std::unordered_map<std::string, std::string>>
287 };
288 
293  std::unique_ptr<table> tbl;
295 };
296 
304 struct host_buffer {
305  // TODO: to be replaced by `host_span`
306  char const* data = nullptr;
307  size_t size = 0;
308  host_buffer() = default;
315  host_buffer(char const* data, size_t size) : data(data), size(size) {}
316 };
317 
325 template <typename T>
326 constexpr inline auto is_byte_like_type()
327 {
328  using non_cv_T = std::remove_cv_t<T>;
329  return std::is_same_v<non_cv_T, int8_t> || std::is_same_v<non_cv_T, char> ||
330  std::is_same_v<non_cv_T, uint8_t> || std::is_same_v<non_cv_T, unsigned char> ||
331  std::is_same_v<non_cv_T, std::byte>;
332 }
333 
337 struct source_info {
338  source_info() = default;
339 
345  explicit source_info(std::vector<std::string> const& file_paths)
346  : _type(io_type::FILEPATH), _filepaths(file_paths)
347  {
348  }
349 
355  explicit source_info(std::string const& file_path)
356  : _type(io_type::FILEPATH), _filepaths({file_path})
357  {
358  }
359 
367  explicit source_info(std::vector<host_buffer> const& host_buffers) : _type(io_type::HOST_BUFFER)
368  {
369  _host_buffers.reserve(host_buffers.size());
370  std::transform(host_buffers.begin(),
371  host_buffers.end(),
372  std::back_inserter(_host_buffers),
373  [](auto const hb) {
374  return cudf::host_span<std::byte const>{
375  reinterpret_cast<std::byte const*>(hb.data), hb.size};
376  });
377  }
378 
387  explicit source_info(char const* host_data, size_t size)
388  : _type(io_type::HOST_BUFFER),
389  _host_buffers(
390  {cudf::host_span<std::byte const>(reinterpret_cast<std::byte const*>(host_data), size)})
391  {
392  }
393 
399  template <typename T, CUDF_ENABLE_IF(is_byte_like_type<std::remove_cv_t<T>>())>
400  explicit source_info(cudf::host_span<cudf::host_span<T>> const host_buffers)
401  : _type(io_type::HOST_BUFFER)
402  {
403  if constexpr (not std::is_same_v<std::remove_cv_t<T>, std::byte>) {
404  _host_buffers.reserve(host_buffers.size());
405  std::transform(host_buffers.begin(),
406  host_buffers.end(),
407  std::back_inserter(_host_buffers),
408  [](auto const s) {
409  return cudf::host_span<std::byte const>{
410  reinterpret_cast<std::byte const*>(s.data()), s.size()};
411  });
412  } else {
413  _host_buffers.assign(host_buffers.begin(), host_buffers.end());
414  }
415  }
416 
422  template <typename T, CUDF_ENABLE_IF(is_byte_like_type<std::remove_cv_t<T>>())>
423  explicit source_info(cudf::host_span<T> host_data)
424  : _type(io_type::HOST_BUFFER),
425  _host_buffers{cudf::host_span<std::byte const>(
426  reinterpret_cast<std::byte const*>(host_data.data()), host_data.size())}
427  {
428  }
429 
436  : _type(io_type::DEVICE_BUFFER), _device_buffers(device_buffers.begin(), device_buffers.end())
437  {
438  }
439 
446  : _type(io_type::DEVICE_BUFFER), _device_buffers({{d_buffer}})
447  {
448  }
449 
455  explicit source_info(std::vector<cudf::io::datasource*> const& sources)
456  : _type(io_type::USER_IMPLEMENTED), _user_sources(sources)
457  {
458  }
459 
466  : _type(io_type::USER_IMPLEMENTED), _user_sources({source})
467  {
468  }
469 
475  [[nodiscard]] auto type() const { return _type; }
481  [[nodiscard]] auto const& filepaths() const { return _filepaths; }
487  [[nodiscard]] auto const& host_buffers() const { return _host_buffers; }
493  [[nodiscard]] auto const& device_buffers() const { return _device_buffers; }
499  [[nodiscard]] auto const& user_sources() const { return _user_sources; }
500 
501  private:
502  io_type _type = io_type::VOID;
503  std::vector<std::string> _filepaths;
504  std::vector<cudf::host_span<std::byte const>> _host_buffers;
505  std::vector<cudf::device_span<std::byte const>> _device_buffers;
506  std::vector<cudf::io::datasource*> _user_sources;
507 };
508 
512 struct sink_info {
513  sink_info() = default;
519  sink_info(size_t num_sinks) : _num_sinks(num_sinks) {}
520 
526  explicit sink_info(std::vector<std::string> const& file_paths)
527  : _type(io_type::FILEPATH), _num_sinks(file_paths.size()), _filepaths(file_paths)
528  {
529  }
530 
536  explicit sink_info(std::string const& file_path)
537  : _type(io_type::FILEPATH), _filepaths({file_path})
538  {
539  }
540 
546  explicit sink_info(std::vector<std::vector<char>*> const& buffers)
547  : _type(io_type::HOST_BUFFER), _num_sinks(buffers.size()), _buffers(buffers)
548  {
549  }
555  explicit sink_info(std::vector<char>* buffer) : _type(io_type::HOST_BUFFER), _buffers({buffer}) {}
556 
562  explicit sink_info(std::vector<cudf::io::data_sink*> const& user_sinks)
563  : _type(io_type::USER_IMPLEMENTED), _num_sinks(user_sinks.size()), _user_sinks(user_sinks)
564  {
565  }
566 
572  explicit sink_info(class cudf::io::data_sink* user_sink)
573  : _type(io_type::USER_IMPLEMENTED), _user_sinks({user_sink})
574  {
575  }
576 
582  [[nodiscard]] auto type() const { return _type; }
588  [[nodiscard]] auto num_sinks() const { return _num_sinks; }
594  [[nodiscard]] auto const& filepaths() const { return _filepaths; }
600  [[nodiscard]] auto const& buffers() const { return _buffers; }
606  [[nodiscard]] auto const& user_sinks() const { return _user_sinks; }
607 
608  private:
609  io_type _type = io_type::VOID;
610  size_t _num_sinks = 1;
611  std::vector<std::string> _filepaths;
612  std::vector<std::vector<char>*> _buffers;
613  std::vector<cudf::io::data_sink*> _user_sinks;
614 };
615 
616 class table_input_metadata;
617 
622  friend table_input_metadata;
623  std::string _name = "";
624  std::optional<bool> _nullable;
625  bool _list_column_is_map = false;
626  bool _use_int96_timestamp = false;
627  bool _output_as_binary = false;
628  bool _skip_compression = false;
629  std::optional<uint8_t> _decimal_precision;
630  std::optional<int32_t> _parquet_field_id;
631  std::optional<int32_t> _type_length;
632  std::vector<column_in_metadata> children;
633  column_encoding _encoding = column_encoding::USE_DEFAULT;
634 
635  public:
636  column_in_metadata() = default;
642  column_in_metadata(std::string_view name) : _name{name} {}
650  {
651  children.push_back(child);
652  return *this;
653  }
654 
661  column_in_metadata& set_name(std::string const& name) noexcept
662  {
663  _name = name;
664  return *this;
665  }
666 
674  {
675  _nullable = nullable;
676  return *this;
677  }
678 
687  {
688  _list_column_is_map = true;
689  return *this;
690  }
691 
701  {
702  _use_int96_timestamp = req;
703  return *this;
704  }
705 
713  column_in_metadata& set_decimal_precision(uint8_t precision) noexcept
714  {
715  _decimal_precision = precision;
716  return *this;
717  }
718 
726  column_in_metadata& set_type_length(int32_t length) noexcept
727  {
728  _type_length = length;
729  return *this;
730  }
731 
738  column_in_metadata& set_parquet_field_id(int32_t field_id) noexcept
739  {
740  _parquet_field_id = field_id;
741  return *this;
742  }
743 
753  {
754  _output_as_binary = binary;
755  if (_output_as_binary and children.size() == 1) {
756  children.emplace_back();
757  } else if (!_output_as_binary and children.size() == 2) {
758  children.pop_back();
759  }
760  return *this;
761  }
762 
771  {
772  _skip_compression = skip;
773  return *this;
774  }
775 
787  {
788  _encoding = encoding;
789  return *this;
790  }
791 
798  column_in_metadata& child(size_type i) noexcept { return children[i]; }
799 
806  [[nodiscard]] column_in_metadata const& child(size_type i) const noexcept { return children[i]; }
807 
813  [[nodiscard]] std::string get_name() const noexcept { return _name; }
814 
820  [[nodiscard]] bool is_nullability_defined() const noexcept { return _nullable.has_value(); }
821 
829  [[nodiscard]] bool nullable() const { return _nullable.value(); }
830 
836  [[nodiscard]] bool is_map() const noexcept { return _list_column_is_map; }
837 
844  [[nodiscard]] bool is_enabled_int96_timestamps() const noexcept { return _use_int96_timestamp; }
845 
851  [[nodiscard]] bool is_decimal_precision_set() const noexcept
852  {
853  return _decimal_precision.has_value();
854  }
855 
863  [[nodiscard]] uint8_t get_decimal_precision() const { return _decimal_precision.value(); }
864 
870  [[nodiscard]] bool is_type_length_set() const noexcept { return _type_length.has_value(); }
871 
879  [[nodiscard]] uint8_t get_type_length() const { return _type_length.value(); }
880 
886  [[nodiscard]] bool is_parquet_field_id_set() const noexcept
887  {
888  return _parquet_field_id.has_value();
889  }
890 
898  [[nodiscard]] int32_t get_parquet_field_id() const { return _parquet_field_id.value(); }
899 
905  [[nodiscard]] size_type num_children() const noexcept { return children.size(); }
906 
912  [[nodiscard]] bool is_enabled_output_as_binary() const noexcept { return _output_as_binary; }
913 
919  [[nodiscard]] bool is_enabled_skip_compression() const noexcept { return _skip_compression; }
920 
926  [[nodiscard]] column_encoding get_encoding() const { return _encoding; }
927 };
928 
933  public:
934  table_input_metadata() = default; // Required by cython
935 
944 
953  explicit table_input_metadata(table_metadata const& metadata);
954 
955  std::vector<column_in_metadata> column_metadata;
956 };
957 
967 
968  partition_info() = default;
975  partition_info(size_type start_row, size_type num_rows) : start_row(start_row), num_rows(num_rows)
976  {
977  }
978 };
979 
985  // Whether to read binary data as a string column
986  bool _convert_binary_to_strings{true};
987  int32_t _type_length{0};
988 
989  std::vector<reader_column_schema> children;
990 
991  public:
992  reader_column_schema() = default;
993 
999  reader_column_schema(size_type number_of_children) { children.resize(number_of_children); }
1000 
1007  {
1008  children.assign(child_span.begin(), child_span.end());
1009  }
1010 
1018  {
1019  children.push_back(child);
1020  return *this;
1021  }
1022 
1029  [[nodiscard]] reader_column_schema& child(size_type i) { return children[i]; }
1030 
1037  [[nodiscard]] reader_column_schema const& child(size_type i) const { return children[i]; }
1038 
1048  {
1049  _convert_binary_to_strings = convert_to_string;
1050  return *this;
1051  }
1052 
1060  {
1061  _type_length = type_length;
1062  return *this;
1063  }
1064 
1070  [[nodiscard]] bool is_enabled_convert_binary_to_strings() const
1071  {
1072  return _convert_binary_to_strings;
1073  }
1074 
1080  [[nodiscard]] int32_t get_type_length() const { return _type_length; }
1081 
1087  [[nodiscard]] size_t get_num_children() const { return children.size(); }
1088 };
1089  // end of group
1091 } // namespace io
1092 } // namespace CUDF_EXPORT cudf
constexpr iterator end() const noexcept
Returns an iterator to the element following the last element of the span.
Definition: span.hpp:134
constexpr iterator begin() const noexcept
Returns an iterator to the first element of the span.
Definition: span.hpp:126
Metadata for a column.
Definition: io/types.hpp:621
column_in_metadata & set_name(std::string const &name) noexcept
Set the name of this column.
Definition: io/types.hpp:661
column_in_metadata & add_child(column_in_metadata const &child)
Add the children metadata of this column.
Definition: io/types.hpp:649
bool is_enabled_output_as_binary() const noexcept
Get whether to encode this column as binary or string data.
Definition: io/types.hpp:912
column_in_metadata & set_parquet_field_id(int32_t field_id) noexcept
Set the parquet field id of this column.
Definition: io/types.hpp:738
column_in_metadata & set_int96_timestamps(bool req) noexcept
Specifies whether this timestamp column should be encoded using the deprecated int96 physical type....
Definition: io/types.hpp:700
column_in_metadata & set_decimal_precision(uint8_t precision) noexcept
Set the decimal precision of this column. Only valid if this column is a decimal (fixed-point) type.
Definition: io/types.hpp:713
bool is_enabled_int96_timestamps() const noexcept
Get whether to encode this timestamp column using deprecated int96 physical type.
Definition: io/types.hpp:844
bool is_parquet_field_id_set() const noexcept
Get whether parquet field id has been set for this column.
Definition: io/types.hpp:886
bool is_decimal_precision_set() const noexcept
Get whether precision has been set for this decimal column.
Definition: io/types.hpp:851
bool is_type_length_set() const noexcept
Get whether type length has been set for this column.
Definition: io/types.hpp:870
bool nullable() const
Gets the explicitly set nullability for this column.
Definition: io/types.hpp:829
size_type num_children() const noexcept
Get the number of children of this column.
Definition: io/types.hpp:905
bool is_map() const noexcept
If this is the metadata of a list column, returns whether it is to be encoded as a map.
Definition: io/types.hpp:836
uint8_t get_decimal_precision() const
Get the decimal precision that was set for this column.
Definition: io/types.hpp:863
column_in_metadata & set_encoding(column_encoding encoding) noexcept
Sets the encoding to use for this column.
Definition: io/types.hpp:786
column_encoding get_encoding() const
Get the encoding that was set for this column.
Definition: io/types.hpp:926
uint8_t get_type_length() const
Get the type length that was set for this column.
Definition: io/types.hpp:879
column_in_metadata & set_output_as_binary(bool binary) noexcept
Specifies whether this column should be written as binary or string data Only valid for the following...
Definition: io/types.hpp:752
column_in_metadata & child(size_type i) noexcept
Get reference to a child of this column.
Definition: io/types.hpp:798
column_in_metadata & set_type_length(int32_t length) noexcept
Set the data length of the column. Only valid if this column is a fixed-length byte array.
Definition: io/types.hpp:726
bool is_enabled_skip_compression() const noexcept
Get whether to skip compressing this column.
Definition: io/types.hpp:919
int32_t get_parquet_field_id() const
Get the parquet field id that was set for this column.
Definition: io/types.hpp:898
std::string get_name() const noexcept
Get the name of this column.
Definition: io/types.hpp:813
column_in_metadata & set_list_column_as_map() noexcept
Specify that this list column should be encoded as a map in the written file.
Definition: io/types.hpp:686
column_in_metadata(std::string_view name)
Construct a new column in metadata object.
Definition: io/types.hpp:642
column_in_metadata & set_nullability(bool nullable) noexcept
Set the nullability of this column.
Definition: io/types.hpp:673
bool is_nullability_defined() const noexcept
Get whether nullability has been explicitly set for this column.
Definition: io/types.hpp:820
column_in_metadata const & child(size_type i) const noexcept
Get const reference to a child of this column.
Definition: io/types.hpp:806
column_in_metadata & set_skip_compression(bool skip) noexcept
Specifies whether this column should not be compressed regardless of the compression codec specified ...
Definition: io/types.hpp:770
Interface class for storing the output data from the writers.
Definition: data_sink.hpp:43
Interface class for providing input data to the readers.
Definition: datasource.hpp:42
schema element for reader
Definition: io/types.hpp:984
reader_column_schema const & child(size_type i) const
Get const reference to a child of this column.
Definition: io/types.hpp:1037
reader_column_schema & set_type_length(int32_t type_length)
Sets the length of fixed length data.
Definition: io/types.hpp:1059
bool is_enabled_convert_binary_to_strings() const
Get whether to encode this column as binary or string data.
Definition: io/types.hpp:1070
int32_t get_type_length() const
Get the length in bytes of this fixed length data.
Definition: io/types.hpp:1080
reader_column_schema(host_span< reader_column_schema > const &child_span)
Construct a new reader column schema object with a span defining the children.
Definition: io/types.hpp:1006
reader_column_schema & set_convert_binary_to_strings(bool convert_to_string)
Specifies whether this column should be written as binary or string data Only valid for the following...
Definition: io/types.hpp:1047
size_t get_num_children() const
Get the number of child objects.
Definition: io/types.hpp:1087
reader_column_schema & add_child(reader_column_schema const &child)
Add the children metadata of this column.
Definition: io/types.hpp:1017
reader_column_schema & child(size_type i)
Get reference to a child of this column.
Definition: io/types.hpp:1029
reader_column_schema(size_type number_of_children)
Construct a new reader column schema object.
Definition: io/types.hpp:999
Metadata for a table.
Definition: io/types.hpp:932
table_input_metadata(table_view const &table)
Construct a new table_input_metadata from a table_view.
table_input_metadata(table_metadata const &metadata)
Construct a new table_input_metadata from a table_metadata object.
std::vector< column_in_metadata > column_metadata
List of column metadata.
Definition: io/types.hpp:955
Statistics about compression performed by a writer.
Definition: io/types.hpp:127
auto compression_ratio() const noexcept
Returns the compression ratio for the successfully compressed blocks.
Definition: io/types.hpp:210
auto num_total_input_bytes() const noexcept
Returns the total size of compression inputs.
Definition: io/types.hpp:197
writer_compression_statistics & operator+=(writer_compression_statistics const &other) noexcept
Adds the values from another writer_compression_statistics object.
Definition: io/types.hpp:159
auto num_failed_bytes() const noexcept
Returns the number of bytes in blocks that failed to compress.
Definition: io/types.hpp:183
writer_compression_statistics()=default
Default constructor.
auto num_skipped_bytes() const noexcept
Returns the number of bytes in blocks that were skipped during compression.
Definition: io/types.hpp:190
writer_compression_statistics(size_t num_compressed_bytes, size_t num_failed_bytes, size_t num_skipped_bytes, size_t num_compressed_output_bytes)
Constructor with initial values.
Definition: io/types.hpp:142
auto num_compressed_bytes() const noexcept
Returns the number of bytes in blocks that were successfully compressed.
Definition: io/types.hpp:176
A set of cudf::column_view's of the same size.
Definition: table_view.hpp:200
A set of cudf::column's of the same size.
Definition: table.hpp:40
statistics_freq
Column statistics granularity type for parquet/orc writers.
Definition: io/types.hpp:96
column_encoding
Valid encodings for use with column_in_metadata::set_encoding()
Definition: io/types.hpp:106
quote_style
Behavior when handling quotations in field data.
Definition: io/types.hpp:86
constexpr auto is_byte_like_type()
Returns true if the type is byte-like, meaning it is reasonable to pass as a pointer to bytes.
Definition: io/types.hpp:326
dictionary_policy
Control use of dictionary encoding for parquet writer.
Definition: io/types.hpp:225
compression_type
Compression algorithms.
Definition: io/types.hpp:57
io_type
Data source or destination types.
Definition: io/types.hpp:75
@ STATISTICS_COLUMN
Full column and offset indices. Implies STATISTICS_ROWGROUP.
Definition: io/types.hpp:100
@ STATISTICS_ROWGROUP
Per-Rowgroup column statistics.
Definition: io/types.hpp:98
@ STATISTICS_NONE
No column statistics.
Definition: io/types.hpp:97
@ STATISTICS_PAGE
Per-page column statistics.
Definition: io/types.hpp:99
@ DELTA_BINARY_PACKED
Use DELTA_BINARY_PACKED encoding (only valid for integer columns)
@ USE_DEFAULT
No encoding has been requested, use default encoding.
@ PLAIN
Use plain encoding.
@ BYTE_STREAM_SPLIT
Use BYTE_STREAM_SPLIT encoding (valid for all fixed width types)
@ MINIMAL
Quote only fields which contain special characters.
@ ALL
Quote all fields.
@ NONNUMERIC
Quote all non-numeric fields.
@ ALWAYS
Use dictionary regardless of impact on compression.
Definition: io/types.hpp:228
@ ADAPTIVE
Use dictionary when it will not impact compression.
Definition: io/types.hpp:227
@ NEVER
Never use dictionary encoding.
Definition: io/types.hpp:226
@ BROTLI
BROTLI format, using LZ77 + Huffman + 2nd order context modeling.
@ XZ
XZ format, using LZMA(2) algorithm.
@ ZIP
ZIP format, using DEFLATE algorithm.
@ BZIP2
BZIP2 format, using Burrows-Wheeler transform.
@ AUTO
Automatically detect or select compression format.
@ HOST_BUFFER
Input/output is a buffer in host memory.
@ USER_IMPLEMENTED
Input/output is handled by a custom user class.
@ VOID
Input/output is nothing. No work is done. Useful for benchmarking.
@ FILEPATH
Input/output is a file path.
@ DEVICE_BUFFER
Input/output is a buffer in device memory.
std::unique_ptr< column > transform(column_view const &input, std::string const &unary_udf, data_type output_type, bool is_ptx, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::device_async_resource_ref mr=cudf::get_current_device_resource_ref())
Creates a new column by applying a unary function against every element of an input column.
int32_t size_type
Row index type for columns and tables.
Definition: types.hpp:95
cuDF interfaces
Definition: aggregation.hpp:35
bool nullable(table_view const &view)
Returns True if any of the columns in the table is nullable. (not entire hierarchy)
APIs for spans.
Device version of C++20 std::span with reduced feature set.
Definition: span.hpp:338
C++20 std::span with reduced feature set.
Definition: span.hpp:219
Detailed name (and optionally nullability) information for output columns.
Definition: io/types.hpp:237
std::optional< bool > is_nullable
Column nullability.
Definition: io/types.hpp:239
std::optional< bool > is_binary
Column is binary (i.e. not a list)
Definition: io/types.hpp:240
std::vector< column_name_info > children
Child column names.
Definition: io/types.hpp:242
bool operator==(column_name_info const &rhs) const
Compares two column name info structs for equality.
Definition: io/types.hpp:266
std::optional< int32_t > type_length
Byte width of data (for fixed length data)
Definition: io/types.hpp:241
std::string name
Column name.
Definition: io/types.hpp:238
column_name_info(std::string _name, std::optional< bool > _is_nullable=std::nullopt, std::optional< bool > _is_binary=std::nullopt)
Construct a column name info with a name, optional nullabilty, and no children.
Definition: io/types.hpp:251
Non-owning view of a host memory buffer.
Definition: io/types.hpp:304
host_buffer(char const *data, size_t size)
Construct a new host buffer object.
Definition: io/types.hpp:315
Information used while writing partitioned datasets.
Definition: io/types.hpp:964
partition_info(size_type start_row, size_type num_rows)
Construct a new partition_info.
Definition: io/types.hpp:975
size_type start_row
The start row of the partition.
Definition: io/types.hpp:965
size_type num_rows
The number of rows in the partition.
Definition: io/types.hpp:966
Destination information for write interfaces.
Definition: io/types.hpp:512
auto const & buffers() const
Get the host buffers of the input.
Definition: io/types.hpp:600
sink_info(std::vector< std::vector< char > * > const &buffers)
Construct a new sink info object for multiple host buffers.
Definition: io/types.hpp:546
sink_info(std::string const &file_path)
Construct a new sink info object for a single file.
Definition: io/types.hpp:536
auto const & filepaths() const
Get the filepaths of the input.
Definition: io/types.hpp:594
sink_info(class cudf::io::data_sink *user_sink)
Construct a new sink info object for a single user-implemented sink.
Definition: io/types.hpp:572
sink_info(std::vector< cudf::io::data_sink * > const &user_sinks)
Construct a new sink info object for multiple user-implemented sinks.
Definition: io/types.hpp:562
auto num_sinks() const
Get the number of sinks.
Definition: io/types.hpp:588
auto const & user_sinks() const
Get the user sinks of the input.
Definition: io/types.hpp:606
sink_info(std::vector< std::string > const &file_paths)
Construct a new sink info object for multiple files.
Definition: io/types.hpp:526
sink_info(size_t num_sinks)
Construct a new sink info object.
Definition: io/types.hpp:519
auto type() const
Get the type of the input.
Definition: io/types.hpp:582
sink_info(std::vector< char > *buffer)
Construct a new sink info object for a single host buffer.
Definition: io/types.hpp:555
Source information for read interfaces.
Definition: io/types.hpp:337
auto const & device_buffers() const
Get the device buffers of the input.
Definition: io/types.hpp:493
source_info(char const *host_data, size_t size)
Construct a new source info object for a single buffer.
Definition: io/types.hpp:387
auto const & filepaths() const
Get the filepaths of the input.
Definition: io/types.hpp:481
source_info(cudf::host_span< T > host_data)
Construct a new source info object for a single buffer.
Definition: io/types.hpp:423
source_info(std::string const &file_path)
Construct a new source info object for a single file.
Definition: io/types.hpp:355
source_info(cudf::host_span< cudf::host_span< T >> const host_buffers)
Construct a new source info object for multiple buffers in host memory.
Definition: io/types.hpp:400
source_info(cudf::device_span< std::byte const > d_buffer)
Construct a new source info object from a device buffer.
Definition: io/types.hpp:445
source_info(cudf::io::datasource *source)
Construct a new source info object for a single user-implemented source.
Definition: io/types.hpp:465
source_info(std::vector< cudf::io::datasource * > const &sources)
Construct a new source info object for multiple user-implemented sources.
Definition: io/types.hpp:455
source_info(cudf::host_span< cudf::device_span< std::byte const >> device_buffers)
Construct a new source info object for multiple buffers in device memory.
Definition: io/types.hpp:435
auto const & host_buffers() const
Get the host buffers of the input.
Definition: io/types.hpp:487
auto type() const
Get the type of the input.
Definition: io/types.hpp:475
source_info(std::vector< std::string > const &file_paths)
Construct a new source info object for multiple files.
Definition: io/types.hpp:345
auto const & user_sources() const
Get the user sources of the input.
Definition: io/types.hpp:499
source_info(std::vector< host_buffer > const &host_buffers)
Construct a new source info object for multiple buffers in host memory.
Definition: io/types.hpp:367
Table metadata returned by IO readers.
Definition: io/types.hpp:277
std::vector< std::unordered_map< std::string, std::string > > per_file_user_data
Per file format-dependent metadata as key-values pairs.
Definition: io/types.hpp:286
std::vector< size_t > num_rows_per_source
Definition: io/types.hpp:280
std::vector< column_name_info > schema_info
Detailed name information for the entire output hierarchy.
Definition: io/types.hpp:279
std::map< std::string, std::string > user_data
Definition: io/types.hpp:283
Table with table metadata used by io readers to return the metadata by value.
Definition: io/types.hpp:292
std::unique_ptr< table > tbl
Table.
Definition: io/types.hpp:293
table_metadata metadata
Table metadata.
Definition: io/types.hpp:294
Class definition for cudf::table.
Type declarations for libcudf.