transform.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <cudf/ast/expressions.hpp>
#include <cudf/column/scalar_column_view.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/export.hpp>
#include <cudf/utilities/memory_resource.hpp>
 
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <variant>
#include <vector>
 
namespace CUDF_EXPORT cudf {
 
using transform_input = std::variant<column_view, scalar_column_view>;
 
struct transform_output {
  data_type type = data_type{type_id::EMPTY};  
 
  output_nullability nullability =
    output_nullability::PRESERVE;  
};
 
[[deprecated("Use transform instead")]] std::unique_ptr<column> transform_extended(
  std::span<transform_input const> inputs,
  std::string const& udf,
  data_type output_type,
  udf_source_type source_type,
  std::optional<void*> user_data    = std::nullopt,
  null_aware is_null_aware          = null_aware::NO,
  std::optional<size_type> row_size = std::nullopt,
  output_nullability null_policy    = output_nullability::PRESERVE,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
struct transform_input_spec {
  type_id type = type_id::EMPTY;  
 
  bool is_scalar = false;  
 
  std::vector<transform_input_spec> children =
    {};  
};
 
struct transform_output_spec {
  type_id type = type_id::EMPTY;  
 
  output_nullability nullability =
    output_nullability::PRESERVE;  
 
  bool has_string_offsets = false;  
  std::vector<transform_output_spec> children =
    {};  
};
 
struct transform_program {
 private:
  struct impl;
 
  std::unique_ptr<impl> impl_;  
 
 public:
  transform_program(std::string const& udf,
                    udf_source_type source_type,
                    null_aware is_null_aware,
                    std::optional<void*> user_data,
                    std::span<transform_input const> inputs,
                    std::span<transform_output const> outputs,
                    std::span<std::unique_ptr<column> const> string_offsets);
 
  transform_program(std::string const& udf,
                    udf_source_type source_type,
                    null_aware is_null_aware,
                    std::optional<void*> user_data,
                    std::span<transform_input_spec const> inputs,
                    std::span<transform_output_spec const> outputs);
 
  transform_program(table_view const& table,
                    std::span<std::reference_wrapper<ast::expression const> const> expressions,
                    cuda::stream_ref stream           = cudf::get_default_stream(),
                    rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
  transform_program(transform_program&& other);
 
  transform_program& operator=(transform_program&& other);
 
  transform_program(transform_program const&)            = delete;  
  transform_program& operator=(transform_program const&) = delete;  
  ~transform_program();                                             
 
  std::unique_ptr<table> run(
    std::span<transform_input const> inputs,
    std::span<transform_output const> outputs,
    std::vector<std::unique_ptr<column>>&& string_offsets,
    std::optional<size_type> row_size,
    cuda::stream_ref stream           = cudf::get_default_stream(),
    rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
  std::unique_ptr<table> run(
    table_view const& table,
    cuda::stream_ref stream           = cudf::get_default_stream(),
    rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
};
 
std::unique_ptr<table> transform(
  std::string const& udf,
  udf_source_type source_type,
  null_aware is_null_aware,
  std::optional<void*> user_data,
  std::span<transform_input const> inputs,
  std::span<transform_output const> outputs,
  std::vector<std::unique_ptr<column>>&& string_offsets,
  std::optional<size_type> row_size,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
[[deprecated("Use transform instead")]] std::unique_ptr<table> multi_transform(
  std::string const& udf,
  udf_source_type source_type,
  null_aware is_null_aware,
  std::optional<void*> user_data,
  std::span<transform_input const> inputs,
  std::span<transform_output const> outputs,
  std::vector<std::unique_ptr<column>>&& string_offsets,
  std::optional<size_type> row_size,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
enum class lto_binary_type : uint8_t {
  LTO_IR,  //< LTO-IR binary
  FATBIN   //< FATBIN binary
};
 
std::unique_ptr<table> transform_lto(
  std::span<uint8_t const> udf,
  lto_binary_type binary_type,
  null_aware is_null_aware,
  std::optional<void*> user_data,
  std::span<transform_input const> inputs,
  std::span<transform_output const> outputs,
  std::vector<std::unique_ptr<column>>&& string_offsets,
  std::optional<size_type> row_size,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
[[deprecated]] std::pair<std::unique_ptr<rmm::device_buffer>, size_type> nans_to_nulls(
  column_view const& input,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> column_nans_to_nulls(
  column_view const& input,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> compute_column(
  table_view const& table,
  ast::expression const& expr,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> compute_column_jit(
  table_view const& table,
  ast::expression const& expr,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<table> compute_table_jit(
  table_view const& table,
  std::span<std::reference_wrapper<ast::expression const> const> expressions,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::pair<std::unique_ptr<rmm::device_buffer>, cudf::size_type> bools_to_mask(
  column_view const& input,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::pair<std::unique_ptr<cudf::table>, std::unique_ptr<cudf::column>> encode(
  cudf::table_view const& input,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::pair<std::unique_ptr<column>, table_view> one_hot_encode(
  column_view const& input,
  column_view const& categories,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> mask_to_bools(
  bitmask_type const* bitmask,
  size_type begin_bit,
  size_type end_bit,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> row_bit_count(
  table_view const& t,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<column> segmented_row_bit_count(
  table_view const& t,
  size_type segment_length,
  cuda::stream_ref stream           = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
  // end of group
}  // namespace CUDF_EXPORT cudf