X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fpostgresqlstorage.cpp;h=f0978086fa48ded34d40c3c82406e2ccee9c26b8;hp=56be64ef214420b60f562fcb5b5ebd49f4386a13;hb=91113c1a557409765625c41b05432af6d0f7e9d3;hpb=029c6d402af7b00b320dd5ce48f230783a88957a

diff --git a/src/core/postgresqlstorage.cpp b/src/core/postgresqlstorage.cpp
index 56be64ef..f0978086 100644
--- a/src/core/postgresqlstorage.cpp
+++ b/src/core/postgresqlstorage.cpp
@@ -194,7 +194,7 @@ void PostgreSqlStorage::setUserSetting(UserId userId, const QString &settingName
   out.setVersion(QDataStream::Qt_4_2);
   out << data;
 
-  QSqlDatabase db = logDb();  
+  QSqlDatabase db = logDb();
   QSqlQuery query(db);
   query.prepare(queryString("insert_user_setting"));
   query.bindValue(":userid", userId.toInt());
@@ -276,7 +276,7 @@ IdentityId PostgreSqlStorage::createIdentity(UserId user, CoreIdentity &identity
     return IdentityId();
   }
 
-  qDebug() << "creatId" << query.first() << query.value(0).toInt();
+  query.first();
   identityId = query.value(0).toInt();
   identity.setId(identityId);
 
@@ -313,7 +313,7 @@ bool PostgreSqlStorage::updateIdentity(UserId user, const CoreIdentity &identity
     qWarning() << " -" << qPrintable(db.lastError().text());
     return false;
   }
-  
+
   QSqlQuery checkQuery(db);
   checkQuery.prepare(queryString("select_checkidentity"));
   checkQuery.bindValue(":identityid", identity.id().toInt());
@@ -359,7 +359,7 @@ bool PostgreSqlStorage::updateIdentity(UserId user, const CoreIdentity &identity
     db.rollback();
     return false;
   }
-  
+
   QSqlQuery deleteNickQuery(db);
   deleteNickQuery.prepare(queryString("delete_nicks"));
   deleteNickQuery.bindValue(":identityid", identity.id().toInt());
@@ -488,7 +488,7 @@ NetworkId PostgreSqlStorage::createNetwork(UserId user, const NetworkInfo &info)
     return NetworkId();
   }
 
