types.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2018-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#ifdef __CUDACC__
#define CUDF_HOST_DEVICE __host__ __device__
#define CUDF_KERNEL __global__ static
#else
#define CUDF_HOST_DEVICE
#define CUDF_KERNEL static
#endif
 
#include <cudf/utilities/export.hpp>
 
#include <cuda/std/iterator>
 
#include <cassert>
#include <cstddef>
#include <cstdint>
 
// Forward declarations
namespace rmm {
class device_buffer;
 
}  // namespace rmm
 
namespace CUDF_EXPORT cudf {
// Forward declaration
class column;
class column_view;
class mutable_column_view;
class string_view;
class list_view;
class struct_view;
class scalar;
 
// clang-format off
class list_scalar;
class struct_scalar;
class string_scalar;
template <typename T> class numeric_scalar;
template <typename T> class fixed_point_scalar;
template <typename T> class timestamp_scalar;
template <typename T> class duration_scalar;
 
class string_scalar_device_view;
template <typename T> class numeric_scalar_device_view;
template <typename T> class fixed_point_scalar_device_view;
template <typename T> class timestamp_scalar_device_view;
template <typename T> class duration_scalar_device_view;
// clang-format on
 
class table;
class table_view;
class mutable_table_view;
 
using size_type         = int32_t;   
using bitmask_type      = uint32_t;  
using valid_type        = uint8_t;   
using thread_index_type = int64_t;   
using char_utf8         = uint32_t;  
 
template <typename T>
size_type distance(T f, T l)
{
  return static_cast<size_type>(cuda::std::distance(f, l));
}
 
enum class order : bool {
  ASCENDING,  
  DESCENDING  
};
 
enum class null_policy : bool {
  EXCLUDE,  
  INCLUDE   
};
 
enum class nan_policy : bool {
  NAN_IS_NULL,  
  NAN_IS_VALID  
};
 
enum class nan_equality /*unspecified*/ {
  ALL_EQUAL,  
  UNEQUAL     
};
 
enum class null_equality : bool {
  EQUAL,   
  UNEQUAL  
};
 
enum class null_order : bool {
  AFTER,  
  BEFORE  
};
 
enum class sorted : bool { NO, YES };
 
struct order_info {
  sorted is_sorted;          
  order ordering;            
  null_order null_ordering;  
};
 
enum class mask_state : int32_t {
  UNALLOCATED,    
  UNINITIALIZED,  
  ALL_VALID,      
  ALL_NULL        
};
 
enum class interpolation : int32_t {
  LINEAR,    
  LOWER,     
  HIGHER,    
  MIDPOINT,  
  NEAREST    
};
 
enum class type_id : int32_t {
  EMPTY,                   
  INT8,                    
  INT16,                   
  INT32,                   
  INT64,                   
  UINT8,                   
  UINT16,                  
  UINT32,                  
  UINT64,                  
  FLOAT32,                 
  FLOAT64,                 
  BOOL8,                   
  TIMESTAMP_DAYS,          
  TIMESTAMP_SECONDS,       
  TIMESTAMP_MILLISECONDS,  
  TIMESTAMP_MICROSECONDS,  
  TIMESTAMP_NANOSECONDS,   
  DURATION_DAYS,           
  DURATION_SECONDS,        
  DURATION_MILLISECONDS,   
  DURATION_MICROSECONDS,   
  DURATION_NANOSECONDS,    
  DICTIONARY32,            
  STRING,                  
  LIST,                    
  DECIMAL32,               
  DECIMAL64,               
  DECIMAL128,              
  STRUCT,                  
  // `NUM_TYPE_IDS` must be last!
  NUM_TYPE_IDS  
};
 
enum class null_aware : bool {
  NO  = 0,  
  YES = 1   
};
 
enum class output_nullability : uint8_t {
  PRESERVE  = 0,  
  ALL_VALID = 1   
};
 
enum class udf_source_type : uint8_t {
  CUDA = 0,  
  PTX  = 1   
};
 
class data_type {
 public:
  data_type()                 = default;
  ~data_type()                = default;
  data_type(data_type const&) = default;  
  data_type(data_type&&)      = default;  
 
  data_type& operator=(data_type const&) = default;
 
  data_type& operator=(data_type&&) = default;
 
  CUDF_HOST_DEVICE explicit constexpr data_type(type_id id) : _id{id} {}
 
  explicit data_type(type_id id, int32_t scale) : _id{id}, _fixed_point_scale{scale}
  {
    assert(id == type_id::DECIMAL32 || id == type_id::DECIMAL64 || id == type_id::DECIMAL128);
  }
 
  [[nodiscard]] CUDF_HOST_DEVICE constexpr type_id id() const noexcept { return _id; }
 
  [[nodiscard]] CUDF_HOST_DEVICE constexpr int32_t scale() const noexcept
  {
    return _fixed_point_scale;
  }
 
 private:
  type_id _id{type_id::EMPTY};
 
  // Below is additional type specific metadata. Currently, only _fixed_point_scale is stored.
 
  int32_t _fixed_point_scale{};  // numeric::scale_type not available here, use int32_t
};
 
constexpr bool operator==(data_type const& lhs, data_type const& rhs)
{
  // use std::tie in the future, breaks NVRTC currently
  return lhs.id() == rhs.id() && lhs.scale() == rhs.scale();
}
 
inline bool operator!=(data_type const& lhs, data_type const& rhs) { return !(lhs == rhs); }
 
std::size_t size_of(data_type t);
 
}  // namespace CUDF_EXPORT cudf