column.hpp

转到此文件的文档。

/*
 * Copyright (c) 2019-2024, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://apache.ac.cn/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once

#include <cudf/column/column_view.hpp>
#include <cudf/null_mask.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/memory_resource.hpp>

#include <rmm/cuda_stream_view.hpp>
#include <rmm/device_buffer.hpp>
#include <rmm/device_uvector.hpp>

#include <memory>
#include <type_traits>
#include <utility>
#include <vector>

namespace CUDF_EXPORT cudf {

class column {
 public
 column() = default;
 ~column() = default;
 column& operator=(column const& other) = delete;
 column& operator=(column&& other) = delete;

 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());

 column(column&& other) noexcept;

 template <typename T, CUDF_ENABLE_IF(cudf::is_numeric<T>() or cudf::is_chrono<T>())>
 column(rmm::device_uvector<T>&& other, rmm::device_buffer&& null_mask, size_type null_count)
 : _type{cudf::data_type{cudf::type_to_id<T>()}},
 _size{[&]() {
 CUDF_EXPECTS(
 other.size() <= static_cast<std::size_t>(std::numeric_limits<size_type>::max()),
 "The device_uvector size exceeds the column size limit",
 std::overflow_error);
 return static_cast<size_type>(other.size());
 }()},
 _data{other.release()},
 _null_mask{std::move(null_mask)},
 _null_count{null_count}
 {
 }

 template <typename B1, typename B2 = rmm::device_buffer>
 column(data_type dtype,
 size_type size,
 B1&& data,
 B2&& null_mask,
 size_type null_count,
 std::vector<std::unique_ptr<column>>&& children = {})
 : _type{dtype},
 _size{size},
 _data{std::forward<B1>(data)},
 _null_mask{std::forward<B2>(null_mask)},
 _null_count{null_count},
 _children{std::move(children)}
 {
 CUDF_EXPECTS(size >= 0, "Column size cannot be negative.");
 }

 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());

 [[nodiscard]] data_type type() const noexcept { return _type; }

 [[nodiscard]] size_type size() const noexcept { return _size; }

 [[nodiscard]] size_type null_count() const { return _null_count; }

 void set_null_mask(rmm::device_buffer&& new_null_mask, size_type 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());

 void set_null_count(size_type new_null_count);

 [[nodiscard]] bool nullable() const noexcept { return (_null_mask.size() > 0); }

 [[nodiscard]] bool has_nulls() const noexcept { return (null_count() > 0); }

 [[nodiscard]] size_type num_children() const noexcept { return _children.size(); }

 column& child(size_type child_index) noexcept { return *_children[child_index]; };

 [[nodiscard]] column const& child(size_type child_index) const noexcept
 {
 return *_children[child_index];
 };

 struct contents {
 std::unique_ptr<rmm::device_buffer> data;
 std::unique_ptr<rmm::device_buffer> null_mask;
 std::vector<std::unique_ptr<column>> children;
 };

 contents release() noexcept;

 [[nodiscard]] column_view view() const;

 operator column_view() const { return this->view(); };

 mutable_column_view mutable_view();

 operator mutable_column_view() { return this->mutable_view(); };

 private
 cudf::data_type _type{type_id::EMPTY};
 cudf::size_type _size{};
 rmm::device_buffer _data{};
 rmm::device_buffer _null_mask{};
 mutable cudf::size_type _null_count{};
 std::vector<std::unique_ptr<column>> _children{};
};
 // end of group
} // namespace CUDF_EXPORT cudf