Switched ConnectionConfig to QString from std::string to fit better into Qt framework
This commit is contained in:
eelke
parent
bcfd82c27d
commit
082293e58a
20 changed files with 1077 additions and 211 deletions
|
|
@ -1,5 +1,6 @@
|
|||
#include "ASyncDBConnection.h"
|
||||
#include "ScopeGuard.h"
|
||||
#include "util.h"
|
||||
#include <chrono>
|
||||
|
||||
using namespace boost::asio;
|
||||
|
|
@ -32,23 +33,23 @@ ASyncDBConnection::State ASyncDBConnection::state() const
|
|||
|
||||
void ASyncDBConnection::setupConnection(const ConnectionConfig &config)
|
||||
{
|
||||
m_config = config;
|
||||
auto keywords = m_config.getKeywords();
|
||||
auto values = m_config.getValues();
|
||||
|
||||
bool ok = m_connection.connectStart(keywords, values);
|
||||
m_config = config;
|
||||
// auto keywords = m_config.getKeywords();
|
||||
// auto values = m_config.getValues();
|
||||
QString conn_string = config.connectionString();
|
||||
bool ok = m_connection.connectStart(conn_string.toStdString().c_str());
|
||||
// auto start = std::chrono::steady_clock::now();
|
||||
if (ok && m_connection.status() != CONNECTION_BAD) {
|
||||
auto sock_handle = m_connection.socket();
|
||||
if (ok && m_connection.status() != CONNECTION_BAD) {
|
||||
auto sock_handle = m_connection.socket();
|
||||
|
||||
m_asioSock.assign(ip::tcp::v4(), sock_handle);
|
||||
m_asioSock.non_blocking(true);
|
||||
m_asioSock.assign(ip::tcp::v4(), sock_handle);
|
||||
m_asioSock.non_blocking(true);
|
||||
|
||||
m_asioSock.async_write_some(null_buffers(),
|
||||
[this] (boost::system::error_code ec, std::size_t s)
|
||||
{ async_connect_handler(ec, s); }
|
||||
);
|
||||
}
|
||||
m_asioSock.async_write_some(null_buffers(),
|
||||
[this] (boost::system::error_code ec, std::size_t s)
|
||||
{ async_connect_handler(ec, s); }
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
void ASyncDBConnection::async_connect_handler(boost::system::error_code ec, std::size_t /*s*/)
|
||||
|
|
|
|||
|
|
@ -2,9 +2,19 @@
|
|||
#include "util.h"
|
||||
#include <QCoreApplication>
|
||||
#include <QProcessEnvironment>
|
||||
#include <QStringBuilder>
|
||||
#include <QUrl>
|
||||
|
||||
namespace {
|
||||
|
||||
class registerMetaTypes {
|
||||
public:
|
||||
registerMetaTypes()
|
||||
{
|
||||
qRegisterMetaTypeStreamOperators<ConnectionConfig>("ConnectionConfig");
|
||||
}
|
||||
} registerMetaTypes_instance;
|
||||
|
||||
struct {
|
||||
SslMode mode;
|
||||
const char* string;
|
||||
|
|
@ -24,18 +34,17 @@ namespace {
|
|||
|
||||
} // end unnamed namespace
|
||||
|
||||
std::string SslModeToString(SslMode sm)
|
||||
{
|
||||
std::string result;
|
||||
QString SslModeToString(SslMode sm)
|
||||
{
|
||||
for (auto e : SslModeStringTable) {
|
||||
if (e.mode == sm) {
|
||||
result = e.string;
|
||||
return QString::fromUtf8(e.string);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
return {};
|
||||
}
|
||||
|
||||
SslMode StringToSslMode(std::string s)
|
||||
SslMode StringToSslMode(QString s)
|
||||
{
|
||||
SslMode result = SslMode::allow;
|
||||
for (auto e : SslModeStringTable) {
|
||||
|
|
@ -43,14 +52,14 @@ SslMode StringToSslMode(std::string s)
|
|||
result = e.mode;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
return {};
|
||||
}
|
||||
|
||||
|
||||
std::vector<const char*> ConnectionConfig::s_keywords = {
|
||||
"host", "hostaddr", "port", "user", "password", "dbname",
|
||||
"sslmode", "sslcert", "sslkey", "sslrootcrt", "sslcrl",
|
||||
"client_encoding", "application_name", nullptr };
|
||||
//std::vector<const char*> ConnectionConfig::s_keywords = {
|
||||
// "host", "hostaddr", "port", "user", "password", "dbname",
|
||||
// "sslmode", "sslcert", "sslkey", "sslrootcrt", "sslcrl",
|
||||
// "client_encoding", "application_name", nullptr };
|
||||
|
||||
|
||||
ConnectionConfig::ConnectionConfig()
|
||||
|
|
@ -83,7 +92,7 @@ const QUuid &ConnectionConfig::uuid() const
|
|||
}
|
||||
|
||||
|
||||
void ConnectionConfig::setName(std::string desc)
|
||||
void ConnectionConfig::setName(const QString& desc)
|
||||
{
|
||||
if (m_name != desc) {
|
||||
m_dirty = true;
|
||||
|
|
@ -91,12 +100,12 @@ void ConnectionConfig::setName(std::string desc)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::name() const
|
||||
const QString& ConnectionConfig::name() const
|
||||
{
|
||||
return m_name;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setHost(std::string host)
|
||||
void ConnectionConfig::setHost(const QString& host)
|
||||
{
|
||||
if (m_host != host) {
|
||||
m_dirty = true;
|
||||
|
|
@ -104,12 +113,12 @@ void ConnectionConfig::setHost(std::string host)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::host() const
|
||||
const QString& ConnectionConfig::host() const
|
||||
{
|
||||
return m_host;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setHostAddr(std::string v)
|
||||
void ConnectionConfig::setHostAddr(const QString &v)
|
||||
{
|
||||
if (m_hostaddr != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -117,26 +126,25 @@ void ConnectionConfig::setHostAddr(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::hostAddr() const
|
||||
const QString& ConnectionConfig::hostAddr() const
|
||||
{
|
||||
return m_hostaddr;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setPort(unsigned short port)
|
||||
{
|
||||
auto p = std::to_string(port);
|
||||
if (m_port != p) {
|
||||
if (m_port != port) {
|
||||
m_dirty = true;
|
||||
m_port = p;
|
||||
m_port = port;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned short ConnectionConfig::port() const
|
||||
{
|
||||
return static_cast<unsigned short>(std::stoi(m_port));
|
||||
return m_port;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setUser(std::string v)
|
||||
void ConnectionConfig::setUser(const QString& v)
|
||||
{
|
||||
if (m_user != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -145,12 +153,12 @@ void ConnectionConfig::setUser(std::string v)
|
|||
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::user() const
|
||||
const QString& ConnectionConfig::user() const
|
||||
{
|
||||
return m_user;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setPassword(std::string v)
|
||||
void ConnectionConfig::setPassword(const QString& v)
|
||||
{
|
||||
if (m_password != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -158,12 +166,12 @@ void ConnectionConfig::setPassword(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::password() const
|
||||
const QString& ConnectionConfig::password() const
|
||||
{
|
||||
return m_password;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setDbname(std::string v)
|
||||
void ConnectionConfig::setDbname(const QString& v)
|
||||
{
|
||||
if (m_dbname != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -171,26 +179,25 @@ void ConnectionConfig::setDbname(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::dbname() const
|
||||
const QString& ConnectionConfig::dbname() const
|
||||
{
|
||||
return m_dbname;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setSslMode(SslMode m)
|
||||
{
|
||||
auto v = SslModeToString(m);
|
||||
if (m_sslMode != v) {
|
||||
if (m_sslMode != m) {
|
||||
m_dirty = true;
|
||||
m_sslMode = v;
|
||||
m_sslMode = m;
|
||||
}
|
||||
}
|
||||
|
||||
SslMode ConnectionConfig::sslMode() const
|
||||
{
|
||||
return StringToSslMode(m_sslMode);
|
||||
return m_sslMode;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setSslCert(std::string v)
|
||||
void ConnectionConfig::setSslCert(const QString& v)
|
||||
{
|
||||
if (m_sslCert != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -198,12 +205,12 @@ void ConnectionConfig::setSslCert(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::sslCert() const
|
||||
const QString& ConnectionConfig::sslCert() const
|
||||
{
|
||||
return m_sslCert;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setSslKey(std::string v)
|
||||
void ConnectionConfig::setSslKey(const QString& v)
|
||||
{
|
||||
if (m_sslKey != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -211,12 +218,12 @@ void ConnectionConfig::setSslKey(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::sslKey() const
|
||||
const QString& ConnectionConfig::sslKey() const
|
||||
{
|
||||
return m_sslKey;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setSslRootCert(std::string v)
|
||||
void ConnectionConfig::setSslRootCert(const QString& v)
|
||||
{
|
||||
if (m_sslRootCert != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -224,12 +231,12 @@ void ConnectionConfig::setSslRootCert(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::sslRootCert() const
|
||||
const QString& ConnectionConfig::sslRootCert() const
|
||||
{
|
||||
return m_sslRootCert;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setSslCrl(std::string v)
|
||||
void ConnectionConfig::setSslCrl(const QString& v)
|
||||
{
|
||||
if (m_sslCrl != v) {
|
||||
m_dirty = true;
|
||||
|
|
@ -237,36 +244,36 @@ void ConnectionConfig::setSslCrl(std::string v)
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& ConnectionConfig::sslCrl() const
|
||||
const QString& ConnectionConfig::sslCrl() const
|
||||
{
|
||||
return m_sslCrl;
|
||||
}
|
||||
|
||||
|
||||
const char * const * ConnectionConfig::getKeywords() const
|
||||
{
|
||||
return s_keywords.data();
|
||||
}
|
||||
//const char * const * ConnectionConfig::getKeywords() const
|
||||
//{
|
||||
// return s_keywords.data();
|
||||
//}
|
||||
|
||||
const char * const * ConnectionConfig::getValues() const
|
||||
{
|
||||
m_values.resize(s_keywords.size(), nullptr);
|
||||
m_values[0] = valuePtr(m_host);
|
||||
m_values[1] = valuePtr(m_hostaddr);
|
||||
m_values[2] = valuePtr(m_port);
|
||||
m_values[3] = valuePtr(m_user);
|
||||
m_values[4] = valuePtr(m_password);
|
||||
m_values[5] = valuePtr(m_dbname);
|
||||
m_values[6] = valuePtr(m_sslMode);
|
||||
m_values[7] = valuePtr(m_sslCert);
|
||||
m_values[8] = valuePtr(m_sslKey);
|
||||
m_values[9] = valuePtr(m_sslRootCert);
|
||||
m_values[10] = valuePtr(m_sslCrl);
|
||||
m_values[11] = "utf8";
|
||||
m_values[12] = valuePtr(m_applicationName);
|
||||
//const char * const * ConnectionConfig::getValues() const
|
||||
//{
|
||||
// m_values.resize(s_keywords.size(), nullptr);
|
||||
// m_values[0] = valuePtr(m_host);
|
||||
// m_values[1] = valuePtr(m_hostaddr);
|
||||
// m_values[2] = valuePtr(m_port);
|
||||
// m_values[3] = valuePtr(m_user);
|
||||
// m_values[4] = valuePtr(m_password);
|
||||
// m_values[5] = valuePtr(m_dbname);
|
||||
// m_values[6] = valuePtr(m_sslMode);
|
||||
// m_values[7] = valuePtr(m_sslCert);
|
||||
// m_values[8] = valuePtr(m_sslKey);
|
||||
// m_values[9] = valuePtr(m_sslRootCert);
|
||||
// m_values[10] = valuePtr(m_sslCrl);
|
||||
// m_values[11] = "utf8";
|
||||
// m_values[12] = valuePtr(m_applicationName);
|
||||
|
||||
return m_values.data();
|
||||
}
|
||||
// return m_values.data();
|
||||
//}
|
||||
|
||||
bool ConnectionConfig::isSameDatabase(const ConnectionConfig &rhs) const
|
||||
{
|
||||
|
|
@ -290,28 +297,111 @@ void ConnectionConfig::clean()
|
|||
|
||||
QString ConnectionConfig::makeLongDescription() const
|
||||
{
|
||||
std::string result(name());
|
||||
result += " (";
|
||||
result += user();
|
||||
result += "@";
|
||||
result += host();
|
||||
result += ":";
|
||||
result += std::to_string(port());
|
||||
result += "/";
|
||||
result += dbname();
|
||||
result += ")";
|
||||
return stdStrToQ(result);
|
||||
QString result;
|
||||
result = name() % " (" % user() % "@" % host() % ":" % QString::number(port()) % "/" % dbname() % ")";
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string ConnectionConfig::encodedPassword() const
|
||||
QByteArray ConnectionConfig::encodedPassword() const
|
||||
{
|
||||
return m_encodedPassword;
|
||||
}
|
||||
|
||||
void ConnectionConfig::setEncodedPassword(const std::string &encodedPassword)
|
||||
void ConnectionConfig::setEncodedPassword(const QByteArray &encodedPassword)
|
||||
{
|
||||
m_dirty = true;
|
||||
m_encodedPassword = encodedPassword;
|
||||
m_encodedPassword = encodedPassword;
|
||||
}
|
||||
|
||||
void ConnectionConfig::write(QDataStream &out) const
|
||||
{
|
||||
// out <<
|
||||
}
|
||||
|
||||
void ConnectionConfig::read(QDataStream &in)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
QString ConnectionConfig::escapeConnectionStringValue(const QString &value)
|
||||
{
|
||||
bool contains_spaces = false;
|
||||
int escapes = 0;
|
||||
for (auto&& c : value)
|
||||
if (c == ' ') contains_spaces = true;
|
||||
else if (c == '\'' || c == '\\') ++escapes;
|
||||
|
||||
if (contains_spaces || escapes > 0 || value.length() == 0) {
|
||||
QString result;
|
||||
result.reserve(2 + value.length() + escapes);
|
||||
result += '\'';
|
||||
for (auto&& c : value) {
|
||||
if (c == '\'' || c == '\\') {
|
||||
result += '\\';
|
||||
}
|
||||
result += c;
|
||||
}
|
||||
result += '\'';
|
||||
return result;
|
||||
}
|
||||
else {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
QString ConnectionConfig::connectionString() const
|
||||
{
|
||||
QString s;
|
||||
s += "host="
|
||||
% escapeConnectionStringValue(m_host)
|
||||
% " port="
|
||||
% QString::number(m_port)
|
||||
% " user="
|
||||
% escapeConnectionStringValue(m_user);
|
||||
s += " password=";
|
||||
s += escapeConnectionStringValue(m_password);
|
||||
s += " dbname=";
|
||||
s += escapeConnectionStringValue(m_dbname);
|
||||
s += " sslmode=";
|
||||
s += SslModeToString(m_sslMode);
|
||||
if (!m_sslCert.isEmpty()) {
|
||||
s += " sslcert=";
|
||||
s += escapeConnectionStringValue(m_sslCert);
|
||||
}
|
||||
if (!m_sslKey.isEmpty()) {
|
||||
s += " sslkey=";
|
||||
s += escapeConnectionStringValue(m_sslKey);
|
||||
}
|
||||
if (!m_sslRootCert.isEmpty()) {
|
||||
s += " sslrootcrt=";
|
||||
s += escapeConnectionStringValue(m_sslRootCert);
|
||||
}
|
||||
if (!m_sslCrl.isEmpty()) {
|
||||
s += " sslCrl=";
|
||||
s += escapeConnectionStringValue(m_sslCrl);
|
||||
}
|
||||
s += " client_encoding=utf8";
|
||||
s += " application_name=";
|
||||
s += escapeConnectionStringValue(m_applicationName);
|
||||
|
||||
// "host", "hostaddr", "port", "user", "password", "dbname",
|
||||
// "sslmode", "sslcert", "sslkey", "sslrootcrt", "sslcrl",
|
||||
// "client_encoding", "application_name", nullptr };
|
||||
// m_values[0] = valuePtr(m_host);
|
||||
// m_values[1] = valuePtr(m_hostaddr);
|
||||
// m_values[2] = valuePtr(m_port);
|
||||
// m_values[3] = valuePtr(m_user);
|
||||
// m_values[4] = valuePtr(m_password);
|
||||
// m_values[5] = valuePtr(m_dbname);
|
||||
// m_values[6] = valuePtr(m_sslMode);
|
||||
// m_values[7] = valuePtr(m_sslCert);
|
||||
// m_values[8] = valuePtr(m_sslKey);
|
||||
// m_values[9] = valuePtr(m_sslRootCert);
|
||||
// m_values[10] = valuePtr(m_sslCrl);
|
||||
// m_values[11] = "utf8";
|
||||
// m_values[12] = valuePtr(m_applicationName);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -347,11 +437,11 @@ void ConnectionConfig::writeToEnvironment(QProcessEnvironment &env) const
|
|||
{
|
||||
strToEnv(env, "PGHOST", m_host);
|
||||
strToEnv(env, "PGHOSTADDR", m_hostaddr);
|
||||
strToEnv(env, "PGPORT", m_port);
|
||||
strToEnv(env, "PGPORT", QString::number(m_port));
|
||||
strToEnv(env, "PGDATABASE", m_dbname);
|
||||
strToEnv(env, "PGUSER", m_user);
|
||||
strToEnv(env, "PGPASSWORD", m_password);
|
||||
strToEnv(env, "PGSSLMODE", m_sslMode);
|
||||
strToEnv(env, "PGSSLMODE", SslModeToString(m_sslMode));
|
||||
strToEnv(env, "PGSSLCERT", m_sslCert);
|
||||
strToEnv(env, "PGSSLKEY", m_sslKey);
|
||||
strToEnv(env, "PGSSLROOTCERT", m_sslRootCert);
|
||||
|
|
@ -363,12 +453,12 @@ void ConnectionConfig::writeToEnvironment(QProcessEnvironment &env) const
|
|||
env.remove("PGREQUIRESSL");
|
||||
}
|
||||
|
||||
void ConnectionConfig::strToEnv(QProcessEnvironment &env, const QString &var, const std::string &val)
|
||||
void ConnectionConfig::strToEnv(QProcessEnvironment &env, const QString &var, const QString &val)
|
||||
{
|
||||
if (val.empty())
|
||||
if (val.isEmpty())
|
||||
env.remove(var);
|
||||
else
|
||||
env.insert(var, stdStrToQ(val));
|
||||
env.insert(var, val);
|
||||
}
|
||||
|
||||
void ConnectionGroup::erase(int idx, int count)
|
||||
|
|
@ -389,3 +479,16 @@ void ConnectionGroup::update(int idx, const ConnectionConfig &cc)
|
|||
*node = cc;
|
||||
node->setParent(this);
|
||||
}
|
||||
|
||||
QDataStream &operator<<(QDataStream &out, const ConnectionConfig &cc)
|
||||
{
|
||||
cc.write(out);
|
||||
return out;
|
||||
}
|
||||
|
||||
QDataStream &operator>>(QDataStream &in, ConnectionConfig &cc)
|
||||
{
|
||||
//in>>myObj.uId>>myObj.passwd>>myObj.statusType;
|
||||
cc.read(in);
|
||||
return in;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,9 @@
|
|||
#ifndef CONNECTION_H
|
||||
#define CONNECTION_H
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QDataStream>
|
||||
#include <QMetaType>
|
||||
#include <QUuid>
|
||||
#include <QVector>
|
||||
#include <vector>
|
||||
|
|
@ -66,44 +69,44 @@ public:
|
|||
void setUuid(const QUuid &uuid);
|
||||
const QUuid &uuid() const;
|
||||
|
||||
void setName(std::string desc);
|
||||
const std::string& name() const;
|
||||
void setName(const QString& desc);
|
||||
const QString& name() const;
|
||||
|
||||
void setHost(std::string host);
|
||||
const std::string& host() const;
|
||||
void setHost(const QString& host);
|
||||
const QString& host() const;
|
||||
|
||||
void setHostAddr(std::string v);
|
||||
const std::string& hostAddr() const;
|
||||
void setHostAddr(const QString& v);
|
||||
const QString& hostAddr() const;
|
||||
|
||||
void setPort(unsigned short port);
|
||||
unsigned short port() const;
|
||||
|
||||
void setUser(std::string v);
|
||||
const std::string& user() const;
|
||||
void setUser(const QString& v);
|
||||
const QString& user() const;
|
||||
|
||||
void setPassword(std::string v);
|
||||
const std::string& password() const;
|
||||
void setPassword(const QString& v);
|
||||
const QString& password() const;
|
||||
|
||||
void setDbname(std::string v);
|
||||
const std::string& dbname() const;
|
||||
void setDbname(const QString& v);
|
||||
const QString& dbname() const;
|
||||
|
||||
void setSslMode(SslMode m);
|
||||
SslMode sslMode() const;
|
||||
|
||||
void setSslCert(std::string v);
|
||||
const std::string& sslCert() const;
|
||||
void setSslCert(const QString& v);
|
||||
const QString& sslCert() const;
|
||||
|
||||
void setSslKey(std::string v);
|
||||
const std::string& sslKey() const;
|
||||
void setSslKey(const QString& v);
|
||||
const QString& sslKey() const;
|
||||
|
||||
void setSslRootCert(std::string v);
|
||||
const std::string& sslRootCert() const;
|
||||
void setSslRootCert(const QString& v);
|
||||
const QString& sslRootCert() const;
|
||||
|
||||
void setSslCrl(std::string v);
|
||||
const std::string& sslCrl() const;
|
||||
void setSslCrl(const QString& v);
|
||||
const QString& sslCrl() const;
|
||||
|
||||
const char * const * getKeywords() const;
|
||||
const char * const * getValues() const;
|
||||
// const char * const * getKeywords() const;
|
||||
// const char * const * getValues() const;
|
||||
|
||||
bool isSameDatabase(const ConnectionConfig &rhs) const;
|
||||
|
||||
|
|
@ -115,38 +118,55 @@ public:
|
|||
bool operator==(QUuid id) const { return m_uuid == id; }
|
||||
|
||||
QString makeLongDescription() const;
|
||||
std::string encodedPassword() const;
|
||||
void setEncodedPassword(const std::string &encodedPassword);
|
||||
QByteArray encodedPassword() const;
|
||||
void setEncodedPassword(const QByteArray &encodedPassword);
|
||||
|
||||
void write(QDataStream &out) const;
|
||||
void read(QDataStream &in);
|
||||
|
||||
/** Escapes a value for inclusion in a keyword value connection string.
|
||||
*
|
||||
* Unlikely it will be everneeded outside this class except for unit testing :)
|
||||
*/
|
||||
static QString escapeConnectionStringValue(const QString &value);
|
||||
QString connectionString() const;
|
||||
private:
|
||||
QUuid m_uuid;
|
||||
std::string m_name;
|
||||
std::string m_host;
|
||||
std::string m_hostaddr;
|
||||
std::string m_port = "5432";
|
||||
QString m_name;
|
||||
QString m_host;
|
||||
QString m_hostaddr;
|
||||
uint16_t m_port = 5432;
|
||||
|
||||
std::string m_user;
|
||||
std::string m_password; ///< TODO do we want to keep this here or should we remember it seperatly?
|
||||
std::string m_dbname;
|
||||
QString m_user;
|
||||
QString m_password; ///< Note this is not saved in the DB only the m_encodedPassword is safed.
|
||||
QString m_dbname;
|
||||
|
||||
std::string m_sslMode;
|
||||
std::string m_sslCert;
|
||||
std::string m_sslKey;
|
||||
std::string m_sslRootCert;
|
||||
std::string m_sslCrl;
|
||||
SslMode m_sslMode = SslMode::prefer;
|
||||
QString m_sslCert;
|
||||
QString m_sslKey;
|
||||
QString m_sslRootCert;
|
||||
QString m_sslCrl;
|
||||
|
||||
std::string m_applicationName;
|
||||
std::string m_encodedPassword;
|
||||
QString m_applicationName;
|
||||
QByteArray m_encodedPassword;
|
||||
|
||||
bool m_dirty = false;
|
||||
ConnectionGroup* m_group = nullptr;
|
||||
|
||||
|
||||
static void strToEnv(QProcessEnvironment &env, const QString &var, const std::string &val);
|
||||
static void strToEnv(QProcessEnvironment &env, const QString &var, const QString &val);
|
||||
|
||||
// static std::vector<const char*> s_keywords;
|
||||
// mutable std::vector<const char*> m_values;
|
||||
|
||||
|
||||
static std::vector<const char*> s_keywords;
|
||||
mutable std::vector<const char*> m_values;
|
||||
};
|
||||
|
||||
Q_DECLARE_METATYPE(ConnectionConfig)
|
||||
|
||||
QDataStream &operator<<(QDataStream &out, const ConnectionConfig &cc);
|
||||
|
||||
QDataStream &operator>>(QDataStream &in, ConnectionConfig &cc);
|
||||
|
||||
|
||||
#endif // CONNECTION_H
|
||||
|
|
|
|||
|
|
@ -6,11 +6,120 @@ namespace {
|
|||
using KeywordHT = std::unordered_set<Keyword>;
|
||||
|
||||
#define PG_KEYWORD(a,b,c) Keyword{a,c},
|
||||
const KeywordHT _ScanKeywords {
|
||||
const KeywordHT _ScanKeywords = {
|
||||
//const Keyword _ScanKeywords[] = {
|
||||
#include <server/parser/kwlist.h>
|
||||
};
|
||||
|
||||
// The following keyword list are for plpgsql and are copied from the postgresql source.
|
||||
// src\pl\plpgsql\src\pl_scanner.c
|
||||
|
||||
static const KeywordHT plpgsql_reserved_keywords = {
|
||||
PG_KEYWORD("all", K_ALL, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("begin", K_BEGIN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("by", K_BY, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("case", K_CASE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("declare", K_DECLARE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("else", K_ELSE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("end", K_END, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("execute", K_EXECUTE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("for", K_FOR, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("foreach", K_FOREACH, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("from", K_FROM, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("if", K_IF, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("in", K_IN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("into", K_INTO, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("loop", K_LOOP, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("not", K_NOT, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("null", K_NULL, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("or", K_OR, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("strict", K_STRICT, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("then", K_THEN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("to", K_TO, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("using", K_USING, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("when", K_WHEN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("while", K_WHILE, RESERVED_KEYWORD)
|
||||
};
|
||||
|
||||
static const KeywordHT plpgsql_unreserved_keywords = {
|
||||
PG_KEYWORD("absolute", K_ABSOLUTE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("alias", K_ALIAS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("array", K_ARRAY, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("assert", K_ASSERT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("backward", K_BACKWARD, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("close", K_CLOSE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("collate", K_COLLATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("column", K_COLUMN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("column_name", K_COLUMN_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constant", K_CONSTANT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constraint", K_CONSTRAINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constraint_name", K_CONSTRAINT_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("continue", K_CONTINUE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("current", K_CURRENT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("cursor", K_CURSOR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("datatype", K_DATATYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("debug", K_DEBUG, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("default", K_DEFAULT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("detail", K_DETAIL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("diagnostics", K_DIAGNOSTICS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("dump", K_DUMP, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("elseif", K_ELSIF, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("elsif", K_ELSIF, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("errcode", K_ERRCODE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("error", K_ERROR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("exception", K_EXCEPTION, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("exit", K_EXIT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("fetch", K_FETCH, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("first", K_FIRST, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("forward", K_FORWARD, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("get", K_GET, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("hint", K_HINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("import", K_IMPORT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("info", K_INFO, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("insert", K_INSERT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("is", K_IS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("last", K_LAST, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("log", K_LOG, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("message", K_MESSAGE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("message_text", K_MESSAGE_TEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("move", K_MOVE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("next", K_NEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("no", K_NO, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("notice", K_NOTICE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("open", K_OPEN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("option", K_OPTION, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("perform", K_PERFORM, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_context", K_PG_CONTEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_datatype_name", K_PG_DATATYPE_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_context", K_PG_EXCEPTION_CONTEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_detail", K_PG_EXCEPTION_DETAIL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_hint", K_PG_EXCEPTION_HINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("print_strict_params", K_PRINT_STRICT_PARAMS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("prior", K_PRIOR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("query", K_QUERY, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("raise", K_RAISE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("relative", K_RELATIVE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("result_oid", K_RESULT_OID, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("return", K_RETURN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("returned_sqlstate", K_RETURNED_SQLSTATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("reverse", K_REVERSE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("row_count", K_ROW_COUNT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("rowtype", K_ROWTYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("schema", K_SCHEMA, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("schema_name", K_SCHEMA_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("scroll", K_SCROLL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("slice", K_SLICE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("sqlstate", K_SQLSTATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("stacked", K_STACKED, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("table", K_TABLE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("table_name", K_TABLE_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("type", K_TYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("use_column", K_USE_COLUMN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("use_variable", K_USE_VARIABLE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("variable_conflict", K_VARIABLE_CONFLICT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("warning", K_WARNING, UNRESERVED_KEYWORD)
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
const Keyword* getPgsqlKeyword(QString s)
|
||||
|
|
|
|||
|
|
@ -19,7 +19,8 @@ inline QString stdStrToQ(const std::string &s)
|
|||
|
||||
inline std::string qStrToStd(const QString &s)
|
||||
{
|
||||
return std::string(s.toUtf8().data());
|
||||
auto ba = s.toUtf8();
|
||||
return std::string(ba.data(), ba.size());
|
||||
}
|
||||
|
||||
inline std::string qvarToStdStr(const QVariant &c)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue