Lightweight 0.20260921.0
Loading...
Searching...
No Matches
SqlColumnTypeDefinitions.hpp
1// SPDX-License-Identifier: Apache-2.0
2
3#pragma once
4
5// See SqlOdbcPrelude.hpp's header comment for why this replaces a direct <Windows.h> include.
6#include "SqlOdbcPrelude.hpp"
7
8#include <cstdint>
9#include <optional>
10#include <variant>
11
12#include <sql.h>
13#include <sqlext.h>
14
15// Microsoft SQL Server extension for TIME(7) with fractional seconds.
16// This is supported by SQL Server 2008 and later, MariaDB and MySQL ODBC drivers.
17// clang-format off
18#if !defined(SQL_SS_TIME2)
19 #define SQL_SS_TIME2 (-154)
20
21 struct SQL_SS_TIME2_STRUCT
22 {
23 SQLUSMALLINT hour;
24 SQLUSMALLINT minute;
25 SQLUSMALLINT second;
26 SQLUINTEGER fraction;
27 };
28
29 static_assert(
30 sizeof(SQL_SS_TIME2_STRUCT) == 12,
31 "SQL_SS_TIME2_STRUCT size must be padded 12 bytes, as per ODBC extension spec."
32 );
33#endif
34// clang-format on
35
36namespace Lightweight
37{
38
39/// @brief Represents if a column is nullable or not.
40enum class SqlNullable : uint8_t
41{
42 NotNull,
43 Null,
44};
45
46namespace SqlColumnTypeDefinitions
47{
48
49 // clang-format off
50struct Bigint { auto operator<=>(Bigint const&) const = default; };
51struct Binary { std::size_t size = 255; auto operator<=>(Binary const&) const = default; };
52struct Bool { auto operator<=>(Bool const&) const = default; };
53struct Char { std::size_t size = 1; auto operator<=>(Char const&) const = default; };
54struct Date { auto operator<=>(Date const&) const = default; };
55struct DateTime { auto operator<=>(DateTime const&) const = default; };
56struct Decimal { std::size_t precision {}; std::size_t scale {}; auto operator<=>(Decimal const&) const = default; };
57struct Guid { auto operator<=>(Guid const&) const = default; };
58struct Integer { auto operator<=>(Integer const&) const = default; };
59struct NChar { std::size_t size = 1; auto operator<=>(NChar const&) const = default; };
60struct NVarchar { std::size_t size = 255; auto operator<=>(NVarchar const&) const = default; };
61struct Real { std::size_t precision = {}; auto operator<=>(Real const&) const = default; };
62struct Smallint { auto operator<=>(Smallint const&) const = default; };
63struct Text { std::size_t size {}; auto operator<=>(Text const&) const = default; };
64struct Time { auto operator<=>(Time const&) const = default; };
65struct Timestamp { auto operator<=>(Timestamp const&) const = default; };
66struct Tinyint { auto operator<=>(Tinyint const&) const = default; };
67struct VarBinary { std::size_t size = 255; auto operator<=>(VarBinary const&) const = default; };
68struct Varchar { std::size_t size = 255; auto operator<=>(Varchar const&) const = default; };
69 // clang-format on
70
71} // namespace SqlColumnTypeDefinitions
72
73using SqlColumnTypeDefinition = std::variant<SqlColumnTypeDefinitions::Bigint,
74 SqlColumnTypeDefinitions::Binary,
75 SqlColumnTypeDefinitions::Bool,
76 SqlColumnTypeDefinitions::Char,
77 SqlColumnTypeDefinitions::Date,
78 SqlColumnTypeDefinitions::DateTime,
79 SqlColumnTypeDefinitions::Decimal,
80 SqlColumnTypeDefinitions::Guid,
81 SqlColumnTypeDefinitions::Integer,
82 SqlColumnTypeDefinitions::NChar,
83 SqlColumnTypeDefinitions::NVarchar,
84 SqlColumnTypeDefinitions::Real,
85 SqlColumnTypeDefinitions::Tinyint,
86 SqlColumnTypeDefinitions::Smallint,
87 SqlColumnTypeDefinitions::Text,
88 SqlColumnTypeDefinitions::Time,
89 SqlColumnTypeDefinitions::Timestamp,
90 SqlColumnTypeDefinitions::VarBinary,
91 SqlColumnTypeDefinitions::Varchar>;
92
93/// Maps ODBC data type (with given @p size and @p precision) to SqlColumnTypeDefinition
94///
95/// @return SqlColumnTypeDefinition if the data type is supported, otherwise std::nullopt
96constexpr std::optional<SqlColumnTypeDefinition> MakeColumnTypeFromNative(int value, std::size_t size, std::size_t precision)
97{
98 // Maps ODBC data types to SqlColumnTypeDefinition
99 // See: https://learn.microsoft.com/en-us/sql/odbc/reference/appendixes/sql-data-types?view=sql-server-ver16
100 using namespace SqlColumnTypeDefinitions;
101 // clang-format off
102 switch (value)
103 {
104 case SQL_BIGINT: return Bigint {};
105 case SQL_BINARY: return Binary { size };
106 case SQL_BIT: return Bool {};
107 case SQL_CHAR: return Char { size };
108 case SQL_DATE: return Date {};
109 case SQL_DECIMAL: return Decimal { .precision = size, .scale = precision };
110 case SQL_DOUBLE: return Real { .precision = 53 };
111 case SQL_FLOAT: return Real { . precision = precision };
112 case SQL_GUID: return Guid {};
113 case SQL_INTEGER: return Integer {};
114 case SQL_LONGVARBINARY: return VarBinary { size };
115 case SQL_LONGVARCHAR: return Varchar { size };
116 case SQL_NUMERIC: return Decimal { .precision = size, .scale = precision };
117 case SQL_REAL: return Real { .precision = 24 };
118 case SQL_SMALLINT: return Smallint {};
119 case SQL_TIME: return Time {};
120 case SQL_TIMESTAMP: return DateTime {};
121 case SQL_TINYINT: return Tinyint {};
122 case SQL_TYPE_DATE: return Date {};
123 case SQL_TYPE_TIME: return Time {};
124 case SQL_SS_TIME2: return Time {}; // Microsoft SQL Server extension
125 case SQL_TYPE_TIMESTAMP: return DateTime {};
126 case SQL_VARBINARY: return VarBinary { size };
127 case SQL_VARCHAR: return Varchar { size };
128 case SQL_WCHAR: return NChar { size };
129 case SQL_WLONGVARCHAR: return NVarchar { size };
130 case SQL_WVARCHAR: return NVarchar { size };
131 case SQL_UNKNOWN_TYPE: return std::nullopt;
132 default: return std::nullopt;
133 }
134 // clang-format on
135}
136
137} // namespace Lightweight