-  qDebug() << "createNet:" << query.first() << query.value(0).toInt();
+  query.first();
   networkId = query.value(0).toInt();
 
   if(!networkId.isValid()) {
@@ -553,9 +553,6 @@ void PostgreSqlStorage::bindServerInfo(QSqlQuery &query, const Network::Server &
 }
 
 bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
-  if(!isValidNetwork(user, info.networkId))
-     return false;
-
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
     qWarning() << "PostgreSqlStorage::updateNetwork(): failed to begin transaction!";
@@ -565,12 +562,18 @@ bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
 
   QSqlQuery updateQuery(db);
   updateQuery.prepare(queryString("update_network"));
+  updateQuery.bindValue(":userid", user.toInt());
   bindNetworkInfo(updateQuery, info);
   safeExec(updateQuery);
   if(!watchQuery(updateQuery)) {
     db.rollback();
     return false;
   }
+  if(updateQuery.numRowsAffected() != 1) {
+    // seems this is not our network...
+    db.rollback();
+    return false;
+  }
 
   QSqlQuery dropServersQuery(db);
   dropServersQuery.prepare("DELETE FROM ircserver WHERE networkid = :networkid");
@@ -603,9 +606,6 @@ bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
 }
 
 bool PostgreSqlStorage::removeNetwork(UserId user, const NetworkId &networkId) {
-  if(!isValidNetwork(user, networkId))
-     return false;
-
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
     qWarning() << "PostgreSqlStorage::removeNetwork(): cannot start transaction!";
@@ -615,6 +615,7 @@ bool PostgreSqlStorage::removeNetwork(UserId user, const NetworkId &networkId) {
 
   QSqlQuery query(db);
   query.prepare(queryString("delete_network"));
+  query.bindValue(":userid", user.toInt());
   query.bindValue(":networkid", networkId.toInt());
   safeExec(query);
   if(!watchQuery(query)) {
@@ -635,7 +636,7 @@ QList<NetworkInfo> PostgreSqlStorage::networks(UserId user) {
     qWarning() << " -" << qPrintable(db.lastError().text());
     return nets;
   }
-  
+
   QSqlQuery networksQuery(db);
   networksQuery.prepare(queryString("select_networks_for_user"));
   networksQuery.bindValue(":userid", user.toInt());
@@ -698,36 +699,6 @@ QList<NetworkInfo> PostgreSqlStorage::networks(UserId user) {
   return nets;
 }
 
-bool PostgreSqlStorage::isValidNetwork(UserId user, const NetworkId &networkId) {
-  QSqlQuery query(logDb());
-  query.prepare(queryString("select_networkExists"));
-  query.bindValue(":userid", user.toInt());
-  query.bindValue(":networkid", networkId.toInt());
-  safeExec(query);
-
-  watchQuery(query);
-  if(!query.first())
-    return false;
-
-  Q_ASSERT(!query.next());
-  return true;
-}
-
-bool PostgreSqlStorage::isValidBuffer(const UserId &user, const BufferId &bufferId) {
-  QSqlQuery query(logDb());
-  query.prepare(queryString("select_bufferExists"));
-  query.bindValue(":userid", user.toInt());
-  query.bindValue(":bufferid", bufferId.toInt());
-  safeExec(query);
-
-  watchQuery(query);
-  if(!query.first())
-    return false;
-
-  Q_ASSERT(!query.next());
-  return true;
-}
-
 QList<NetworkId> PostgreSqlStorage::connectedNetworks(UserId user) {
   QList<NetworkId> connectedNets;
 
@@ -873,7 +844,7 @@ BufferInfo PostgreSqlStorage::bufferInfo(UserId user, const NetworkId &networkId
   if(query.first()) {
     BufferInfo bufferInfo = BufferInfo(query.value(0).toInt(), networkId, (BufferInfo::Type)query.value(1).toInt(), 0, buffer);
     if(query.next()) {
-      qCritical() << "PostgreSqlStorage::getBufferInfo(): received more then one Buffer!";
+      qCritical() << "PostgreSqlStorage::bufferInfo(): received more then one Buffer!";
       qCritical() << "         Query:" << query.lastQuery();
       qCritical() << "  bound Values:";
       QList<QVariant> list = query.boundValues().values();
@@ -940,7 +911,7 @@ QList<BufferInfo> PostgreSqlStorage::requestBuffers(UserId user) {
     qWarning() << " -" << qPrintable(db.lastError().text());
     return bufferlist;
   }
-  
+
   QSqlQuery query(db);
   query.prepare(queryString("select_buffers"));
   query.bindValue(":userid", user.toInt());
@@ -963,7 +934,7 @@ QList<BufferId> PostgreSqlStorage::requestBufferIdsForNetwork(UserId user, Netwo
     qWarning() << " -" << qPrintable(db.lastError().text());
     return bufferList;
   }
-  
+
   QSqlQuery query(db);
   query.prepare(queryString("select_buffers_for_network"));
   query.bindValue(":networkid", networkId.toInt());
@@ -979,9 +950,6 @@ QList<BufferId> PostgreSqlStorage::requestBufferIdsForNetwork(UserId user, Netwo
 }
 
 bool PostgreSqlStorage::removeBuffer(const UserId &user, const BufferId &bufferId) {
-  if(!isValidBuffer(user, bufferId))
-    return false;
-
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
     qWarning() << "PostgreSqlStorage::removeBuffer(): cannot start transaction!";
@@ -990,36 +958,67 @@ bool PostgreSqlStorage::removeBuffer(const UserId &user, const BufferId &bufferI
 
   QSqlQuery query(db);
   query.prepare(queryString("delete_buffer_for_bufferid"));
+  query.bindValue(":userid", user.toInt());
   query.bindValue(":bufferid", bufferId.toInt());
   safeExec(query);
   if(!watchQuery(query)) {
     db.rollback();
     return false;
   }
-  db.commit();
-  return true;
+
+  int numRows = query.numRowsAffected();
+  switch(numRows) {
+  case 0:
+    db.commit();
+    return false;
+  case 1:
+    db.commit();
+    return false;
+  default:
+    // there was more then one buffer deleted...
+    qWarning() << "PostgreSqlStorage::removeBuffer(): Userid" << user << "BufferId" << "caused deletion of" << numRows << "Buffers! Rolling back transaction...";
+    db.rollback();
+    return false;
+  }
 }
 
 bool PostgreSqlStorage::renameBuffer(const UserId &user, const BufferId &bufferId, const QString &newName) {
-  if(!isValidBuffer(user, bufferId))
+  QSqlDatabase db = logDb();
+  if(!db.transaction()) {
+    qWarning() << "PostgreSqlStorage::renameBuffer(): cannot start transaction!";
     return false;
+  }
 
-  QSqlQuery query(logDb());
+  QSqlQuery query(db);
   query.prepare(queryString("update_buffer_name"));
   query.bindValue(":buffername", newName);
   query.bindValue(":buffercname", newName.toLower());
+  query.bindValue(":userid", user.toInt());
   query.bindValue(":bufferid", bufferId.toInt());
   safeExec(query);
   if(query.lastError().isValid()) {
+    watchQuery(query);
+    db.rollback();
     return false;
   }
-  return true;
-}
 
-bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const BufferId &bufferId1, const BufferId &bufferId2) {
-  if(!isValidBuffer(user, bufferId1) || !isValidBuffer(user, bufferId2))
+  int numRows = query.numRowsAffected();
+  switch(numRows) {
+  case 0:
+    db.commit();
+    return false;
+  case 1:
+    db.commit();
+    return false;
+  default:
+    // there was more then one buffer deleted...
+    qWarning() << "PostgreSqlStorage::renameBuffer(): Userid" << user << "BufferId" << "affected" << numRows << "Buffers! Rolling back transaction...";
+    db.rollback();
     return false;
+  }
+}
 
+bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const BufferId &bufferId1, const BufferId &bufferId2) {
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
     qWarning() << "PostgreSqlStorage::mergeBuffersPermanently(): cannot start transaction!";
@@ -1027,6 +1026,23 @@ bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const Buffer
     return false;
   }
 
+  QSqlQuery checkQuery(db);
+  checkQuery.prepare("SELECT count(*) FROM buffer"
+		     "WHERE userid = :userid AND bufferid IN (:buffer1, :buffer2)");
+  checkQuery.bindValue(":userid", user.toInt());
+  checkQuery.bindValue(":buffer1", bufferId1.toInt());
+  checkQuery.bindValue(":buffer2", bufferId2.toInt());
+  safeExec(checkQuery);
+  if(!watchQuery(checkQuery)) {
+    db.rollback();
+    return false;
+  }
+  checkQuery.first();
+  if(checkQuery.value(0).toInt() != 2) {
+    db.rollback();
+    return false;
+  }
+
   QSqlQuery query(db);
   query.prepare(queryString("update_backlog_bufferid"));
   query.bindValue(":oldbufferid", bufferId2.toInt());
@@ -1088,7 +1104,7 @@ QHash<BufferId, MsgId> PostgreSqlStorage::bufferLastSeenMsgIds(UserId user) {
   return lastSeenHash;
 }
 
-MsgId PostgreSqlStorage::logMessage(Message msg) {
+bool PostgreSqlStorage::logMessage(Message &msg) {
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
     qWarning() << "PostgreSqlStorage::logMessage(): cannot start transaction!";
@@ -1096,69 +1112,166 @@ MsgId PostgreSqlStorage::logMessage(Message msg) {
     return false;
   }
 
-  QSqlQuery logMessageQuery(db);
-  logMessageQuery.prepare(queryString("insert_message"));
-  logMessageQuery.bindValue(":time", msg.timestamp().toTime_t());
-  logMessageQuery.bindValue(":bufferid", msg.bufferInfo().bufferId().toInt());
-  logMessageQuery.bindValue(":type", msg.type());
-  logMessageQuery.bindValue(":flags", (int)msg.flags());
-  logMessageQuery.bindValue(":sender", msg.sender());
-  logMessageQuery.bindValue(":message", msg.contents());
-  safeExec(logMessageQuery);
+  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()
+	 << msg.type()
+	 << (int)msg.flags()
+	 << msg.sender()
+	 << msg.contents();
+  QSqlQuery logMessageQuery = executePreparedQuery("insert_message", params, db);
 
   if(logMessageQuery.lastError().isValid()) {
     // first we need to reset the transaction
     db.rollback();
-    db.transaction(); 
+    db.transaction();
 
-    QSqlQuery addSenderQuery(db);
-    addSenderQuery.prepare(queryString("insert_sender"));
-    addSenderQuery.bindValue(":sender", msg.sender());
-    safeExec(addSenderQuery);
-    safeExec(logMessageQuery);
 
+    // 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);
+    QSqlQuery addSenderQuery = executePreparedQuery("insert_sender", msg.sender(), db);
+    if(addSenderQuery.lastError().isValid())
+      rollbackSavePoint("sender_sp1", db);
+    else
+      releaseSavePoint("sender_sp1", db);
+
+    logMessageQuery = db.exec(logMessageQuery.lastQuery());
     if(!watchQuery(logMessageQuery)) {
+      qDebug() << "==================== Sender Query:";
+      watchQuery(addSenderQuery);
+      qDebug() << "==================== /Sender Query";
       db.rollback();
-      return MsgId();
+      return false;
     }
   }
 
   logMessageQuery.first();
   MsgId msgId = logMessageQuery.value(0).toInt();
   db.commit();
+  if(msgId.isValid()) {
+    msg.setMsgId(msgId);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool PostgreSqlStorage::logMessages(MessageList &msgs) {
+  QSqlDatabase db = logDb();
+  if(!db.transaction()) {
+    qWarning() << "PostgreSqlStorage::logMessage(): cannot start transaction!";
+    qWarning() << " -" << qPrintable(db.lastError().text());
+    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();
+    if(senders.contains(sender))
+      continue;
+    senders << sender;
+
+    savePoint("sender_sp", db);
+    QSqlQuery addSenderQuery = executePreparedQuery("insert_sender", sender, db);
+    if(addSenderQuery.lastError().isValid())
+      rollbackSavePoint("sender_sp", db);
+    else
+      releaseSavePoint("sender_sp", db);
+  }
+
+  // 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];
+    QVariantList params;
+    params << msg.timestamp()
+	   << msg.bufferInfo().bufferId().toInt()
+	   << msg.type()
+	   << (int)msg.flags()
+	   << msg.sender()
+	   << msg.contents();
+    QSqlQuery logMessageQuery = executePreparedQuery("insert_message", params, db);
+    if(!watchQuery(logMessageQuery)) {
+      db.rollback();
+      error = true;
+      break;
+    } else {
+      logMessageQuery.first();
+      msg.setMsgId(logMessageQuery.value(0).toInt());
+    }
+  }
+
+  if(error) {
+    // we had a rollback in the db so we need to reset all msgIds
+    for(int i = 0; i < msgs.count(); i++) {
+      msgs[i].setMsgId(MsgId());
+    }
+    return false;
+  }
 
-  Q_ASSERT(msgId.isValid());
-  return msgId;
+  db.commit();
+  return true;
 }
 
 QList<Message> PostgreSqlStorage::requestMsgs(UserId user, BufferId bufferId, MsgId first, MsgId last, int limit) {
   QList<Message> messagelist;
 
+  QSqlDatabase db = logDb();
+  if(!beginReadOnlyTransaction(db)) {
+    qWarning() << "PostgreSqlStorage::requestMsgs(): cannot start read only transaction!";
+    qWarning() << " -" << qPrintable(db.lastError().text());
+    return messagelist;
+  }
+
   BufferInfo bufferInfo = getBufferInfo(user, bufferId);
-  if(!bufferInfo.isValid())
+  if(!bufferInfo.isValid()) {
+    db.rollback();
     return messagelist;
+  }
 
-  QSqlQuery query(logDb());
-  
+  QSqlQuery query(db);
   if(last == -1 && first == -1) {
-    query.prepare(queryString("select_messagesNewestK"));
+    query.prepare(queryString("select_messages"));
   } else if(last == -1) {
     query.prepare(queryString("select_messagesNewerThan"));
     query.bindValue(":firstmsg", first.toInt());
   } else {
-    query.prepare(queryString("select_messages"));
+    query.prepare(queryString("select_messagesRange"));
     query.bindValue(":lastmsg", last.toInt());
     query.bindValue(":firstmsg", first.toInt());
   }
-
   query.bindValue(":bufferid", bufferId.toInt());
-  query.bindValue(":limit", limit);
   safeExec(query);
+  if(!watchQuery(query)) {
+    db.rollback();
+    return messagelist;
+  }
 
-  watchQuery(query);
-
-  while(query.next()) {
-    Message msg(QDateTime::fromTime_t(query.value(1).toInt()),
+  QDateTime timestamp;
+  for(int i = 0; i < limit && query.next(); i++) {
+    timestamp = query.value(1).toDateTime();
+    timestamp.setTimeSpec(Qt::UTC);
+    Message msg(timestamp,
                 bufferInfo,
                 (Message::Type)query.value(2).toUInt(),
                 query.value(5).toString(),
@@ -1167,18 +1280,28 @@ QList<Message> PostgreSqlStorage::requestMsgs(UserId user, BufferId bufferId, Ms
     msg.setMsgId(query.value(0).toInt());
     messagelist << msg;
   }
+
+  db.commit();
   return messagelist;
 }
 
 QList<Message> PostgreSqlStorage::requestAllMsgs(UserId user, MsgId first, MsgId last, int limit) {
   QList<Message> messagelist;
 
+  // requestBuffers uses it's own transaction.
   QHash<BufferId, BufferInfo> bufferInfoHash;
   foreach(BufferInfo bufferInfo, requestBuffers(user)) {
     bufferInfoHash[bufferInfo.bufferId()] = bufferInfo;
   }
 
-  QSqlQuery query(logDb());
+  QSqlDatabase db = logDb();
+  if(!beginReadOnlyTransaction(db)) {
+    qWarning() << "PostgreSqlStorage::requestAllMsgs(): cannot start read only transaction!";
+    qWarning() << " -" << qPrintable(db.lastError().text());
+    return messagelist;
+  }
+
+  QSqlQuery query(db);
   if(last == -1) {
     query.prepare(queryString("select_messagesAllNew"));
   } else {
@@ -1187,13 +1310,17 @@ QList<Message> PostgreSqlStorage::requestAllMsgs(UserId user, MsgId first, MsgId
   }
   query.bindValue(":userid", user.toInt());
   query.bindValue(":firstmsg", first.toInt());
-  query.bindValue(":limit", limit);
   safeExec(query);
+  if(!watchQuery(query)) {
+    db.rollback();
+    return messagelist;
+  }
 
-  watchQuery(query);
-
-  while(query.next()) {
-    Message msg(QDateTime::fromTime_t(query.value(2).toInt()),
+  QDateTime timestamp;
+  for(int i = 0; i < limit && query.next(); i++) {
+    timestamp = query.value(1).toDateTime();
+    timestamp.setTimeSpec(Qt::UTC);
+    Message msg(timestamp,
                 bufferInfoHash[query.value(1).toInt()],
                 (Message::Type)query.value(3).toUInt(),
                 query.value(6).toString(),
@@ -1203,6 +1330,7 @@ QList<Message> PostgreSqlStorage::requestAllMsgs(UserId user, MsgId first, MsgId
     messagelist << msg;
   }
 
+  db.commit();
   return messagelist;
 }
 
@@ -1233,3 +1361,81 @@ bool PostgreSqlStorage::beginReadOnlyTransaction(QSqlDatabase &db) {
   QSqlQuery query = db.exec("BEGIN TRANSACTION READ ONLY");
   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
+
+  QMutexLocker locker(&_queryHashMutex);
+
+  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;
+  } else {
+    _preparedQueries[db.connectionName()][handle] = queryId;
+    return true;
+  }
+}
+
+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();
+  }
+
+  QSqlDriver *driver = db.driver();
+
+  QStringList paramStrings;
+  QSqlField field;
+  for(int i = 0; i < params.count(); i++) {
+    const QVariant &value = params.at(i);
+    field.setType(value.type());
+    if(value.isNull())
+      field.clear();
+    else
+      field.setValue(value);
+
+    paramStrings << driver->formatValue(field);
+  }
+
+  const QString &queryId = _preparedQueries[db.connectionName()][handle];
+  if(params.isEmpty()) {
+    return db.exec(QString("EXECUTE %1").arg(queryId));
+  } else {
+    // qDebug() << "preparedExec:" << QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", "));
+    return db.exec(QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", ")));
+  }
+}
+
+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();
+  }
+
+  QSqlField field;
+  field.setType(param.type());
+  if(param.isNull())
+    field.clear();
+  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));
+}
+
+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));
+}
+