列类#

group column_classes
class column#
#include <column.hpp>

一个包含可空设备数据的容器，作为一列元素。

公共函数

column(column const &other, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过深度复制other的内容来构造一个新的列对象。

使用指定的 stream 和 device_memory_resource 进行所有分配和复制。

Parameters:

  • other – 要复制的 column

  • stream – 用于设备内存操作的CUDA流。

  • mr – 用于所有设备内存分配的设备内存资源

column(column &&other) noexcept#

将内容从 other 移动到新列。

移动后，other.size() == 0 并且 other.type() = {EMPTY}

Parameters:

other – 其内容将被移动到新列中的列

template<typename T>
inline column(rmm::device_uvector<T> &&other, rmm::device_buffer &&null_mask, size_type null_count)#

通过获取device_uvector内容的所有权来构造一个新列。

Parameters:

  • other – 其内容将被移动到新列的 device_uvector。

  • null_mask – 列的空值指示位掩码。如果 null_count 为 0，则可能为空。

  • null_count – 空元素的数量。

template<typename B1, typename B2 = rmm::device_buffer>
inline column(data_type dtype, size_type size, B1 &&data, B2 &&null_mask, size_type null_count, std::vector<std::unique_ptr<column>> &&children = {})#

从现有的设备内存中构造一个新列。

注意

此构造函数主要用于列工厂函数中。

Throws:

cudf::logic_error – 如果 size < 0

Parameters:

  • dtype – 元素类型

  • size – 列中的元素数量

  • data – 列的数据

  • null_mask – 列的空值指示位掩码。如果 null_count 为 0，则可能为空。

  • null_count – 可选，空元素的数量。

  • children – 可选项，子列的向量

explicit column(column_view view, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过深度复制column_view的内容来构造一个新列。

这解释了column_view的偏移量。

Parameters:

  • view – 要复制的视图

  • stream – 用于设备内存操作的CUDA流。

  • mr – 用于所有设备内存分配的设备内存资源

inline data_type type() const noexcept#

返回列的逻辑元素类型。

Returns:

列的逻辑元素类型

inline size_type size() const noexcept#

返回元素的数量。

Returns:

元素的数量

inline size_type null_count() const#

返回空元素的数量。

Returns:

空元素的数量

void set_null_mask(rmm::device_buffer &&new_null_mask, size_type new_null_count)#

将列的空值指示器位掩码设置为 new_null_mask。

Throws:

cudf::logic_error – 如果 new_null_count 大于 0 并且 new_null_mask 的大小与此列的大小不匹配。

Parameters:

  • new_null_mask – 新的空值指示位掩码（右值重载和移动）用于设置列的空值指示掩码。如果 new_null_count 为 0，则可能为空。

  • new_null_count – 空元素的数量。

void set_null_mask(rmm::device_buffer const &new_null_mask, size_type new_null_count, rmm::cuda_stream_view stream = cudf::get_default_stream())#

将列的空值指示器位掩码设置为 new_null_mask。

Throws:

cudf::logic_error – 如果 new_null_count 大于 0 并且 new_null_mask 的大小与此列的大小不匹配。

Parameters:

  • new_null_mask – 新的空值指示位掩码（左值重载和复制）用于设置列的空值指示掩码。如果 new_null_count 为 0，则可能为空。

  • new_null_count – 空元素的数量

  • stream – 执行分配和复制的流。如果未指定，则使用默认的CUDF流。

void set_null_count(size_type new_null_count)#

更新空元素的数量。

Throws:

cudf::logic_error – 如果 new_null_count > 0 and nullable() == false

Parameters:

new_null_count – 新的空值计数。

inline bool nullable() const noexcept#

指示该列是否可能包含空值，即它有一个分配的空值掩码。

这可能返回 false 当且仅当 null_count() == 0。

即使null_count() == 0，也可能返回true。此函数仅指示列是否分配了空值掩码。

Returns:

true 该列可以包含空值

Returns:

false 该列不能包含空值

inline bool has_nulls() const noexcept#

指示该列是否包含空元素。

Returns:

true 一个或多个元素为空

Returns:

false 零元素为空

inline size_type num_children() const noexcept#

返回子列的数量。

Returns:

子列的数量

inline column &child(size_type child_index) noexcept#

返回对指定子项的引用。

Parameters:

child_index – 所需子项的索引

Returns:

引用所需的子项

inline column const &child(size_type child_index) const noexcept#

返回指定子元素的常量引用。

Parameters:

child_index – 所需子项的索引

Returns:

对所需子项的常量引用

contents release() noexcept#

释放列内容的所有权。

调用者有责任在调用release()之前查询size(), null_count(), type()。

在调用release()后，该列将为空，即：

Returns:

一个包含数据、空掩码和列子元素的 contents 结构体。

column_view view() const#

创建列数据及其子项的不可变、非拥有视图。

Returns:

不可变的、非拥有的视图

inline operator column_view() const#

隐式转换为 column_view 的运算符。

这允许将column对象直接传递给需要column_view的函数。转换是自动的。

Returns:

不可变的、非拥有的 column_view

mutable_column_view mutable_view()#

创建一个可变的、非拥有的列数据视图，包括空值掩码和子列。

Returns:

可变的、非拥有的视图

inline operator mutable_column_view()#

隐式转换为 mutable_column_view 的运算符。

这允许将column对象传递给接受mutable_column_view的函数。转换是自动的。

如果修改了空值掩码，调用者应适当地更新空值计数。

Returns:

可变的、非拥有的 mutable_column_view

struct contents#
#include <column.hpp>

列的包装器。

由 column::release() 返回。

公共成员

std::unique_ptr<rmm::device_buffer> data#

数据设备内存缓冲区

std::unique_ptr<rmm::device_buffer> null_mask#

空掩码设备内存缓冲区

std::vector<std::unique_ptr<column>> children#

子列

struct nullate#

指示在编译时或运行时存在空值。

如果在编译时使用，此指示器可以告诉优化器包含或排除任何空值检查子句。

struct DYNAMIC#

nullate::DYNAMIC 将空值的确定推迟到运行时而不是编译时。调用代码负责在运行时使用构造函数参数指定是否存在空值。

公共函数

inline explicit constexpr DYNAMIC(bool b) noexcept#

创建一个运行时无效对象。

另请参阅

cudf::column_device_view::optional_begin 例如用法

Parameters:

b – 如果在应用此对象的操作中预期有空值，则为True。

inline constexpr operator bool() const noexcept#

如果在此对象应用的操作中预期有空值，则返回 true。

Returns:

true 如果在应用此对象的操作中预期有空值，则为 true，否则为 false

公共成员

bool value#

如果预期为空，则为True。

struct NO : public std::bool_constant<false>#
struct YES : public std::bool_constant<true>#
class column_device_view : public cudf::detail::column_device_view_base#

设备数据的不可变、非拥有视图，作为一列元素，可在CUDA设备代码中轻松复制和使用。

由 cudf::detail::lists_column_device_view, cudf::detail::structs_column_device_view 子类化

公共类型

using count_it = thrust::counting_iterator<size_type>#

计数迭代器。

template<typename T>
using const_iterator = thrust::transform_iterator<detail::value_accessor<T>, count_it>#

用于导航此列的迭代器。

template<typename T, typename Nullate>
using const_optional_iterator = thrust::transform_iterator<detail::optional_accessor<T, Nullate>, count_it>#

用于导航此列的可选迭代器。

template<typename T, bool has_nulls>
using const_pair_iterator = thrust::transform_iterator<detail::pair_accessor<T, has_nulls>, count_it>#

用于导航此列的配对迭代器。

template<typename T, bool has_nulls>
using const_pair_rep_iterator = thrust::transform_iterator<detail::pair_rep_accessor<T, has_nulls>, count_it>#

用于导航此列的配对重复迭代器。

每一行的值以其代表形式访问。

公共函数

column_device_view(column_device_view const&) = default#

复制构造函数。

column_device_view(column_device_view&&) = default#

移动构造函数。

column_device_view &operator=(column_device_view const&) = default#

复制赋值运算符。

Returns:

引用此对象

column_device_view &operator=(column_device_view&&) = default#

移动赋值运算符。

Returns:

对此对象的引用（在转移所有权后）

column_device_view(column_view column, void *h_ptr, void *d_ptr)#

使用指定的主机内存指针（h_ptr）来存储子对象，并使用设备内存指针（d_ptr）作为任何子对象指针的基础，创建此类的实例。

Parameters:

  • column – 从中创建此实例的列视图。

  • h_ptr – 用于放置任何子数据的主机内存指针。

  • d_ptr – 设备内存指针，用于基于此指针创建任何子指针。

inline column_device_view slice(size_type offset, size_type size) const noexcept#

获取一个新的column_device_view，它是此列的一个切片。

示例：

// column = column_device_view([1, 2, 3, 4, 5, 6, 7])
auto c = column.slice(1, 3);
// c = column_device_view([2, 3, 4])
auto c1 = column.slice(2, 3);
// c1 = column_device_view([3, 4, 5])

Parameters:

  • offset – 切片中第一个元素的索引

  • size – 切片中的元素数量

Returns:

此列的一部分

template<typename T>
inline T element(size_type element_index) const noexcept#

返回指定索引处元素的引用。

如果指定索引处的元素为NULL，即is_null(element_index) == true，则任何尝试使用结果的行为都将导致未定义的行为。

此函数考虑了偏移量。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。对于is_rep_layout_compatible为false的类型T，可能存在此函数的特化。

Template Parameters:

T – 元素类型

Parameters:

element_index – 所需元素的位置

Returns:

引用指定索引处的元素

template<typename T>
inline const_iterator<T> begin() const#

返回指向列的第一个元素的迭代器。

此迭代器仅支持has_nulls() == false的列。在has_nulls() == true的列上使用它时，访问空元素将导致未定义的行为。

如果 column_device_view::has_element_accessor() 为 false，则此函数不参与重载解析。

对于包含空元素的列，使用make_null_replacement_iterator。

Template Parameters:

T – 列中元素的类型

Returns:

指向列的第一个元素的迭代器

template<typename T>
inline const_iterator<T> end() const#

返回一个指向列最后一个元素之后的元素的迭代器。

此迭代器仅支持has_nulls() == false的列。在has_nulls() == true的列上使用它时，访问空元素将导致未定义的行为。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

对于包含空元素的列，使用make_null_replacement_iterator。

Returns:

指向列中最后一个元素之后的元素的迭代器

template<typename T, typename Nullate>
inline auto optional_begin(Nullate has_nulls) const#

返回一个可选的迭代器到列的第一个元素。

解引用返回的迭代器会返回一个 cuda::std::optional。

此迭代器的元素在上下文中转换为布尔值。如果对象包含值，则转换返回 true；如果不包含值，则返回 false。

使用nullate::DYNAMIC调用此方法会将空值的假设推迟到运行时，由调用者指示列是否包含空值。当算法将在多个迭代器上执行且不需要在编译时处理所有迭代器类型的组合时，nullate::DYNAMIC非常有用。

template<typename T>
void some_function(cudf::column_view<T> const& col_view){
   auto d_col = cudf::column_device_view::create(col_view);
   // Create a `DYNAMIC` optional iterator
   auto optional_iterator =
      d_col->optional_begin<T>(cudf::nullate::DYNAMIC{col_view.has_nulls()});
}

使用nullate::YES调用此方法意味着该列支持空值，并且返回的可选值可能不包含值。

使用nullate::NO调用此方法意味着该列没有空值，并且可选返回值将始终包含一个值。

template<typename T, bool has_nulls>
void some_function(cudf::column_view<T> const& col_view){
   auto d_col = cudf::column_device_view::create(col_view);
   if constexpr(has_nulls) {
     auto optional_iterator = d_col->optional_begin<T>(cudf::nullate::YES{});
     //use optional_iterator
   } else {
     auto optional_iterator = d_col->optional_begin<T>(cudf::nullate::NO{});
     //use optional_iterator
   }
}

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:
Template Parameters:

  • T – 列中元素的类型

  • Nullate – 一种 cudf::nullate 类型，描述如何检查空值

Parameters:

has_nulls – 一个 cudf::nullate 类型，描述如何检查空值

Returns:

一个可选的迭代器，指向列的第一个元素

template<typename T, bool has_nulls>
inline const_pair_iterator<T, has_nulls> pair_begin() const#

返回指向列的第一个元素的一对迭代器。

解引用返回的迭代器会返回一个 thrust::pair bool>。

如果位置 i 的元素是有效的（或 has_nulls == false），那么对于 p = *(iter + i)，p.first 包含位置 i 的元素值，且 p.second == true。

否则，如果i位置的元素为空，则p.first的值为未定义，且p.second == false。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:

  • cudf::logic_error – 如果 tparam has_nulls == true 并且 nullable() == false

  • cudf::logic_error – 如果列数据类型和元素类型不匹配。

Returns:

指向列的第一个元素的一对迭代器

template<typename T, bool has_nulls>
inline const_pair_rep_iterator<T, has_nulls> pair_rep_begin() const#

返回指向列的第一个元素的一对迭代器。

解引用返回的迭代器会返回一个 thrust::pair bool>，其中 rep_type 是 device_storage_type，用于在设备上存储值的类型。

如果位置 i 的元素是有效的（或 has_nulls == false），那么对于 p = *(iter + i)，p.first 包含位置 i 的元素值，且 p.second == true。

否则，如果i位置的元素为空，则p.first的值为未定义，且p.second == false。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:

  • cudf::logic_error – 如果 tparam has_nulls == true 并且 nullable() == false

  • cudf::logic_error – 如果列数据类型和元素类型不匹配。

Returns:

指向列的第一个元素的一对迭代器

template<typename T, typename Nullate>
inline auto optional_end(Nullate has_nulls) const#

返回一个可选的迭代器，指向列中最后一个元素之后的元素。

返回的迭代器表示一个cuda::std::optional元素。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:
Template Parameters:

  • T – 列中元素的类型

  • Nullate – 一种 cudf::nullate 类型，描述如何检查空值

Parameters:

has_nulls – 一个 cudf::nullate 类型，描述如何检查空值

Returns:

一个可选的迭代器，指向列中最后一个元素之后的元素

template<typename T, bool has_nulls>
inline const_pair_iterator<T, has_nulls> pair_end() const#

返回一个指向列中最后一个元素之后的元素的迭代器对。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:

  • cudf::logic_error – 如果 tparam has_nulls == true 并且 nullable() == false

  • cudf::logic_error – 如果列数据类型和元素类型不匹配。

Returns:

指向列中最后一个元素之后的元素的一对迭代器

template<typename T, bool has_nulls>
inline const_pair_rep_iterator<T, has_nulls> pair_rep_end() const#

返回一个指向列中最后一个元素之后的元素的迭代器对。

如果 column_device_view::has_element_accessor() 为假，则此函数不参与重载解析。

Throws:

  • cudf::logic_error – 如果 tparam has_nulls == true 并且 nullable() == false

  • cudf::logic_error – 如果列数据类型和元素类型不匹配。

Returns:

指向列中最后一个元素之后的元素的一对迭代器

void destroy()#

销毁 column_device_view 对象。

注意

不释放列数据，仅释放为保存子视图而分配的设备内存。

inline column_device_view child(size_type child_index) const noexcept#

返回指定的子项。

Parameters:

child_index – 所需子项的索引

Returns:

column_view 请求的子 column_view

inline device_span<column_device_view const> children() const noexcept#

返回包含此列子元素的span。

Returns:

包含此列子元素的 span

inline size_type num_child_columns() const noexcept#

返回子列的数量。

Returns:

子列的数量

公共静态函数

template<typename T>
static inline constexpr bool has_element_accessor()#

对于给定的 T，指示 column_device_view::element() 是否具有有效的重载。

Template Parameters:

T – 元素类型

Returns:

true 如果 column_device_view::element() 有一个有效的重载，false 否则

static std::unique_ptr<column_device_view, std::function<void(column_device_view*)>> create(column_view source_view, rmm::cuda_stream_view stream = cudf::get_default_stream())#

用于构建可在设备内存中使用的列视图的工厂。

分配并复制source_view的子视图到设备内存中，以便在设备代码中访问它们。

如果 source_view.num_children() == 0，则不会分配设备内存。

返回一个std::unique_ptr<column_device_view>，带有自定义删除器以释放为子项分配的设备内存。

应将 column_device_view 通过值传递给 GPU 内核。

Parameters:

  • source_view – 使 column_view 在设备代码中可用

  • stream – 用于子列设备内存操作的CUDA流。

Returns:

一个指向column_device_view的unique_ptr，使得来自source_view的数据在设备内存中可用。

static std::size_t extent(column_view const &source_view)#

返回保存指定列及其子列的设备视图所需内存的大小（以字节为单位）。

Parameters:

source_view – 用于此计算的 column_view。

Returns:

存储在GPU内存中的设备视图的字节数

class mutable_column_device_view : public cudf::detail::column_device_view_base#

一个可变的、非拥有的设备数据视图，作为一列元素，这些元素在CUDA设备代码中可轻松复制和使用。

公共类型

using count_it = thrust::counting_iterator<size_type>#

计数迭代器。

template<typename T>
using iterator = thrust::transform_iterator<detail::mutable_value_accessor<T>, count_it>#

用于导航此列的迭代器。

公共函数

mutable_column_device_view(mutable_column_device_view const&) = default#

复制构造函数。

mutable_column_device_view(mutable_column_device_view&&) = default#

移动构造函数。

mutable_column_device_view &operator=(mutable_column_device_view const&) = default#

复制赋值运算符。

Returns:

引用此对象

mutable_column_device_view &operator=(mutable_column_device_view&&) = default#

移动赋值运算符。

Returns:

对此对象的引用（在转移所有权后）

mutable_column_device_view(mutable_column_view column, void *h_ptr, void *d_ptr)#

使用指定的主机内存指针（h_ptr）来存储子对象，并使用设备内存指针（d_ptr）作为任何子对象指针的基础，创建此类的实例。

Parameters:

  • column – 从中创建此实例的列视图。

  • h_ptr – 用于放置任何子数据的主机内存指针。

  • d_ptr – 设备内存指针，用于基于此指针创建任何子指针。

template<typename T = void>
inline T *head() const noexcept#

返回指向基础设备内存分配的指针，并将其转换为指定类型。

此函数仅在 is_rep_layout_compatible() 或 std::is_same_v 为真时参与重载解析。

注意

如果 offset() == 0，那么 head() == data()

注意

很少需要访问列的head()分配，而应该通过data()来访问元素。

Template Parameters:

类型 – 要转换的类型

Returns:

指向基础数据的类型化指针

template<typename T>
inline T *data() const noexcept#

返回转换为指定类型的基础数据，加上偏移量。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。

注意

如果 offset() == 0，那么 head() == data()

Template Parameters:

T – 要转换的类型

Returns:

指向基础数据的类型化指针，包括偏移量

template<typename T>
inline T &element(size_type element_index) const noexcept#

返回指定索引处元素的引用。

此函数考虑了偏移量。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。对于is_rep_layout_compatible为false的类型T，可能存在此函数的特化。

Template Parameters:

T – 元素类型

Parameters:

element_index – 所需元素的位置

Returns:

引用指定索引处的元素

inline bitmask_type *null_mask() const noexcept#

返回指向底层位掩码分配的原始指针。

注意

此函数不考虑offset()。

注意

如果 null_count() == 0，这可能返回 nullptr。

Returns:

指向底层位掩码分配的原始指针

template<typename T>
inline iterator<T> begin()#

返回在基础数据转换为指定类型后的第一个元素（考虑偏移量）。

如果 mutable_column_device_view::has_element_accessor() 为 false，则此函数不参与重载解析。

Template Parameters:

T – 所需的类型

Returns:

指向转换后的第一个元素的指针

template<typename T>
inline iterator<T> end()#

在基础数据转换为指定类型后，返回最后一个元素之后的一个元素。

如果 mutable_column_device_view::has_element_accessor() 为 false，则此函数不参与重载解析。

Template Parameters:

T – 所需的类型

Returns:

指向转换后最后一个元素之后的一个元素

inline mutable_column_device_view child(size_type child_index) const noexcept#

返回指定的子项。

Parameters:

child_index – 所需子项的索引

Returns:

请求的子 column_view

inline void set_mask_word(size_type word_index, bitmask_type new_word) const noexcept#

使用新单词更新null_mask()中指定的位掩码单词。

注意

如果nullable() == false，调用此函数是未定义行为。

Parameters:

  • word_index – 要更新的单词的索引

  • new_word – 新的位掩码字

void destroy()#

销毁 mutable_column_device_view 对象。

注意

不释放列数据，仅释放为保存子视图而分配的设备内存。

公共静态函数

static std::unique_ptr<mutable_column_device_view, std::function<void(mutable_column_device_view*)>> create(mutable_column_view source_view, rmm::cuda_stream_view stream = cudf::get_default_stream())#

用于构建可在设备内存中使用的列视图的工厂。

分配并复制source_view的子视图到设备内存中，以便在设备代码中访问它们。

如果 source_view.num_children() == 0，则不会分配设备内存。

返回一个std::unique_ptr<mutable_column_device_view>，带有自定义删除器以释放为子项分配的设备内存。

应将 mutable_column_device_view 通过值传递给 GPU 内核。

Parameters:

  • source_view – 使 column_view 在设备代码中可用

  • stream – 用于子列设备内存操作的CUDA流。

Returns:

一个指向mutable_column_device_view的unique_ptr，使得来自source_view的数据在设备内存中可用。

template<typename T>
static inline constexpr bool has_element_accessor()#

对于给定的 T，指示 mutable_column_device_view::element() 是否具有有效的重载。

Returns:

true 如果 mutable_column_device_view::element() 有一个有效的重载，false

static std::size_t extent(mutable_column_view source_view)#

返回保存指定列及其子列的设备视图所需内存的大小（以字节为单位）。

Parameters:

source_view – 用于此计算的 column_view。

Returns:

保存指定列及其子列的设备视图所需的内存大小（以字节为单位）

class column_view : public cudf::detail::column_view_base#
#include <column_view.hpp>

设备数据的非拥有、不可变视图，作为一列元素，其中一些元素可能为空，由位掩码指示。

一个 column_view 可以从 cudf::column 隐式构造，也可以从指向预先存在的设备内存的指针显式构造。

除非另有说明，column_view 的数据和位掩码的内存布局应遵循 Arrow 物理内存布局规范：https://arrow.apache.org/docs/memory_layout.html

因为 column_view 是非拥有的，所以当 column_view 对象被创建或销毁时，不会分配或释放设备内存。

要启用零拷贝切片，column_view 有一个 offset，它表示列中第一个元素相对于基础设备内存分配的索引。默认情况下，offset() 为零。

由 cudf::dictionary_column_view, cudf::lists_column_view, cudf::strings_column_view, cudf::structs_column_view, cudf::tdigest::tdigest_column_view 子类化

公共函数

column_view(column_view const&) = default#

复制构造函数。

column_view(column_view&&) = default#

移动构造函数。

column_view &operator=(column_view const&) = default#

复制赋值运算符。

Returns:

引用此对象

column_view &operator=(column_view&&) = default#

移动赋值运算符。

Returns:

引用此对象

column_view(data_type type, size_type size, void const *data, bitmask_type const *null_mask, size_type null_count, size_type offset = 0, std::vector<column_view> const &children = {})#

从指向设备内存的指针为列的元素和位掩码构造一个column_view。

如果 null_count() 为零，null_mask 是可选的。

如果 type 是 EMPTY，指定的 null_count 将被忽略，并且 null_count() 将始终返回与 size() 相同的值

Throws:
Parameters:

  • type – 元素类型

  • size – 元素的数量

  • data – 指向包含列元素的设备内存的指针

  • null_mask – 指向设备内存的指针，包含空指示器位掩码

  • null_count – 空元素的数量。

  • offset – 可选的，第一个元素的索引

  • children – 可选的，根据元素类型，子列可能包含额外的数据

inline column_view child(size_type child_index) const noexcept#

返回指定的子项。

Parameters:

child_index – 所需子项的索引

Returns:

请求的子 column_view

inline size_type num_children() const noexcept#

返回子列的数量。

Returns:

子列的数量

inline auto child_begin() const noexcept#

返回指向子列视图有序序列开头的迭代器。

Returns:

一个迭代器，指向引用第一个子列的column_view

inline auto child_end() const noexcept#

返回指向子列视图有序序列末尾的迭代器。

Returns:

一个迭代器，指向column_view的子列末尾之后的位置

template<typename T>
inline column_view(device_span<T const> data)#

从 device_span 构造一个列视图。

仅支持数字和日期类型。

Template Parameters:

T – 设备跨度类型。必须是常量并且与列视图的类型匹配。

Parameters:

data – 一个包含列视图数据的类型化设备跨度。

template<typename T>
inline operator device_span<T const>() const#

将列视图转换为设备跨度。

仅支持数值和日期时间数据类型。列视图不能为空。

Template Parameters:

T – 设备跨度类型。必须是常量并且与列视图的类型匹配。

Throws:
Returns:

列视图数据的类型化设备跨度。

class mutable_column_view : public cudf::detail::column_view_base#
#include <column_view.hpp>

设备数据的非拥有、可变视图，作为一列元素，其中一些元素可能为空，由位掩码指示。

一个 mutable_column_view 可以从 cudf::column 隐式构造，也可以从指向预先存在的设备内存的指针显式构造。

除非另有说明，mutable_column_view的数据和位掩码的内存布局预计将遵循Arrow物理内存布局规范：https://arrow.apache.org/docs/memory_layout.html

因为 mutable_column_view 是非拥有的，所以在创建或销毁 mutable_column_view 对象时，不会分配或释放设备内存。

要启用零拷贝切片，mutable_column_view 有一个 offset，它表示列中第一个元素相对于基础设备内存分配的索引。默认情况下，offset() 为零。

公共函数

mutable_column_view(mutable_column_view const&) = default#

复制构造函数。

mutable_column_view(mutable_column_view&&) = default#

移动构造函数。

mutable_column_view &operator=(mutable_column_view const&) = default#

复制赋值运算符。

Returns:

引用此对象

mutable_column_view &operator=(mutable_column_view&&) = default#

移动赋值运算符。

Returns:

对此对象的引用（在转移所有权后）

mutable_column_view(data_type type, size_type size, void *data, bitmask_type *null_mask, size_type null_count, size_type offset = 0, std::vector<mutable_column_view> const &children = {})#

从指向设备内存的指针为列的元素和位掩码构造一个mutable_column_view。

如果 type 是 EMPTY，指定的 null_count 将被忽略，并且 null_count() 将始终返回与 size() 相同的值

Throws:
Parameters:

  • type – 元素类型

  • size – 元素的数量

  • data – 指向包含列元素的设备内存的指针

  • null_mask – 指向设备内存的指针，包含空指示器位掩码

  • null_count – 空元素的数量。

  • offset – 可选的，第一个元素的索引

  • children – 可选的，根据元素类型，子列可能包含额外的数据

template<typename T = void>
inline T *head() const noexcept#

返回指向基础设备内存分配的指针，并将其转换为指定类型。

此函数仅在 is_rep_layout_compatible() 或 std::is_same_v 为真时参与重载解析。

注意

如果 offset() == 0，那么 head() == data()

注意

很少需要访问列的head()分配，而应该通过data()来访问元素。

Template Parameters:

类型 – 要转换的类型

Returns:

指向基础数据的类型化指针

template<typename T>
inline T *data() const noexcept#

返回转换为指定类型的基础数据，加上偏移量。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。

注意

如果 offset() == 0，那么 head() == data()

Template Parameters:

T – 要转换的类型

Returns:

指向基础数据的类型化指针，包括偏移量

template<typename T>
inline T *begin() const noexcept#

返回在基础数据转换为指定类型后的第一个元素（考虑偏移量）。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。

Template Parameters:

T – 所需的类型

Returns:

指向转换后的第一个元素的指针

template<typename T>
inline T *end() const noexcept#

在基础数据转换为指定类型后，返回最后一个元素之后的一个元素。

如果is_rep_layout_compatible为false，则此函数不参与重载解析。

Template Parameters:

T – 所需的类型

Returns:

指向转换后最后一个元素之后的一个元素

inline bitmask_type *null_mask() const noexcept#

返回指向底层位掩码分配的原始指针。

注意

此函数不考虑offset()。

注意

如果 null_count() == 0，这可能返回 nullptr。

Returns:

指向底层位掩码分配的原始指针

void set_null_count(size_type new_null_count)#

设置空值计数。

Throws:

cudf::logic_error – 如果 new_null_count > 0 并且 nullable() == false

Parameters:

new_null_count – 新的空值计数

inline mutable_column_view child(size_type child_index) const noexcept#

返回对指定子项的引用。

Parameters:

child_index – 所需子项的索引

Returns:

请求的子项 mutable_column_view

inline size_type num_children() const noexcept#

返回子列的数量。

Returns:

子列的数量

inline auto child_begin() const noexcept#

返回指向子列视图有序序列开头的迭代器。

Returns:

一个迭代器，指向引用第一个子列的mutable_column_view

inline auto child_end() const noexcept#

返回指向子列视图有序序列末尾的迭代器。

Returns:

一个迭代器，指向mutable_column_view中最后一个子列之后的元素

operator column_view() const#

将可变视图转换为不可变视图。

Returns:

可变视图元素的不可变视图

目录：