column_factories.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.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>
 
#include <thrust/pair.h>
 
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::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<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<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