megamove

src/PgsqlConn.h

@@ -0,0 +1,473 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <pgsql/libpq-fe.h>
+#include <cassert>
+#include <QString>
+
+#include <vector>
+#include <codecvt>
+#include <memory>
+
+#include <fmt/format.h>
+
+namespace Pgsql {
+
+	const Oid oid_bool = 16;
+	const Oid oid_int2 = 21;
+	const Oid oid_int4 = 23;
+	const Oid oid_int8 = 20;
+	const Oid oid_float4 = 700;
+	const Oid oid_float8 = 701;
+	const Oid oid_numeric = 1700;
+	const Oid oid_oid = 26;
+	const Oid oid_varchar = 1043;
+
+
+
+	class Params {
+	public:
+		Params();
+		Params(const Params& rhs);
+		Params& operator=(const Params& rhs);
+		Params(const Params&& rhs);
+		~Params();
+
+//		template <typename T>
+//		Params& add(const T& val, Oid oid = InvalidOid)
+//		{
+
+//			fmt::FormatInt(
+//			int idx = i-1;
+//			m_strings[idx] = value_to_dbstring(val);
+//			m_paramValues[idx] = m_strings[idx].c_str();
+
+//			return *this;
+//		}
+
+
+		/** \brief Add a parameter to the list.
+		 *
+		 * The class takes ownership of data and will try to delete[] it.
+		 */
+		void addText(const char *data, Oid oid);
+		void add(const QString &s, Oid oid);
+		void addBinary(const char *data, int length, Oid oid);
+		void clear();
+
+	private:
+		using t_paramValues = std::vector<const char *>;
+
+		void deleteValues()
+		{
+			for (auto e : m_paramValues)
+				delete[] e;
+		}
+
+		/* Assumes other lists already have been copied */
+		void copyValues(const t_paramValues &r);
+
+		std::vector<Oid> m_paramTypes;
+		t_paramValues m_paramValues;
+		std::vector<int> m_paramLengths; ///< postgresql ignores lengths for text parameters but we will it anyway for efficient copying
+		std::vector<int> m_paramFormats;
+	};
+
+	class Connection;
+	/*
+	This library has multiple layers.
+
+	Layer 1 delivers lowlevel C++ wrappers for the basic libpq functionality. Adding
+	automatic resource management.
+
+	*/
+
+//	class ConnectionParams {
+//	public:
+//		std::string host;
+//		std::string hostaddr;
+//		unsigned short port = 5432;
+//		std::string dbname;
+//		std::string user;
+//		std::string password;
+//		int connect_timeout = -1; ///< -1 omit (ie uses default)
+//		std::string application_name;
+
+//	};
+
+	class ErrorDetails {
+	public:
+		static ErrorDetails createErrorDetailsFromPGresult(const PGresult *res);
+
+		std::string errorMessage;
+		std::string state; ///< PG_DIAG_SQLSTATE Error code as listed in	https://www.postgresql.org/docs/9.5/static/errcodes-appendix.html
+		std::string severity;
+		std::string messagePrimary;
+		std::string messageDetail;
+		std::string messageHint;
+		int statementPosition; ///< First character is one, measured in characters not bytes!
+		int internalPosition;
+		std::string internalQuery;
+		std::string context;
+		std::string schemaName;
+		std::string tableName;
+		std::string columnName;
+		std::string datatypeName;
+		std::string constraintName;
+		std::string sourceFile;
+		std::string sourceLine;
+		std::string sourceFunction;
+	};
+
+	/** \brief Class that is returned as value of a cell to facilitate auto conversion.
+	 */
+	class Value {
+	public:
+		Value(const char *val, Oid typ)
+			: m_val(val), m_typ(typ)
+		{}
+
+		QString asQString() const
+		{
+			return QString::fromUtf8(m_val);
+		}
+
+		operator QString() const
+		{
+			return QString::fromUtf8(m_val);
+		}
+
+		operator std::string() const
+		{
+			return m_val;
+		}
+
+		operator short() const
+		{
+			return (short)std::atoi(m_val);
+		}
+
+		operator int() const
+		{
+			return std::atoi(m_val);
+		}
+
+		operator Oid() const
+		{
+			return operator int();
+		}
+
+		operator __int64() const
+		{
+			return strtoull(m_val, nullptr, 10);
+		}
+
+		operator bool() const
+		{
+			return strcmp(m_val, "t") == 0;
+		}
+
+	private:
+		const char *m_val;
+		Oid m_typ;
+
+	};
+
+
+	class Result;
+
+	/** \brief A reference to a specific row from a result.
+	 *
+	 * As it is a reference its contents won't be valid after its associated result has
+	 * been destroyed.
+	 */
+	class Row {
+	public:
+		Row(const Result &result, int row)
+			: m_result(result)
+			, m_row(row)
+		{}
+
+		bool next();
+		bool operator==(const Row& rhs)
+		{
+			return &m_result == &rhs.m_result
+					&& m_row == rhs.m_row;
+		}
+
+		Value get(int col) const;
+		//Value get(const char *colname) const;
+		//bool get(int col, QString &s);
+	private:
+		const Result& m_result;
+		int m_row;
+	};
+
+	/** \brief Non-copyable but movable wrapper for a postgresql result.
+	 *
+	 * This class makes sure the result is removed from memory. It also supplies an iterator for the
+	 * rows from the result facilitating also the use of the cpp for each.
+	 */
+	class Result {
+	public:
+		class const_iterator {
+		public:
+			const_iterator(const Result &r, int rw)
+				: m_row(r, rw)
+			{}
+
+			const_iterator operator++()
+			{
+				const_iterator t(*this);
+				m_row.next();
+				return t;
+			}
+
+			const_iterator& operator++(int)
+			{
+				m_row.next();
+				return *this;
+			}
+
+			bool operator==(const const_iterator &rhs)
+			{
+				return m_row == rhs.m_row;
+			}
+
+			bool operator!=(const const_iterator &rhs)
+			{
+				return !operator==(rhs);
+			}
+
+			const Row& operator*()
+			{
+				return m_row;
+			}
+			const Row& operator->()
+			{
+				return m_row;
+			}
+
+		private:
+			Row m_row;
+		};
+
+		Result() = default;
+		Result(PGresult *result);
+		~Result();
+
+		Result(const Result &rhs) = delete;
+		Result& operator=(const Result &rhs) = delete;
+
+		Result(Result &&rhs);
+		Result& operator=(Result &&rhs);
+
+		operator bool() const;
+
+		ExecStatusType resultStatus();
+
+		std::string getResStatus();
+
+		/** Use this to retrieve an error code when this is an error result
+		 *
+		 * The possible code are listed in https://www.postgresql.org/docs/9.5/static/errcodes-appendix.html
+		 */
+		std::string diagSqlState();
+		/** Retrieves all the error fields. */
+		ErrorDetails diagDetails();
+
+		const_iterator begin() const
+		{
+			return const_iterator(*this, 0);
+		}
+
+		const_iterator end() const
+		{
+			return const_iterator(*this, getRows());
+		}
+
+		int tuplesAffected() const;
+		int getRows() const;
+		int getCols() const;
+
+		const char* const getColName(int idx) const;
+
+		const char * getVal(int col, int row) const;
+		Value get(int col, int row) const;
+		Oid type(int col) const;
+		bool null(int col, int row) const;
+
+
+//		iterator begin();
+	private:
+		PGresult *result = nullptr;
+	};
+
+
+	/** \brief Wrapper for a cancel object from libpq.
+	 */
+	class Canceller {
+	public:
+		Canceller() = default;
+		Canceller(PGcancel *c);
+		Canceller(const Canceller&) = delete;
+		Canceller& operator=(const Canceller&) = delete;
+		Canceller(Canceller&& rhs);
+		Canceller& operator=(Canceller&& rhs);
+		~Canceller();
+
+		bool cancel(std::string *error);
+	private:
+		PGcancel *m_cancel = nullptr;
+	};
+
+	/** \brief Class for connecting to the database.
+	 *
+	 * The class isolates the programmer from the worst C style parts
+	 * of the libpq API but is mostly a very thin wrapper.
+	 */
+	class Connection {
+	public:
+		Connection();
+		~Connection();
+
+		Connection(const Connection &rhs) = delete;
+		Connection& operator=(const Connection &rhs) = delete;
+
+		Connection(Connection &&rhs);
+		Connection& operator=(Connection &&rhs);
+
+//		void connect(const ConnectionParams &params);
+		bool connect(const char *params);
+		bool connect(const QString &params)
+		{
+			return connect(params.toUtf8().data());
+		}
+		bool connect(const char *const * keywords, const char* const * values, int expand_dbname);
+
+		bool connectStart(const char *params);
+
+		bool connectStart(const std::string &params)
+		{
+			return connectStart(params.c_str());
+		}
+
+		bool connectStart(const QString &params)
+		{
+			return connectStart(params.toUtf8().data());
+		}
+		bool connectStart(const char * const *keywords,
+						  const char * const *values);
+
+		PostgresPollingStatusType connectPoll();
+		ConnStatusType status();
+		int socket();
+
+		void close();
+		Canceller getCancel();
+
+		std::string getErrorMessage() const;
+
+		Result query(const char * command);
+		Result query(const QString &command)
+		{
+			return query(command.toUtf8().data());
+		}
+
+		bool sendQuery(const char * query);
+		bool sendQuery(const std::string &command)
+		{
+			return sendQuery(command.c_str());
+		}
+		bool sendQuery(const QString &command)
+		{
+			return sendQuery(command.toUtf8().data());
+		}
+
+		std::shared_ptr<Result> getResult();
+
+		bool consumeInput();
+		bool isBusy();
+
+		void setNoticeReceiver(std::function<void(const PGresult *)> callback);
+	private:
+		PGconn *conn = nullptr;
+		std::function<void(const PGresult *)> notifyReceiver;
+
+		static void notifyReceiveFunc(void *arg, const PGresult *result);
+	};
+
+
+
+
+//	class Field {
+//	public:
+
+//		std::string getName() const;
+
+//	private:
+//		//Tuples tuples;
+//		int field;
+//		//
+
+//	};
+
+//	class Tuples {
+//	public:
+//		int getRowCount() const;
+//		int getColCount() const;
+
+//		Field getField(const std::string &fname);
+//		Field getField(const int idx);
+
+//		class const_iterator {
+//		public:
+//            const_iterator& operator++();
+//		};
+
+//		void rewind();
+
+
+//	};
+
+//	class OkResult: public Result {
+//	public:
+//		/** If the result is a data result then returns an interface for processing this data.
+
+//		The returned interface remains valid as long as this OkResult exists.
+//		*/
+//		Tuples* hasTuples();
+//	};
+
+//	class ErrorResult: public Result {
+//
+//	};
+
+//	class ITransaction {
+//	public:
+//
+//		Canceller Query(std::string query,
+//			std::function<void(OkResult)> on_success,
+//			std::function<void()> on_cancelled,
+//			std::function<void(ErrorResult)> on_error);
+//
+//		Canceller Query(std::string query,
+//			std::function<void(OkResult)> on_success,
+//			std::function<void()> on_cancelled,
+//			std::function<void(ErrorResult)> on_error);
+//
+//
+//		void Rollback(
+//			std::function<void(OkResult)> on_success,
+//			std::function<void(ErrorResult)> on_error);
+//		void Commit(
+//			std::function<void(OkResult)> on_success,
+//			std::function<void()> on_cancelled,
+//			std::function<void(ErrorResult)> on_error);
+//
+//	};
+}
+
+
+