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());
return IdentityId();
}
- qDebug() << "creatId" << query.first() << query.value(0).toInt();
+ query.first();
identityId = query.value(0).toInt();
identity.setId(identityId);
qWarning() << " -" << qPrintable(db.lastError().text());
return false;
}
-
+
QSqlQuery checkQuery(db);
checkQuery.prepare(queryString("select_checkidentity"));
checkQuery.bindValue(":identityid", identity.id().toInt());
db.rollback();
return false;
}
-
+
QSqlQuery deleteNickQuery(db);
deleteNickQuery.prepare(queryString("delete_nicks"));
deleteNickQuery.bindValue(":identityid", identity.id().toInt());
return NetworkId();
}
- qDebug() << "createNet:" << query.first() << query.value(0).toInt();
+ query.first();
networkId = query.value(0).toInt();
if(!networkId.isValid()) {
}
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!";
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");
}
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!";
QSqlQuery query(db);
query.prepare(queryString("delete_network"));
+ query.bindValue(":userid", user.toInt());
query.bindValue(":networkid", networkId.toInt());
safeExec(query);
if(!watchQuery(query)) {
qWarning() << " -" << qPrintable(db.lastError().text());
return nets;
}
-
+
QSqlQuery networksQuery(db);
networksQuery.prepare(queryString("select_networks_for_user"));
networksQuery.bindValue(":userid", user.toInt());
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;
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();
qWarning() << " -" << qPrintable(db.lastError().text());
return bufferlist;
}
-
+
QSqlQuery query(db);
query.prepare(queryString("select_buffers"));
query.bindValue(":userid", user.toInt());
qWarning() << " -" << qPrintable(db.lastError().text());
return bufferList;
}
-
+
QSqlQuery query(db);
query.prepare(queryString("select_buffers_for_network"));
query.bindValue(":networkid", networkId.toInt());
}
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!";
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!";
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());
return lastSeenHash;
}
-MsgId PostgreSqlStorage::logMessage(Message msg) {
+bool PostgreSqlStorage::logMessage(Message &msg) {
QSqlDatabase db = logDb();
if(!db.transaction()) {
qWarning() << "PostgreSqlStorage::logMessage(): cannot start transaction!";
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(),
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 {
}
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(),
messagelist << msg;
}
+ db.commit();
return messagelist;
}
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 ¶ms, 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 ¶m, 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));
+}
+
projects / quassel.git / blobdiff