aggregation.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021, 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/types.hpp>
 
#include <functional>
#include <memory>
#include <vector>
 
namespace cudf {
// forward declaration
namespace detail {
class aggregation_finalizer;
}  // namespace detail
class aggregation {
 public:
  enum Kind {
    SUM,             
    PRODUCT,         
    MIN,             
    MAX,             
    COUNT_VALID,     
    COUNT_ALL,       
    ANY,             
    ALL,             
    SUM_OF_SQUARES,  
    MEAN,            
    VARIANCE,        
    STD,             
    MEDIAN,          
    QUANTILE,        
    ARGMAX,          
    ARGMIN,          
    NUNIQUE,         
    NTH_ELEMENT,     
    ROW_NUMBER,      
    COLLECT_LIST,    
    COLLECT_SET,     
    LEAD,            
    LAG,             
    PTX,             
    CUDA 
  };
 
  aggregation(aggregation::Kind a) : kind{a} {}
  Kind kind;  
 
  virtual bool is_equal(aggregation const& other) const { return kind == other.kind; }
 
  virtual size_t do_hash() const { return std::hash<int>{}(kind); }
 
  virtual std::unique_ptr<aggregation> clone() const
 {
    return std::make_unique<aggregation>(*this);
  }
 
  virtual ~aggregation() = default;
 
  // override functions for compound aggregations
  virtual std::vector<aggregation::Kind> get_simple_aggregations(data_type col_type) const;
  virtual void finalize(cudf::detail::aggregation_finalizer& finalizer);
};
 
enum class udf_type : bool { CUDA, PTX };
 
std::unique_ptr<aggregation> make_sum_aggregation();
 
std::unique_ptr<aggregation> make_product_aggregation();
 
std::unique_ptr<aggregation> make_min_aggregation();
 
std::unique_ptr<aggregation> make_max_aggregation();
 
std::unique_ptr<aggregation> make_count_aggregation(
  null_policy null_handling = null_policy::EXCLUDE);
 
std::unique_ptr<aggregation> make_any_aggregation();
 
std::unique_ptr<aggregation> make_all_aggregation();
 
std::unique_ptr<aggregation> make_sum_of_squares_aggregation();
 
std::unique_ptr<aggregation> make_mean_aggregation();
 
std::unique_ptr<aggregation> make_variance_aggregation(size_type ddof = 1);
 
std::unique_ptr<aggregation> make_std_aggregation(size_type ddof = 1);
 
std::unique_ptr<aggregation> make_median_aggregation();
 
std::unique_ptr<aggregation> make_quantile_aggregation(std::vector<double> const& q,
                                                       interpolation i = interpolation::LINEAR);
 
std::unique_ptr<aggregation> make_argmax_aggregation();
 
std::unique_ptr<aggregation> make_argmin_aggregation();
 
std::unique_ptr<aggregation> make_nunique_aggregation(
  null_policy null_handling = null_policy::EXCLUDE);
 
std::unique_ptr<aggregation> make_nth_element_aggregation(
  size_type n, null_policy null_handling = null_policy::INCLUDE);
 
std::unique_ptr<aggregation> make_row_number_aggregation();
 
std::unique_ptr<aggregation> make_collect_list_aggregation(
  null_policy null_handling = null_policy::INCLUDE);
 
std::unique_ptr<aggregation> make_collect_set_aggregation(
  null_policy null_handling = null_policy::INCLUDE,
  null_equality nulls_equal = null_equality::EQUAL,
  nan_equality nans_equal   = nan_equality::UNEQUAL);
 
std::unique_ptr<aggregation> make_lag_aggregation(size_type offset);
 
std::unique_ptr<aggregation> make_lead_aggregation(size_type offset);
 
std::unique_ptr<aggregation> make_udf_aggregation(udf_type type,
                                                  std::string const& user_defined_aggregator,
                                                  data_type output_type);
  // end of group
}  // namespace cudf