pg_types.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/postgres/io/pg_types.hpp
/// @brief Postgres-specific types I/O support
 
#include <cstdint>
#include <string>
#include <string_view>
 
#include <userver/storages/postgres/detail/db_data_type_name.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres {
 
/// PostgreSQL Oid type.
// Aliased to unsigned int to match the type used in libpq.
using Oid = unsigned int;
inline constexpr Oid kInvalidOid = 0;
 
//@{
/** @name Type aliases for integral types */
using Smallint = std::int16_t;
using Integer = std::int32_t;
using Bigint = std::int64_t;
//@}
 
//@{
using Float4 = float;
using Float8 = double;
//@}
 
/// @brief Identity for a PostgreSQL type name
struct DBTypeName {
    const std::string_view schema;
    const std::string_view name;
 
    constexpr DBTypeName() : schema{}, name{} {}
    explicit constexpr DBTypeName(std::pair<std::string_view, std::string_view> n) : schema(n.first), name(n.second) {}
    /// Implicit constructor from a string literal, to enable declarations like
    /// @code
    /// DBTypeName my_type = "my_schema.my_type";
    /// @endcode
    /* implicit */ constexpr DBTypeName(const char* name) : DBTypeName(utils::ParseDBName(name)) {}
    constexpr DBTypeName(std::string_view s, std::string_view n) : schema(s), name(n) {}
 
    bool operator==(const DBTypeName& rhs) const { return name == rhs.name && schema == rhs.schema; }
    bool operator<(const DBTypeName& rhs) const {
        auto schema_cmp = schema.compare(rhs.schema);
        if (schema_cmp < 0) {
            return true;
        } else if (schema_cmp == 0) {
            return name < rhs.name;
        }
        return false;
    }
 
    bool Empty() const { return name.empty(); }
    std::size_t GetHash() const;
    std::string ToString() const;
};
struct DBTypeName {…};
 
/// @brief Description of a PostgreSQL type.
/// The structure is selected from the pg_catalog.pg_type table (not all, only
/// appropriate fields).
/// See https://www.postgresql.org/docs/12/catalog-pg-type.html
struct DBTypeDescription {
    enum class TypeClass : char {
        kUnknown = 'X',
        kBase = 'b',
        kComposite = 'c',
        kDomain = 'd',
        kEnum = 'e',
        kPseudo = 'p',
        kRange = 'r'
    };
    /// @brief PosgtreSQL type category.
    /// See
    /// https://www.postgresql.org/docs/12/catalog-pg-type.html#CATALOG-TYPCATEGORY-TABLE
    enum class TypeCategory : char {
        kInvalid = 0,        //!< Invalid type category
        kArray = 'A',        //!< https://www.postgresql.org/docs/12/arrays.html
        kBoolean = 'B',      //!< https://www.postgresql.org/docs/12/datatype-boolean.html
        kComposite = 'C',    //!< https://www.postgresql.org/docs/12/rowtypes.html
        kDatetime = 'D',     //!< https://www.postgresql.org/docs/12/datatype-datetime.html
        kEnumeration = 'E',  //!< https://www.postgresql.org/docs/12/datatype-enum.html
        kGeometric = 'G',    //!< https://www.postgresql.org/docs/12/datatype-geometric.html
        kNetwork = 'I',      //!< https://www.postgresql.org/docs/12/datatype-net-types.html
        kNumeric = 'N',      //!< https://www.postgresql.org/docs/12/datatype-numeric.html
        kPseudotype = 'P',   //!< https://www.postgresql.org/docs/12/datatype-pseudo.html
        kRange = 'R',        //!< https://www.postgresql.org/docs/12/rangetypes.html
        kString = 'S',       //!< https://www.postgresql.org/docs/12/datatype-character.html
        kTimespan = 'T',     //!< https://www.postgresql.org/docs/12/datatype-datetime.html
        kUser = 'U',         //!< User types, created by fourth form of create type
                             /// statement
                             /// https://www.postgresql.org/docs/12/sql-createtype.html
        kBitstring = 'V',    //!< https://www.postgresql.org/docs/12/datatype-bit.html
        kUnknown = 'X'       //!< Unknown type category
    };
    enum class TypeCategory : char {…};
 
    /// pg_type.oid
    Oid oid{kInvalidOid};
    /// pg_namespace.nspname
    std::string schema;
    /// pg_type.typname
    std::string name;
    /// pg_type.typlen
    Integer length{0};
    /// pg_type.typtype
    TypeClass type_class{TypeClass::kUnknown};
    /// pg_type.typcategory
    TypeCategory category{TypeCategory::kInvalid};
    /// pg_type.typrelid
    Oid relation_id{kInvalidOid};
    /// pg_type.typelem
    /// If not zero, this type is an array
    Oid element_type{kInvalidOid};
    /// pg_type.typarray
    Oid array_type{kInvalidOid};
    /// pg_type.typbasetype
    /// Base type for domains
    Oid base_type{kInvalidOid};
    /// pg_type.typnotnull
    /// Used only with domains
    bool not_null{false};
    // TODO rest of domain fields. or eliminate them if they are not needed
 
