rolling.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <cudf/aggregation.hpp>
#include <cudf/rolling/range_window_bounds.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/export.hpp>
#include <cudf/utilities/memory_resource.hpp>
#include <cudf/utilities/span.hpp>
 
#include <rmm/resource_ref.hpp>
 
#include <memory>
#include <optional>
#include <variant>
 
namespace CUDF_EXPORT cudf {
struct bounded_closed {
  cudf::scalar const& delta_;  
 
  bounded_closed(cudf::scalar const& delta) : delta_{delta} {}
  [[nodiscard]] cudf::scalar const* delta() const noexcept { return &delta_; }
};
 
struct bounded_open {
  cudf::scalar const& delta_;  
 
  bounded_open(cudf::scalar const& delta) : delta_{delta} {}
 
  [[nodiscard]] cudf::scalar const* delta() const noexcept { return &delta_; }
};
 
struct unbounded {
  [[nodiscard]] constexpr cudf::scalar const* delta() const noexcept { return nullptr; }
};
struct current_row {
  [[nodiscard]] constexpr cudf::scalar const* delta() const noexcept { return nullptr; }
};
 
using range_window_type = std::variant<unbounded, current_row, bounded_closed, bounded_open>;
 
struct rolling_request {
  column_view values;     
  size_type min_periods;  
  std::unique_ptr<rolling_aggregation> aggregation;  
};
 
std::pair<std::unique_ptr<column>, std::unique_ptr<column>> make_range_windows(
  table_view const& group_keys,
  column_view const& orderby,
  order order,
  null_order null_order,
  range_window_type preceding,
  range_window_type following,
  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> rolling_window(
  column_view const& input,
  size_type preceding_window,
  size_type following_window,
  size_type min_periods,
  rolling_aggregation const& agg,
  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> rolling_window(
  column_view const& input,
  column_view const& default_outputs,
  size_type preceding_window,
  size_type following_window,
  size_type min_periods,
  rolling_aggregation const& agg,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
struct window_bounds {
 public:
  static window_bounds get(size_type value) { return window_bounds(false, value); }
 
  static window_bounds unbounded()
  {
    return window_bounds(true, std::numeric_limits<cudf::size_type>::max());
  }
 
  [[nodiscard]] bool is_unbounded() const { return _is_unbounded; }
 
  [[nodiscard]] size_type value() const { return _value; }
 
 private:
  explicit window_bounds(bool is_unbounded_, size_type value_ = 0)
    : _is_unbounded{is_unbounded_}, _value{value_}
  {
  }
 
  bool const _is_unbounded;  
  size_type const _value;    
};
 
std::unique_ptr<column> grouped_rolling_window(
  table_view const& group_keys,
  column_view const& input,
  size_type preceding_window,
  size_type following_window,
  size_type min_periods,
  rolling_aggregation const& aggr,
  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> grouped_rolling_window(
  table_view const& group_keys,
  column_view const& input,
  window_bounds preceding_window,
  window_bounds following_window,
  size_type min_periods,
  rolling_aggregation const& aggr,
  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> grouped_rolling_window(
  table_view const& group_keys,
  column_view const& input,
  column_view const& default_outputs,
  size_type preceding_window,
  size_type following_window,
  size_type min_periods,
  rolling_aggregation const& aggr,
  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> grouped_rolling_window(
  table_view const& group_keys,
  column_view const& input,
  column_view const& default_outputs,
  window_bounds preceding_window,
  window_bounds following_window,
  size_type min_periods,
  rolling_aggregation const& aggr,
  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> grouped_range_rolling_window(
  table_view const& group_keys,
  column_view const& orderby_column,
  cudf::order const& order,
  column_view const& input,
  range_window_bounds const& preceding,
  range_window_bounds const& following,
  size_type min_periods,
  rolling_aggregation const& aggr,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<table> grouped_range_rolling_window(
  table_view const& group_keys,
  column_view const& orderby,
  order order,
  null_order null_order,
  range_window_type preceding,
  range_window_type following,
  host_span<rolling_request const> requests,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
std::unique_ptr<table> grouped_range_rolling_window(
  table_view const& group_keys,
  table_view const& orderby,
  host_span<order const> orders,
  host_span<null_order const> null_orders,
  range_window_type preceding,
  range_window_type following,
  host_span<rolling_request const> requests,
  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> rolling_window(
  column_view const& input,
  column_view const& preceding_window,
  column_view const& following_window,
  size_type min_periods,
  rolling_aggregation const& agg,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
bool is_valid_rolling_aggregation(data_type source, aggregation::Kind kind);  // end of group
}  // namespace CUDF_EXPORT cudf