column.hpp

Go to the documentation of this file.

/*
 * 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
 *
 *     http://www.apache.org/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 <rmm/cuda_stream_view.hpp>
#include <rmm/device_buffer.hpp>
#include <rmm/device_uvector.hpp>
#include <rmm/mr/device/per_device_resource.hpp>
#include <rmm/resource_ref.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 = rmm::mr::get_current_device_resource());
 
  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 = rmm::mr::get_current_device_resource());
 
  [[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