    DBTypeName GetName() const { return {schema.c_str(), name.c_str()}; }
    std::size_t GetNameHash() const;
 
    struct NameHash {
        std::size_t operator()(const DBTypeDescription& type) const { return type.GetNameHash(); }
    };
    struct NameHash {…};
    struct NamesEqual {
        bool operator()(const DBTypeDescription& lhs, const DBTypeDescription& rhs) const {
            return lhs.name == rhs.name && lhs.schema == rhs.schema;
        }
    };
    struct NamesEqual {…};
    struct TypeCategoryHash {
        using IntegralType = std::underlying_type_t<TypeCategory>;
        auto operator()(TypeCategory val) const { return std::hash<IntegralType>{}(static_cast<IntegralType>(val)); }
    };
    struct TypeCategoryHash {…};
};
struct DBTypeDescription {…};
 
/// Description of a field in a user-defined composite type, for type checking
struct CompositeFieldDef {
    Oid owner{kInvalidOid};
    std::string name;
    Oid type{kInvalidOid};
 
    static CompositeFieldDef EmptyDef() { return {kInvalidOid, {}, kInvalidOid}; }
};
struct CompositeFieldDef {…};
 
std::string ToString(DBTypeDescription::TypeClass);
 
namespace io {
/// Oids are predefined for postgres fundamental types
/// Constants can be found here
/// https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
/// Oid values can also be retrieved from PostgreSQL instance by running query
/// @code
/// select t.oid as "Oid", pg_catalog.format_type(t.oid, null) as "Name"
/// from pg_catalog.pg_type t
///     left join pg_catalog.pg_namespace n on n.oid = t.typnamespace
/// where (t.typrelid = 0 or (select c.relkind = 'c' from pg_catalog.pg_class c
/// where c.oid = t.typrelid))
///   and not exists(select 1 from pg_catalog.pg_type el where el.oid =
///   t.typelem and el.typarray = t.oid) and n.nspname = 'pg_catalog'
/// order by 1, 2
/// @endcode
enum class PredefinedOids {
    kInvalid = kInvalidOid,
    kBoolean = 16,
    kBytea = 17,
    kChar = 18,
    kName = 19,
    kInt8 = 20,
    kInt2 = 21,
    kInt2Vector = 22,
    kInt4 = 23,
    kRegproc = 24,
    kText = 25,
    kOid = 26,
    kTid = 27,
    kXid = 28,
    kCid = 29,
    kOidVector = 30,
    kJson = 114,
    kJsonArray = 199,  // Not in documentation
    kXml = 142,
    kPgNodeTree = 194,
    kPgDdlCommand = 32,
    kPoint = 600,
    kLseg = 601,
    kPath = 602,
    kBox = 603,
    kPolygon = 604,
    kLine = 628,
    kLineArray = 629,
    kFloat4 = 700,
    kFloat8 = 701,
    kAbstime = 702,
    kReltime = 703,
    kTinterval = 704,
    kUnknown = 705,
    kCircle = 718,
    kCircleArray = 719,  // Not in documentation
    kCash = 790,
    kMacaddr = 829,
    kMacaddrArray = 1040,
    kMacaddr8 = 774,
    kMacaddr8Array = 775,
    kInet = 869,
    kInetArray = 1041,
    kCidr = 650,
    kCidrArray = 651,
    kBooleanArray = 1000,  // Not in documentation
    kByteaArray = 1001,    // Not in documentation
    kCharArray = 1002,     // Not in documentation
    kNameArray = 1003,     // Not in documentation
    kInt2Array = 1005,
    kInt4Array = 1007,
    kTextArray = 1009,
    kTidArray = 1010,      // Not in documentation
    kXidArray = 1011,      // Not in documentation
    kCidArray = 1012,      // Not in documentation
    kBphcarArray = 1014,   // Not in documentation
    kVarcharArray = 1015,  // Not in documentation
    kInt8Array = 1016,     // Not in documentation
    kPointArray = 1017,    // Not in documentation
    kLsegArray = 1018,     // Not in documentation
    kPathArray = 1019,     // Not in documentation
    kBoxArray = 1020,      // Not in documentation
    kFloat4Array = 1021,
    kFloat8Array = 1022,   // Not in documentation
    kPolygonArray = 1027,  // Not in documentation
    kOidArray = 1028,
    kAclItem = 1033,
    kCstringArray = 1263,
    kBpchar = 1042,
    kVarchar = 1043,
    kDate = 1082,
    kTime = 1083,
    kDateArray = 1182,  // Not in documentation
    kTimeArray = 1183,  // Not in documentation
    kTimestamp = 1114,
    kTimestampArray = 1115,  // Not in documentation
    kTimestamptz = 1184,
    kTimestamptzArray = 1185,  // Not in documentation
    kInterval = 1186,
    kIntervalArray = 1187,  // Not in documentation
    kNumericArray = 1231,   // Not in documentation
    kTimetz = 1266,
    kBit = 1560,
    kBitArray = 1561,
    kVarbit = 1562,
    kVarbitArray = 1563,
    kNumeric = 1700,
    kRefcursor = 1790,
    kRegprocedure = 2202,
    kRegoper = 2203,
    kRegoperator = 2204,
    kRegclass = 2205,
    kRegtype = 2206,
    kRegrole = 4096,
    kRegtypearray = 2211,
    kUuid = 2950,
    kUuidArray = 2951,  // Not in documentation
    kLsn = 3220,
    kLsnArray = 3221,
    kTsvector = 3614,
    kGtsvector = 3642,
    kTsquery = 3615,
    kRegconfig = 3734,
    kRegdictionary = 3769,
    kJsonb = 3802,
    kJsonbArray = 3807,  // Not in documentation
    kRecord = 2249,
    kRecordArray = 2287,
    kCstring = 2275,
    kAny = 2276,
    kAnyArray = 2277,
    kVoid = 2278,
    kTrigger = 2279,
    kEvttrigger = 3838,
    kLanguageHandler = 2280,
    kInternal = 2281,
    kOpaque = 2282,
    kAnyElement = 2283,
    kAnyNonArray = 2776,
    kAnyEnum = 3500,
    kFdwHandler = 3115,
    kAnyRange = 3831,
    kInt4Range = 3904,
    kInt4RangeArray = 3905,         // Not in documentation
    kNumRange = 3906,               // Not in documentation
    kNumRangeArray = 3907,          // Not in documentation
    kTimestampRange = 3908,         // Not in documentation
    kTimestampRangeArray = 3909,    // Not in documentation
    kTimestamptzRange = 3910,       // Not in documentation
    kTimestamptzRangeArray = 3911,  // Not in documentation
    kDateRange = 3912,              // Not in documentation
    kDateRangeArray = 3913,         // Not in documentation
    kInt8Range = 3926,              // Not in documentation
    kInt8RangeArray = 3927,         // Not in documentation
};
enum class PredefinedOids {…};
 
template <PredefinedOids TypeOid>
using PredefinedOid = std::integral_constant<PredefinedOids, TypeOid>;
 
//@{
/** @name Array types for predefined oids */
template <PredefinedOids TypeOid>
struct ArrayType : PredefinedOid<PredefinedOids::kInvalid> {};
 
template <>
struct ArrayType<PredefinedOids::kBoolean> : PredefinedOid<PredefinedOids::kBooleanArray> {};
template <>
struct ArrayType<PredefinedOids::kBytea> : PredefinedOid<PredefinedOids::kByteaArray> {};
template <>
struct ArrayType<PredefinedOids::kChar> : PredefinedOid<PredefinedOids::kCharArray> {};
template <>
struct ArrayType<PredefinedOids::kName> : PredefinedOid<PredefinedOids::kNameArray> {};
template <>
struct ArrayType<PredefinedOids::kInt2> : PredefinedOid<PredefinedOids::kInt2Array> {};
template <>
struct ArrayType<PredefinedOids::kInt4> : PredefinedOid<PredefinedOids::kInt4Array> {};
template <>
struct ArrayType<PredefinedOids::kInt8> : PredefinedOid<PredefinedOids::kInt8Array> {};
template <>
struct ArrayType<PredefinedOids::kText> : PredefinedOid<PredefinedOids::kTextArray> {};
template <>
struct ArrayType<PredefinedOids::kOid> : PredefinedOid<PredefinedOids::kOidArray> {};
template <>
struct ArrayType<PredefinedOids::kCidr> : PredefinedOid<PredefinedOids::kCidArray> {};
template <>
struct ArrayType<PredefinedOids::kInet> : PredefinedOid<PredefinedOids::kInetArray> {};
template <>
struct ArrayType<PredefinedOids::kTid> : PredefinedOid<PredefinedOids::kTidArray> {};
template <>
struct ArrayType<PredefinedOids::kXid> : PredefinedOid<PredefinedOids::kXidArray> {};
template <>
struct ArrayType<PredefinedOids::kCid> : PredefinedOid<PredefinedOids::kCidArray> {};
template <>
struct ArrayType<PredefinedOids::kLsn> : PredefinedOid<PredefinedOids::kLsnArray> {};
 
template <>
struct ArrayType<PredefinedOids::kFloat4> : PredefinedOid<PredefinedOids::kFloat4Array> {};
template <>
struct ArrayType<PredefinedOids::kFloat8> : PredefinedOid<PredefinedOids::kFloat8Array> {};
 
template <>
struct ArrayType<PredefinedOids::kBpchar> : PredefinedOid<PredefinedOids::kBphcarArray> {};
template <>
struct ArrayType<PredefinedOids::kVarchar> : PredefinedOid<PredefinedOids::kVarcharArray> {};
 
template <>
struct ArrayType<PredefinedOids::kDate> : PredefinedOid<PredefinedOids::kDateArray> {};
 
template <>
struct ArrayType<PredefinedOids::kTime> : PredefinedOid<PredefinedOids::kTimeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kTimestamp> : PredefinedOid<PredefinedOids::kTimestampArray> {};
template <>
struct ArrayType<PredefinedOids::kTimestamptz> : PredefinedOid<PredefinedOids::kTimestamptzArray> {};
 
template <>
struct ArrayType<PredefinedOids::kInterval> : PredefinedOid<PredefinedOids::kIntervalArray> {};
 
template <>
struct ArrayType<PredefinedOids::kBit> : PredefinedOid<PredefinedOids::kBitArray> {};
 
template <>
struct ArrayType<PredefinedOids::kVarbit> : PredefinedOid<PredefinedOids::kVarbitArray> {};
 
template <>
struct ArrayType<PredefinedOids::kNumeric> : PredefinedOid<PredefinedOids::kNumericArray> {};
 
template <>
struct ArrayType<PredefinedOids::kUuid> : PredefinedOid<PredefinedOids::kUuidArray> {};
 
template <>
struct ArrayType<PredefinedOids::kInt4Range> : PredefinedOid<PredefinedOids::kInt4RangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kNumRange> : PredefinedOid<PredefinedOids::kNumRangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kTimestampRange> : PredefinedOid<PredefinedOids::kTimestampRangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kTimestamptzRange> : PredefinedOid<PredefinedOids::kTimestamptzRangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kDateRange> : PredefinedOid<PredefinedOids::kDateRangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kInt8Range> : PredefinedOid<PredefinedOids::kInt8RangeArray> {};
 
template <>
struct ArrayType<PredefinedOids::kPoint> : PredefinedOid<PredefinedOids::kPointArray> {};
template <>
struct ArrayType<PredefinedOids::kLseg> : PredefinedOid<PredefinedOids::kLsegArray> {};
template <>
struct ArrayType<PredefinedOids::kLine> : PredefinedOid<PredefinedOids::kLineArray> {};
template <>
struct ArrayType<PredefinedOids::kBox> : PredefinedOid<PredefinedOids::kBoxArray> {};
template <>
struct ArrayType<PredefinedOids::kPath> : PredefinedOid<PredefinedOids::kPathArray> {};
template <>
struct ArrayType<PredefinedOids::kPolygon> : PredefinedOid<PredefinedOids::kPolygonArray> {};
template <>
struct ArrayType<PredefinedOids::kCircle> : PredefinedOid<PredefinedOids::kCircleArray> {};
 
template <>
struct ArrayType<PredefinedOids::kJson> : PredefinedOid<PredefinedOids::kJsonArray> {};
template <>
struct ArrayType<PredefinedOids::kJsonb> : PredefinedOid<PredefinedOids::kJsonbArray> {};
 
template <>
struct ArrayType<PredefinedOids::kRecord> : PredefinedOid<PredefinedOids::kRecordArray> {};
 
template <>
struct ArrayType<PredefinedOids::kMacaddr> : PredefinedOid<PredefinedOids::kMacaddrArray> {};
 
template <>
struct ArrayType<PredefinedOids::kMacaddr8> : PredefinedOid<PredefinedOids::kMacaddr8Array> {};
 
//@}
 
}  // namespace io
}  // namespace storages::postgres
 
USERVER_NAMESPACE_END
 
namespace std {
 
template <>
struct hash<USERVER_NAMESPACE::storages::postgres::io::PredefinedOids> {
    std::size_t operator()(USERVER_NAMESPACE::storages::postgres::io::PredefinedOids value) const {
        return static_cast<std::size_t>(value);
    }
};
struct hash<USERVER_NAMESPACE::storages::postgres::io::PredefinedOids> {…};
 
template <>
struct hash<USERVER_NAMESPACE::storages::postgres::DBTypeName> {
    std::size_t operator()(const USERVER_NAMESPACE::storages::postgres::DBTypeName& value) const {
        return value.GetHash();
    }
};
struct hash<USERVER_NAMESPACE::storages::postgres::DBTypeName> {…};
 
}  // namespace std