22 #include <cudf/detail/concatenate.hpp>
23 #include <cudf/detail/iterator.cuh>
24 #include <cudf/detail/null_mask.hpp>
25 #include <cudf/detail/utilities/vector_factories.hpp>
36 #include <cudf_test/column_utilities.hpp>
37 #include <cudf_test/cudf_gtest.hpp>
38 #include <cudf_test/default_stream.hpp>
43 #include <thrust/copy.h>
44 #include <thrust/functional.h>
45 #include <thrust/host_vector.h>
46 #include <thrust/iterator/constant_iterator.h>
47 #include <thrust/iterator/counting_iterator.h>
48 #include <thrust/iterator/transform_iterator.h>
100 template <
typename From,
typename To>
110 template <
typename FromT = From,
112 std::enable_if_t<std::is_same_v<FromT, ToT>,
void>* =
nullptr>
127 typename FromT = From,
130 std::is_constructible_v<ToT, FromT>),
132 constexpr ToT
operator()(FromT element)
const
134 return static_cast<ToT
>(element);
146 typename FromT = From,
148 std::enable_if_t<std::is_integral_v<FromT> && cudf::is_timestamp<ToT>(),
void>* =
nullptr>
151 return ToT{
typename ToT::duration{element}};
165 template <
typename ElementTo,
166 typename ElementFrom,
167 typename InputIterator,
168 std::enable_if_t<not cudf::is_fixed_point<ElementTo>()>* =
nullptr>
171 static_assert(cudf::is_fixed_width<ElementTo>(),
"Unexpected non-fixed width type.");
172 auto transformer = fixed_width_type_converter<ElementFrom, ElementTo>{};
173 auto transform_begin = thrust::make_transform_iterator(begin, transformer);
175 auto const elements = thrust::host_vector<ElementTo>(transform_begin, transform_begin + size);
194 template <
typename ElementTo,
195 typename ElementFrom,
196 typename InputIterator,
197 std::enable_if_t<not cudf::is_fixed_point<ElementFrom>() and
199 rmm::device_buffer make_elements(InputIterator begin, InputIterator end)
201 using RepType =
typename ElementTo::rep;
202 auto transformer = fixed_width_type_converter<ElementFrom, RepType>{};
203 auto transform_begin = thrust::make_transform_iterator(begin, transformer);
205 auto const elements = thrust::host_vector<RepType>(transform_begin, transform_begin + size);
220 template <
typename ElementTo,
221 typename ElementFrom,
222 typename InputIterator,
223 std::enable_if_t<cudf::is_fixed_point<ElementFrom>() and
225 rmm::device_buffer make_elements(InputIterator begin, InputIterator end)
228 using RepType =
typename ElementTo::rep;
230 auto to_rep = [](ElementTo fp) {
return fp.value(); };
231 auto transformer_begin = thrust::make_transform_iterator(begin, to_rep);
233 auto const elements = thrust::host_vector<RepType>(transformer_begin, transformer_begin + size);
252 template <
typename Val
idityIterator>
253 std::pair<std::vector<bitmask_type>,
cudf::size_type> make_null_mask_vector(ValidityIterator begin,
254 ValidityIterator end)
259 auto null_mask = std::vector<bitmask_type>(num_words, 0);
261 for (
auto i = 0; i < size; ++i) {
285 template <
typename Val
idityIterator>
286 std::pair<rmm::device_buffer, cudf::size_type> make_null_mask(ValidityIterator begin,
287 ValidityIterator end)
289 auto [null_mask,
null_count] = make_null_mask_vector(begin, end);
310 template <
typename StringsIterator,
typename Val
idityIterator>
311 auto make_chars_and_offsets(StringsIterator begin, StringsIterator end, ValidityIterator v)
313 std::vector<char> chars{};
314 std::vector<cudf::size_type> offsets(1, 0);
315 for (
auto str = begin; str < end; ++str) {
316 std::string tmp = (*v++) ? std::string(*str) : std::string{};
317 chars.insert(chars.end(), std::cbegin(tmp), std::cend(tmp));
318 offsets.push_back(offsets.back() + tmp.length());
320 return std::pair(std::move(chars), std::move(offsets));
332 template <
typename ElementTo,
typename SourceElementT = ElementTo>
340 std::vector<ElementTo> empty;
344 detail::make_elements<ElementTo, SourceElementT>(empty.begin(), empty.end()),
367 template <
typename InputIterator>
373 detail::make_elements<ElementTo, SourceElementT>(begin, end),
401 template <
typename InputIterator,
typename Val
idityIterator>
406 auto [null_mask,
null_count] = detail::make_null_mask(v, v + size);
409 detail::make_elements<ElementTo, SourceElementT>(begin, end),
410 std::move(null_mask),
426 template <
typename ElementFrom>
449 template <
typename ElementFrom>
451 std::initializer_list<bool> validity)
473 template <
typename Val
idityIterator,
typename ElementFrom>
497 template <
typename InputIterator>
500 std::initializer_list<bool>
const& validity)
522 template <
typename ElementFrom>
526 thrust::make_transform_iterator(elements.begin(), [](
auto const& e) { return e.first; });
527 auto end = begin + elements.size();
529 thrust::make_transform_iterator(elements.begin(), [](
auto const& e) { return e.second; });
539 template <
typename Rep>
558 template <
typename FixedPo
intRepIterator>
560 FixedPointRepIterator end,
564 CUDF_EXPECTS(numeric::is_supported_representation_type<Rep>(),
"not valid representation type");
567 auto const elements = thrust::host_vector<Rep>(begin, end);
568 auto const id = type_to_id<numeric::fixed_point<Rep, numeric::Radix::BASE_10>>();
623 template <
typename FixedPo
intRepIterator,
typename Val
idityIterator>
625 FixedPointRepIterator end,
630 CUDF_EXPECTS(numeric::is_supported_representation_type<Rep>(),
"not valid representation type");
633 auto const elements = thrust::host_vector<Rep>(begin, end);
634 auto const id = type_to_id<numeric::fixed_point<Rep, numeric::Radix::BASE_10>>();
636 auto [null_mask,
null_count] = detail::make_null_mask(v, v + size);
641 std::move(null_mask),
663 std::initializer_list<bool> validity,
666 std::cbegin(elements), std::cend(elements), std::cbegin(validity), scale)
688 template <
typename Val
idityIterator>
716 template <
typename FixedPo
intRepIterator>
718 FixedPointRepIterator end,
719 std::initializer_list<bool>
const& validity,
756 template <
typename StringsIterator>
760 if (num_strings == 0) {
764 auto all_valid = thrust::make_constant_iterator(
true);
765 auto [chars, offsets] = detail::make_chars_and_offsets(begin, end, all_valid);
766 auto d_chars = cudf::detail::make_device_uvector_async(
768 auto d_offsets = std::make_unique<cudf::column>(
769 cudf::detail::make_device_uvector_sync(
805 template <
typename StringsIterator,
typename Val
idityIterator>
810 if (num_strings == 0) {
814 auto [chars, offsets] = detail::make_chars_and_offsets(begin, end, v);
815 auto [null_mask,
null_count] = detail::make_null_mask_vector(v, v + num_strings);
816 auto d_chars = cudf::detail::make_device_uvector_async(
818 auto d_offsets = std::make_unique<cudf::column>(
819 cudf::detail::make_device_uvector_async(
823 auto d_bitmask = cudf::detail::make_device_uvector_sync(
826 num_strings, std::move(d_offsets), d_chars.release(),
null_count, d_bitmask.release());
864 template <
typename Val
idityIterator>
886 std::initializer_list<bool> validity)
914 thrust::make_transform_iterator(strings.begin(), [](
auto const& s) { return s.first; });
915 auto end = begin + strings.size();
917 thrust::make_transform_iterator(strings.begin(), [](
auto const& s) { return s.second; });
930 template <
typename KeyElementTo,
typename SourceElementT = KeyElementTo>
965 template <
typename InputIterator>
999 template <
typename InputIterator,
typename Val
idityIterator>
1022 template <
typename ElementFrom>
1046 template <
typename ElementFrom>
1048 std::initializer_list<bool> validity)
1071 template <
typename Val
idityIterator,
typename ElementFrom>
1097 template <
typename InputIterator>
1100 std::initializer_list<bool>
const& validity)
1159 template <
typename StringsIterator>
1195 template <
typename StringsIterator,
typename Val
idityIterator>
1239 template <
typename Val
idityIterator>
1261 std::initializer_list<bool> validity)
1302 template <
typename T,
typename SourceElementT = T>
1323 template <typename Element = T, std::enable_if_t<cudf::is_fixed_width<Element>()>* =
nullptr>
1326 build_from_non_nested(
1345 template <
typename Element = T,
1346 typename InputIterator,
1347 std::enable_if_t<cudf::is_fixed_width<Element>()>* =
nullptr>
1350 build_from_non_nested(
1369 template <
typename Element = T,
1370 typename ValidityIterator,
1371 std::enable_if_t<cudf::is_fixed_width<Element>()>* =
nullptr>
1375 build_from_non_nested(
1396 template <
typename Element = T,
1397 typename InputIterator,
1398 typename ValidityIterator,
1399 std::enable_if_t<cudf::is_fixed_width<Element>()>* =
nullptr>
1403 build_from_non_nested(std::move(
1420 template <
typename Element = T,
1421 std::enable_if_t<std::is_same_v<Element, cudf::string_view>>* =
nullptr>
1424 build_from_non_nested(
1443 template <
typename Element = T,
1444 typename ValidityIterator,
1445 std::enable_if_t<std::is_same_v<Element, cudf::string_view>>* =
nullptr>
1449 build_from_non_nested(
1477 std::vector<bool> valids;
1478 build_from_nested(elements, valids);
1522 template <
typename Val
idityIterator>
1527 std::vector<bool> validity;
1531 std::back_inserter(validity),
1533 build_from_nested(elements, validity);
1565 std::unique_ptr<cudf::column>&& offsets,
1566 std::unique_ptr<cudf::column>&& values,
1575 std::move(null_mask),
1595 void build_from_nested(std::initializer_list<lists_column_wrapper<T, SourceElementT>> elements,
1596 std::vector<bool>
const& v)
1598 auto valids = cudf::detail::make_counting_transform_iterator(
1599 0, [&v](
auto i) {
return v.empty() ?
true : v[i]; });
1602 auto const hierarchy_and_depth =
1603 std::accumulate(elements.begin(),
1605 std::pair<column_view, int32_t>{{}, -1},
1606 [](
auto acc, lists_column_wrapper
const& lcw) {
1607 return lcw.depth > acc.second ? std::pair(lcw.get_view(), lcw.depth) : acc;
1609 column_view expected_hierarchy = hierarchy_and_depth.first;
1610 int32_t
const expected_depth = hierarchy_and_depth.second;
1613 auto [cols, stubs] = preprocess_columns(elements, expected_hierarchy, expected_depth);
1617 std::vector<size_type> offsetv;
1621 std::back_inserter(offsetv),
1624 size_type ret = count;
1625 if (valid) { count += col.size(); }
1629 offsetv.push_back(count);
1634 std::vector<column_view> children;
1636 std::cbegin(cols), std::cend(cols), valids, std::back_inserter(children), thrust::identity{});
1644 depth = expected_depth + 1;
1648 return cudf::test::detail::make_null_mask(v.begin(), v.end());
1656 std::move(null_mask),
1667 void build_from_non_nested(std::unique_ptr<column> c)
1672 std::vector<size_type> offsetv;
1673 if (c->size() > 0) {
1674 offsetv.push_back(0);
1675 offsetv.push_back(c->size());
1684 size_type num_elements = offsets->size() == 0 ? 0 : offsets->size() - 1;
1727 std::unique_ptr<column> normalize_column(column_view
const& col,
1728 column_view
const& expected_hierarchy)
1732 CUDF_EXPECTS(col.is_empty(),
"Encountered mismatched column!");
1734 auto remainder =
empty_like(expected_hierarchy);
1738 lists_column_view lcv(col);
1741 std::make_unique<column>(lcv.offsets()),
1742 normalize_column(lists_column_view(col).child(),
1743 lists_column_view(expected_hierarchy).child()),
1750 std::pair<std::vector<column_view>, std::vector<std::unique_ptr<column>>> preprocess_columns(
1751 std::initializer_list<lists_column_wrapper<T, SourceElementT>>
const& elements,
1752 column_view& expected_hierarchy,
1755 std::vector<std::unique_ptr<column>> stubs;
1756 std::vector<column_view> cols;
1763 std::back_inserter(cols),
1764 [&](lists_column_wrapper
const& l) -> column_view {
1768 if (l.depth < expected_depth) {
1782 CUDF_EXPECTS(l.wrapped->size() == 0,
"Mismatch in column types!");
1783 stubs.push_back(empty_like(expected_hierarchy));
1785 stubs.push_back(normalize_column(l.get_view(), expected_hierarchy));
1787 return *(stubs.back());
1790 return l.get_view();
1793 return {std::move(cols), std::move(stubs)};
1796 column_view get_view()
const {
return root ? lists_column_view(*wrapped).child() : *wrapped; }
1835 std::vector<bool>
const& validity = {})
1837 init(std::move(child_columns), validity);
1861 std::initializer_list<std::reference_wrapper<detail::column_wrapper>> child_column_wrappers,
1862 std::vector<bool>
const& validity = {})
1864 std::vector<std::unique_ptr<cudf::column>> child_columns;
1865 child_columns.reserve(child_column_wrappers.size());
1867 child_column_wrappers.end(),
1868 std::back_inserter(child_columns),
1869 [&](
auto const& column_wrapper) {
1870 return std::make_unique<cudf::column>(column_wrapper.get(),
1871 cudf::test::get_default_stream());
1873 init(std::move(child_columns), validity);
1896 template <
typename V>
1898 std::initializer_list<std::reference_wrapper<detail::column_wrapper>> child_column_wrappers,
1901 std::vector<std::unique_ptr<cudf::column>> child_columns;
1902 child_columns.reserve(child_column_wrappers.size());
1904 child_column_wrappers.end(),
1905 std::back_inserter(child_columns),
1906 [&](
auto const& column_wrapper) {
1907 return std::make_unique<cudf::column>(column_wrapper.get(),
1908 cudf::test::get_default_stream());
1910 init(std::move(child_columns), validity_iter);
1914 void init(std::vector<std::unique_ptr<cudf::column>>&& child_columns,
1915 std::vector<bool>
const& validity)
1917 size_type num_rows = child_columns.empty() ? 0 : child_columns[0]->size();
1920 child_columns.end(),
1921 [&](
auto const& p_column) { return p_column->size() == num_rows; }),
1922 "All struct member columns must have the same row count.");
1925 "Validity buffer must have as many elements as rows in the struct column.");
1929 return cudf::test::detail::make_null_mask(validity.begin(), validity.end());
1933 std::move(child_columns),
1935 std::move(null_mask),
1939 template <
typename V>
1940 void init(std::vector<std::unique_ptr<cudf::column>>&& child_columns, V validity_iterator)
1942 size_type const num_rows = child_columns.empty() ? 0 : child_columns[0]->size();
1945 child_columns.end(),
1946 [&](
auto const& p_column) { return p_column->size() == num_rows; }),
1947 "All struct member columns must have the same row count.");
1949 std::vector<bool> validity(num_rows);
1950 std::copy(validity_iterator, validity_iterator + num_rows, validity.begin());
1952 init(std::move(child_columns), validity);
Utilities for bit and bitmask operations.
A non-owning, immutable view of device data as a column of elements, some of which may be null as ind...
A container of nullable device data as a column of elements.
Indicator for the logical data type of an element in a column.
A wrapper class for operations on a dictionary column.
column_view indices() const noexcept
Returns the column of indices.
column_view keys() const noexcept
Returns the column of keys.
Given a column-view of lists type, an instance of this class provides a wrapper on this compound colu...
A non-owning, mutable view of device data as a column of elements, some of which may be null as indic...
Base class for a wrapper around a cudf::column.
std::unique_ptr< cudf::column > wrapped
The wrapped column.
std::unique_ptr< cudf::column > release()
Releases internal unique_ptr to wrapped column.
dictionary_column_wrapper(StringsIterator begin, StringsIterator end, ValidityIterator v)
Construct a nullable dictionary column of strings from the range [begin,end) using the range [v,...
dictionary_column_wrapper(std::initializer_list< std::string > strings, std::initializer_list< bool > validity)
Construct a nullable dictionary column of strings from a list of strings and a list of booleans to in...
column_view indices() const
Access indices column view.
dictionary_column_wrapper(std::initializer_list< std::string > strings)
Construct a non-nullable dictionary column of strings from a list of strings.
dictionary_column_wrapper(StringsIterator begin, StringsIterator end)
Construct a non-nullable dictionary column of strings from the range [begin,end).
dictionary_column_wrapper(std::initializer_list< std::string > strings, ValidityIterator v)
Construct a nullable dictionary column of strings from a list of strings and the range [v,...
column_view keys() const
Access keys column view.
dictionary_column_wrapper()
Default constructor initializes an empty dictionary column of strings.
column_wrapper derived class for wrapping dictionary columns.
dictionary_column_wrapper(std::initializer_list< ElementFrom > elements)
Construct a non-nullable dictionary column of fixed-width elements from an initializer list.
dictionary_column_wrapper(std::initializer_list< ElementFrom > elements, std::initializer_list< bool > validity)
Construct a nullable dictionary column from a list of fixed-width elements using another list to indi...
dictionary_column_wrapper(std::initializer_list< ElementFrom > element_list, ValidityIterator v)
Construct a nullable dictionary column from a list of fixed-width elements and the range [v,...
dictionary_column_wrapper()
Default constructor initializes an empty column with dictionary type.
dictionary_column_wrapper(InputIterator begin, InputIterator end)
Construct a non-nullable dictionary column of the fixed-width elements in the range [begin,...
dictionary_column_wrapper(InputIterator begin, InputIterator end, ValidityIterator v)
Construct a nullable dictionary column of the fixed-width elements in the range [begin,...
dictionary_column_wrapper(InputIterator begin, InputIterator end, std::initializer_list< bool > const &validity)
Construct a nullable dictionary column of the fixed-width elements in the range [begin,...
A wrapper for a column of fixed-width elements.
fixed_point_column_wrapper(FixedPointRepIterator begin, FixedPointRepIterator end, std::initializer_list< bool > const &validity, numeric::scale_type scale)
Construct a nullable column of the decimal elements in the range [begin,end) using a validity initial...
fixed_point_column_wrapper(std::initializer_list< Rep > elements, std::initializer_list< bool > validity, numeric::scale_type scale)
Construct a nullable column from an initializer list of decimal elements using another list to indica...
fixed_point_column_wrapper(FixedPointRepIterator begin, FixedPointRepIterator end, numeric::scale_type scale)
Construct a non-nullable column of the decimal elements in the range [begin,end).
fixed_point_column_wrapper(std::initializer_list< Rep > element_list, ValidityIterator v, numeric::scale_type scale)
Construct a nullable column from an initializer list of decimal elements and the range [v,...
fixed_point_column_wrapper(std::initializer_list< Rep > values, numeric::scale_type scale)
Construct a non-nullable column of decimal elements from an initializer list.
fixed_point_column_wrapper(FixedPointRepIterator begin, FixedPointRepIterator end, ValidityIterator v, numeric::scale_type scale)
Construct a nullable column of the fixed-point elements from a range.
column_wrapper derived class for wrapping columns of fixed-width elements.
fixed_width_column_wrapper(InputIterator begin, InputIterator end, std::initializer_list< bool > const &validity)
Construct a nullable column of the fixed-width elements in the range [begin,end) using a validity ini...
fixed_width_column_wrapper(std::initializer_list< std::pair< ElementFrom, bool >> elements)
Construct a nullable column from a list of pairs of fixed-width elements and validity booleans of eac...
fixed_width_column_wrapper(std::initializer_list< ElementFrom > elements, std::initializer_list< bool > validity)
Construct a nullable column from a list of fixed-width elements using another list to indicate the va...
fixed_width_column_wrapper(std::initializer_list< ElementFrom > elements)
Construct a non-nullable column of fixed-width elements from an initializer list.
fixed_width_column_wrapper(InputIterator begin, InputIterator end, ValidityIterator v)
Construct a nullable column of the fixed-width elements in the range [begin,end) using the range [v,...
fixed_width_column_wrapper(std::initializer_list< ElementFrom > element_list, ValidityIterator v)
Construct a nullable column from a list of fixed-width elements and the range [v, v + element_list....
fixed_width_column_wrapper(InputIterator begin, InputIterator end)
Construct a non-nullable column of the fixed-width elements in the range [begin,end).
fixed_width_column_wrapper()
Default constructor initializes an empty column with proper dtype.
column_wrapper derived class for wrapping columns of lists.
lists_column_wrapper(InputIterator begin, InputIterator end)
Construct a lists column containing a single list of fixed-width type from an iterator range.
lists_column_wrapper(std::initializer_list< lists_column_wrapper< T, SourceElementT >> elements, ValidityIterator v)
Construct a lists column of nested lists from an initializer list of values and a validity iterator.
static lists_column_wrapper< T > make_one_empty_row_column(bool valid=true)
Construct a list column containing a single empty, optionally null row.
lists_column_wrapper(InputIterator begin, InputIterator end, ValidityIterator v)
Construct a lists column containing a single list of fixed-width type from an iterator range and a va...
lists_column_wrapper()
Construct am empty lists column.
lists_column_wrapper(std::initializer_list< lists_column_wrapper< T, SourceElementT >> elements)
Construct a lists column of nested lists from an initializer list of values.
lists_column_wrapper(std::initializer_list< SourceElementT > elements)
Construct a lists column containing a single list of fixed-width type from an initializer list of val...
lists_column_wrapper(std::initializer_list< std::string > elements, ValidityIterator v)
Construct a lists column containing a single list of strings from an initializer list of values and a...
lists_column_wrapper(std::initializer_list< std::string > elements)
Construct a lists column containing a single list of strings from an initializer list of values.
lists_column_wrapper(std::initializer_list< SourceElementT > elements, ValidityIterator v)
Construct a lists column containing a single list of fixed-width type from an initializer list of val...
column_wrapper derived class for wrapping columns of strings.
strings_column_wrapper(std::initializer_list< std::pair< std::string, bool >> strings)
Construct a nullable column from a list of pairs of strings and validity booleans of each string.
strings_column_wrapper()
Default constructor initializes an empty column of strings.
strings_column_wrapper(std::initializer_list< std::string > strings)
Construct a non-nullable column of strings from a list of strings.
strings_column_wrapper(std::initializer_list< std::string > strings, std::initializer_list< bool > validity)
Construct a nullable column of strings from a list of strings and a list of booleans to indicate the ...
strings_column_wrapper(std::initializer_list< std::string > strings, ValidityIterator v)
Construct a nullable column of strings from a list of strings and the range [v, v + strings....
strings_column_wrapper(StringsIterator begin, StringsIterator end)
Construct a non-nullable column of strings from the range [begin,end).
strings_column_wrapper(StringsIterator begin, StringsIterator end, ValidityIterator v)
Construct a nullable column of strings from the range [begin,end) using the range [v,...
column_wrapper derived class for wrapping columns of structs.
structs_column_wrapper(std::initializer_list< std::reference_wrapper< detail::column_wrapper >> child_column_wrappers, V validity_iter)
Constructs a struct column from the list of column wrappers for child columns.
structs_column_wrapper(std::initializer_list< std::reference_wrapper< detail::column_wrapper >> child_column_wrappers, std::vector< bool > const &validity={})
Constructs a struct column from the list of column wrappers for child columns.
structs_column_wrapper(std::vector< std::unique_ptr< cudf::column >> &&child_columns, std::vector< bool > const &validity={})
Constructs a struct column from the specified list of pre-constructed child columns.
void const * data() const noexcept
Class definition for cudf::column.
Column APIs for gather, scatter, split, slice, etc.
Dictionary column encode and decode APIs.
Class definition for fixed point data type.
std::unique_ptr< column > empty_like(column_view const &input)
Initializes and returns an empty column of the same type as the input.
std::unique_ptr< column > make_strings_column(cudf::device_span< thrust::pair< char const *, size_type > const > strings, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Construct a STRING type column given a device span of pointer/size pairs.
std::unique_ptr< cudf::column > make_lists_column(size_type num_rows, std::unique_ptr< column > offsets_column, std::unique_ptr< column > child_column, size_type null_count, rmm::device_buffer &&null_mask, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Construct a LIST type column given offsets column, child column, null mask and null count.
std::unique_ptr< column > make_empty_column(data_type type)
Creates an empty column of the specified type.
std::unique_ptr< cudf::column > make_structs_column(size_type num_rows, std::vector< std::unique_ptr< column >> &&child_columns, size_type null_count, rmm::device_buffer &&null_mask, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Construct a STRUCT column using specified child columns as members.
cudf::size_type null_count(bitmask_type const *bitmask, size_type start, size_type stop, rmm::cuda_stream_view stream=cudf::get_default_stream())
Given a validity bitmask, counts the number of null elements (unset bits) in the range [start,...
std::size_t bitmask_allocation_size_bytes(size_type number_of_bits, std::size_t padding_boundary=64)
Computes the required bytes necessary to represent the specified number of bits with a given padding ...
rmm::device_buffer copy_bitmask(bitmask_type const *mask, size_type begin_bit, size_type end_bit, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Creates a device_buffer from a slice of bitmask defined by a range of indices [begin_bit,...
rmm::device_buffer create_null_mask(size_type size, mask_state state, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Creates a device_buffer for use as a null value indicator bitmask of a column.
std::unique_ptr< column > concatenate(host_span< column_view const > columns_to_concat, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Concatenates multiple columns into a single column.
rmm::cuda_stream_view const get_default_stream()
Get the current default stream.
std::unique_ptr< column > encode(column_view const &column, data_type indices_type=data_type{type_id::UINT32}, rmm::cuda_stream_view stream=cudf::get_default_stream(), rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
Construct a dictionary column by dictionary encoding an existing column.
scale_type
The scale type for fixed_point.
device_memory_resource * get_current_device_resource()
CUDF_HOST_DEVICE void set_bit_unsafe(bitmask_type *bitmask, size_type bit_index)
Sets the specified bit to 1
#define CUDF_EXPECTS(...)
Macro for checking (pre-)conditions that throws an exception when a condition is violated.
constexpr bool is_fixed_point()
Indicates whether the type T is a fixed-point type.
int32_t size_type
Row index type for columns and tables.
uint32_t bitmask_type
Bitmask type stored as 32-bit unsigned integer.
size_type distance(T f, T l)
Similar to std::distance but returns cudf::size_type and performs static_cast
constexpr bool is_nested()
Indicates whether T is a nested type.
@ ALL_NULL
Null mask allocated, initialized to all elements NULL.
@ UINT32
4 byte unsigned integer
@ EMPTY
Always null with no underlying data.
@ DICTIONARY32
Dictionary type using int32 indices.
Class definition for cudf::lists_column_view.
fixed_point and supporting types
APIs for managing validity bitmasks.
Convert between source and target types when they differ and where possible.
constexpr ToT operator()(FromT element) const
No conversion necessary: Same type, simply copy element to output.
Defines the mapping between cudf::type_id runtime type information and concrete C++ types.
Type declarations for libcudf.