column_factories.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cudf/column/column.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/memory_resource.hpp>
#include <cudf/utilities/span.hpp>
#include <cudf/utilities/traits.hpp>
 
#include <rmm/cuda_stream_view.hpp>
 
namespace CUDF_EXPORT cudf {
std::unique_ptr<column> make_empty_column(data_type type);
 
std::unique_ptr<column> make_empty_column(type_id id);
 
std::unique_ptr<column> make_numeric_column(
  data_type type,
  size_type size,
  mask_state state                  = mask_state::UNALLOCATED,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
template <typename B>
std::unique_ptr<column> make_numeric_column(
  data_type type,
  size_type size,
  B&& null_mask,
  size_type null_count,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())
{
  CUDF_EXPECTS(is_numeric(type), "Invalid, non-numeric type.");
  return std::make_unique<column>(type,
                                  size,
                                  rmm::device_buffer{size * cudf::size_of(type), stream, mr},
                                  std::forward<B>(null_mask),
                                  null_count);
}
 
std::unique_ptr<column> make_fixed_point_column(
  data_type type,
  size_type size,
  mask_state state                  = mask_state::UNALLOCATED,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
template <typename B>
std::unique_ptr<column> make_fixed_point_column(
  data_type type,
  size_type size,
  B&& null_mask,
  size_type null_count,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())
{
  CUDF_EXPECTS(is_fixed_point(type), "Invalid, non-fixed_point type.");
  return std::make_unique<column>(type,
                                  size,
                                  rmm::device_buffer{size * cudf::size_of(type), stream, mr},
                                  std::forward<B>(null_mask),
                                  null_count);
}
 
std::unique_ptr<column> make_timestamp_column(
  data_type type,
  size_type size,
  mask_state state                  = mask_state::UNALLOCATED,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
template <typename B>
std::unique_ptr<column> make_timestamp_column(
  data_type type,
  size_type size,
  B&& null_mask,
  size_type null_count,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())
{
  CUDF_EXPECTS(is_timestamp(type), "Invalid, non-timestamp type.");
  return std::make_unique<column>(type,
                                  size,
                                  rmm::device_buffer{size * cudf::size_of(type), stream, mr},
                                  std::forward<B>(null_mask),
                                  null_count);
}
 
std::unique_ptr<column> make_duration_column(
  data_type type,
  size_type size,
  mask_state state                  = mask_state::UNALLOCATED,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
template <typename B>
std::unique_ptr<column> make_duration_column(
  data_type type,
  size_type size,
  B&& null_mask,
  size_type null_count,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())
{
  CUDF_EXPECTS(is_duration(type), "Invalid, non-duration type.");
  return std::make_unique<column>(type,
                                  size,
                                  rmm::device_buffer{size * cudf::size_of(type), stream, mr},
                                  std::forward<B>(null_mask),
                                  null_count);
}
 
std::unique_ptr<column> make_fixed_width_column(
  data_type type,
  size_type size,
  mask_state state                  = mask_state::UNALLOCATED,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
template <typename B>
std::unique_ptr<column> make_fixed_width_column(
  data_type type,
  size_type size,
  B&& null_mask,
  size_type null_count,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())
{
  CUDF_EXPECTS(is_fixed_width(type), "Invalid, non-fixed-width type.");
  if (is_timestamp(type)) {
    return make_timestamp_column(type, size, std::forward<B>(null_mask), null_count, stream, mr);
  } else if (is_duration(type)) {
    return make_duration_column(type, size, std::forward<B>(null_mask), null_count, stream, mr);
  } else if (is_fixed_point(type)) {
    return make_fixed_point_column(type, size, std::forward<B>(null_mask), null_count, stream, mr);
  }
  return make_numeric_column(type, size, std::forward<B>(null_mask), null_count, stream, mr);
}
 
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::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::vector<std::unique_ptr<column>> make_strings_column_batch(
  std::vector<cudf::device_span<thrust::pair<char const*, size_type> const>> const& input,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> make_strings_column(
  cudf::device_span<string_view const> string_views,
  string_view const null_placeholder,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> make_strings_column(size_type num_strings,
                                            std::unique_ptr<column> offsets_column,
                                            rmm::device_buffer&& chars_buffer,
                                            size_type null_count,
                                            rmm::device_buffer&& null_mask);
 
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::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> make_empty_lists_column(
  data_type child_type,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
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::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<cudf::column> create_structs_hierarchy(
  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::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> make_column_from_scalar(
  scalar const& s,
  size_type size,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> make_dictionary_from_scalar(
  scalar const& s,
  size_type size,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
  // end of group
}  // namespace CUDF_EXPORT cudf