types.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2023, 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
 
#ifdef __CUDACC__
#define CUDF_HOST_DEVICE __host__ __device__
#else
#define CUDF_HOST_DEVICE
#endif
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
 
// Forward declarations
namespace rmm {
class device_buffer;
 
}  // namespace rmm
 
namespace 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;   
 
template <typename T>
size_type distance(T f, T l)
{
  return static_cast<size_type>(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  
};
 
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;
 
  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]] constexpr type_id id() const noexcept { return _id; }
 
  [[nodiscard]] 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 JITIFY 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