2899 lines
67 KiB
C++
2899 lines
67 KiB
C++
#ifndef _SQL_POSTGRES_H_
|
|
#define _SQL_POSTGRES_H_
|
|
|
|
#pragma once
|
|
|
|
#include <string>
|
|
#include <map>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <exception>
|
|
#include <sstream>
|
|
#include <chrono>
|
|
#include <algorithm>
|
|
#include <assert.h>
|
|
#include "qtl_common.hpp"
|
|
#include "qtl_async.hpp"
|
|
|
|
#define FRONTEND
|
|
|
|
#include <libpq-fe.h>
|
|
#include <libpq/libpq-fs.h>
|
|
#include <pgtypes_error.h>
|
|
#include <pgtypes_interval.h>
|
|
#include <pgtypes_timestamp.h>
|
|
#include <pgtypes_numeric.h>
|
|
#include <pgtypes_date.h>
|
|
|
|
extern "C"
|
|
{
|
|
#include <c.h>
|
|
#include <catalog/pg_type.h>
|
|
}
|
|
|
|
|
|
#ifdef open
|
|
#undef open
|
|
#endif //open
|
|
|
|
#ifdef vsnprintf
|
|
#undef vsnprintf
|
|
#endif
|
|
#ifdef snprintf
|
|
#undef snprintf
|
|
#endif
|
|
#ifdef sprintf
|
|
#undef sprintf
|
|
#endif
|
|
#ifdef vfprintf
|
|
#undef vfprintf
|
|
#endif
|
|
#ifdef fprintf
|
|
#undef fprintf
|
|
#endif
|
|
#ifdef printf
|
|
#undef printf
|
|
#endif
|
|
#ifdef rename
|
|
#undef rename
|
|
#endif
|
|
#ifdef unlink
|
|
#undef unlink
|
|
#endif
|
|
|
|
#if defined(_WIN32) && _WIN32_WINNT < 0x0601
|
|
|
|
#ifdef _M_IX86
|
|
|
|
#define _WS2_32_WINSOCK_SWAP_LONGLONG(l) \
|
|
( ( ((l) >> 56) & 0x00000000000000FFLL ) | \
|
|
( ((l) >> 40) & 0x000000000000FF00LL ) | \
|
|
( ((l) >> 24) & 0x0000000000FF0000LL ) | \
|
|
( ((l) >> 8) & 0x00000000FF000000LL ) | \
|
|
( ((l) << 8) & 0x000000FF00000000LL ) | \
|
|
( ((l) << 24) & 0x0000FF0000000000LL ) | \
|
|
( ((l) << 40) & 0x00FF000000000000LL ) | \
|
|
( ((l) << 56) & 0xFF00000000000000LL ) )
|
|
|
|
#ifndef htonll
|
|
__inline unsigned __int64 htonll(unsigned __int64 Value)
|
|
{
|
|
const unsigned __int64 Retval = _WS2_32_WINSOCK_SWAP_LONGLONG(Value);
|
|
return Retval;
|
|
}
|
|
#endif /* htonll */
|
|
|
|
#ifndef ntohll
|
|
__inline unsigned __int64 ntohll(unsigned __int64 Value)
|
|
{
|
|
const unsigned __int64 Retval = _WS2_32_WINSOCK_SWAP_LONGLONG(Value);
|
|
return Retval;
|
|
}
|
|
|
|
#endif /* ntohll */
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
namespace qtl
|
|
{
|
|
namespace postgres
|
|
{
|
|
|
|
namespace detail
|
|
{
|
|
|
|
inline int16_t ntoh(int16_t v)
|
|
{
|
|
return static_cast<int16_t>(ntohs(v));
|
|
}
|
|
inline uint16_t ntoh(uint16_t v)
|
|
{
|
|
return ntohs(v);
|
|
}
|
|
inline int32_t ntoh(int32_t v)
|
|
{
|
|
return static_cast<int32_t>(ntohl(v));
|
|
}
|
|
inline uint32_t ntoh(uint32_t v)
|
|
{
|
|
return ntohl(v);
|
|
}
|
|
inline uint64_t ntoh(uint64_t v)
|
|
{
|
|
#ifdef _WIN32
|
|
return ntohll(v);
|
|
#else
|
|
return be64toh(v);
|
|
#endif
|
|
}
|
|
inline int64_t ntoh(int64_t v)
|
|
{
|
|
return ntoh(static_cast<uint64_t>(v));
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && !std::is_const<T>::value>::type>
|
|
inline T& ntoh_inplace(T& v)
|
|
{
|
|
v = ntoh(v);
|
|
return v;
|
|
}
|
|
|
|
inline int16_t hton(int16_t v)
|
|
{
|
|
return static_cast<int16_t>(htons(v));
|
|
}
|
|
inline uint16_t hton(uint16_t v)
|
|
{
|
|
return htons(v);
|
|
}
|
|
inline int32_t hton(int32_t v)
|
|
{
|
|
return static_cast<int32_t>(htonl(v));
|
|
}
|
|
inline uint32_t hton(uint32_t v)
|
|
{
|
|
return htonl(v);
|
|
}
|
|
inline uint64_t hton(uint64_t v)
|
|
{
|
|
#ifdef _WIN32
|
|
return htonll(v);
|
|
#else
|
|
return htobe64(v);
|
|
#endif
|
|
}
|
|
inline int64_t hton(int64_t v)
|
|
{
|
|
return hton(static_cast<uint64_t>(v));
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && !std::is_const<T>::value>::type>
|
|
inline T& hton_inplace(T& v)
|
|
{
|
|
v = hton(v);
|
|
return v;
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && !std::is_const<T>::value>::type>
|
|
std::pair<std::vector<char>::iterator, size_t> push(std::vector<char>& buffer, T v)
|
|
{
|
|
v = hton_inplace(v);
|
|
char* data = reinterpret_cast<char*>(&v);
|
|
auto it = buffer.insert(buffer.end(), data, data + sizeof(T));
|
|
return std::make_pair(it, sizeof(T));
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && !std::is_const<T>::value>::type>
|
|
const char* pop(const char* data, T& v)
|
|
{
|
|
v = ntoh(*reinterpret_cast<const T*>(data));
|
|
return data + sizeof(T);
|
|
}
|
|
}
|
|
|
|
class base_database;
|
|
class result;
|
|
|
|
class error : public std::exception
|
|
{
|
|
public:
|
|
error() : m_errmsg() { }
|
|
explicit error(PGconn* conn, PGVerbosity verbosity = PQERRORS_DEFAULT, PGContextVisibility show_context = PQSHOW_CONTEXT_ERRORS)
|
|
{
|
|
//PQsetErrorVerbosity(conn, verbosity);
|
|
//PQsetErrorContextVisibility(conn, show_context);
|
|
const char* errmsg = PQerrorMessage(conn);
|
|
if (errmsg) m_errmsg = errmsg;
|
|
else m_errmsg.clear();
|
|
}
|
|
|
|
explicit error(PGresult* res)
|
|
{
|
|
const char* errmsg = PQresultErrorMessage(res);
|
|
if (errmsg) m_errmsg = errmsg;
|
|
else m_errmsg.clear();
|
|
}
|
|
|
|
explicit error(const char* errmsg) : m_errmsg(errmsg) { }
|
|
|
|
virtual const char* what() const NOEXCEPT override { return m_errmsg.data(); }
|
|
operator bool() const { return !m_errmsg.empty(); }
|
|
|
|
protected:
|
|
std::string m_errmsg;
|
|
};
|
|
|
|
class timeout : public error
|
|
{
|
|
public:
|
|
timeout()
|
|
{
|
|
m_errmsg = "timeout";
|
|
}
|
|
};
|
|
|
|
inline void verify_pgtypes_error(int ret)
|
|
{
|
|
if(ret && errno != 0)
|
|
throw std::system_error(std::error_code(errno, std::generic_category()));
|
|
}
|
|
|
|
struct interval
|
|
{
|
|
::interval* value;
|
|
|
|
interval()
|
|
{
|
|
value = PGTYPESinterval_new();
|
|
}
|
|
explicit interval(char* str)
|
|
{
|
|
value = PGTYPESinterval_from_asc(str, nullptr);
|
|
}
|
|
interval(const interval& src) : interval()
|
|
{
|
|
verify_pgtypes_error(PGTYPESinterval_copy(src.value, value));
|
|
}
|
|
interval(interval&& src)
|
|
{
|
|
value = src.value;
|
|
src.value = PGTYPESinterval_new();
|
|
}
|
|
~interval()
|
|
{
|
|
PGTYPESinterval_free(value);
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
return PGTYPESinterval_to_asc(value);
|
|
}
|
|
|
|
interval& operator=(const interval& src)
|
|
{
|
|
if(&src!=this)
|
|
verify_pgtypes_error(PGTYPESinterval_copy(src.value, value));
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
struct timestamp
|
|
{
|
|
::timestamp value;
|
|
|
|
timestamp() = default;
|
|
|
|
static timestamp now()
|
|
{
|
|
timestamp result;
|
|
PGTYPEStimestamp_current(&result.value);
|
|
return result;
|
|
}
|
|
explicit timestamp(char* str)
|
|
{
|
|
value = PGTYPEStimestamp_from_asc(str, nullptr);
|
|
verify_pgtypes_error(1);
|
|
}
|
|
|
|
int format(char* str, int n, const char* format) const
|
|
{
|
|
timestamp temp = *this;
|
|
return PGTYPEStimestamp_fmt_asc(&temp.value, str, n, format);
|
|
}
|
|
static timestamp parse(char* str, const char* format)
|
|
{
|
|
timestamp result;
|
|
verify_pgtypes_error(PGTYPEStimestamp_defmt_asc(str, format, &result.value));
|
|
return result;
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
char* str = PGTYPEStimestamp_to_asc(value);
|
|
std::string result = str;
|
|
PGTYPESchar_free(str);
|
|
return result;
|
|
}
|
|
|
|
timestamp& operator += (const interval& span)
|
|
{
|
|
verify_pgtypes_error(PGTYPEStimestamp_add_interval(&value, span.value, &value));
|
|
return *this;
|
|
}
|
|
|
|
timestamp& operator -= (const interval& span)
|
|
{
|
|
verify_pgtypes_error(PGTYPEStimestamp_sub_interval(&value, span.value, &value));
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
inline timestamp operator+(const timestamp& a, const interval& b)
|
|
{
|
|
timestamp result=a;
|
|
return result+=b;
|
|
}
|
|
|
|
inline timestamp operator-(const timestamp& a, const interval& b)
|
|
{
|
|
timestamp result=a;
|
|
result -= b;
|
|
return result;
|
|
}
|
|
|
|
|
|
struct timestamptz
|
|
{
|
|
::TimestampTz value;
|
|
/*
|
|
timestamptz() = default;
|
|
explicit timestamptz(pg_time_t v)
|
|
{
|
|
value = (TimestampTz)v -
|
|
((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
|
|
value *= USECS_PER_SEC;
|
|
}
|
|
|
|
static timestamptz now()
|
|
{
|
|
timestamptz result;
|
|
auto tp = std::chrono::system_clock::now();
|
|
int sec = tp.time_since_epoch().count()*std::nano::num/std::nano::den;
|
|
int usec = tp.time_since_epoch().count()*std::nano::num % std::nano::den;
|
|
|
|
result.value = (TimestampTz)sec -
|
|
((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
|
|
result.value = (result.value * USECS_PER_SEC) + usec;
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
};
|
|
|
|
struct date
|
|
{
|
|
::date value;
|
|
|
|
date() = default;
|
|
explicit date(timestamp dt)
|
|
{
|
|
value = PGTYPESdate_from_timestamp(dt.value);
|
|
}
|
|
explicit date(char* str)
|
|
{
|
|
value = PGTYPESdate_from_asc(str, nullptr);
|
|
verify_pgtypes_error(1);
|
|
}
|
|
explicit date(int year, int month, int day)
|
|
{
|
|
int mdy[3] = { month, day, year };
|
|
PGTYPESdate_mdyjul(mdy, &value);
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
char* str = PGTYPESdate_to_asc(value);
|
|
std::string result = str;
|
|
PGTYPESchar_free(str);
|
|
return str;
|
|
}
|
|
|
|
static date now()
|
|
{
|
|
date result;
|
|
PGTYPESdate_today(&result.value);
|
|
return result;
|
|
}
|
|
|
|
static date parse(char* str, const char* format)
|
|
{
|
|
date result;
|
|
verify_pgtypes_error(PGTYPESdate_defmt_asc(&result.value, format, str));
|
|
return result;
|
|
}
|
|
|
|
std::string format(const char* format)
|
|
{
|
|
std::string result;
|
|
result.resize(128);
|
|
verify_pgtypes_error(PGTYPESdate_fmt_asc(value, format, const_cast<char*>(result.data())));
|
|
result.resize(strlen(result.data()));
|
|
return result;
|
|
}
|
|
|
|
std::tuple<int, int, int> get_date()
|
|
{
|
|
int mdy[3];
|
|
PGTYPESdate_julmdy(value, mdy);
|
|
return std::make_tuple(mdy[2], mdy[0], mdy[1]);
|
|
}
|
|
|
|
int dayofweek()
|
|
{
|
|
return PGTYPESdate_dayofweek(value);
|
|
}
|
|
};
|
|
|
|
struct decimal
|
|
{
|
|
::decimal value;
|
|
};
|
|
|
|
struct numeric
|
|
{
|
|
::numeric* value;
|
|
|
|
numeric()
|
|
{
|
|
value = PGTYPESnumeric_new();
|
|
}
|
|
numeric(int v) : numeric()
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_from_int(v, value));
|
|
}
|
|
numeric(long v) : numeric()
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_from_long(v, value));
|
|
}
|
|
numeric(double v) : numeric()
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_from_double(v, value));
|
|
}
|
|
numeric(const decimal& v) : numeric()
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_from_decimal(const_cast<::decimal*>(&v.value), value));
|
|
}
|
|
numeric(const numeric& src) : numeric()
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_copy(src.value, value));
|
|
}
|
|
explicit numeric(const char* str)
|
|
{
|
|
value = PGTYPESnumeric_from_asc(const_cast<char*>(str), nullptr);
|
|
}
|
|
~numeric()
|
|
{
|
|
PGTYPESnumeric_free(value);
|
|
}
|
|
|
|
operator double() const
|
|
{
|
|
double result;
|
|
verify_pgtypes_error(PGTYPESnumeric_to_double(value, &result));
|
|
return result;
|
|
}
|
|
|
|
operator int() const
|
|
{
|
|
int result;
|
|
verify_pgtypes_error(PGTYPESnumeric_to_int(value, &result));
|
|
return result;
|
|
}
|
|
|
|
operator long() const
|
|
{
|
|
long result;
|
|
verify_pgtypes_error(PGTYPESnumeric_to_long(value, &result));
|
|
return result;
|
|
}
|
|
|
|
operator decimal() const
|
|
{
|
|
decimal result;
|
|
verify_pgtypes_error(PGTYPESnumeric_to_decimal(value, &result.value));
|
|
return result;
|
|
}
|
|
|
|
int compare(const numeric& other) const
|
|
{
|
|
return PGTYPESnumeric_cmp(value, other.value);
|
|
}
|
|
|
|
inline numeric& operator+=(const numeric& b)
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_add(value, b.value, value));
|
|
return *this;
|
|
}
|
|
|
|
inline numeric& operator-=(const numeric& b)
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_sub(value, b.value, value));
|
|
return *this;
|
|
}
|
|
|
|
inline numeric& operator*=(const numeric& b)
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_mul(value, b.value, value));
|
|
return *this;
|
|
}
|
|
|
|
inline numeric& operator/=(const numeric& b)
|
|
{
|
|
verify_pgtypes_error(PGTYPESnumeric_div(value, b.value, value));
|
|
return *this;
|
|
}
|
|
|
|
std::string to_string(int dscale=-1) const
|
|
{
|
|
char* str = PGTYPESnumeric_to_asc(value, dscale);
|
|
std::string result = str;
|
|
PGTYPESchar_free(str);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
inline numeric operator+(const numeric& a, const numeric& b)
|
|
{
|
|
numeric result;
|
|
verify_pgtypes_error(PGTYPESnumeric_add(a.value, b.value, result.value));
|
|
return result;
|
|
}
|
|
|
|
inline numeric operator-(const numeric& a, const numeric& b)
|
|
{
|
|
numeric result;
|
|
verify_pgtypes_error(PGTYPESnumeric_sub(a.value, b.value, result.value));
|
|
return result;
|
|
}
|
|
|
|
inline numeric operator*(const numeric& a, const numeric& b)
|
|
{
|
|
numeric result;
|
|
verify_pgtypes_error(PGTYPESnumeric_mul(a.value, b.value, result.value));
|
|
return result;
|
|
}
|
|
|
|
inline numeric operator/(const numeric& a, const numeric& b)
|
|
{
|
|
numeric result;
|
|
verify_pgtypes_error(PGTYPESnumeric_div(a.value, b.value, result.value));
|
|
return result;
|
|
}
|
|
|
|
inline bool operator==(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) == 0;
|
|
}
|
|
|
|
inline bool operator<(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) < 0;
|
|
}
|
|
|
|
inline bool operator>(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) > 0;
|
|
}
|
|
|
|
inline bool operator<=(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) <= 0;
|
|
}
|
|
|
|
inline bool operator>=(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) >= 0;
|
|
}
|
|
|
|
inline bool operator!=(const numeric& a, const numeric& b)
|
|
{
|
|
return a.compare(b) != 0;
|
|
}
|
|
|
|
class large_object : public qtl::blobbuf
|
|
{
|
|
public:
|
|
large_object() : m_conn(nullptr), m_id(InvalidOid), m_fd(-1) { }
|
|
large_object(PGconn* conn, Oid loid, std::ios_base::openmode mode)
|
|
{
|
|
open(conn, loid, mode);
|
|
}
|
|
large_object(const large_object&) = delete;
|
|
large_object(large_object&& src)
|
|
{
|
|
swap(src);
|
|
src.m_conn = nullptr;
|
|
src.m_fd = -1;
|
|
}
|
|
~large_object()
|
|
{
|
|
close();
|
|
}
|
|
|
|
static large_object create(PGconn* conn, Oid loid = InvalidOid)
|
|
{
|
|
Oid oid = lo_create(conn, loid);
|
|
if (oid == InvalidOid)
|
|
throw error(conn);
|
|
return large_object(conn, oid, std::ios::in|std::ios::out|std::ios::binary);
|
|
}
|
|
static large_object load(PGconn* conn, const char* filename, Oid loid = InvalidOid)
|
|
{
|
|
Oid oid = lo_import_with_oid(conn, filename, loid);
|
|
if (oid == InvalidOid)
|
|
throw error(conn);
|
|
return large_object(conn, oid, std::ios::in | std::ios::out | std::ios::binary);
|
|
}
|
|
void save(const char* filename) const
|
|
{
|
|
if (lo_export(m_conn, m_id, filename) < 0)
|
|
throw error(m_conn);
|
|
}
|
|
|
|
void unlink()
|
|
{
|
|
close();
|
|
if (lo_unlink(m_conn, m_id) < 0)
|
|
throw error(m_conn);
|
|
}
|
|
|
|
large_object& operator=(const large_object&) = delete;
|
|
large_object& operator=(large_object&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
swap(src);
|
|
src.close();
|
|
}
|
|
return *this;
|
|
}
|
|
bool is_open() const { return m_fd >= 0; }
|
|
Oid oid() const { return m_id; }
|
|
|
|
void open(PGconn* conn, Oid loid, std::ios_base::openmode mode)
|
|
{
|
|
int lomode = 0;
|
|
if (mode&std::ios_base::in)
|
|
lomode |= INV_READ;
|
|
if (mode&std::ios_base::out)
|
|
lomode |= INV_WRITE;
|
|
m_conn = conn;
|
|
m_id = loid;
|
|
m_fd = lo_open(m_conn, loid, lomode);
|
|
if (m_fd < 0)
|
|
throw error(m_conn);
|
|
|
|
m_size = size();
|
|
init_buffer(mode);
|
|
if (mode&std::ios_base::trunc)
|
|
{
|
|
if (lo_truncate(m_conn, m_fd, 0) < 0)
|
|
throw error(m_conn);
|
|
}
|
|
}
|
|
|
|
void close()
|
|
{
|
|
if (m_fd >= 0)
|
|
{
|
|
overflow();
|
|
if (lo_close(m_conn, m_fd) < 0)
|
|
throw error(m_conn);
|
|
m_fd = -1;
|
|
}
|
|
}
|
|
|
|
void flush()
|
|
{
|
|
if (m_fd >= 0)
|
|
overflow();
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
pg_int64 size = 0;
|
|
if (m_fd >= 0)
|
|
{
|
|
pg_int64 org = lo_tell64(m_conn, m_fd);
|
|
size = lo_lseek64(m_conn, m_fd, 0, SEEK_END);
|
|
lo_lseek64(m_conn, m_fd, org, SEEK_SET);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
void resize(size_t n)
|
|
{
|
|
if (m_fd >= 0 && lo_truncate64(m_conn, m_fd, n) < 0)
|
|
throw error(m_conn);
|
|
}
|
|
|
|
void swap(large_object& other)
|
|
{
|
|
std::swap(m_conn, other.m_conn);
|
|
std::swap(m_id, other.m_id);
|
|
std::swap(m_fd, other.m_fd);
|
|
qtl::blobbuf::swap(other);
|
|
}
|
|
|
|
protected:
|
|
enum { default_buffer_size = 4096 };
|
|
|
|
virtual bool read_blob(char* buffer, off_type& count, pos_type position) override
|
|
{
|
|
return lo_lseek64(m_conn, m_fd, position, SEEK_SET) >= 0 && lo_read(m_conn, m_fd, buffer, count) > 0;
|
|
}
|
|
virtual void write_blob(const char* buffer, size_t count) override
|
|
{
|
|
if (lo_write(m_conn, m_fd, buffer, count) < 0)
|
|
throw error(m_conn);
|
|
}
|
|
|
|
private:
|
|
PGconn* m_conn;
|
|
Oid m_id;
|
|
int m_fd;
|
|
};
|
|
|
|
struct array_header
|
|
{
|
|
int32_t ndim;
|
|
int32_t flags;
|
|
int32_t elemtype;
|
|
struct dimension {
|
|
int32_t length;
|
|
int32_t lower_bound;
|
|
} dims[1];
|
|
};
|
|
|
|
/*
|
|
template<typename T>
|
|
struct oid_traits
|
|
{
|
|
typedef T value_type;
|
|
static Oid type_id;
|
|
static Oid array_type_id; //optional
|
|
static const char* get(value_type& result, const char* begin, const char* end);
|
|
static std::pair<const char*, size_t> data(const T& v, std::vector<char*>& buffer);
|
|
};
|
|
*/
|
|
|
|
template<typename T, Oid id>
|
|
struct base_object_traits
|
|
{
|
|
typedef T value_type;
|
|
enum { type_id = id };
|
|
static bool is_match(Oid v)
|
|
{
|
|
return v == type_id;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct object_traits;
|
|
|
|
#define QTL_POSTGRES_SIMPLE_TRAITS(T, oid, array_oid) \
|
|
template<> struct object_traits<T> : public base_object_traits<T, oid> { \
|
|
enum { array_type_id = array_oid }; \
|
|
static const char* get(value_type& result, const char* data, const char* end) \
|
|
{ \
|
|
result = *reinterpret_cast<const value_type*>(data); \
|
|
return data+sizeof(value_type); \
|
|
} \
|
|
static std::pair<const char*, size_t> data(const T& v, std::vector<char>& /*data*/) { \
|
|
return std::make_pair(reinterpret_cast<const char*>(&v), sizeof(T)); \
|
|
} \
|
|
};
|
|
|
|
QTL_POSTGRES_SIMPLE_TRAITS(bool, BOOLOID, 1000)
|
|
QTL_POSTGRES_SIMPLE_TRAITS(char, CHAROID, 1002)
|
|
QTL_POSTGRES_SIMPLE_TRAITS(float, FLOAT4OID, FLOAT4ARRAYOID)
|
|
QTL_POSTGRES_SIMPLE_TRAITS(double, FLOAT8OID, 1022)
|
|
|
|
template<typename T, Oid id, Oid array_id>
|
|
struct integral_traits : public base_object_traits<T, id>
|
|
{
|
|
enum { array_type_id = array_id };
|
|
typedef typename base_object_traits<T, id>::value_type value_type;
|
|
static const char* get(value_type& v, const char* data, const char* end)
|
|
{
|
|
return detail::pop(data, v);
|
|
}
|
|
static std::pair<const char*, size_t> data(value_type v, std::vector<char>& buffer)
|
|
{
|
|
size_t n = buffer.size();
|
|
detail::push(buffer, v);
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<int16_t> : public integral_traits<int16_t, INT2OID, INT2ARRAYOID>
|
|
{
|
|
};
|
|
|
|
template<> struct object_traits<int32_t> : public integral_traits<int32_t, INT4OID, INT4ARRAYOID>
|
|
{
|
|
};
|
|
|
|
template<> struct object_traits<int64_t> : public integral_traits<int64_t, INT8OID, 1016>
|
|
{
|
|
};
|
|
|
|
template<> struct object_traits<Oid> : public integral_traits<Oid, OIDOID, OIDARRAYOID>
|
|
{
|
|
};
|
|
|
|
template<typename T>
|
|
struct text_traits : public base_object_traits<T, TEXTOID>
|
|
{
|
|
enum { array_type_id = TEXTARRAYOID };
|
|
};
|
|
|
|
template<> struct object_traits<const char*> : public text_traits<const char*>
|
|
{
|
|
static bool is_match(Oid v)
|
|
{
|
|
return v == TEXTOID || v == VARCHAROID || v == BPCHAROID;
|
|
}
|
|
static const char* get(const char*& result, const char* data, const char* end)
|
|
{
|
|
result = data;
|
|
return end;
|
|
}
|
|
static std::pair<const char*, size_t> data(const char* v, std::vector<char>& /*buffer*/)
|
|
{
|
|
return std::make_pair(v, strlen(v));
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<char*> : public object_traits<const char*>
|
|
{
|
|
};
|
|
|
|
template<> struct object_traits<std::string> : public text_traits<std::string>
|
|
{
|
|
static bool is_match(Oid v)
|
|
{
|
|
return v == TEXTOID || v == VARCHAROID || v == BPCHAROID;
|
|
}
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result.assign(data, end);
|
|
return end;
|
|
}
|
|
static std::pair<const char*, size_t> data(const std::string& v, std::vector<char>& /*buffer*/)
|
|
{
|
|
return std::make_pair(v.data(), v.size());
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<timestamp> : public base_object_traits<timestamp, TIMESTAMPOID>
|
|
{
|
|
enum { array_type_id = TIMESTAMPOID+1 };
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result = *reinterpret_cast<const timestamp*>(data);
|
|
result.value = detail::ntoh(result.value);
|
|
return data+sizeof(timestamp);
|
|
}
|
|
static std::pair<const char*, size_t> data(const timestamp& v, std::vector<char>& buffer)
|
|
{
|
|
size_t n = buffer.size();
|
|
detail::push(buffer, v.value);
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<timestamptz> : public base_object_traits<timestamptz, TIMESTAMPTZOID>
|
|
{
|
|
enum { array_type_id = TIMESTAMPTZOID+1 };
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result = *reinterpret_cast<const timestamptz*>(data);
|
|
result.value = detail::ntoh(result.value);
|
|
return data+sizeof(timestamptz);
|
|
}
|
|
static std::pair<const char*, size_t> data(const timestamptz& v, std::vector<char>& buffer)
|
|
{
|
|
size_t n = buffer.size();
|
|
detail::push(buffer, v.value);
|
|
return std::make_pair(buffer.data() + n, buffer.size() - n);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<interval> : public base_object_traits<interval, INTERVALOID>
|
|
{
|
|
enum { array_type_id = INTERVALOID+1 };
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
const ::interval* value = reinterpret_cast<const ::interval*>(data);
|
|
result.value->time = detail::ntoh(value->time);
|
|
result.value->month = detail::ntoh(value->month);
|
|
return data+sizeof(interval);
|
|
}
|
|
static std::pair<const char*, size_t> data(const interval& v, std::vector<char>& buffer)
|
|
{
|
|
size_t n = buffer.size();
|
|
detail::push(buffer, v.value->time);
|
|
detail::push(buffer, v.value->month);
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<date> : public base_object_traits<date, DATEOID>
|
|
{
|
|
enum { array_type_id = 1182 };
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result = *reinterpret_cast<const date*>(data);
|
|
result.value = detail::ntoh(result.value);
|
|
return data+sizeof(date);
|
|
}
|
|
static std::pair<const char*, size_t> data(const date& v, std::vector<char>& buffer)
|
|
{
|
|
size_t n=buffer.size();
|
|
detail::push(buffer, v.value);
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct bytea_traits : public base_object_traits<T, BYTEAOID>
|
|
{
|
|
enum { array_type_id = 1001 };
|
|
};
|
|
|
|
template<> struct object_traits<qtl::const_blob_data> : public bytea_traits<qtl::const_blob_data>
|
|
{
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result.data = data;
|
|
result.size = end-data;
|
|
return end;
|
|
}
|
|
static std::pair<const char*, size_t> data(const qtl::const_blob_data& v, std::vector<char>& /*buffer*/)
|
|
{
|
|
assert(v.size <= UINT32_MAX);
|
|
return std::make_pair(static_cast<const char*>(v.data), v.size);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<qtl::blob_data> : public bytea_traits<qtl::blob_data>
|
|
{
|
|
static const char* get(qtl::blob_data& value, const char* data, const char* end)
|
|
{
|
|
if (value.size < end-data)
|
|
throw std::out_of_range("no enough buffer to receive blob data.");
|
|
memcpy(value.data, data, end-data);
|
|
return end;
|
|
}
|
|
static std::pair<const char*, size_t> data(const qtl::blob_data& v, std::vector<char>& /*buffer*/)
|
|
{
|
|
assert(v.size <= UINT32_MAX);
|
|
return std::make_pair(static_cast<char*>(v.data), v.size);
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<std::vector<uint8_t>> : public bytea_traits<std::vector<uint8_t>>
|
|
{
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
result.assign(data, end);
|
|
return end;
|
|
}
|
|
static std::pair<const char*, size_t> data(const std::vector<uint8_t>& v, std::vector<char>& /*buffer*/)
|
|
{
|
|
assert(v.size() <= UINT32_MAX);
|
|
return std::make_pair(reinterpret_cast<const char*>(v.data()), v.size());
|
|
}
|
|
};
|
|
|
|
template<> struct object_traits<large_object> : public base_object_traits<large_object, OIDOID>
|
|
{
|
|
enum { array_type_id = OIDARRAYOID };
|
|
static value_type get(PGconn* conn, const char* data, const char* end)
|
|
{
|
|
int32_t oid;
|
|
object_traits<int32_t>::get(oid, data, end);
|
|
return large_object(conn, oid, std::ios::in | std::ios::out | std::ios::binary);
|
|
}
|
|
static std::pair<const char*, size_t> data(const large_object& v, std::vector<char>& buffer)
|
|
{
|
|
return object_traits<int32_t>::data(v.oid(), buffer);
|
|
}
|
|
};
|
|
|
|
template<typename T, Oid id>
|
|
struct vector_traits : public base_object_traits<std::vector<T>, id>
|
|
{
|
|
typedef typename base_object_traits<std::vector<T>, id>::value_type value_type;
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
if (end - data < sizeof(array_header))
|
|
throw std::overflow_error("insufficient data left in message");
|
|
|
|
array_header header = *reinterpret_cast<const array_header*>(data);
|
|
detail::ntoh_inplace(header.ndim);
|
|
detail::ntoh_inplace(header.flags);
|
|
detail::ntoh_inplace(header.elemtype);
|
|
detail::ntoh_inplace(header.dims[0].length);
|
|
detail::ntoh_inplace(header.dims[0].lower_bound);
|
|
if (header.ndim != 1 || !object_traits<T>::is_match(header.elemtype))
|
|
throw std::bad_cast();
|
|
|
|
data += sizeof(array_header);
|
|
result.reserve(header.dims[0].length);
|
|
|
|
for (int32_t i = 0; i != header.dims[0].length; i++)
|
|
{
|
|
int32_t size;
|
|
T value;
|
|
data = detail::pop(data, size);
|
|
if (end - data < size)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
data = object_traits<T>::get(value, data, data + size);
|
|
if (data > end)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
result.push_back(value);
|
|
}
|
|
return data;
|
|
}
|
|
static std::pair<const char*, size_t> data(const std::vector<T>& v, std::vector<char>& buffer)
|
|
{
|
|
assert(v.size() <= INT32_MAX);
|
|
size_t n = buffer.size();
|
|
buffer.resize(n+sizeof(array_header));
|
|
array_header* header = reinterpret_cast<array_header*>(buffer.data()+n);
|
|
header->ndim = detail::hton(1);
|
|
header->flags = detail::hton(0);
|
|
header->elemtype = detail::hton(static_cast<int32_t>(object_traits<T>::type_id));
|
|
header->dims[0].length = detail::hton(static_cast<int32_t>(v.size()));
|
|
header->dims[0].lower_bound = detail::hton(1);
|
|
|
|
std::vector<char> temp;
|
|
for (const T& e : v)
|
|
{
|
|
std::pair<const char*, size_t> blob = object_traits<T>::data(e, temp);
|
|
detail::push(buffer, static_cast<int32_t>(blob.second));
|
|
buffer.insert(buffer.end(), blob.first, blob.first + blob.second);
|
|
}
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<typename Iterator, Oid id>
|
|
struct iterator_traits : public base_object_traits<Iterator, id>
|
|
{
|
|
static const char* get(Iterator first, Iterator last, const char* data, const char* end)
|
|
{
|
|
if (end - data < sizeof(array_header))
|
|
throw std::overflow_error("insufficient data left in message");
|
|
|
|
array_header header = *reinterpret_cast<const array_header*>(data);
|
|
detail::ntoh_inplace(header.ndim);
|
|
detail::ntoh_inplace(header.flags);
|
|
detail::ntoh_inplace(header.elemtype);
|
|
detail::ntoh_inplace(header.dims[0].length);
|
|
detail::ntoh_inplace(header.dims[0].lower_bound);
|
|
if (header.ndim != 1 || !object_traits<typename std::iterator_traits<Iterator>::value_type>::is_match(header.elemtype))
|
|
throw std::bad_cast();
|
|
|
|
data += sizeof(array_header);
|
|
if (std::distance(first, last) < header.dims[0].length)
|
|
throw std::out_of_range("length of array out of range");
|
|
|
|
Iterator it = first;
|
|
for (int32_t i = 0; i != header.dims[0].length; i++, it++)
|
|
{
|
|
int32_t size;
|
|
data = detail::pop(data, size);
|
|
if (end - data < size)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
data = object_traits<typename std::iterator_traits<Iterator>::value_type>::get(*it, data, data + size);
|
|
if (data >= end)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
}
|
|
return data;
|
|
}
|
|
static std::pair<const char*, size_t> data(Iterator first, Iterator last, std::vector<char>& buffer)
|
|
{
|
|
assert(std::distance(first, last) <= INT32_MAX);
|
|
size_t n = buffer.size();
|
|
buffer.resize(n + sizeof(array_header));
|
|
array_header* header = reinterpret_cast<array_header*>(buffer.data() + n);
|
|
header->ndim = detail::hton(1);
|
|
header->flags = detail::hton(0);
|
|
header->elemtype = detail::hton(static_cast<int32_t>(object_traits<typename std::iterator_traits<Iterator>::value_type>::type_id));
|
|
header->dims[0].length = detail::hton(static_cast<int32_t>(std::distance(first, last)));
|
|
header->dims[0].lower_bound = detail::hton(1);
|
|
|
|
std::vector<char> temp;
|
|
for (Iterator it=first; it!=last; it++)
|
|
{
|
|
std::pair<const char*, size_t> blob = object_traits<typename std::iterator_traits<Iterator>::value_type>::data(*it, temp);
|
|
detail::push(buffer, static_cast<int32_t>(blob.second));
|
|
buffer.insert(buffer.end(), blob.first, blob.first + blob.second);
|
|
}
|
|
return std::make_pair(buffer.data() + n, buffer.size() - n);
|
|
}
|
|
};
|
|
|
|
template<typename Iterator, Oid id>
|
|
struct range_traits : public base_object_traits<std::pair<Iterator, Iterator>, id>
|
|
{
|
|
static const char* get(std::pair<Iterator, Iterator>& result, const char* data, const char* end)
|
|
{
|
|
return iterator_traits<Iterator, id>::get(result.first, result.second, data, end);
|
|
}
|
|
static std::pair<const char*, size_t> data(const std::pair<Iterator, Iterator>& v, std::vector<char>& buffer)
|
|
{
|
|
return iterator_traits<Iterator, id>::data(v.first, v.second, buffer);
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct object_traits<std::vector<T>> : public vector_traits<T, object_traits<T>::array_type_id>
|
|
{
|
|
};
|
|
|
|
template<typename Iterator>
|
|
struct object_traits<std::pair<typename std::enable_if<std::is_object<typename std::iterator_traits<Iterator>::value_type>::value, Iterator>::type, Iterator>> :
|
|
public range_traits<Iterator, object_traits<typename std::iterator_traits<Iterator>::value_type>::array_type_id>
|
|
{
|
|
};
|
|
|
|
template<typename T, size_t N, Oid id>
|
|
struct carray_traits : public base_object_traits<T(&)[N], id>
|
|
{
|
|
static const char* get(T (&result)[N], const char* data, const char* end)
|
|
{
|
|
return iterator_traits<T*, id>::get(std::begin(result), std::end(result), data, end);
|
|
}
|
|
static std::pair<const char*, size_t> data(const T (&v)[N], std::vector<char>& buffer)
|
|
{
|
|
return iterator_traits<const T*, id>::data(std::begin(v), std::end(v), buffer);
|
|
}
|
|
};
|
|
|
|
template<typename T, size_t N, Oid id>
|
|
struct array_traits : public base_object_traits<std::array<T, N>, id>
|
|
{
|
|
static const char* get(std::array<T, N>& result, const char* data, const char* end)
|
|
{
|
|
return iterator_traits<T*, id>::get(std::begin(result), std::end(result), data, end);
|
|
}
|
|
static std::pair<const char*, size_t> data(const std::array<T, N>& v, std::vector<char>& buffer)
|
|
{
|
|
return iterator_traits<T*, id>::data(std::begin(v), std::end(v), buffer);
|
|
}
|
|
};
|
|
|
|
template<typename T, size_t N> struct object_traits<T (&)[N]> : public carray_traits<T, N, object_traits<T>::array_type_id>
|
|
{
|
|
};
|
|
|
|
template<typename T, size_t N> struct object_traits<std::array<T, N>> : public array_traits<T, N, object_traits<T>::array_type_id>
|
|
{
|
|
};
|
|
|
|
namespace detail
|
|
{
|
|
|
|
struct field_header
|
|
{
|
|
Oid type;
|
|
int32_t length;
|
|
};
|
|
|
|
template<typename Type>
|
|
static const char* get_field(Type& field, const char* data, const char* end)
|
|
{
|
|
field_header header = *reinterpret_cast<const field_header*>(data);
|
|
detail::ntoh_inplace(header.type);
|
|
detail::ntoh_inplace(header.length);
|
|
data += sizeof(field_header);
|
|
if (end - data < header.length)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
|
|
return object_traits<Type>::get(field, data, data + header.length);
|
|
}
|
|
|
|
template<typename Tuple, size_t N>
|
|
struct get_field_helper
|
|
{
|
|
const char* operator()(Tuple& result, const char* data, const char* end)
|
|
{
|
|
if (end - data < sizeof(field_header))
|
|
throw std::overflow_error("insufficient data left in message");
|
|
|
|
auto& field = std::get<std::tuple_size<Tuple>::value - N>(result);
|
|
data = get_field(field, data, end);
|
|
get_field_helper<Tuple, N - 1>()(result, data, end);
|
|
return data;
|
|
}
|
|
};
|
|
template<typename Tuple>
|
|
struct get_field_helper<Tuple, 1>
|
|
{
|
|
const char* operator()(Tuple& result, const char* data, const char* end)
|
|
{
|
|
if (end - data < sizeof(field_header))
|
|
throw std::overflow_error("insufficient data left in message");
|
|
|
|
auto& field = std::get<std::tuple_size<Tuple>::value - 1>(result);
|
|
return get_field(field, data, end);
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
static void push_field(const Type& field, std::vector<char>& buffer)
|
|
{
|
|
std::vector<char> temp;
|
|
detail::push(buffer, static_cast<int32_t>(object_traits<Type>::type_id));
|
|
auto result = object_traits<Type>::data(field, temp);
|
|
detail::push(buffer, static_cast<int32_t>(result.second));
|
|
buffer.insert(buffer.end(), result.first, result.first + result.second);
|
|
}
|
|
|
|
template<typename Tuple, size_t N>
|
|
struct push_field_helper
|
|
{
|
|
void operator()(const Tuple& data, std::vector<char>& buffer)
|
|
{
|
|
const auto& field = std::get<std::tuple_size<Tuple>::value - N>(data);
|
|
push_field(field, buffer);
|
|
push_field_helper<Tuple, N - 1>()(data, buffer);
|
|
}
|
|
};
|
|
template<typename Tuple>
|
|
struct push_field_helper<Tuple, 1>
|
|
{
|
|
void operator()(const Tuple& data, std::vector<char>& buffer)
|
|
{
|
|
const auto& field = std::get<std::tuple_size<Tuple>::value - 1>(data);
|
|
push_field(field, buffer);
|
|
}
|
|
};
|
|
|
|
template<typename Tuple>
|
|
static const char* get_fields(Tuple& result, const char* data, const char* end)
|
|
{
|
|
return get_field_helper<Tuple, std::tuple_size<Tuple>::value>()(result, data, end);
|
|
}
|
|
|
|
template<typename Tuple>
|
|
static void push_fields(const Tuple& data, std::vector<char>& buffer)
|
|
{
|
|
push_field_helper<Tuple, std::tuple_size<Tuple>::value>()(data, buffer);
|
|
}
|
|
|
|
}
|
|
|
|
template<typename Tuple, Oid id>
|
|
struct tuple_traits : public base_object_traits<Tuple, id>
|
|
{
|
|
typedef typename base_object_traits<Tuple, id>::value_type value_type;
|
|
static const char* get(value_type& result, const char* data, const char* end)
|
|
{
|
|
int32_t count;
|
|
data = detail::pop(data, count);
|
|
if (data >= end)
|
|
throw std::overflow_error("insufficient data left in message");
|
|
if (std::tuple_size<Tuple>::value != count)
|
|
throw std::bad_cast();
|
|
return detail::get_fields(result, data, end);
|
|
}
|
|
static std::pair<const char*, size_t> data(const value_type& v, std::vector<char>& buffer)
|
|
{
|
|
size_t n = buffer.size();
|
|
detail::push(buffer, static_cast<int32_t>(std::tuple_size<value_type>::value));
|
|
detail::push_fields(v, buffer);
|
|
return std::make_pair(buffer.data()+n, buffer.size()-n);
|
|
}
|
|
};
|
|
|
|
template<typename... Types>
|
|
struct object_traits<std::tuple<Types...>> : public tuple_traits<std::tuple<Types...>, InvalidOid>
|
|
{
|
|
};
|
|
|
|
template<typename T1, typename T2>
|
|
struct object_traits<std::pair<T1, T2>> : public tuple_traits<std::pair<T1, T2>, InvalidOid>
|
|
{
|
|
};
|
|
|
|
struct binder
|
|
{
|
|
binder() = default;
|
|
template<typename T>
|
|
explicit binder(const T& v)
|
|
{
|
|
m_type = object_traits<T>::value();
|
|
auto pair = object_traits<T>::data(v);
|
|
m_value = pair.first;
|
|
m_length = pair.second;
|
|
}
|
|
binder(const char* data, size_t n, Oid oid)
|
|
{
|
|
m_type = oid;
|
|
m_value = data;
|
|
m_length = n;
|
|
}
|
|
|
|
Oid constexpr type() const { return m_type; }
|
|
size_t length() const { return m_length; }
|
|
const char* value() const { return m_value; }
|
|
|
|
template<typename T>
|
|
T get()
|
|
{
|
|
if (!object_traits<T>::is_match(m_type))
|
|
throw std::bad_cast();
|
|
|
|
T v;
|
|
object_traits<T>::get(v, m_value, m_value + m_length);
|
|
return v;
|
|
}
|
|
template<typename T>
|
|
T get(PGconn* conn)
|
|
{
|
|
if (!object_traits<T>::is_match(m_type))
|
|
throw std::bad_cast();
|
|
|
|
return object_traits<T>::get(conn, m_value, m_value + m_length);
|
|
}
|
|
template<typename T>
|
|
void get(T& v)
|
|
{
|
|
if (object_traits<T>::type_id!= InvalidOid && !object_traits<T>::is_match(m_type))
|
|
throw std::bad_cast();
|
|
|
|
object_traits<T>::get(v, m_value, m_value + m_length);
|
|
}
|
|
|
|
void bind(std::nullptr_t)
|
|
{
|
|
m_value = nullptr;
|
|
m_length = 0;
|
|
}
|
|
void bind(qtl::null)
|
|
{
|
|
bind(nullptr);
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<!std::is_array<T>::value>::type>
|
|
void bind(const T& v)
|
|
{
|
|
typedef typename std::decay<T>::type param_type;
|
|
if (m_type!=0 && !object_traits<param_type>::is_match(m_type))
|
|
throw std::bad_cast();
|
|
|
|
auto pair = object_traits<param_type>::data(v, m_data);
|
|
m_value = pair.first;
|
|
m_length = pair.second;
|
|
}
|
|
void bind(const char* data, size_t length=0)
|
|
{
|
|
m_value = data;
|
|
if(length>0) m_length = length;
|
|
else m_length = strlen(data);
|
|
}
|
|
template<typename T, size_t N>
|
|
void bind(const T(&v)[N])
|
|
{
|
|
if (m_type != 0 && !object_traits<T(&)[N]>::is_match(m_type))
|
|
throw std::bad_cast();
|
|
|
|
auto pair = object_traits<T(&)[N]>::data(v, m_data);
|
|
m_value = pair.first;
|
|
m_length = pair.second;
|
|
}
|
|
|
|
private:
|
|
Oid m_type;
|
|
const char* m_value;
|
|
size_t m_length;
|
|
std::vector<char> m_data;
|
|
};
|
|
|
|
template<size_t N, size_t I, typename Arg, typename... Other>
|
|
inline void make_binder_list_helper(std::array<binder, N>& binders, Arg&& arg, Other&&... other)
|
|
{
|
|
binders[I]=binder(arg);
|
|
make_binder_list_helper<N, I+1>(binders, std::forward<Other>(other)...);
|
|
}
|
|
|
|
template<typename... Args>
|
|
inline std::array<binder, sizeof...(Args)> make_binder_list(Args&&... args)
|
|
{
|
|
std::array<binder, sizeof...(Args)> binders;
|
|
binders.reserve(sizeof...(Args));
|
|
make_binder_list_helper<sizeof...(Args), 0>(binders, std::forward<Args>(args)...);
|
|
return binders;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool in_impl(const T& from, const T& to)
|
|
{
|
|
return std::equal_to<T>()(from, to);
|
|
}
|
|
|
|
template<typename T, typename... Ts >
|
|
inline bool in_impl(const T& from, const T& to, const Ts&... other)
|
|
{
|
|
return std::equal_to<T>()(from, to) || in_impl(from, other...);
|
|
}
|
|
|
|
template<typename T, T... values>
|
|
inline bool in(const T& v)
|
|
{
|
|
return in_impl(v, values...);
|
|
}
|
|
|
|
class result
|
|
{
|
|
public:
|
|
result(PGresult* res) : m_res(res) { }
|
|
result(const result&) = delete;
|
|
result(result&& src)
|
|
{
|
|
m_res = src.m_res;
|
|
src.m_res = nullptr;
|
|
}
|
|
|
|
result& operator=(const result&) = delete;
|
|
result& operator=(result&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
clear();
|
|
m_res = src.m_res;
|
|
src.m_res = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
~result()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
PGresult* handle() const { return m_res; }
|
|
operator bool() const { return m_res != nullptr; }
|
|
|
|
ExecStatusType status() const
|
|
{
|
|
return PQresultStatus(m_res);
|
|
}
|
|
|
|
long long affected_rows() const
|
|
{
|
|
char* result = PQcmdTuples(m_res);
|
|
if (result)
|
|
return strtoll(result, nullptr, 10);
|
|
else
|
|
return 0LL;
|
|
}
|
|
|
|
unsigned int get_column_count() const { return PQnfields(m_res); }
|
|
|
|
int get_param_count() const
|
|
{
|
|
return PQnparams(m_res);
|
|
}
|
|
|
|
Oid get_param_type(int col) const
|
|
{
|
|
return PQparamtype(m_res, col);
|
|
}
|
|
|
|
const char* get_column_name(int col) const
|
|
{
|
|
return PQfname(m_res, col);
|
|
}
|
|
int get_column_index(const char* name) const
|
|
{
|
|
return PQfnumber(m_res, name);
|
|
}
|
|
int get_column_length(int col) const
|
|
{
|
|
return PQfsize(m_res, col);
|
|
}
|
|
Oid get_column_type(int col) const
|
|
{
|
|
return PQftype(m_res, col);
|
|
}
|
|
|
|
const char* get_value(int row, int col) const
|
|
{
|
|
return PQgetvalue(m_res, row, col);
|
|
}
|
|
|
|
bool is_null(int row, int col) const
|
|
{
|
|
return PQgetisnull(m_res, row, col);
|
|
}
|
|
|
|
int length(int row, int col) const
|
|
{
|
|
return PQgetlength(m_res, row, col);
|
|
}
|
|
|
|
Oid insert_oid() const
|
|
{
|
|
return PQoidValue(m_res);
|
|
}
|
|
|
|
template<ExecStatusType... Excepted>
|
|
void verify_error()
|
|
{
|
|
if (m_res)
|
|
{
|
|
ExecStatusType got = status();
|
|
if (! in<ExecStatusType, Excepted...>(got))
|
|
throw error(m_res);
|
|
}
|
|
}
|
|
|
|
template<ExecStatusType... Excepted>
|
|
void verify_error(error& e)
|
|
{
|
|
if (m_res)
|
|
{
|
|
ExecStatusType got = status();
|
|
if (!in<ExecStatusType, Excepted...>(got))
|
|
e = error(m_res);
|
|
}
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
if (m_res)
|
|
{
|
|
PQclear(m_res);
|
|
m_res = nullptr;
|
|
}
|
|
}
|
|
|
|
private:
|
|
PGresult* m_res;
|
|
};
|
|
|
|
class base_statement
|
|
{
|
|
friend class error;
|
|
public:
|
|
explicit base_statement(base_database& db);
|
|
~base_statement()
|
|
{
|
|
}
|
|
base_statement(const base_statement&) = delete;
|
|
base_statement(base_statement&& src)
|
|
: m_conn(src.m_conn), m_binders(std::move(src.m_binders)), m_res(std::move(src.m_res)), _name(std::move(src._name))
|
|
{
|
|
}
|
|
base_statement& operator=(const base_statement&) = delete;
|
|
base_statement& operator=(base_statement&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
close();
|
|
m_conn = src.m_conn;
|
|
m_binders = std::move(src.m_binders);
|
|
m_res = std::move(src.m_res);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
result& get_result() { return m_res; }
|
|
|
|
void close()
|
|
{
|
|
m_res = nullptr;
|
|
}
|
|
|
|
uint64_t affetced_rows() const
|
|
{
|
|
return m_res.affected_rows();
|
|
}
|
|
|
|
void bind_param(size_t index, const char* param, size_t length)
|
|
{
|
|
m_binders[index].bind(param, length);
|
|
}
|
|
template<class Param>
|
|
void bind_param(size_t index, const Param& param)
|
|
{
|
|
m_binders[index].bind(param);
|
|
}
|
|
|
|
template<class Type>
|
|
void bind_field(size_t index, Type&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
value = Type();
|
|
else
|
|
value = m_binders[index].get<typename std::remove_const<Type>::type>();
|
|
}
|
|
|
|
void bind_field(size_t index, char* value, size_t length)
|
|
{
|
|
memcpy(value, m_binders[index].value(), std::min<size_t>(length, m_binders[index].length()));
|
|
}
|
|
|
|
template<size_t N>
|
|
void bind_field(size_t index, std::array<char, N>&& value)
|
|
{
|
|
bind_field(index, value.data(), value.size());
|
|
}
|
|
|
|
template<typename T>
|
|
void bind_field(size_t index, bind_string_helper<T>&& value)
|
|
{
|
|
value.assign(m_binders[index].value(), m_binders[index].length());
|
|
}
|
|
|
|
template<typename Type>
|
|
void bind_field(size_t index, indicator<Type>&& value)
|
|
{
|
|
if (m_res)
|
|
{
|
|
qtl::bind_field(*this, index, value.data);
|
|
value.is_null = m_res.is_null(0, static_cast<int>(index));
|
|
value.length = m_res.length(0, static_cast<int>(index));
|
|
value.is_truncated = m_binders[index].length() < value.length;
|
|
}
|
|
}
|
|
|
|
void bind_field(size_t index, large_object&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
value.close();
|
|
else
|
|
value = m_binders[index].get<large_object>(m_conn);
|
|
}
|
|
void bind_field(size_t index, blob_data&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
{
|
|
value.data = nullptr;
|
|
value.size = 0;
|
|
}
|
|
else
|
|
{
|
|
m_binders[index].get(value);
|
|
}
|
|
}
|
|
|
|
template<typename... Types>
|
|
void bind_field(size_t index, std::tuple<Types...>&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
value = std::tuple<Types...>();
|
|
else
|
|
m_binders[index].get(value);
|
|
}
|
|
|
|
#ifdef _QTL_ENABLE_CPP17
|
|
|
|
template<typename T>
|
|
inline void bind_field(size_t index, std::optional<T>&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
{
|
|
value.reset();
|
|
}
|
|
else
|
|
{
|
|
T v;
|
|
bind_field(index, v);
|
|
value = std::move(v);
|
|
}
|
|
}
|
|
|
|
void bind_field(size_t index, std::any&& value)
|
|
{
|
|
if (m_res.is_null(0, static_cast<int>(index)))
|
|
{
|
|
value = nullptr;
|
|
}
|
|
else
|
|
{
|
|
Oid oid = m_res.get_column_type(index);
|
|
switch (oid)
|
|
{
|
|
case object_traits<bool>::type_id:
|
|
value = field_cast<bool>(index);
|
|
break;
|
|
case object_traits<char>::type_id:
|
|
value = field_cast<char>(index);
|
|
break;
|
|
case object_traits<float>::type_id:
|
|
value = field_cast<float>(index);
|
|
break;
|
|
case object_traits<double>::type_id:
|
|
value = field_cast<double>(index);
|
|
break;
|
|
case object_traits<int16_t>::type_id:
|
|
value = field_cast<int16_t>(index);
|
|
break;
|
|
case object_traits<int32_t>::type_id:
|
|
value = field_cast<int32_t>(index);
|
|
break;
|
|
case object_traits<int64_t>::type_id:
|
|
value = field_cast<int64_t>(index);
|
|
break;
|
|
case object_traits<Oid>::type_id:
|
|
value = field_cast<Oid>(index);
|
|
break;
|
|
case object_traits<std::string>::type_id:
|
|
value = field_cast<std::string>(index);
|
|
break;
|
|
case object_traits<timestamp>::type_id:
|
|
value = field_cast<timestamp>(index);
|
|
break;
|
|
case object_traits<interval>::type_id:
|
|
value = field_cast<interval>(index);
|
|
break;
|
|
case object_traits<date>::type_id:
|
|
value = field_cast<date>(index);
|
|
break;
|
|
case object_traits<std::vector<uint8_t>>::type_id:
|
|
value = field_cast<std::vector<uint8_t>>(index);
|
|
break;
|
|
case object_traits<bool>::array_type_id:
|
|
value = field_cast<std::vector<bool>>(index);
|
|
break;
|
|
case object_traits<char>::array_type_id:
|
|
value = field_cast<std::vector<char>>(index);
|
|
break;
|
|
case object_traits<float>::array_type_id:
|
|
value = field_cast<std::vector<float>>(index);
|
|
break;
|
|
case object_traits<double>::array_type_id:
|
|
value = field_cast<std::vector<double>>(index);
|
|
break;
|
|
case object_traits<int16_t>::array_type_id:
|
|
value = field_cast<std::vector<int16_t>>(index);
|
|
break;
|
|
case object_traits<int32_t>::array_type_id:
|
|
value = field_cast<std::vector<int32_t>>(index);
|
|
break;
|
|
case object_traits<int64_t>::array_type_id:
|
|
value = field_cast<std::vector<int64_t>>(index);
|
|
break;
|
|
case object_traits<Oid>::array_type_id:
|
|
value = field_cast<std::vector<Oid>>(index);
|
|
break;
|
|
case object_traits<std::string>::array_type_id:
|
|
value = field_cast<std::vector<std::string>>(index);
|
|
break;
|
|
case object_traits<timestamp>::array_type_id:
|
|
value = field_cast<std::vector<timestamp>>(index);
|
|
break;
|
|
case object_traits<interval>::array_type_id:
|
|
value = field_cast<std::vector<interval>>(index);
|
|
break;
|
|
case object_traits<date>::array_type_id:
|
|
value = field_cast<std::vector<date>>(index);
|
|
break;
|
|
default:
|
|
throw postgres::error("Unsupported field type");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // C++17
|
|
|
|
protected:
|
|
PGconn* m_conn;
|
|
result m_res;
|
|
std::string _name;
|
|
std::vector<binder> m_binders;
|
|
|
|
template<ExecStatusType... Excepted>
|
|
void verify_error()
|
|
{
|
|
if (m_res)
|
|
m_res.verify_error<Excepted...>();
|
|
else
|
|
throw error(m_conn);
|
|
}
|
|
void finish(result& res)
|
|
{
|
|
while (res)
|
|
{
|
|
res = PQgetResult(m_conn);
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
T field_cast(size_t index)
|
|
{
|
|
T v;
|
|
m_binders[index].get(v);
|
|
return v;
|
|
}
|
|
};
|
|
|
|
class statement : public base_statement
|
|
{
|
|
public:
|
|
explicit statement(base_database& db) : base_statement(db)
|
|
{
|
|
}
|
|
statement(const statement&) = delete;
|
|
statement(statement&& src) : base_statement(std::move(src))
|
|
{
|
|
}
|
|
|
|
~statement()
|
|
{
|
|
finish(m_res);
|
|
|
|
if (!_name.empty())
|
|
{
|
|
std::ostringstream oss;
|
|
oss << "DEALLOCATE " << _name << ";";
|
|
result res = PQexec(m_conn, oss.str().data());
|
|
error e(res.handle());
|
|
}
|
|
}
|
|
|
|
void open(const char* command, int nParams=0, const Oid *paramTypes=nullptr)
|
|
{
|
|
_name.resize(sizeof(intptr_t) * 2+1);
|
|
int n = sprintf(const_cast<char*>(_name.data()), "q%p", this);
|
|
_name.resize(n);
|
|
std::transform(_name.begin(), _name.end(), _name.begin(), tolower);
|
|
result res = PQprepare(m_conn, _name.data(), command, nParams, paramTypes);
|
|
res.verify_error<PGRES_COMMAND_OK>();
|
|
}
|
|
template<typename... Types>
|
|
void open(const char* command)
|
|
{
|
|
auto binder_list = make_binder_list(Types()...);
|
|
std::array<Oid, sizeof...(Types)> types;
|
|
std::transform(binder_list.begin(), binder_list.end(), types.begin(), [](const binder& b) {
|
|
return b.type();
|
|
});
|
|
|
|
open(command, types.size(), types.data());
|
|
}
|
|
|
|
void attach(const char* name)
|
|
{
|
|
result res = PQdescribePrepared(m_conn, name);
|
|
res.verify_error<PGRES_COMMAND_OK>();
|
|
_name = name;
|
|
}
|
|
|
|
void execute()
|
|
{
|
|
if(!PQsendQueryPrepared(m_conn, _name.data(), 0, nullptr, nullptr, nullptr, 1))
|
|
throw error(m_conn);
|
|
if (!PQsetSingleRowMode(m_conn))
|
|
throw error(m_conn);
|
|
m_res = PQgetResult(m_conn);
|
|
verify_error<PGRES_COMMAND_OK, PGRES_SINGLE_TUPLE>();
|
|
}
|
|
|
|
template<typename Types>
|
|
void execute(const Types& params)
|
|
{
|
|
const size_t count = qtl::params_binder<statement, Types>::size;
|
|
if (count > 0)
|
|
{
|
|
m_binders.resize(count);
|
|
qtl::bind_params(*this, params);
|
|
|
|
std::array<const char*, count> values;
|
|
std::array<int, count> lengths;
|
|
std::array<int, count> formats;
|
|
for (size_t i = 0; i != m_binders.size(); i++)
|
|
{
|
|
values[i] = m_binders[i].value();
|
|
lengths[i] = static_cast<int>(m_binders[i].length());
|
|
formats[i] = 1;
|
|
}
|
|
if (!PQsendQueryPrepared(m_conn, _name.data(), static_cast<int>(m_binders.size()), values.data(), lengths.data(), formats.data(), 1))
|
|
throw error(m_conn);
|
|
}
|
|
else
|
|
{
|
|
if (!PQsendQueryPrepared(m_conn, _name.data(), 0, nullptr, nullptr, nullptr, 1))
|
|
throw error(m_conn);
|
|
}
|
|
if (!PQsetSingleRowMode(m_conn))
|
|
throw error(m_conn);
|
|
m_res = PQgetResult(m_conn);
|
|
verify_error<PGRES_COMMAND_OK, PGRES_SINGLE_TUPLE, PGRES_TUPLES_OK>();
|
|
}
|
|
|
|
template<typename Types>
|
|
bool fetch(Types&& values)
|
|
{
|
|
if (m_res)
|
|
{
|
|
ExecStatusType status = m_res.status();
|
|
if (status == PGRES_SINGLE_TUPLE)
|
|
{
|
|
int count = m_res.get_column_count();
|
|
if (count > 0)
|
|
{
|
|
m_binders.resize(count);
|
|
for (int i = 0; i != count; i++)
|
|
{
|
|
m_binders[i]=binder(m_res.get_value(0, i), m_res.length(0, i),
|
|
m_res.get_column_type(i));
|
|
}
|
|
qtl::bind_record(*this, std::forward<Types>(values));
|
|
}
|
|
m_res = PQgetResult(m_conn);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
verify_error<PGRES_TUPLES_OK>();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool next_result()
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
return m_res && m_res.status() == PGRES_SINGLE_TUPLE;
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
finish(m_res);
|
|
m_res.clear();
|
|
}
|
|
};
|
|
|
|
class base_database
|
|
{
|
|
protected:
|
|
base_database()
|
|
{
|
|
m_conn = nullptr;
|
|
}
|
|
|
|
public:
|
|
typedef postgres::error exception_type;
|
|
|
|
base_database(const base_database&) = delete;
|
|
base_database(base_database&& src)
|
|
{
|
|
m_conn = src.m_conn;
|
|
src.m_conn = nullptr;
|
|
}
|
|
|
|
~base_database()
|
|
{
|
|
if (m_conn)
|
|
PQfinish(m_conn);
|
|
}
|
|
|
|
base_database& operator=(const base_database&) = delete;
|
|
base_database& operator=(base_database&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
if (m_conn)
|
|
PQfinish(m_conn);
|
|
m_conn = src.m_conn;
|
|
src.m_conn = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
const char* errmsg() const
|
|
{
|
|
return PQerrorMessage(m_conn);
|
|
}
|
|
|
|
PGconn* handle() { return m_conn; }
|
|
|
|
const char* encoding() const
|
|
{
|
|
int encoding = PQclientEncoding(m_conn);
|
|
return (encoding >= 0) ? pg_encoding_to_char(encoding) : nullptr;
|
|
}
|
|
|
|
void encoding(const char* encoding)
|
|
{
|
|
if (PQsetClientEncoding(m_conn, encoding))
|
|
throw error(m_conn);
|
|
}
|
|
|
|
void trace(FILE* stream)
|
|
{
|
|
PQtrace(m_conn, stream);
|
|
}
|
|
void untrace()
|
|
{
|
|
PQuntrace(m_conn);
|
|
}
|
|
|
|
const char* current() const
|
|
{
|
|
return PQdb(m_conn);
|
|
}
|
|
|
|
const char* user() const
|
|
{
|
|
return PQuser(m_conn);
|
|
}
|
|
|
|
const char* host() const
|
|
{
|
|
return PQhost(m_conn);
|
|
}
|
|
|
|
const char* password() const
|
|
{
|
|
return PQpass(m_conn);
|
|
}
|
|
|
|
const char* port() const
|
|
{
|
|
return PQport(m_conn);
|
|
}
|
|
|
|
const char* options() const
|
|
{
|
|
return PQoptions(m_conn);
|
|
}
|
|
|
|
ConnStatusType status() const
|
|
{
|
|
return PQstatus(m_conn);
|
|
}
|
|
|
|
PGTransactionStatusType transactionStatus() const
|
|
{
|
|
return PQtransactionStatus(m_conn);
|
|
}
|
|
|
|
const char* parameterStatus(const char *paramName) const
|
|
{
|
|
return PQparameterStatus(m_conn, paramName);
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
if(status() == CONNECTION_BAD)
|
|
PQreset(m_conn);
|
|
}
|
|
|
|
void close()
|
|
{
|
|
PQfinish(m_conn);
|
|
m_conn = nullptr;
|
|
}
|
|
|
|
protected:
|
|
PGconn* m_conn;
|
|
void throw_exception() { throw postgres::error(m_conn); }
|
|
};
|
|
|
|
class simple_statment : public base_statement
|
|
{
|
|
public:
|
|
simple_statment(base_database& db, qtl::postgres::result&& res) : base_statement(db)
|
|
{
|
|
m_res = std::move(res);
|
|
}
|
|
|
|
template<typename ValueProc>
|
|
void fetch_all(ValueProc& proc)
|
|
{
|
|
int row_count = PQntuples(m_res.handle());
|
|
if (row_count > 0)
|
|
{
|
|
int col_count = m_res.get_column_count();
|
|
m_binders.resize(col_count);
|
|
auto values = qtl::detail::make_values(proc);
|
|
for (int i = 0; i != row_count; i++)
|
|
{
|
|
for (int j = 0; j != col_count; j++)
|
|
{
|
|
m_binders[j] = binder(m_res.get_value(i, j), m_res.length(i, j),
|
|
m_res.get_column_type(j));
|
|
}
|
|
qtl::bind_record(*this, std::forward<decltype(values)>(values));
|
|
qtl::detail::apply(proc, std::forward<decltype(values)>(values));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
class database : public base_database, public qtl::base_database<database, statement>
|
|
{
|
|
public:
|
|
database() = default;
|
|
|
|
bool open(const std::map<std::string, std::string>& params, bool expand_dbname = false)
|
|
{
|
|
std::vector<const char*> keywords(params.size()+1);
|
|
std::vector<const char*> values(params.size()+1);
|
|
for (auto& param : params)
|
|
{
|
|
keywords.push_back(param.first.data());
|
|
values.push_back(param.second.data());
|
|
}
|
|
keywords.push_back(nullptr);
|
|
values.push_back(nullptr);
|
|
m_conn = PQconnectdbParams(keywords.data(), values.data(), expand_dbname);
|
|
return m_conn != nullptr && status()== CONNECTION_OK;
|
|
}
|
|
|
|
bool open(const char * conninfo)
|
|
{
|
|
m_conn = PQconnectdb(conninfo);
|
|
return m_conn != nullptr && status() == CONNECTION_OK;
|
|
}
|
|
|
|
bool open(const char* host, const char* user, const char* password,
|
|
unsigned short port = 5432, const char* db = "postgres", const char* options = nullptr)
|
|
{
|
|
char port_text[16];
|
|
sprintf(port_text, "%u", port);
|
|
m_conn = PQsetdbLogin(host, port_text, options, nullptr, db, user, password);
|
|
return m_conn != nullptr && status() == CONNECTION_OK;
|
|
}
|
|
|
|
statement open_command(const char* query_text, size_t /*text_length*/)
|
|
{
|
|
statement stmt(*this);
|
|
stmt.open(query_text);
|
|
return stmt;
|
|
}
|
|
statement open_command(const char* query_text)
|
|
{
|
|
return open_command(query_text, 0);
|
|
}
|
|
statement open_command(const std::string& query_text)
|
|
{
|
|
return open_command(query_text.data());
|
|
}
|
|
|
|
void simple_execute(const char* query_text, uint64_t* paffected = nullptr)
|
|
{
|
|
qtl::postgres::result res(PQexec(m_conn, query_text));
|
|
if (!res) throw_exception();
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>();
|
|
if (paffected) *paffected = res.affected_rows();
|
|
}
|
|
template<typename ValueProc>
|
|
void simple_query(const char* query_text, ValueProc&& proc)
|
|
{
|
|
qtl::postgres::result res(PQexec(m_conn, query_text));
|
|
if (!res) throw_exception();
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>();
|
|
if (res.status() == PGRES_TUPLES_OK)
|
|
{
|
|
simple_statment stmt(*this, std::move(res));
|
|
stmt.fetch_all(std::forward<ValueProc>(proc));
|
|
}
|
|
}
|
|
|
|
void auto_commit(bool on)
|
|
{
|
|
if(on)
|
|
simple_execute("SET AUTOCOMMIT TO ON");
|
|
else
|
|
simple_execute("SET AUTOCOMMIT TO OFF");
|
|
}
|
|
|
|
void begin_transaction()
|
|
{
|
|
simple_execute("BEGIN");
|
|
}
|
|
void rollback()
|
|
{
|
|
simple_execute("ROLLBACK");
|
|
}
|
|
void commit()
|
|
{
|
|
simple_execute("COMMIT");
|
|
}
|
|
|
|
bool is_alive()
|
|
{
|
|
qtl::postgres::result res(PQexec(m_conn, ""));
|
|
return res && res.status() == PGRES_COMMAND_OK;
|
|
}
|
|
|
|
};
|
|
|
|
inline int event_flags(PostgresPollingStatusType status)
|
|
{
|
|
int flags = 0;
|
|
if (status == PGRES_POLLING_READING)
|
|
flags |= event::ef_read;
|
|
else if (status == PGRES_POLLING_WRITING)
|
|
flags |= event::ef_write;
|
|
else if (status == PGRES_POLLING_FAILED)
|
|
flags |= event::ef_exception;
|
|
return flags;
|
|
}
|
|
|
|
class async_connection;
|
|
|
|
template<typename Handler>
|
|
inline void async_wait(qtl::event* event, PGconn* conn, int timeout, Handler&& handler)
|
|
{
|
|
int flushed = PQflush(conn);
|
|
if (flushed < 0)
|
|
{
|
|
handler(error(conn));
|
|
return;
|
|
}
|
|
if (flushed == 1)
|
|
{
|
|
event->set_io_handler(qtl::event::ef_read | qtl::event::ef_write, timeout,
|
|
[event, conn, timeout, handler](int flags) mutable {
|
|
if (flags&qtl::event::ef_timeout)
|
|
{
|
|
handler(postgres::timeout());
|
|
return;
|
|
}
|
|
if (flags&qtl::event::ef_read)
|
|
{
|
|
if (!PQconsumeInput(conn))
|
|
{
|
|
handler(error(conn));
|
|
return;
|
|
}
|
|
}
|
|
if (flags&(qtl::event::ef_read | qtl::event::ef_write | event::ef_exception))
|
|
async_wait(event, conn, timeout, handler);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
event->set_io_handler(qtl::event::ef_read, 10,
|
|
[event, conn, timeout, handler](int flags) mutable {
|
|
if (flags&qtl::event::ef_timeout)
|
|
{
|
|
handler(postgres::timeout());
|
|
}
|
|
else if (flags&(qtl::event::ef_read | qtl::event::ef_exception))
|
|
{
|
|
if (PQconsumeInput(conn))
|
|
{
|
|
if (!PQisBusy(conn))
|
|
handler(postgres::error());
|
|
else
|
|
async_wait(event, conn, timeout, handler);
|
|
}
|
|
else
|
|
{
|
|
handler(postgres::error(conn));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
handler(postgres::error(conn));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
class async_statement : public base_statement
|
|
{
|
|
public:
|
|
async_statement(async_connection& db);
|
|
async_statement(async_statement&& src)
|
|
: base_statement(std::move(src)), m_timeout(2)
|
|
{
|
|
m_event = src.m_event;
|
|
m_timeout = src.m_timeout;
|
|
src.m_event = nullptr;
|
|
}
|
|
async_statement& operator=(async_statement&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
base_statement::operator =(std::move(src));
|
|
m_event = src.m_event;
|
|
m_timeout = src.m_timeout;
|
|
src.m_event = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
~async_statement()
|
|
{
|
|
close();
|
|
}
|
|
|
|
/*
|
|
Handler defiens as:
|
|
void handler(const qtl::mysql::error& e);
|
|
*/
|
|
template<typename Handler>
|
|
void open(Handler&& handler, const char* command, int nParams = 0, const Oid *paramTypes = nullptr)
|
|
{
|
|
_name.resize(sizeof(intptr_t) * 2 + 1);
|
|
int n = sprintf(const_cast<char*>(_name.data()), "q%p", this);
|
|
_name.resize(n);
|
|
std::transform(_name.begin(), _name.end(), _name.begin(), tolower);
|
|
if (PQsendPrepare(m_conn, _name.data(), command, nParams, paramTypes))
|
|
{
|
|
async_wait([this, handler](error e) mutable {
|
|
if (!e)
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
if (m_res)
|
|
{
|
|
m_res.verify_error<PGRES_COMMAND_OK>(e);
|
|
while(m_res)
|
|
m_res = PQgetResult(m_conn);
|
|
}
|
|
}
|
|
handler(e);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
_name.clear();
|
|
handler(error(m_conn));
|
|
}
|
|
}
|
|
|
|
template<typename Handler, typename... Types>
|
|
void open(Handler&& handler, const char* command)
|
|
{
|
|
auto binder_list = make_binder_list(Types()...);
|
|
std::array<Oid, sizeof...(Types)> types;
|
|
std::transform(binder_list.begin(), binder_list.end(), types.begin(), [](const binder& b) {
|
|
return b.type();
|
|
});
|
|
|
|
open(std::forward<Handler>(handler), command, types.size(), types.data());
|
|
}
|
|
|
|
void close()
|
|
{
|
|
while (m_res)
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
}
|
|
|
|
if (!_name.empty())
|
|
{
|
|
std::ostringstream oss;
|
|
oss << "DEALLOCATE " << _name << ";";
|
|
result res = PQexec(m_conn, oss.str().data());
|
|
error e;
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>(e);
|
|
finish(res);
|
|
if(e) throw e;
|
|
}
|
|
base_statement::close();
|
|
}
|
|
|
|
template<typename Handler>
|
|
void close(Handler&& handler)
|
|
{
|
|
while (m_res)
|
|
{
|
|
if(PQisBusy(m_conn))
|
|
{
|
|
async_wait([this, handler](const error& e) mutable {
|
|
close(handler);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
}
|
|
}
|
|
|
|
if (!_name.empty() && PQstatus(m_conn) == CONNECTION_OK)
|
|
{
|
|
std::ostringstream oss;
|
|
oss << "DEALLOCATE " << _name << ";";
|
|
bool ok = PQsendQuery(m_conn, oss.str().data());
|
|
if (ok)
|
|
{
|
|
async_wait([this, handler](postgres::error e) mutable {
|
|
if (PQstatus(m_conn) == CONNECTION_OK)
|
|
{
|
|
result res(PQgetResult(m_conn));
|
|
if (res)
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>(e);
|
|
if (!e) _name.clear();
|
|
finish(res);
|
|
handler(e);
|
|
}
|
|
else
|
|
{
|
|
_name.clear();
|
|
handler(error());
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
handler(error(m_conn));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_name.clear();
|
|
}
|
|
}
|
|
|
|
/*
|
|
ExecuteHandler defiens as:
|
|
void handler(const qtl::mysql::error& e, uint64_t affected);
|
|
*/
|
|
template<typename ExecuteHandler>
|
|
void execute(ExecuteHandler&& handler)
|
|
{
|
|
if (PQsendQueryPrepared(m_conn, _name.data(), 0, nullptr, nullptr, nullptr, 1) &&
|
|
PQsetSingleRowMode(m_conn))
|
|
{
|
|
async_wait([this, handler](error e) {
|
|
if (!e)
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
m_res.verify_error<PGRES_COMMAND_OK, PGRES_SINGLE_TUPLE>(e);
|
|
finish(m_res);
|
|
}
|
|
handler(e);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
handler(error(m_conn));
|
|
}
|
|
}
|
|
|
|
template<typename Types, typename Handler>
|
|
void execute(const Types& params, Handler&& handler)
|
|
{
|
|
const size_t count = qtl::params_binder<statement, Types>::size;
|
|
if (count > 0)
|
|
{
|
|
m_binders.resize(count);
|
|
qtl::bind_params(*this, params);
|
|
|
|
std::array<const char*, count> values;
|
|
std::array<int, count> lengths;
|
|
std::array<int, count> formats;
|
|
for (size_t i = 0; i != m_binders.size(); i++)
|
|
{
|
|
values[i] = m_binders[i].value();
|
|
lengths[i] = static_cast<int>(m_binders[i].length());
|
|
formats[i] = 1;
|
|
}
|
|
if (!PQsendQueryPrepared(m_conn, _name.data(), static_cast<int>(m_binders.size()), values.data(), lengths.data(), formats.data(), 1))
|
|
{
|
|
handler(error(m_conn), 0);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!PQsendQueryPrepared(m_conn, _name.data(), 0, nullptr, nullptr, nullptr, 1))
|
|
{
|
|
handler(error(m_conn), 0);
|
|
return;
|
|
}
|
|
}
|
|
if (!PQsetSingleRowMode(m_conn))
|
|
{
|
|
handler(error(m_conn), 0);
|
|
return;
|
|
}
|
|
if (PQisBusy(m_conn))
|
|
{
|
|
async_wait([this, handler](error e) mutable {
|
|
if (!e)
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
m_res.verify_error<PGRES_COMMAND_OK, PGRES_SINGLE_TUPLE>(e);
|
|
int64_t affected = m_res.affected_rows();
|
|
finish(m_res);
|
|
handler(e, affected);
|
|
}
|
|
else
|
|
{
|
|
handler(e, 0);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
template<typename Types, typename RowHandler, typename FinishHandler>
|
|
void fetch(Types&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
|
|
{
|
|
if (m_res)
|
|
{
|
|
ExecStatusType status = m_res.status();
|
|
if (status == PGRES_SINGLE_TUPLE)
|
|
{
|
|
int count = m_res.get_column_count();
|
|
if (count > 0)
|
|
{
|
|
m_binders.resize(count);
|
|
for (int i = 0; i != count; i++)
|
|
{
|
|
m_binders[i] = binder(m_res.get_value(0, i), m_res.length(0, i),
|
|
m_res.get_column_type(i));
|
|
}
|
|
qtl::bind_record(*this, std::forward<Types>(values));
|
|
}
|
|
row_handler();
|
|
if (PQisBusy(m_conn))
|
|
{
|
|
async_wait([this, &values, row_handler, finish_handler](const error& e) {
|
|
if (e)
|
|
{
|
|
finish_handler(e);
|
|
}
|
|
else
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
fetch(std::forward<Types>(values), row_handler, finish_handler);
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
fetch(std::forward<Types>(values), row_handler, finish_handler);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error e;
|
|
m_res.verify_error<PGRES_TUPLES_OK>(e);
|
|
finish_handler(e);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
finish_handler(error());
|
|
}
|
|
}
|
|
|
|
template<typename Handler>
|
|
void next_result(Handler&& handler)
|
|
{
|
|
async_wait([this, handler](const error& e) {
|
|
if (e)
|
|
{
|
|
handler(e);
|
|
}
|
|
else
|
|
{
|
|
m_res = PQgetResult(m_conn);
|
|
handler(error());
|
|
}
|
|
});
|
|
}
|
|
|
|
private:
|
|
event* m_event;
|
|
int m_timeout;
|
|
template<typename Handler>
|
|
void async_wait(Handler&& handler)
|
|
{
|
|
qtl::postgres::async_wait(m_event, m_conn, m_timeout, std::forward<Handler>(handler));
|
|
}
|
|
};
|
|
|
|
class async_connection : public base_database, public qtl::async_connection<async_connection, async_statement>
|
|
{
|
|
public:
|
|
async_connection() : m_connect_timeout(2), m_query_timeout(2)
|
|
{
|
|
}
|
|
async_connection(async_connection&& src)
|
|
: base_database(std::move(src)), m_connect_timeout(src.m_connect_timeout), m_query_timeout(src.m_query_timeout)
|
|
{
|
|
}
|
|
async_connection& operator=(async_connection&& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
base_database::operator=(std::move(src));
|
|
m_connect_timeout = src.m_connect_timeout;
|
|
m_query_timeout = src.m_query_timeout;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
OpenHandler defines as:
|
|
void handler(const qtl::postgres::error& e) NOEXCEPT;
|
|
*/
|
|
template<typename EventLoop, typename OpenHandler>
|
|
void open(EventLoop& ev, OpenHandler&& handler, const std::map<std::string, std::string>& params, bool expand_dbname = false)
|
|
{
|
|
std::vector<const char*> keywords;
|
|
std::vector<const char*> values;
|
|
keywords.reserve(params.size());
|
|
values.reserve(params.size());
|
|
for (auto& param : params)
|
|
{
|
|
keywords.push_back(param.first.data());
|
|
values.push_back(param.second.data());
|
|
}
|
|
keywords.push_back(nullptr);
|
|
values.push_back(nullptr);
|
|
m_conn = PQconnectStartParams(keywords.data(), values.data(), expand_dbname);
|
|
if (m_conn == nullptr)
|
|
throw std::bad_alloc();
|
|
if (status() == CONNECTION_BAD)
|
|
{
|
|
handler(error(m_conn));
|
|
return;
|
|
}
|
|
|
|
if (PQsetnonblocking(m_conn, true)!=0)
|
|
handler(error(m_conn));
|
|
get_options();
|
|
bind(ev);
|
|
wait_connect(std::forward<OpenHandler>(handler));
|
|
}
|
|
|
|
template<typename EventLoop, typename OpenHandler>
|
|
void open(EventLoop& ev, OpenHandler&& handler, const char * conninfo)
|
|
{
|
|
m_conn = PQconnectStart(conninfo);
|
|
if (m_conn == nullptr)
|
|
throw std::bad_alloc();
|
|
if (status() == CONNECTION_BAD)
|
|
{
|
|
handler(error(m_conn));
|
|
return;
|
|
}
|
|
|
|
PQsetnonblocking(m_conn, true);
|
|
get_options();
|
|
bind(ev);
|
|
wait_connect(std::forward<OpenHandler>(handler));
|
|
}
|
|
|
|
template<typename OpenHandler>
|
|
void reset(OpenHandler&& handler)
|
|
{
|
|
PQresetStart(m_conn);
|
|
wait_reset(std::forward<OpenHandler>(handler));
|
|
}
|
|
|
|
/*
|
|
Handler defines as:
|
|
void handler(const qtl::mysql::error& e, uint64_t affected) NOEXCEPT;
|
|
*/
|
|
template<typename ExecuteHandler>
|
|
void simple_execute(ExecuteHandler&& handler, const char* query_text) NOEXCEPT
|
|
{
|
|
bool ok = PQsendQuery(m_conn, query_text);
|
|
if (ok)
|
|
{
|
|
async_wait([this, handler](postgres::error e) mutable {
|
|
result res(PQgetResult(m_conn));
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>(e);
|
|
uint64_t affected = res.affected_rows();
|
|
handler(e, affected);
|
|
while (res)
|
|
res = PQgetResult(m_conn);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
handler(error(m_conn), 0);
|
|
}
|
|
}
|
|
|
|
template<typename Handler>
|
|
void auto_commit(Handler&& handler, bool on) NOEXCEPT
|
|
{
|
|
simple_execute(std::forward<Handler>(handler),
|
|
on ? "SET AUTOCOMMIT TO ON" : "SET AUTOCOMMIT TO OFF");
|
|
}
|
|
|
|
template<typename Handler>
|
|
void begin_transaction(Handler&& handler) NOEXCEPT
|
|
{
|
|
simple_execute(std::forward<Handler>(handler), "BEGIN");
|
|
}
|
|
|
|
template<typename Handler>
|
|
void rollback(Handler&& handler) NOEXCEPT
|
|
{
|
|
simple_execute(std::forward<Handler>(handler), "ROLLBACK");
|
|
}
|
|
|
|
template<typename Handler>
|
|
void commit(Handler&& handler) NOEXCEPT
|
|
{
|
|
simple_execute(std::forward<Handler>(handler), "COMMIT");
|
|
}
|
|
|
|
/*
|
|
ResultHandler defines as:
|
|
void result_handler(const qtl::postgres::error& e) NOEXCEPT;
|
|
*/
|
|
template<typename RowHandler, typename ResultHandler>
|
|
void simple_query(const char* query, RowHandler&& row_handler, ResultHandler&& result_handler) NOEXCEPT
|
|
{
|
|
bool ok = PQsendQuery(m_conn, query);
|
|
if (ok)
|
|
{
|
|
async_wait([this, row_handler, result_handler](postgres::error e) mutable {
|
|
result res(PQgetResult(m_conn));
|
|
res.verify_error<PGRES_COMMAND_OK, PGRES_TUPLES_OK>(e);
|
|
if (e)
|
|
{
|
|
result_handler(e, 0);
|
|
return;
|
|
}
|
|
uint64_t affected = res.affected_rows();
|
|
while (res && res.status() == PGRES_TUPLES_OK)
|
|
{
|
|
simple_statment stmt(*this, std::move(res));
|
|
stmt.fetch_all(row_handler);
|
|
res = PQgetResult(m_conn);
|
|
}
|
|
result_handler(e, affected);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
result_handler(error(m_conn), 0);
|
|
}
|
|
}
|
|
|
|
template<typename Handler>
|
|
void open_command(const char* query_text, size_t /*text_length*/, Handler&& handler)
|
|
{
|
|
std::shared_ptr<async_statement> stmt = std::make_shared<async_statement>(*this);
|
|
stmt->open([stmt, handler](const postgres::error& e) mutable {
|
|
handler(e, stmt);
|
|
}, query_text, 0);
|
|
}
|
|
|
|
template<typename Handler>
|
|
void is_alive(Handler&& handler) NOEXCEPT
|
|
{
|
|
simple_execute(std::forward<Handler>(handler), "");
|
|
}
|
|
|
|
socket_type socket() const NOEXCEPT { return PQsocket(m_conn); }
|
|
|
|
int connect_timeout() const { return m_connect_timeout; }
|
|
void connect_timeout(int timeout) { m_connect_timeout = timeout; }
|
|
int query_timeout() const { return m_query_timeout; }
|
|
void query_timeout(int timeout) { m_query_timeout = timeout; }
|
|
|
|
private:
|
|
int m_connect_timeout;
|
|
int m_query_timeout;
|
|
|
|
void get_options()
|
|
{
|
|
PQconninfoOption* options = PQconninfo(m_conn);
|
|
m_connect_timeout = 2;
|
|
for (PQconninfoOption* option = options; option; option++)
|
|
{
|
|
if (strcmp(option->keyword, "connect_timeout") == 0)
|
|
{
|
|
if (option->val)
|
|
m_connect_timeout = atoi(option->val);
|
|
break;
|
|
}
|
|
}
|
|
PQconninfoFree(options);
|
|
}
|
|
|
|
template<typename OpenHandler>
|
|
void wait_connect(OpenHandler&& handler) NOEXCEPT
|
|
{
|
|
PostgresPollingStatusType status = PQconnectPoll(m_conn);
|
|
switch (status)
|
|
{
|
|
case PGRES_POLLING_READING:
|
|
case PGRES_POLLING_WRITING:
|
|
m_event_handler->set_io_handler(event_flags(status), m_connect_timeout,
|
|
[this, handler](int flags) mutable {
|
|
if (flags&event::ef_timeout)
|
|
{
|
|
handler(postgres::timeout());
|
|
}
|
|
else if(flags&(event::ef_read|event::ef_write | event::ef_exception))
|
|
wait_connect(std::forward<OpenHandler>(handler));
|
|
});
|
|
break;
|
|
case PGRES_POLLING_FAILED:
|
|
handler(postgres::error(handle()));
|
|
break;
|
|
case PGRES_POLLING_OK:
|
|
//PQsetnonblocking(m_conn, true);
|
|
handler(postgres::error());
|
|
}
|
|
}
|
|
|
|
template<typename OpenHandler>
|
|
void wait_reset(OpenHandler&& handler) NOEXCEPT
|
|
{
|
|
PostgresPollingStatusType status = PQresetPoll(m_conn);
|
|
switch (status)
|
|
{
|
|
case PGRES_POLLING_READING:
|
|
case PGRES_POLLING_WRITING:
|
|
m_event_handler->set_io_handler(event_flags(status), m_connect_timeout,
|
|
[this, handler](int flags) mutable {
|
|
if (flags&event::ef_timeout)
|
|
{
|
|
handler(postgres::timeout());
|
|
}
|
|
else if (flags&(event::ef_read | event::ef_write | event::ef_exception))
|
|
wait_reset(std::forward<OpenHandler>(handler));
|
|
});
|
|
break;
|
|
case PGRES_POLLING_FAILED:
|
|
handler(postgres::error(m_conn));
|
|
break;
|
|
case PGRES_POLLING_OK:
|
|
handler(postgres::error());
|
|
}
|
|
}
|
|
|
|
template<typename Handler>
|
|
void async_wait(Handler&& handler)
|
|
{
|
|
qtl::postgres::async_wait(event(), m_conn, m_query_timeout, std::forward<Handler>(handler));
|
|
}
|
|
|
|
};
|
|
|
|
inline async_statement::async_statement(async_connection& db)
|
|
: base_statement(static_cast<base_database&>(db))
|
|
{
|
|
m_event = db.event();
|
|
m_timeout = db.query_timeout();
|
|
}
|
|
|
|
|
|
typedef qtl::transaction<database> transaction;
|
|
|
|
template<typename Record>
|
|
using query_iterator = qtl::query_iterator<statement, Record>;
|
|
|
|
template<typename Record>
|
|
using query_result = qtl::query_result<statement, Record>;
|
|
|
|
inline base_statement::base_statement(base_database& db) : m_res(nullptr)
|
|
{
|
|
m_conn = db.handle();
|
|
m_res = nullptr;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#endif //_SQL_POSTGRES_H_
|
|
|