From 22e0839fd6912b888b7c3c790573aef1f5df3936 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Wed, 18 Nov 2020 16:55:04 +0000 Subject: Clang format --- libodbcpp/odbc-bind.h | 13 +- libodbcpp/odbc-column.cpp | 22 +-- libodbcpp/odbc-column.h | 349 +++++++++++++++++++++++++---------- libodbcpp/odbc-command.cpp | 8 +- libodbcpp/odbc-command.h | 58 +++--- libodbcpp/odbc-connection.cpp | 37 ++-- libodbcpp/odbc-connection.h | 59 +++--- libodbcpp/odbc-dsn.cpp | 5 +- libodbcpp/odbc-dsn.h | 13 +- libodbcpp/odbc-error.cpp | 13 +- libodbcpp/odbc-error.h | 14 +- libodbcpp/odbc-mock.cpp | 47 ++--- libodbcpp/odbc-mock.h | 12 +- libodbcpp/odbc-modifycommand.cpp | 5 +- libodbcpp/odbc-modifycommand.h | 11 +- libodbcpp/odbc-param.cpp | 40 ++-- libodbcpp/odbc-param.h | 390 ++++++++++++++++++++++++++++++--------- libodbcpp/odbc-param_fwd.h | 29 ++- libodbcpp/odbc-selectcommand.cpp | 60 +++--- libodbcpp/odbc-selectcommand.h | 23 ++- libodbcpp/unittests/testodbc.cpp | 36 ++-- 21 files changed, 782 insertions(+), 462 deletions(-) (limited to 'libodbcpp') diff --git a/libodbcpp/odbc-bind.h b/libodbcpp/odbc-bind.h index 7a982e6..e1dd57f 100644 --- a/libodbcpp/odbc-bind.h +++ b/libodbcpp/odbc-bind.h @@ -6,15 +6,14 @@ namespace ODBC { class Bind { - public: - virtual ~Bind() = default; + public: + virtual ~Bind() = default; - virtual SQLSMALLINT ctype() const = 0; // The C type ID - virtual SQLULEN size() const = 0; // The size of the data - protected: - mutable SQLLEN bindLen; // How much data the driver wants to store + virtual SQLSMALLINT ctype() const = 0; // The C type ID + virtual SQLULEN size() const = 0; // The size of the data + protected: + mutable SQLLEN bindLen; // How much data the driver wants to store }; } #endif - diff --git a/libodbcpp/odbc-column.cpp b/libodbcpp/odbc-column.cpp index 2a25f9b..3d968c2 100644 --- a/libodbcpp/odbc-column.cpp +++ b/libodbcpp/odbc-column.cpp @@ -1,14 +1,12 @@ -#include -#include -#include #include "odbc-column.h" #include "odbc-command.h" -#include "odbc-selectcommand.h" #include "odbc-error.h" +#include "odbc-selectcommand.h" +#include +#include +#include -ODBC::Column::Column(SelectCommand * sc, const Glib::ustring & s, unsigned int i) : - DB::Column(s, i), - selectCmd(sc) +ODBC::Column::Column(SelectCommand * sc, const Glib::ustring & s, unsigned int i) : DB::Column(s, i), selectCmd(sc) { bindLen = 0; } @@ -51,14 +49,12 @@ ODBC::Column::bind() ODBC::TimeStampColumn::operator boost::posix_time::ptime() const { - return boost::posix_time::ptime( - boost::gregorian::date(data.year, data.month, data.day), - boost::posix_time::time_duration(data.hour, data.minute, data.second, data.fraction)); + return boost::posix_time::ptime(boost::gregorian::date(data.year, data.month, data.day), + boost::posix_time::time_duration(data.hour, data.minute, data.second, data.fraction)); } ODBC::IntervalColumn::operator boost::posix_time::time_duration() const { - auto dur = boost::posix_time::time_duration( - (24 * data.intval.day_second.day) + data.intval.day_second.hour, + auto dur = boost::posix_time::time_duration((24 * data.intval.day_second.day) + data.intval.day_second.hour, data.intval.day_second.minute, data.intval.day_second.second, data.intval.day_second.fraction); return (data.interval_sign ? -dur : dur); } @@ -84,7 +80,7 @@ ODBC::CharArrayColumn::apply(DB::HandleField & h) const if (isNull()) { return h.null(); } - h.string({ data.data(), (std::size_t)bindLen }); + h.string({data.data(), (std::size_t)bindLen}); } void ODBC::TimeStampColumn::apply(DB::HandleField & h) const diff --git a/libodbcpp/odbc-column.h b/libodbcpp/odbc-column.h index 5d7c7d4..4f3c697 100644 --- a/libodbcpp/odbc-column.h +++ b/libodbcpp/odbc-column.h @@ -1,130 +1,285 @@ #ifndef ODBC_COLUMN_H #define ODBC_COLUMN_H -#include -#include -#include -#include #include "odbc-bind.h" #include "odbc-param.h" +#include +#include +#include +#include namespace ODBC { class SelectCommand; class Column : public virtual Bind, public virtual DB::Column { - public: - Column(SelectCommand *, const Glib::ustring & s, unsigned int i); - virtual ~Column() = default; - void bind(); - virtual void * rwDataAddress() = 0; - virtual bool resize(); + public: + Column(SelectCommand *, const Glib::ustring & s, unsigned int i); + virtual ~Column() = default; + void bind(); + virtual void * rwDataAddress() = 0; + virtual bool resize(); + + virtual operator int() const + { + throw std::bad_cast(); + } + virtual operator long() const + { + throw std::bad_cast(); + } + virtual operator long long() const + { + throw std::bad_cast(); + } + virtual operator unsigned int() const + { + throw std::bad_cast(); + } + virtual operator unsigned long() const + { + throw std::bad_cast(); + } + virtual operator unsigned long long() const + { + throw std::bad_cast(); + } - virtual operator int () const { throw std::bad_cast(); } - virtual operator long () const { throw std::bad_cast(); } - virtual operator long long () const { throw std::bad_cast(); } - virtual operator unsigned int () const { throw std::bad_cast(); } - virtual operator unsigned long () const { throw std::bad_cast(); } - virtual operator unsigned long long () const { throw std::bad_cast(); } + virtual operator double() const + { + throw std::bad_cast(); + } + virtual operator float() const + { + throw std::bad_cast(); + } - virtual operator double () const { throw std::bad_cast(); } - virtual operator float () const { throw std::bad_cast(); } + virtual operator std::string() const + { + throw std::bad_cast(); + } + virtual operator Glib::ustring() const + { + throw std::bad_cast(); + } - virtual operator std::string () const { throw std::bad_cast(); } - virtual operator Glib::ustring () const { throw std::bad_cast(); } + virtual operator struct tm() const + { + throw std::bad_cast(); + } + virtual operator SQL_TIMESTAMP_STRUCT() const + { + throw std::bad_cast(); + } - virtual operator struct tm () const { throw std::bad_cast(); } - virtual operator SQL_TIMESTAMP_STRUCT () const { throw std::bad_cast(); } + [[nodiscard]] bool isNull() const override; + virtual void apply(DB::HandleField &) const override = 0; - [[nodiscard]] bool isNull() const override; - virtual void apply(DB::HandleField &) const override = 0; + const SelectCommand * selectCmd; - const SelectCommand * selectCmd; - protected: - virtual const Param * meAsAParam() const = 0; + protected: + virtual const Param * meAsAParam() const = 0; }; class CharArrayColumn : public Column, public Param { - public: - typedef std::vector CharArray; - CharArrayColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i, SQLULEN sizeHint) : - DB::Column(n, i), - Column(sc, n, i) - { - data.resize(std::max(sizeHint, 64) + 1); - } - virtual SQLSMALLINT ctype() const override { return SQL_C_CHAR; } - virtual SQLSMALLINT stype() const override { return SQL_CHAR; } - virtual SQLULEN size() const override { return data.size(); } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return &data.front(); } - virtual void * rwDataAddress() override { return &data.front(); } - void operator=(const Glib::ustring & d); - bool resize() override; - virtual operator std::string () const override { return std::string(&data.front(), bindLen); } - virtual operator Glib::ustring () const override { return std::string(&data.front(), bindLen); } - virtual void apply(DB::HandleField &) const override; - protected: - virtual const Param * meAsAParam() const override { return this; } - CharArray data; + public: + typedef std::vector CharArray; + CharArrayColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i, SQLULEN sizeHint) : + DB::Column(n, i), Column(sc, n, i) + { + data.resize(std::max(sizeHint, 64) + 1); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_CHAR; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_CHAR; + } + virtual SQLULEN + size() const override + { + return data.size(); + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return &data.front(); + } + virtual void * + rwDataAddress() override + { + return &data.front(); + } + void operator=(const Glib::ustring & d); + bool resize() override; + virtual operator std::string() const override + { + return std::string(&data.front(), bindLen); + } + virtual operator Glib::ustring() const override + { + return std::string(&data.front(), bindLen); + } + virtual void apply(DB::HandleField &) const override; + + protected: + virtual const Param * + meAsAParam() const override + { + return this; + } + CharArray data; }; class SignedIntegerColumn : public Column, public SignedIntegerParam { - public: - SignedIntegerColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : - DB::Column(n, i), - Column(sc, n, i) { } - virtual SQLSMALLINT ctype() const override { return SignedIntegerParam::ctype(); } - virtual SQLULEN size() const override { return SignedIntegerParam::size(); } - virtual void * rwDataAddress() override { return &data; } - virtual operator int () const override { return data; } - virtual operator long () const override { return data; } - virtual operator long long () const override { return data; } - virtual const Param * meAsAParam() const override { return this; } - virtual void apply(DB::HandleField &) const override; + public: + SignedIntegerColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : + DB::Column(n, i), Column(sc, n, i) + { + } + virtual SQLSMALLINT + ctype() const override + { + return SignedIntegerParam::ctype(); + } + virtual SQLULEN + size() const override + { + return SignedIntegerParam::size(); + } + virtual void * + rwDataAddress() override + { + return &data; + } + virtual operator int() const override + { + return data; + } + virtual operator long() const override + { + return data; + } + virtual operator long long() const override + { + return data; + } + virtual const Param * + meAsAParam() const override + { + return this; + } + virtual void apply(DB::HandleField &) const override; }; #ifdef COMPLETENESS class UnsignedIntegerColumn : public Column, public UnsignedIntegerParam { - public: - UnsignedIntegerColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : - Column(sc, n, i) { } - virtual const Param * meAsAParam() const override { return this; } + public: + UnsignedIntegerColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : Column(sc, n, i) { } + virtual const Param * + meAsAParam() const override + { + return this; + } }; #endif class FloatingPointColumn : public Column, public FloatingPointParam { - public: - FloatingPointColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : - DB::Column(n, i), - Column(sc, n, i) { } - virtual SQLSMALLINT ctype() const override { return FloatingPointParam::ctype(); } - virtual SQLULEN size() const override { return FloatingPointParam::size(); } - virtual void * rwDataAddress() override { return &data; } - virtual operator double () const override { return data; } - virtual operator float () const override { return data; } - virtual const Param * meAsAParam() const override { return this; } - virtual void apply(DB::HandleField &) const override; + public: + FloatingPointColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : + DB::Column(n, i), Column(sc, n, i) + { + } + virtual SQLSMALLINT + ctype() const override + { + return FloatingPointParam::ctype(); + } + virtual SQLULEN + size() const override + { + return FloatingPointParam::size(); + } + virtual void * + rwDataAddress() override + { + return &data; + } + virtual operator double() const override + { + return data; + } + virtual operator float() const override + { + return data; + } + virtual const Param * + meAsAParam() const override + { + return this; + } + virtual void apply(DB::HandleField &) const override; }; class IntervalColumn : public Column, public IntervalParam { - public: - IntervalColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : - DB::Column(n, i), - Column(sc, n, i) { } - virtual SQLSMALLINT ctype() const override { return IntervalParam::ctype(); } - virtual SQLULEN size() const override { return IntervalParam::size(); } - virtual void * rwDataAddress() override { return &data; } - virtual operator boost::posix_time::time_duration () const; - virtual const Param * meAsAParam() const override { return this; } - virtual void apply(DB::HandleField &) const override; + public: + IntervalColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : DB::Column(n, i), Column(sc, n, i) + { + } + virtual SQLSMALLINT + ctype() const override + { + return IntervalParam::ctype(); + } + virtual SQLULEN + size() const override + { + return IntervalParam::size(); + } + virtual void * + rwDataAddress() override + { + return &data; + } + virtual operator boost::posix_time::time_duration() const; + virtual const Param * + meAsAParam() const override + { + return this; + } + virtual void apply(DB::HandleField &) const override; }; class TimeStampColumn : public Column, public TimeStampParam { - public: - TimeStampColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : - DB::Column(n, i), - Column(sc, n, i) { } - virtual SQLSMALLINT ctype() const override { return TimeStampParam::ctype(); } - virtual SQLULEN size() const override { return TimeStampParam::size(); } - virtual void * rwDataAddress() override { return &data; } - virtual operator boost::posix_time::ptime () const; - virtual const Param * meAsAParam() const override { return this; } - virtual void apply(DB::HandleField &) const override; + public: + TimeStampColumn(SelectCommand * sc, const Glib::ustring & n, unsigned int i) : + DB::Column(n, i), Column(sc, n, i) + { + } + virtual SQLSMALLINT + ctype() const override + { + return TimeStampParam::ctype(); + } + virtual SQLULEN + size() const override + { + return TimeStampParam::size(); + } + virtual void * + rwDataAddress() override + { + return &data; + } + virtual operator boost::posix_time::ptime() const; + virtual const Param * + meAsAParam() const override + { + return this; + } + virtual void apply(DB::HandleField &) const override; }; } #endif - diff --git a/libodbcpp/odbc-command.cpp b/libodbcpp/odbc-command.cpp index 34febf3..c73b3f9 100644 --- a/libodbcpp/odbc-command.cpp +++ b/libodbcpp/odbc-command.cpp @@ -3,10 +3,7 @@ #include "odbc-param.h" #include -ODBC::Command::Command(const Connection & c, const std::string & s) : - DB::Command(s), - hStmt(nullptr), - connection(c) +ODBC::Command::Command(const Connection & c, const std::string & s) : DB::Command(s), hStmt(nullptr), connection(c) { RETCODE rc = SQLAllocHandle(SQL_HANDLE_STMT, c.conn, &hStmt); if (!SQL_SUCCEEDED(rc)) { @@ -16,7 +13,7 @@ ODBC::Command::Command(const Connection & c, const std::string & s) : if (!SQL_SUCCEEDED(rc)) { throw ConnectionError(rc, SQL_HANDLE_STMT, hStmt); } - rc = SQLPrepare(hStmt, (SQLCHAR*)sql.c_str(), sql.length()); + rc = SQLPrepare(hStmt, (SQLCHAR *)sql.c_str(), sql.length()); if (!SQL_SUCCEEDED(rc)) { SQLFreeHandle(SQL_HANDLE_STMT, hStmt); throw Error(rc, SQL_HANDLE_STMT, hStmt); @@ -29,4 +26,3 @@ ODBC::Command::Command(const Connection & c, const std::string & s) : } params.resize(pcount); } - diff --git a/libodbcpp/odbc-command.h b/libodbcpp/odbc-command.h index ceba2dc..b0aa3fa 100644 --- a/libodbcpp/odbc-command.h +++ b/libodbcpp/odbc-command.h @@ -1,54 +1,52 @@ #ifndef ODBC_COMMAND_H #define ODBC_COMMAND_H -#include -#include #include "odbc-connection.h" #include "odbc-param_fwd.h" +#include #include +#include namespace ODBC { using ParamPtr = std::unique_ptr; class Command : public virtual DB::Command { - using Params = std::vector; - public: - Command(const Connection &, const std::string & sql); + using Params = std::vector; + + public: + Command(const Connection &, const std::string & sql); - void bindParamI(unsigned int i, int val) override; - void bindParamI(unsigned int i, long val) override; - void bindParamI(unsigned int i, long long val) override; - void bindParamI(unsigned int i, unsigned int val) override; - void bindParamI(unsigned int i, unsigned long int val) override; - void bindParamI(unsigned int i, unsigned long long int val) override; + void bindParamI(unsigned int i, int val) override; + void bindParamI(unsigned int i, long val) override; + void bindParamI(unsigned int i, long long val) override; + void bindParamI(unsigned int i, unsigned int val) override; + void bindParamI(unsigned int i, unsigned long int val) override; + void bindParamI(unsigned int i, unsigned long long int val) override; - void bindParamB(unsigned int i, bool val) override; + void bindParamB(unsigned int i, bool val) override; - void bindParamF(unsigned int i, double val) override; - void bindParamF(unsigned int i, float val) override; + void bindParamF(unsigned int i, double val) override; + void bindParamF(unsigned int i, float val) override; - void bindParamS(unsigned int i, const Glib::ustring &) override; - void bindParamS(unsigned int i, const std::string_view &) override; + void bindParamS(unsigned int i, const Glib::ustring &) override; + void bindParamS(unsigned int i, const std::string_view &) override; - void bindParamT(unsigned int i, const boost::posix_time::time_duration &) override; - void bindParamT(unsigned int i, const boost::posix_time::ptime &) override; + void bindParamT(unsigned int i, const boost::posix_time::time_duration &) override; + void bindParamT(unsigned int i, const boost::posix_time::ptime &) override; - void bindNull(unsigned int i) override; + void bindNull(unsigned int i) override; - protected: - friend class Param; - friend class Column; - SQLHSTMT hStmt; - const Connection& connection; + protected: + friend class Param; + friend class Column; + SQLHSTMT hStmt; + const Connection & connection; - private: - Params params; + private: + Params params; - template - ParamType * - makeParam(unsigned int idx); + template ParamType * makeParam(unsigned int idx); }; } #endif - diff --git a/libodbcpp/odbc-connection.cpp b/libodbcpp/odbc-connection.cpp index 8ecaf2c..84e316d 100644 --- a/libodbcpp/odbc-connection.cpp +++ b/libodbcpp/odbc-connection.cpp @@ -1,23 +1,20 @@ -#include -#include -#include -#include #include "odbc-connection.h" -#include "odbc-selectcommand.h" -#include "odbc-modifycommand.h" #include "error.h" +#include "odbc-modifycommand.h" +#include "odbc-selectcommand.h" +#include +#include +#include +#include NAMEDFACTORY("odbc", ODBC::Connection, DB::ConnectionFactory); -ODBC::Connection::Connection(const DSN& d) : - env(nullptr), - conn(nullptr), - thinkDelStyle(DB::BulkDeleteUsingUsing), - thinkUpdStyle(DB::BulkUpdateUsingFromSrc) +ODBC::Connection::Connection(const DSN & d) : + env(nullptr), conn(nullptr), thinkDelStyle(DB::BulkDeleteUsingUsing), thinkUpdStyle(DB::BulkUpdateUsingFromSrc) { connectPre(); - RETCODE dberr = SQLConnect(conn, (SQLCHAR*)d.dsn.c_str(), SQL_NTS, - (SQLCHAR*)d.username.c_str(), SQL_NTS, (SQLCHAR*)d.password.c_str(), SQL_NTS); + RETCODE dberr = SQLConnect(conn, (SQLCHAR *)d.dsn.c_str(), SQL_NTS, (SQLCHAR *)d.username.c_str(), SQL_NTS, + (SQLCHAR *)d.password.c_str(), SQL_NTS); if (!SQL_SUCCEEDED(dberr)) { throw ConnectionError(dberr, SQL_HANDLE_DBC, conn); } @@ -32,7 +29,7 @@ ODBC::Connection::connectPre() throw ConnectionError(dberr, SQL_HANDLE_ENV, env); } - dberr = SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0); + dberr = SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0); if (!SQL_SUCCEEDED(dberr)) { throw ConnectionError(dberr, SQL_HANDLE_ENV, env); } @@ -69,13 +66,11 @@ ODBC::Connection::connectPost() } ODBC::Connection::Connection(const std::string & s) : - env(nullptr), - conn(nullptr), - thinkDelStyle(DB::BulkDeleteUsingUsing), - thinkUpdStyle(DB::BulkUpdateUsingFromSrc) + env(nullptr), conn(nullptr), thinkDelStyle(DB::BulkDeleteUsingUsing), thinkUpdStyle(DB::BulkUpdateUsingFromSrc) { connectPre(); - RETCODE dberr = SQLDriverConnect(conn, nullptr, (SQLCHAR*)s.c_str(), s.length(), nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + RETCODE dberr = SQLDriverConnect( + conn, nullptr, (SQLCHAR *)s.c_str(), s.length(), nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); if (!SQL_SUCCEEDED(dberr)) { throw ConnectionError(dberr, SQL_HANDLE_DBC, conn); } @@ -187,8 +182,6 @@ ODBC::Connection::ping() const } ODBC::ConnectionError::ConnectionError(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle) : - ODBC::Error(err, handletype, handle), - DB::ConnectionError() + ODBC::Error(err, handletype, handle), DB::ConnectionError() { } - diff --git a/libodbcpp/odbc-connection.h b/libodbcpp/odbc-connection.h index 3574c42..a7853e4 100644 --- a/libodbcpp/odbc-connection.h +++ b/libodbcpp/odbc-connection.h @@ -1,46 +1,45 @@ #ifndef ODBC_CONNECTION_H #define ODBC_CONNECTION_H -#include -#include #include "odbc-dsn.h" #include "odbc-error.h" +#include +#include #include namespace ODBC { class ConnectionError : public virtual Error, public virtual DB::ConnectionError { - public: - ConnectionError(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle); + public: + ConnectionError(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle); }; class Connection : public DB::Connection { - public: - Connection(const DSN& d); - Connection(const std::string & str); - ~Connection(); - SQLHENV env; - SQLHDBC conn; - - void beginTxInt() override; - void commitTxInt() override; - void rollbackTxInt() override; - void ping() const override; - std::string getAttrStr(SQLINTEGER) const; - SQLINTEGER getAttrInt(SQLINTEGER) const; - DB::BulkDeleteStyle bulkDeleteStyle() const override; - DB::BulkUpdateStyle bulkUpdateStyle() const override; - - DB::SelectCommandPtr select(const std::string & sql, const DB::CommandOptionsCPtr &) override; - DB::ModifyCommandPtr modify(const std::string & sql, const DB::CommandOptionsCPtr &) override; - - private: - DB::BulkDeleteStyle thinkDelStyle; - DB::BulkUpdateStyle thinkUpdStyle; - - void connectPre(); - void connectPost(); + public: + Connection(const DSN & d); + Connection(const std::string & str); + ~Connection(); + SQLHENV env; + SQLHDBC conn; + + void beginTxInt() override; + void commitTxInt() override; + void rollbackTxInt() override; + void ping() const override; + std::string getAttrStr(SQLINTEGER) const; + SQLINTEGER getAttrInt(SQLINTEGER) const; + DB::BulkDeleteStyle bulkDeleteStyle() const override; + DB::BulkUpdateStyle bulkUpdateStyle() const override; + + DB::SelectCommandPtr select(const std::string & sql, const DB::CommandOptionsCPtr &) override; + DB::ModifyCommandPtr modify(const std::string & sql, const DB::CommandOptionsCPtr &) override; + + private: + DB::BulkDeleteStyle thinkDelStyle; + DB::BulkUpdateStyle thinkUpdStyle; + + void connectPre(); + void connectPost(); }; } #endif - diff --git a/libodbcpp/odbc-dsn.cpp b/libodbcpp/odbc-dsn.cpp index d2802bd..9d300f4 100644 --- a/libodbcpp/odbc-dsn.cpp +++ b/libodbcpp/odbc-dsn.cpp @@ -1,9 +1,6 @@ #include "odbc-dsn.h" ODBC::DSN::DSN(std::string d, std::string u, std::string p) : - dsn(std::move(d)), - username(std::move(u)), - password(std::move(p)) + dsn(std::move(d)), username(std::move(u)), password(std::move(p)) { } - diff --git a/libodbcpp/odbc-dsn.h b/libodbcpp/odbc-dsn.h index 4568cb6..0d33507 100644 --- a/libodbcpp/odbc-dsn.h +++ b/libodbcpp/odbc-dsn.h @@ -5,14 +5,13 @@ namespace ODBC { class DSN { - public: - DSN(std::string, std::string, std::string); - virtual ~DSN() = default; - const std::string dsn; // DSN name for odbc.ini - const std::string username; // User name - const std::string password; // Password + public: + DSN(std::string, std::string, std::string); + virtual ~DSN() = default; + const std::string dsn; // DSN name for odbc.ini + const std::string username; // User name + const std::string password; // Password }; } #endif - diff --git a/libodbcpp/odbc-error.cpp b/libodbcpp/odbc-error.cpp index afa1d42..93f11c0 100644 --- a/libodbcpp/odbc-error.cpp +++ b/libodbcpp/odbc-error.cpp @@ -1,11 +1,12 @@ #include "odbc-error.h" -#include #include +#include namespace AdHoc { StreamWriterT('5') { - template - static void write(stream & s, const std::array & sqlstatus, const Pn & ... pn) + template + static void + write(stream & s, const std::array & sqlstatus, const Pn &... pn) { static_assert(l > 5); s.write((const char * const)sqlstatus.data(), 5); @@ -21,10 +22,11 @@ AdHocFormatter(ODBCError, "Failed to get diagnostics for return code %?"); ODBC::Error::Error(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle) { std::array sqlstatus {}; - SQLINTEGER sqlerr; + SQLINTEGER sqlerr; std::array sqlerrmsg {}; - SQLRETURN rc = SQLGetDiagRec(handletype, handle, 1, sqlstatus.data(), &sqlerr, sqlerrmsg.data(), sqlerrmsg.size(), nullptr); + SQLRETURN rc = SQLGetDiagRec( + handletype, handle, 1, sqlstatus.data(), &sqlerr, sqlerrmsg.data(), sqlerrmsg.size(), nullptr); switch (rc) { case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: @@ -51,4 +53,3 @@ ODBC::Error::message() const noexcept { return msg; } - diff --git a/libodbcpp/odbc-error.h b/libodbcpp/odbc-error.h index addc528..b19f2c0 100644 --- a/libodbcpp/odbc-error.h +++ b/libodbcpp/odbc-error.h @@ -1,20 +1,20 @@ #ifndef ODBC_ERROR_H #define ODBC_ERROR_H +#include +#include #include #include -#include -#include namespace ODBC { class Error : public AdHoc::Exception { - public: - Error(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle); + public: + Error(RETCODE err, SQLSMALLINT handletype, SQLHANDLE handle); - std::string message() const noexcept override; + std::string message() const noexcept override; - private: - std::string msg; + private: + std::string msg; }; } diff --git a/libodbcpp/odbc-mock.cpp b/libodbcpp/odbc-mock.cpp index 29a9278..21b332a 100644 --- a/libodbcpp/odbc-mock.cpp +++ b/libodbcpp/odbc-mock.cpp @@ -1,33 +1,34 @@ -#include "odbc-connection.h" #include "odbc-mock.h" +#include "odbc-connection.h" #include namespace ODBC { -Mock::Mock(const std::string & b, const std::string & masterdb, const std::string & name, const std::vector & ss) : - MockServerDatabase(b + ";" + masterdb, name, "odbc"), - base(b) -{ - Mock::CreateNewDatabase(); - PlaySchemaScripts(ss); -} + Mock::Mock(const std::string & b, const std::string & masterdb, const std::string & name, + const std::vector & ss) : + MockServerDatabase(b + ";" + masterdb, name, "odbc"), + base(b) + { + Mock::CreateNewDatabase(); + PlaySchemaScripts(ss); + } -AdHocFormatter(MockConnStr, "%?;Database=%?"); -DB::ConnectionPtr -Mock::openConnection() const -{ - return std::make_shared(MockConnStr::get(base, testDbName)); -} + AdHocFormatter(MockConnStr, "%?;Database=%?"); + DB::ConnectionPtr + Mock::openConnection() const + { + return std::make_shared(MockConnStr::get(base, testDbName)); + } -Mock::~Mock() -{ - Mock::DropDatabase(); -} + Mock::~Mock() + { + Mock::DropDatabase(); + } -void Mock::DropDatabase() const -{ - MockServerDatabase::DropDatabase(); -} + void + Mock::DropDatabase() const + { + MockServerDatabase::DropDatabase(); + } } - diff --git a/libodbcpp/odbc-mock.h b/libodbcpp/odbc-mock.h index 8371cf6..5db50f5 100644 --- a/libodbcpp/odbc-mock.h +++ b/libodbcpp/odbc-mock.h @@ -1,16 +1,17 @@ #ifndef MOCKODBCDATASOURCE_H #define MOCKODBCDATASOURCE_H -#include +#include #include +#include #include -#include namespace ODBC { -class DLL_PUBLIC Mock : public DB::MockServerDatabase { + class DLL_PUBLIC Mock : public DB::MockServerDatabase { public: - Mock(const std::string & base, const std::string & master, const std::string & name, const std::vector & ss); + Mock(const std::string & base, const std::string & master, const std::string & name, + const std::vector & ss); ~Mock() override; SPECIAL_MEMBERS_MOVE_RO(Mock); @@ -22,9 +23,8 @@ class DLL_PUBLIC Mock : public DB::MockServerDatabase { private: [[nodiscard]] DB::ConnectionPtr openConnection() const override; -}; + }; } #endif - diff --git a/libodbcpp/odbc-modifycommand.cpp b/libodbcpp/odbc-modifycommand.cpp index 3bea818..2fca416 100644 --- a/libodbcpp/odbc-modifycommand.cpp +++ b/libodbcpp/odbc-modifycommand.cpp @@ -2,9 +2,7 @@ #include "odbc-error.h" ODBC::ModifyCommand::ModifyCommand(const ODBC::Connection & c, const std::string & sql) : - DB::Command(sql), - ODBC::Command(c, sql), - DB::ModifyCommand(sql) + DB::Command(sql), ODBC::Command(c, sql), DB::ModifyCommand(sql) { } @@ -27,4 +25,3 @@ ODBC::ModifyCommand::execute(bool anc) } throw DB::NoRowsAffected(); } - diff --git a/libodbcpp/odbc-modifycommand.h b/libodbcpp/odbc-modifycommand.h index 3993d63..de3f7e0 100644 --- a/libodbcpp/odbc-modifycommand.h +++ b/libodbcpp/odbc-modifycommand.h @@ -1,17 +1,16 @@ #ifndef ODBC_MODIFYCOMMAND_H #define ODBC_MODIFYCOMMAND_H -#include #include "odbc-command.h" +#include namespace ODBC { class ModifyCommand : public Command, public DB::ModifyCommand { - public: - ModifyCommand(const Connection &, const std::string & sql); - // Execute the command and return effected row count - unsigned int execute(bool allowNoChange = true) override; + public: + ModifyCommand(const Connection &, const std::string & sql); + // Execute the command and return effected row count + unsigned int execute(bool allowNoChange = true) override; }; } #endif - diff --git a/libodbcpp/odbc-param.cpp b/libodbcpp/odbc-param.cpp index a185393..a14d244 100644 --- a/libodbcpp/odbc-param.cpp +++ b/libodbcpp/odbc-param.cpp @@ -1,26 +1,14 @@ -#include #include "odbc-param.h" #include "odbc-command.h" #include "odbc-error.h" #include +#include -ODBC::Param::Param() : - paramCmd(nullptr), - paramIdx(0), - paramBound(false), - dataLength(0) -{ -} +ODBC::Param::Param() : paramCmd(nullptr), paramIdx(0), paramBound(false), dataLength(0) { } -ODBC::Param::Param(Command * c, unsigned int i) : - paramCmd(c), - paramIdx(i), - paramBound(false), - dataLength(0) -{ -} +ODBC::Param::Param(Command * c, unsigned int i) : paramCmd(c), paramIdx(i), paramBound(false), dataLength(0) { } -template +template ParamType * ODBC::Command::makeParam(unsigned int idx) { @@ -29,7 +17,7 @@ ODBC::Command::makeParam(unsigned int idx) } auto & p = params[idx]; if (p) { - if (auto np = dynamic_cast(p.get())) { + if (auto np = dynamic_cast(p.get())) { return np; } } @@ -41,8 +29,8 @@ void ODBC::Param::bind() const { if (!paramBound) { - RETCODE rc = SQLBindParameter(paramCmd->hStmt, paramIdx + 1, SQL_PARAM_INPUT, ctype(), stype(), - size(), dp(), const_cast(dataAddress()), size(), &bindLen); + RETCODE rc = SQLBindParameter(paramCmd->hStmt, paramIdx + 1, SQL_PARAM_INPUT, ctype(), stype(), size(), dp(), + const_cast(dataAddress()), size(), &bindLen); if (!SQL_SUCCEEDED(rc)) { throw Error(rc, SQL_HANDLE_STMT, paramCmd->hStmt); } @@ -51,13 +39,12 @@ ODBC::Param::bind() const } #define SIMPLEBINDER(ctype, otype, suf) \ -void \ -ODBC::Command::bindParam##suf(unsigned int i, ctype val) \ -{ \ - ODBC::otype * p = makeParam(i); \ - *p = val; \ - p->bind(); \ -} + void ODBC::Command::bindParam##suf(unsigned int i, ctype val) \ + { \ + ODBC::otype * p = makeParam(i); \ + *p = val; \ + p->bind(); \ + } SIMPLEBINDER(int, SignedIntegerParam, I); SIMPLEBINDER(long, SignedIntegerParam, I); SIMPLEBINDER(long long, SignedIntegerParam, I); @@ -135,4 +122,3 @@ ODBC::IntervalParam::operator=(const boost::posix_time::time_duration & d) data.intval.day_second.fraction = d.fractional_seconds(); return *this; } - diff --git a/libodbcpp/odbc-param.h b/libodbcpp/odbc-param.h index 6ef5ae1..03aaef5 100644 --- a/libodbcpp/odbc-param.h +++ b/libodbcpp/odbc-param.h @@ -1,116 +1,326 @@ #ifndef ODBC_PARAM_H #define ODBC_PARAM_H -#include -#include -#include #include "odbc-param_fwd.h" #include +#include +#include +#include namespace ODBC { class BooleanParam : public Param { - public: - BooleanParam() : Param() { } - BooleanParam(Command * c, unsigned int i) : Param(c, i) { bindLen = BooleanParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_BIT; } - virtual SQLSMALLINT stype() const override { return SQL_C_BIT; } - virtual SQLULEN size() const override { return sizeof(SQLINTEGER); } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return &data; } - BooleanParam & operator=(const SQLINTEGER & d) { data = d; return *this; } - protected: - SQLINTEGER data; + public: + BooleanParam() : Param() { } + BooleanParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = BooleanParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_BIT; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_C_BIT; + } + virtual SQLULEN + size() const override + { + return sizeof(SQLINTEGER); + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return &data; + } + BooleanParam & + operator=(const SQLINTEGER & d) + { + data = d; + return *this; + } + + protected: + SQLINTEGER data; }; class SignedIntegerParam : public Param { - public: - SignedIntegerParam() : Param() { } - SignedIntegerParam(Command * c, unsigned int i) : Param(c, i) { bindLen = SignedIntegerParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_LONG; } - virtual SQLSMALLINT stype() const override { return SQL_C_LONG; } - virtual SQLULEN size() const override { return sizeof(SQLINTEGER); } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return &data; } - SignedIntegerParam & operator=(const SQLINTEGER & d) { data = d; return *this; } - protected: - SQLINTEGER data; + public: + SignedIntegerParam() : Param() { } + SignedIntegerParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = SignedIntegerParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_LONG; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_C_LONG; + } + virtual SQLULEN + size() const override + { + return sizeof(SQLINTEGER); + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return &data; + } + SignedIntegerParam & + operator=(const SQLINTEGER & d) + { + data = d; + return *this; + } + + protected: + SQLINTEGER data; }; class UnsignedIntegerParam : public Param { - public: - UnsignedIntegerParam() : Param() { } - UnsignedIntegerParam(Command * c, unsigned int i) : Param(c, i) { bindLen = UnsignedIntegerParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_ULONG; } - virtual SQLSMALLINT stype() const override { return SQL_C_ULONG; } - virtual SQLULEN size() const override { return sizeof(SQLUINTEGER); } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return &data; } - UnsignedIntegerParam & operator=(const SQLUINTEGER & d) { data = d; return *this; } - protected: - SQLUINTEGER data; + public: + UnsignedIntegerParam() : Param() { } + UnsignedIntegerParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = UnsignedIntegerParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_ULONG; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_C_ULONG; + } + virtual SQLULEN + size() const override + { + return sizeof(SQLUINTEGER); + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return &data; + } + UnsignedIntegerParam & + operator=(const SQLUINTEGER & d) + { + data = d; + return *this; + } + + protected: + SQLUINTEGER data; }; class FloatingPointParam : public Param { - public: - FloatingPointParam() : Param() { } - FloatingPointParam(Command * c, unsigned int i) : Param(c, i) { bindLen = FloatingPointParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_DOUBLE; } - virtual SQLSMALLINT stype() const override { return SQL_C_DOUBLE; } - virtual SQLULEN size() const override { return sizeof(SQLDOUBLE); } - virtual SQLINTEGER dp() const override { return 10; } - virtual const void * dataAddress() const override { return &data; } - FloatingPointParam & operator=(const SQLDOUBLE & d) { data = d; return *this; } - protected: - SQLDOUBLE data; + public: + FloatingPointParam() : Param() { } + FloatingPointParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = FloatingPointParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_DOUBLE; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_C_DOUBLE; + } + virtual SQLULEN + size() const override + { + return sizeof(SQLDOUBLE); + } + virtual SQLINTEGER + dp() const override + { + return 10; + } + virtual const void * + dataAddress() const override + { + return &data; + } + FloatingPointParam & + operator=(const SQLDOUBLE & d) + { + data = d; + return *this; + } + + protected: + SQLDOUBLE data; }; class StdStringParam : public Param { - public: - StdStringParam() : Param() { } - StdStringParam(Command * c, unsigned int i) : Param(c, i) { bindLen = StdStringParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_CHAR; } - virtual SQLSMALLINT stype() const override { return SQL_CHAR; } - virtual SQLULEN size() const override { return data.length(); } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return data.data(); } - StdStringParam & operator=(const std::string_view & d); - StdStringParam & operator=(const Glib::ustring & d); - protected: - std::string data; + public: + StdStringParam() : Param() { } + StdStringParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = StdStringParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_CHAR; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_CHAR; + } + virtual SQLULEN + size() const override + { + return data.length(); + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return data.data(); + } + StdStringParam & operator=(const std::string_view & d); + StdStringParam & operator=(const Glib::ustring & d); + + protected: + std::string data; }; class IntervalParam : public Param { - public: - IntervalParam() : Param() { } - IntervalParam(Command * c, unsigned int i) : Param(c, i) { bindLen = IntervalParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_INTERVAL_DAY_TO_SECOND; } - virtual SQLSMALLINT stype() const override { return SQL_INTERVAL_DAY_TO_SECOND; } - virtual SQLULEN size() const override { return sizeof(SQL_INTERVAL_STRUCT); } - virtual SQLINTEGER dp() const override { return boost::posix_time::time_res_traits::num_fractional_digits(); } - virtual const void * dataAddress() const override { return &data; } - IntervalParam & operator=(const boost::posix_time::time_duration & d); - protected: - SQL_INTERVAL_STRUCT data; + public: + IntervalParam() : Param() { } + IntervalParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = IntervalParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_INTERVAL_DAY_TO_SECOND; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_INTERVAL_DAY_TO_SECOND; + } + virtual SQLULEN + size() const override + { + return sizeof(SQL_INTERVAL_STRUCT); + } + virtual SQLINTEGER + dp() const override + { + return boost::posix_time::time_res_traits::num_fractional_digits(); + } + virtual const void * + dataAddress() const override + { + return &data; + } + IntervalParam & operator=(const boost::posix_time::time_duration & d); + + protected: + SQL_INTERVAL_STRUCT data; }; class TimeStampParam : public Param { - public: - TimeStampParam() : Param() { } - TimeStampParam(Command * c, unsigned int i) : Param(c, i) { bindLen = TimeStampParam::size(); } - virtual SQLSMALLINT ctype() const override { return SQL_C_TYPE_TIMESTAMP; } - virtual SQLSMALLINT stype() const override { return SQL_TYPE_TIMESTAMP; } - virtual SQLULEN size() const override { return sizeof(SQL_TIMESTAMP_STRUCT); } - virtual SQLINTEGER dp() const override { return boost::posix_time::time_res_traits::num_fractional_digits(); } - virtual const void * dataAddress() const override { return &data; } - TimeStampParam & operator=(const boost::posix_time::ptime & d); - protected: - SQL_TIMESTAMP_STRUCT data; + public: + TimeStampParam() : Param() { } + TimeStampParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = TimeStampParam::size(); + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_TYPE_TIMESTAMP; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_TYPE_TIMESTAMP; + } + virtual SQLULEN + size() const override + { + return sizeof(SQL_TIMESTAMP_STRUCT); + } + virtual SQLINTEGER + dp() const override + { + return boost::posix_time::time_res_traits::num_fractional_digits(); + } + virtual const void * + dataAddress() const override + { + return &data; + } + TimeStampParam & operator=(const boost::posix_time::ptime & d); + + protected: + SQL_TIMESTAMP_STRUCT data; }; class NullParam : public Param { - public: - NullParam() : Param() { } - NullParam(Command * c, unsigned int i) : Param(c, i) { bindLen = SQL_NULL_DATA; } - virtual SQLSMALLINT ctype() const override { return SQL_C_LONG; } - virtual SQLSMALLINT stype() const override { return SQL_C_LONG; } - virtual SQLULEN size() const override { return 0; } - virtual SQLINTEGER dp() const override { return 0; } - virtual const void * dataAddress() const override { return NULL; } + public: + NullParam() : Param() { } + NullParam(Command * c, unsigned int i) : Param(c, i) + { + bindLen = SQL_NULL_DATA; + } + virtual SQLSMALLINT + ctype() const override + { + return SQL_C_LONG; + } + virtual SQLSMALLINT + stype() const override + { + return SQL_C_LONG; + } + virtual SQLULEN + size() const override + { + return 0; + } + virtual SQLINTEGER + dp() const override + { + return 0; + } + virtual const void * + dataAddress() const override + { + return NULL; + } }; } #endif - diff --git a/libodbcpp/odbc-param_fwd.h b/libodbcpp/odbc-param_fwd.h index 88c3dae..6c32d02 100644 --- a/libodbcpp/odbc-param_fwd.h +++ b/libodbcpp/odbc-param_fwd.h @@ -1,29 +1,28 @@ #ifndef ODBC_PARAM_FWD_H #define ODBC_PARAM_FWD_H -#include #include "odbc-bind.h" +#include namespace ODBC { class Command; class Param : public virtual Bind { - public: - Param(); - Param(Command *, unsigned int idx); - void bind() const; + public: + Param(); + Param(Command *, unsigned int idx); + void bind() const; - virtual SQLSMALLINT stype() const = 0; // The SQL type ID - virtual SQLINTEGER dp() const = 0; // The decimal place count - virtual const void * dataAddress() const = 0; // The address of the data + virtual SQLSMALLINT stype() const = 0; // The SQL type ID + virtual SQLINTEGER dp() const = 0; // The decimal place count + virtual const void * dataAddress() const = 0; // The address of the data - protected: - friend class Column; - mutable Command * paramCmd; - mutable unsigned int paramIdx; - mutable bool paramBound; // Has SqlBind(...) been called since last change of address? - SQLLEN dataLength; + protected: + friend class Column; + mutable Command * paramCmd; + mutable unsigned int paramIdx; + mutable bool paramBound; // Has SqlBind(...) been called since last change of address? + SQLLEN dataLength; }; } #endif - diff --git a/libodbcpp/odbc-selectcommand.cpp b/libodbcpp/odbc-selectcommand.cpp index 82947a7..d40ab2f 100644 --- a/libodbcpp/odbc-selectcommand.cpp +++ b/libodbcpp/odbc-selectcommand.cpp @@ -1,15 +1,13 @@ #include "odbc-selectcommand.h" -#include "odbc-error.h" #include "odbc-column.h" -#include -#include -#include +#include "odbc-error.h" #include +#include +#include +#include ODBC::SelectCommand::SelectCommand(const Connection & c, const std::string & s) : - DB::Command(s), - ODBC::Command(c, s), - DB::SelectCommand(s) + DB::Command(s), ODBC::Command(c, s), DB::SelectCommand(s) { } @@ -26,7 +24,7 @@ ODBC::SelectCommand::fetch() return fetch(SQL_FETCH_NEXT, 0); } -constexpr std::array truncated = { '0', '1', '0', '0', '4', '\0' }; +constexpr std::array truncated = {'0', '1', '0', '0', '4', '\0'}; bool ODBC::SelectCommand::fetch(SQLSMALLINT orientation, SQLLEN offset) { @@ -36,31 +34,29 @@ ODBC::SelectCommand::fetch(SQLSMALLINT orientation, SQLLEN offset) RETCODE rc = SQLFetchScroll(hStmt, orientation, offset); switch (rc) { case SQL_SUCCESS_WITH_INFO: - default: - { - std::array sqlstatus {}; - RETCODE diagrc = SQLGetDiagRec(SQL_HANDLE_STMT, hStmt, 1, sqlstatus.data(), nullptr, nullptr, 0, nullptr); - if (SQL_SUCCEEDED(diagrc)) { - if (sqlstatus == truncated) { - for (const auto & c : largeColumns) { - c->resize(); - } - return fetch(SQL_FETCH_RELATIVE, 0); + default: { + std::array sqlstatus {}; + RETCODE diagrc = SQLGetDiagRec(SQL_HANDLE_STMT, hStmt, 1, sqlstatus.data(), nullptr, nullptr, 0, nullptr); + if (SQL_SUCCEEDED(diagrc)) { + if (sqlstatus == truncated) { + for (const auto & c : largeColumns) { + c->resize(); } - } - } - [[ fallthrough ]]; - case SQL_SUCCESS: - { - bool resized = false; - for (const auto & c : largeColumns) { - resized |= c->resize(); - } - if (resized) { return fetch(SQL_FETCH_RELATIVE, 0); } - return true; } + } + [[fallthrough]]; + case SQL_SUCCESS: { + bool resized = false; + for (const auto & c : largeColumns) { + resized |= c->resize(); + } + if (resized) { + return fetch(SQL_FETCH_RELATIVE, 0); + } + return true; + } case SQL_NO_DATA: return false; } @@ -84,7 +80,7 @@ ODBC::SelectCommand::execute() int sqlcol = col + 1; // NOLINTNEXTLINE(hicpp-no-array-decay) if (!SQL_SUCCEEDED(rc = SQLDescribeCol(hStmt, sqlcol, _colName.data(), _colName.size(), &nameLen, &bindType, - &bindSize, &dp, &nullable))) { + &bindSize, &dp, &nullable))) { throw Error(rc, SQL_HANDLE_STMT, hStmt); } Glib::ustring colName((const char *)_colName.data(), nameLen); @@ -129,7 +125,8 @@ ODBC::SelectCommand::execute() throw DB::ColumnTypeNotSupported(); default: SQLLEN octetSize = 0; - if (!SQL_SUCCEEDED(rc = SQLColAttribute(hStmt, sqlcol, SQL_DESC_OCTET_LENGTH, nullptr, 0, nullptr, &octetSize))) { + if (!SQL_SUCCEEDED(rc + = SQLColAttribute(hStmt, sqlcol, SQL_DESC_OCTET_LENGTH, nullptr, 0, nullptr, &octetSize))) { throw Error(rc, SQL_HANDLE_STMT, hStmt); } bindSize = octetSize; @@ -141,4 +138,3 @@ ODBC::SelectCommand::execute() dynamic_cast(ncol)->bind(); } } - diff --git a/libodbcpp/odbc-selectcommand.h b/libodbcpp/odbc-selectcommand.h index efa584e..1dbf798 100644 --- a/libodbcpp/odbc-selectcommand.h +++ b/libodbcpp/odbc-selectcommand.h @@ -1,25 +1,24 @@ #ifndef ODBC_SELECTCOMMAND_H #define ODBC_SELECTCOMMAND_H -#include #include "odbc-command.h" +#include namespace ODBC { class Column; class SelectCommand : public Command, public DB::SelectCommand { - public: - SelectCommand (const Connection &, const std::string & sql); - ~SelectCommand(); - bool fetch() override; - void execute() override; + public: + SelectCommand(const Connection &, const std::string & sql); + ~SelectCommand(); + bool fetch() override; + void execute() override; - private: - bool fetch(SQLSMALLINT orientation = SQL_FETCH_NEXT, SQLLEN offset = 0); - typedef std::shared_ptr ColumnPtr; - typedef std::set Columns; - Columns largeColumns; + private: + bool fetch(SQLSMALLINT orientation = SQL_FETCH_NEXT, SQLLEN offset = 0); + typedef std::shared_ptr ColumnPtr; + typedef std::set Columns; + Columns largeColumns; }; } #endif - diff --git a/libodbcpp/unittests/testodbc.cpp b/libodbcpp/unittests/testodbc.cpp index 5263eb5..14fe0a3 100644 --- a/libodbcpp/unittests/testodbc.cpp +++ b/libodbcpp/unittests/testodbc.cpp @@ -1,30 +1,30 @@ #define BOOST_TEST_MODULE TestODBC #include +#include +#include #include +#include #include +#include #include #include -#include -#include -#include #include -#include -#include class StandardMockDatabase : public DB::PluginMock { - public: - StandardMockDatabase() : DB::PluginMock( "odbcmock", { rootDir / "odbcschema.sql" }, +public: + StandardMockDatabase() : + DB::PluginMock("odbcmock", {rootDir / "odbcschema.sql"}, "Driver=psqlodbcw.so;uid=postgres;servername=/run/postgresql", "Database=postgres") - { - } + { + } }; -BOOST_GLOBAL_FIXTURE( StandardMockDatabase ); +BOOST_GLOBAL_FIXTURE(StandardMockDatabase); -BOOST_FIXTURE_TEST_SUITE( Core, DB::TestCore ); +BOOST_FIXTURE_TEST_SUITE(Core, DB::TestCore); -BOOST_AUTO_TEST_CASE( transactions ) +BOOST_AUTO_TEST_CASE(transactions) { auto ro = DB::MockDatabase::openConnectionTo("odbcmock"); @@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE( transactions ) BOOST_REQUIRE_EQUAL(false, ro->inTx()); } -BOOST_AUTO_TEST_CASE( bindAndSend ) +BOOST_AUTO_TEST_CASE(bindAndSend) { auto rw = DB::MockDatabase::openConnectionTo("odbcmock"); @@ -53,7 +53,7 @@ BOOST_AUTO_TEST_CASE( bindAndSend ) BOOST_CHECK_EQUAL(1, mod->execute()); } -BOOST_AUTO_TEST_CASE( bindAndSelect ) +BOOST_AUTO_TEST_CASE(bindAndSelect) { auto ro = DB::MockDatabase::openConnectionTo("odbcmock"); @@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE( bindAndSelect ) BOOST_REQUIRE_EQUAL(1, rows); } -BOOST_AUTO_TEST_CASE( bindAndSelectOther ) +BOOST_AUTO_TEST_CASE(bindAndSelectOther) { auto ro = DB::MockDatabase::openConnectionTo("odbcmock"); @@ -85,13 +85,14 @@ BOOST_AUTO_TEST_CASE( bindAndSelectOther ) assertColumnValueHelper(*select, 1, 123.45); assertColumnValueHelper(*select, 2, std::string_view("some text")); // assertColumnValueHelper(*select, 3, true); - assertColumnValueHelper(*select, 4, boost::posix_time::ptime_from_tm({ 3, 6, 23, 27, 3, 115, 0, 0, 0, 0, nullptr})); + assertColumnValueHelper( + *select, 4, boost::posix_time::ptime_from_tm({3, 6, 23, 27, 3, 115, 0, 0, 0, 0, nullptr})); rows += 1; } BOOST_REQUIRE_EQUAL(1, rows); } -BOOST_AUTO_TEST_CASE( multibyte ) +BOOST_AUTO_TEST_CASE(multibyte) { auto ro = DB::MockDatabase::openConnectionTo("odbcmock"); @@ -106,4 +107,3 @@ BOOST_AUTO_TEST_CASE( multibyte ) } BOOST_AUTO_TEST_SUITE_END(); - -- cgit v1.2.3