SqlType.hpp

Go to the documentation of this file.

 
#ifndef TABLEAU_HYPER_SQLTYPE_HPP
#define TABLEAU_HYPER_SQLTYPE_HPP
 
#include <hyperapi/impl/infra.hpp>
#include <string>
#include <hyperapi/hyperapi.h>
 
namespace hyperapi {
 
static CONSTEXPR_OPTIONAL optional<internal::AnyType> null = {};
 
enum class TypeTag : int {
   Unsupported = HYPER_UNSUPPORTED,
   Bool = HYPER_BOOL,
   BigInt = HYPER_BIG_INT,
   SmallInt = HYPER_SMALL_INT,
   Int = HYPER_INT,
   Numeric = HYPER_NUMERIC,
   Float = HYPER_FLOAT,
   Double = HYPER_DOUBLE,
   Oid = HYPER_OID,
   Bytes = HYPER_BYTE_A,
   Text = HYPER_TEXT,
   Varchar = HYPER_VARCHAR,
   Char = HYPER_CHAR,
   Json = HYPER_JSON,
   Date = HYPER_DATE,
   Interval = HYPER_INTERVAL,
   Time = HYPER_TIME,
   Timestamp = HYPER_TIMESTAMP,
   TimestampTZ = HYPER_TIMESTAMP_TZ,
   TabGeography = HYPER_TABGEOGRAPHY,
   // Deprecated alias for `TabGeography`. Will be removed as part of W-17701666.
   Geography = HYPER_GEOGRAPHY
};
 
class SqlType final {
   public:
   SqlType(TypeTag tag, uint32_t oid, hyper_type_modifier_t modifier = HYPER_UNUSED_MODIFIER) noexcept
      : tag_(tag), internalOid_(oid), modifier_(modifier) {
   }
 
   TypeTag getTag() const noexcept { return tag_; }
 
   uint32_t getInternalOid() const noexcept { return internalOid_; }
 
   uint32_t getInternalTypeModifier() const noexcept { return modifier_; }
 
   uint32_t getPrecision() const noexcept;
 
   uint32_t getScale() const noexcept;
 
   uint32_t getMaxLength() const noexcept;
 
   std::string toString() const;
 
   static SqlType boolean() noexcept { return {TypeTag::Bool, HYPER_OID_BOOL}; }
   static SqlType bigInt() noexcept { return {TypeTag::BigInt, HYPER_OID_BIG_INT}; }
   static SqlType smallInt() noexcept { return {TypeTag::SmallInt, HYPER_OID_SMALL_INT}; }
   static SqlType integer() noexcept { return {TypeTag::Int, HYPER_OID_INT}; }
   static SqlType numeric(uint16_t precision, uint16_t scale) noexcept { return {TypeTag::Numeric, HYPER_OID_NUMERIC, hyper_encode_numeric_modifier(precision, scale)}; }
   static SqlType real() noexcept { return {TypeTag::Float, HYPER_OID_FLOAT}; }
   static SqlType doublePrecision() noexcept { return {TypeTag::Double, HYPER_OID_DOUBLE}; }
   static SqlType oid() noexcept { return {TypeTag::Oid, HYPER_OID_OID}; }
   static SqlType bytes() noexcept { return {TypeTag::Bytes, HYPER_OID_BYTE_A}; }
   static SqlType text() noexcept { return {TypeTag::Text, HYPER_OID_TEXT}; }
   static SqlType varchar(uint32_t maxLength) noexcept { return {TypeTag::Varchar, HYPER_OID_VARCHAR, hyper_encode_string_modifier(maxLength)}; }
   static SqlType character(uint32_t maxLength) noexcept { return {TypeTag::Char, static_cast<uint32_t>((maxLength == 1) ? HYPER_OID_CHAR1 : HYPER_OID_CHAR), hyper_encode_string_modifier(maxLength)}; }
   static SqlType json() noexcept { return {TypeTag::Json, HYPER_OID_JSON}; }
   static SqlType date() noexcept { return {TypeTag::Date, HYPER_OID_DATE}; }
   static SqlType interval() noexcept { return {TypeTag::Interval, HYPER_OID_INTERVAL}; }
   static SqlType time() noexcept { return {TypeTag::Time, HYPER_OID_TIME}; }
   static SqlType timestamp() noexcept { return {TypeTag::Timestamp, HYPER_OID_TIMESTAMP}; }
   static SqlType timestampTZ() noexcept { return {TypeTag::TimestampTZ, HYPER_OID_TIMESTAMP_TZ}; }
   static SqlType tabgeography() noexcept { return {TypeTag::TabGeography, HYPER_OID_TABGEOGRAPHY}; }
   static SqlType geography() noexcept { return {TypeTag::Geography, HYPER_OID_GEOGRAPHY}; }
 
   friend bool operator==(const SqlType& a, const SqlType& b) noexcept;
   friend bool operator>(const SqlType& a, const SqlType& b) noexcept;
   friend bool operator!=(const SqlType& a, const SqlType& b) noexcept;
   friend bool operator<(const SqlType& a, const SqlType& b) noexcept;
   friend bool operator<=(const SqlType& a, const SqlType& b) noexcept;
   friend bool operator>=(const SqlType& a, const SqlType& b) noexcept;
   friend std::ostream& operator<<(std::ostream& os, const SqlType& obj);
 
   private:
   TypeTag tag_;
   uint32_t internalOid_;
   hyper_type_modifier_t modifier_;
 
   friend class internal::HyperTableDefinition;
   friend struct std::hash<hyperapi::SqlType>;
};
}
 
namespace std {
 
template <>
struct hash<hyperapi::SqlType> {
   size_t operator()(const hyperapi::SqlType& type) const noexcept { return (static_cast<size_t>(type.tag_) << 32) | type.modifier_; }
};
}
 
#include <hyperapi/impl/SqlType.impl.hpp>
 
#endif