X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fpostgresqlstorage.cpp;h=84e6a05fc293d1250daf5fb1b7687a58be3d786b;hp=25053735c07e11a3eaccb389c3e43018e9cb360c;hb=85c5d43cd1a1f6b4e9fe41fe533c743517017d37;hpb=d13c54e1850b5ed6980e6350beaf4469e680b4f1

diff --git a/src/core/postgresqlstorage.cpp b/src/core/postgresqlstorage.cpp
index 25053735..84e6a05f 100644
--- a/src/core/postgresqlstorage.cpp
+++ b/src/core/postgresqlstorage.cpp
@@ -338,7 +338,7 @@ IdentityId PostgreSqlStorage::createIdentity(UserId user, CoreIdentity &identity
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::createIdentity(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::createIdentity(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return IdentityId();
   }
@@ -421,7 +421,7 @@ bool PostgreSqlStorage::updateIdentity(UserId user, const CoreIdentity &identity
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::updateIdentity(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::updateIdentity(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return false;
   }
@@ -550,7 +550,7 @@ NetworkId PostgreSqlStorage::createNetwork(UserId user, const NetworkInfo &info)
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::createNetwork(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::createNetwork(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return NetworkId();
   }
@@ -568,6 +568,9 @@ void PostgreSqlStorage::bindNetworkInfo(QSqlQuery &query, const NetworkInfo &inf
   query.bindValue(":useautoidentify", info.useAutoIdentify);
   query.bindValue(":autoidentifyservice", info.autoIdentifyService);
   query.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
+  query.bindValue(":usesasl", info.useSasl);
+  query.bindValue(":saslaccount", info.saslAccount);
+  query.bindValue(":saslpassword", info.saslPassword);
   query.bindValue(":useautoreconnect", info.useAutoReconnect);
   query.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
   query.bindValue(":autoreconnectretries", info.autoReconnectRetries);
@@ -637,7 +640,7 @@ bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::updateNetwork(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::updateNetwork(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return false;
   }
@@ -707,6 +710,9 @@ QList<NetworkInfo> PostgreSqlStorage::networks(UserId user) {
     net.autoReconnectRetries = networksQuery.value(13).toInt();
     net.unlimitedReconnectRetries = networksQuery.value(14).toBool();
     net.rejoinChannels = networksQuery.value(15).toBool();
+    net.useSasl = networksQuery.value(16).toBool();
+    net.saslAccount = networksQuery.value(17).toString();
+    net.saslPassword = networksQuery.value(18).toString();
 
     serversQuery.bindValue(":networkid", net.networkId.toInt());
     safeExec(serversQuery);
@@ -1096,6 +1102,7 @@ bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const Buffer
 
   QSqlQuery delBufferQuery(logDb());
   delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
+  delBufferQuery.bindValue(":userid", user.toInt());
   delBufferQuery.bindValue(":bufferid", bufferId2.toInt());
   safeExec(delBufferQuery);
   if(!watchQuery(delBufferQuery)) {
@@ -1191,13 +1198,6 @@ bool PostgreSqlStorage::logMessage(Message &msg) {
     return false;
   }
 
-  if(!prepareQuery("insert_message", queryString("insert_message"), db)) {
-    qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_message");
-    qWarning() << "  Error:" << db.lastError().text();
-    db.rollback();
-    return false;
-  }
-
   QVariantList params;
   params << msg.timestamp()
 	 << msg.bufferInfo().bufferId().toInt()
@@ -1212,7 +1212,6 @@ bool PostgreSqlStorage::logMessage(Message &msg) {
     db.rollback();
     db.transaction();
 
-
     // it's possible that the sender was already added by another thread
     // since the insert might fail we're setting a savepoint
     savePoint("sender_sp1", db);
@@ -1251,12 +1250,6 @@ bool PostgreSqlStorage::logMessages(MessageList &msgs) {
     return false;
   }
 
-  if(!prepareQuery("insert_sender", queryString("insert_sender"), db)) {
-    qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_sender");
-    qWarning() << "  Error:" << db.lastError().text();
-    db.rollback();
-    return false;
-  }
   QSet<QString> senders;
   for(int i = 0; i < msgs.count(); i++) {
     const QString &sender = msgs.at(i).sender();
@@ -1273,12 +1266,6 @@ bool PostgreSqlStorage::logMessages(MessageList &msgs) {
   }
 
   // yes we loop twice over the same list. This avoids alternating queries.
-  if(!prepareQuery("insert_message", queryString("insert_message"), db)) {
-    qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_message");
-    qWarning() << "  Error:" << db.lastError().text();
-    db.rollback();
-    return false;
-  }
   bool error = false;
   for(int i = 0; i < msgs.count(); i++) {
     Message &msg = msgs[i];
@@ -1346,13 +1333,6 @@ QList<Message> PostgreSqlStorage::requestMsgs(UserId user, BufferId bufferId, Ms
   else
     params << "ALL";
 
-  if(!prepareQuery(queryName, queryString(queryName), db)) {
-    qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString(queryName);
-    qWarning() << "  Error:" << db.lastError().text();
-    db.rollback();
-    return messagelist;
-  }
-
   QSqlQuery query = executePreparedQuery(queryName, params, db);
 
   if(!watchQuery(query)) {
@@ -1456,30 +1436,49 @@ bool PostgreSqlStorage::beginReadOnlyTransaction(QSqlDatabase &db) {
   return !query.lastError().isValid();
 }
 
-bool PostgreSqlStorage::prepareQuery(const QString &handle, const QString &query, const QSqlDatabase &db) {
-  if(_preparedQueries.contains(db.connectionName()) && _preparedQueries[db.connectionName()].contains(handle))
-    return true; // already prepared
+QSqlQuery PostgreSqlStorage::prepareAndExecuteQuery(const QString &queryname, const QString &paramstring, const QSqlDatabase &db) {
+  // Query preparing is done lazily. That means that instead of always checking if the query is already prepared
+  // we just EXECUTE and catch the error
+  QSqlQuery query;
 
-  QMutexLocker locker(&_queryHashMutex);
+  db.exec("SAVEPOINT quassel_prepare_query");
+  if(paramstring.isNull()) {
+    query = db.exec(QString("EXECUTE quassel_%1").arg(queryname));
+  } else {
+    query = db.exec(QString("EXECUTE quassel_%1 (%2)").arg(queryname).arg(paramstring));
+  }
 
-  static unsigned int stmtCount = 0;
-  QString queryId = QLatin1String("quassel_") + QString::number(++stmtCount, 16);
-  // qDebug() << "prepare:" << QString("PREPARE %1 AS %2").arg(queryId).arg(query);
-  db.exec(QString("PREPARE %1 AS %2").arg(queryId).arg(query));
   if(db.lastError().isValid()) {
-    return false;
+    // and once again: Qt leaves us without error codes so we either parse (language dependant(!)) strings
+    // or we just guess the error. As we're only interested in unprepared queries, this will be our guess. :)
+    db.exec("ROLLBACK TO SAVEPOINT quassel_prepare_query");
+    QSqlQuery checkQuery = db.exec(QString("SELECT count(name) FROM pg_prepared_statements WHERE name = 'quassel_%1' AND from_sql = TRUE").arg(queryname.toLower()));
+    checkQuery.first();
+    if(checkQuery.value(0).toInt() == 0) {
+      db.exec(QString("PREPARE quassel_%1 AS %2").arg(queryname).arg(queryString(queryname)));
+      if(db.lastError().isValid()) {
+        qWarning() << "PostgreSqlStorage::prepareQuery(): unable to prepare query:" << queryname << "AS" << queryString(queryname);
+        qWarning() << "  Error:" << db.lastError().text();
+        return QSqlQuery(db);
+      }
+    }
+    // we alwas execute the query again, even if the query was already prepared.
+    // this ensures, that the error is properly propagated to the calling function
+    // (otherwise the lasst call would be the test select to pg_prepared_statements
+    // which always gives a proper result)
+    if(paramstring.isNull()) {
+      query = db.exec(QString("EXECUTE quassel_%1").arg(queryname));
+    } else {
+      query = db.exec(QString("EXECUTE quassel_%1 (%2)").arg(queryname).arg(paramstring));
+    }
   } else {
-    _preparedQueries[db.connectionName()][handle] = queryId;
-    return true;
+    // only release the SAVEPOINT
+    db.exec("RELEASE SAVEPOINT quassel_prepare_query");
   }
+  return query;
 }
 
-QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const QVariantList &params, const QSqlDatabase &db) {
-  if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
-    qWarning() << "PostgreSqlStorage::executePreparedQuery() no prepared Query with handle" << handle << "on Database" << db.connectionName();
-    return QSqlQuery(db);
-  }
-
+QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &queryname, const QVariantList &params, const QSqlDatabase &db) {
   QSqlDriver *driver = db.driver();
 
   QStringList paramStrings;
@@ -1495,21 +1494,14 @@ QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const Q
     paramStrings << driver->formatValue(field);
   }
 
-  const QString &queryId = _preparedQueries[db.connectionName()][handle];
   if(params.isEmpty()) {
-    return db.exec(QString("EXECUTE %1").arg(queryId));
+    return prepareAndExecuteQuery(queryname, db);
   } else {
-    // qDebug() << "preparedExec:" << QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", "));
-    return db.exec(QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", ")));
+    return prepareAndExecuteQuery(queryname, paramStrings.join(", "), db);
   }
 }
 
-QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const QVariant &param, const QSqlDatabase &db) {
-  if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
-    qWarning() << "PostgreSqlStorage::executePreparedQuery() no prepared Query with handle" << handle << "on Database" << db.connectionName();
-    return QSqlQuery(db);
-  }
-
+QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &queryname, const QVariant &param, const QSqlDatabase &db) {
   QSqlField field;
   field.setType(param.type());
   if(param.isNull())
@@ -1517,20 +1509,12 @@ QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const Q
   else
     field.setValue(param);
 
-  const QString &queryId = _preparedQueries[db.connectionName()][handle];
   QString paramString = db.driver()->formatValue(field);
-
-  // qDebug() << "preparedExec:" << QString("EXECUTE %1 (%2)").arg(queryId).arg(paramString);
-  return db.exec(QString("EXECUTE %1 (%2)").arg(queryId).arg(paramString));
+  return prepareAndExecuteQuery(queryname, paramString, db);
 }
 
-void PostgreSqlStorage::deallocateQuery(const QString &handle, const QSqlDatabase &db) {
-  if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
-    return;
-  }
-  QMutexLocker locker(&_queryHashMutex);
-  QString queryId = _preparedQueries[db.connectionName()].take(handle);
-  db.exec(QString("DEALLOCATE %1").arg(queryId));
+void PostgreSqlStorage::deallocateQuery(const QString &queryname, const QSqlDatabase &db) {
+  db.exec(QString("DEALLOCATE quassel_%1").arg(queryname));
 }
 
 // ========================================
@@ -1654,6 +1638,9 @@ bool PostgreSqlMigrationWriter::writeMo(const NetworkMO &network) {
   bindValue(19, network.awaymessage);
   bindValue(20, network.attachperform);
   bindValue(21, network.detachperform);
+  bindValue(22, network.usesasl);
+  bindValue(23, network.saslaccount);
+  bindValue(24, network.saslpassword);
   return exec();
 }