table.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2023, 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.hpp>
#include <cudf/table/table_view.hpp>
#include <cudf/utilities/default_stream.hpp>
 
#include <rmm/cuda_stream_view.hpp>
#include <rmm/mr/device/per_device_resource.hpp>
 
#include <memory>
#include <vector>
 
namespace cudf {
 
class table {
 public:
  table()                        = default;
  ~table()                       = default;
  table(table&&)                 = default;  
  table& operator=(table const&) = delete;
  table& operator=(table&&)      = delete;
 
  table(table const& other);
 
  table(std::vector<std::unique_ptr<column>>&& columns);
 
  table(table_view view,
        rmm::cuda_stream_view stream        = cudf::get_default_stream(),
        rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  [[nodiscard]] size_type num_columns() const noexcept { return _columns.size(); }
 
  [[nodiscard]] size_type num_rows() const noexcept { return _num_rows; }
 
  [[nodiscard]] table_view view() const;
 
  operator table_view() const { return this->view(); };
 
  mutable_table_view mutable_view();
 
  operator mutable_table_view() { return this->mutable_view(); };
 
  std::vector<std::unique_ptr<column>> release();
 
  template <typename InputIterator>
  table_view select(InputIterator begin, InputIterator end) const
  {
    std::vector<column_view> columns(std::distance(begin, end));
    std::transform(
      begin, end, columns.begin(), [this](auto index) { return _columns.at(index)->view(); });
    return table_view(columns);
  }
 
  [[nodiscard]] table_view select(std::vector<cudf::size_type> const& column_indices) const
  {
    return select(column_indices.begin(), column_indices.end());
  };
 
  column& get_column(cudf::size_type column_index) { return *(_columns.at(column_index)); }
 
  [[nodiscard]] column const& get_column(cudf::size_type i) const { return *(_columns.at(i)); }
 
 private:
  std::vector<std::unique_ptr<column>> _columns{};
  size_type _num_rows{};
};
 
}  // namespace cudf