src/core/sqlitestorage.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-07 by the Quassel IRC Team                         *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "sqlitestorage.h"
  22
  23 #include <QtSql>
  24
  25 #include "network.h"
  26
  27 #include "util.h"
  28 #include "logger.h"
  29
  30 int SqliteStorage::_maxRetryCount = 150; // yes this is a large number... only other way to "handle" this is bailing out...
  31
  32 SqliteStorage::SqliteStorage(QObject *parent)
  33   : AbstractSqlStorage(parent)
  34 {
  35 }
  36
  37 SqliteStorage::~SqliteStorage() {
  38 }
  39
  40 bool SqliteStorage::isAvailable() const {
  41   if(!QSqlDatabase::isDriverAvailable("QSQLITE")) return false;
  42   return true;
  43 }
  44
  45 QString SqliteStorage::displayName() const {
  46   return QString("SQLite");
  47 }
  48
  49 QString SqliteStorage::description() const {
  50   return tr("SQLite is a file-based database engine that does not require any setup. It is suitable for small and medium-sized "
  51             "databases that do not require access via network. Use SQLite if your Quassel Core should store its data on the same machine "
  52             "it is running on, and if you only expect a few users to use your core.");
  53 }
  54
  55 int SqliteStorage::installedSchemaVersion() {
  56   QSqlQuery query = logDb().exec("SELECT value FROM coreinfo WHERE key = 'schemaversion'");
  57   if(query.first())
  58     return query.value(0).toInt();
  59
  60   // maybe it's really old... (schema version 0)
  61   query = logDb().exec("SELECT MAX(version) FROM coreinfo");
  62   if(query.first())
  63     return query.value(0).toInt();
  64
  65   return AbstractSqlStorage::installedSchemaVersion();
  66 }
  67
  68 UserId SqliteStorage::addUser(const QString &user, const QString &password) {
  69   QSqlQuery query(logDb());
  70   query.prepare(queryString("insert_quasseluser"));
  71   query.bindValue(":username", user);
  72   query.bindValue(":password", cryptedPassword(password));
  73   safeExec(query);
  74   if(query.lastError().isValid() && query.lastError().number() == 19) { // user already exists - sadly 19 seems to be the general constraint violation error...
  75     return 0;
  76   }
  77
  78   query.prepare(queryString("select_userid"));
  79   query.bindValue(":username", user);
  80   safeExec(query);
  81   query.first();
  82   UserId uid = query.value(0).toInt();
  83   emit userAdded(uid, user);
  84   return uid;
  85 }
  86
  87 void SqliteStorage::updateUser(UserId user, const QString &password) {
  88   QSqlQuery query(logDb());
  89   query.prepare(queryString("update_userpassword"));
  90   query.bindValue(":userid", user.toInt());
  91   query.bindValue(":password", cryptedPassword(password));
  92   safeExec(query);
  93 }
  94
  95 void SqliteStorage::renameUser(UserId user, const QString &newName) {
  96   QSqlQuery query(logDb());
  97   query.prepare(queryString("update_username"));
  98   query.bindValue(":userid", user.toInt());
  99   query.bindValue(":username", newName);
 100   safeExec(query);
 101   emit userRenamed(user, newName);
 102 }
 103
 104 UserId SqliteStorage::validateUser(const QString &user, const QString &password) {
 105   QSqlQuery query(logDb());
 106   query.prepare(queryString("select_authuser"));
 107   query.bindValue(":username", user);
 108   query.bindValue(":password", cryptedPassword(password));
 109   safeExec(query);
 110
 111   if(query.first()) {
 112     return query.value(0).toInt();
 113   } else {
 114     return 0;
 115   }
 116 }
 117
 118 UserId SqliteStorage::internalUser() {
 119   QSqlQuery query(logDb());
 120   query.prepare(queryString("select_internaluser"));
 121   safeExec(query);
 122
 123   if(query.first()) {
 124     return query.value(0).toInt();
 125   } else {
 126     return 0;
 127   }
 128 }
 129
 130 void SqliteStorage::delUser(UserId user) {
 131   QSqlQuery query(logDb());
 132   query.prepare(queryString("delete_backlog_by_uid"));
 133   query.bindValue(":userid", user.toInt());
 134   safeExec(query);
 135
 136   query.prepare(queryString("delete_buffers_by_uid"));
 137   query.bindValue(":userid", user.toInt());
 138   safeExec(query);
 139
 140   query.prepare(queryString("delete_networks_by_uid"));
 141   query.bindValue(":userid", user.toInt());
 142   safeExec(query);
 143
 144   query.prepare(queryString("delete_quasseluser"));
 145   query.bindValue(":userid", user.toInt());
 146   safeExec(query);
 147   // I hate the lack of foreign keys and on delete cascade... :(
 148   emit userRemoved(user);
 149 }
 150
 151 void SqliteStorage::setUserSetting(UserId userId, const QString &settingName, const QVariant &data) {
 152   QByteArray rawData;
 153   QDataStream out(&rawData, QIODevice::WriteOnly);
 154   out.setVersion(QDataStream::Qt_4_2);
 155   out << data;
 156
 157   QSqlQuery query(logDb());
 158   query.prepare(queryString("insert_user_setting"));
 159   query.bindValue(":userid", userId.toInt());
 160   query.bindValue(":settingname", settingName);
 161   query.bindValue(":settingvalue", rawData);
 162   safeExec(query);
 163
 164   if(query.lastError().isValid()) {
 165     QSqlQuery updateQuery(logDb());
 166     updateQuery.prepare(queryString("update_user_setting"));
 167     updateQuery.bindValue(":userid", userId.toInt());
 168     updateQuery.bindValue(":settingname", settingName);
 169     updateQuery.bindValue(":settingvalue", rawData);
 170     safeExec(updateQuery);
 171   }
 172
 173 }
 174
 175 QVariant SqliteStorage::getUserSetting(UserId userId, const QString &settingName, const QVariant &defaultData) {
 176   QSqlQuery query(logDb());
 177   query.prepare(queryString("select_user_setting"));
 178   query.bindValue(":userid", userId.toInt());
 179   query.bindValue(":settingname", settingName);
 180   safeExec(query);
 181
 182   if(query.first()) {
 183     QVariant data;
 184     QByteArray rawData = query.value(0).toByteArray();
 185     QDataStream in(&rawData, QIODevice::ReadOnly);
 186     in.setVersion(QDataStream::Qt_4_2);
 187     in >> data;
 188     return data;
 189   } else {
 190     return defaultData;
 191   }
 192 }
 193
 194 NetworkId SqliteStorage::createNetwork(UserId user, const NetworkInfo &info) {
 195   NetworkId networkId;
 196   QSqlQuery query(logDb());
 197   query.prepare(queryString("insert_network"));
 198   query.bindValue(":userid", user.toInt());
 199   query.bindValue(":networkname", info.networkName);
 200   safeExec(query);
 201
 202   networkId = getNetworkId(user, info.networkName);
 203   if(!networkId.isValid()) {
 204     watchQuery(query);
 205   } else {
 206     NetworkInfo newNetworkInfo = info;
 207     newNetworkInfo.networkId = networkId;
 208     updateNetwork(user, newNetworkInfo);
 209   }
 210   return networkId;
 211 }
 212
 213 bool SqliteStorage::updateNetwork(UserId user, const NetworkInfo &info) {
 214   if(!isValidNetwork(user, info.networkId))
 215      return false;
 216
 217   QSqlQuery updateQuery(logDb());
 218   updateQuery.prepare(queryString("update_network"));
 219   updateQuery.bindValue(":networkname", info.networkName);
 220   updateQuery.bindValue(":identityid", info.identity.toInt());
 221   updateQuery.bindValue(":usecustomencoding", info.useCustomEncodings ? 1 : 0);
 222   updateQuery.bindValue(":encodingcodec", QString(info.codecForEncoding));
 223   updateQuery.bindValue(":decodingcodec", QString(info.codecForDecoding));
 224   updateQuery.bindValue(":servercodec", QString(info.codecForServer));
 225   updateQuery.bindValue(":userandomserver", info.useRandomServer ? 1 : 0);
 226   updateQuery.bindValue(":perform", info.perform.join("\n"));
 227   updateQuery.bindValue(":useautoidentify", info.useAutoIdentify ? 1 : 0);
 228   updateQuery.bindValue(":autoidentifyservice", info.autoIdentifyService);
 229   updateQuery.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
 230   updateQuery.bindValue(":useautoreconnect", info.useAutoReconnect ? 1 : 0);
 231   updateQuery.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
 232   updateQuery.bindValue(":autoreconnectretries", info.autoReconnectRetries);
 233   updateQuery.bindValue(":unlimitedconnectretries", info.unlimitedReconnectRetries ? 1 : 0);
 234   updateQuery.bindValue(":rejoinchannels", info.rejoinChannels ? 1 : 0);
 235   updateQuery.bindValue(":networkid", info.networkId.toInt());
 236   safeExec(updateQuery);
 237   if(!watchQuery(updateQuery))
 238     return false;
 239
 240   QSqlQuery dropServersQuery(logDb());
 241   dropServersQuery.prepare("DELETE FROM ircserver WHERE networkid = :networkid");
 242   dropServersQuery.bindValue(":networkid", info.networkId.toInt());
 243   safeExec(dropServersQuery);
 244   if(!watchQuery(dropServersQuery))
 245     return false;
 246
 247   QSqlQuery insertServersQuery(logDb());
 248   insertServersQuery.prepare(queryString("insert_server"));
 249   foreach(QVariant server_, info.serverList) {
 250     QVariantMap server = server_.toMap();
 251     insertServersQuery.bindValue(":hostname", server["Host"]);
 252     insertServersQuery.bindValue(":port", server["Port"].toInt());
 253     insertServersQuery.bindValue(":password", server["Password"]);
 254     insertServersQuery.bindValue(":ssl", server["UseSSL"].toBool() ? 1 : 0);
 255     insertServersQuery.bindValue(":userid", user.toInt());
 256     insertServersQuery.bindValue(":networkid", info.networkId.toInt());
 257
 258     safeExec(insertServersQuery);
 259     if(!watchQuery(insertServersQuery))
 260       return false;
 261   }
 262
 263   return true;
 264 }
 265
 266 bool SqliteStorage::removeNetwork(UserId user, const NetworkId &networkId) {
 267   if(!isValidNetwork(user, networkId))
 268      return false;
 269
 270   bool withTransaction = logDb().driver()->hasFeature(QSqlDriver::Transactions);
 271   if(withTransaction) {
 272     sync();
 273     if(!logDb().transaction()) {
 274       qWarning() << "SqliteStorage::removeNetwork(): cannot start transaction. continuing with out rollback support!";
 275       withTransaction = false;
 276     }
 277   }
 278
 279   QSqlQuery deleteBacklogQuery(logDb());
 280   deleteBacklogQuery.prepare(queryString("delete_backlog_for_network"));
 281   deleteBacklogQuery.bindValue(":networkid", networkId.toInt());
 282   safeExec(deleteBacklogQuery);
 283   if(!watchQuery(deleteBacklogQuery)) {
 284     if(withTransaction)
 285       logDb().rollback();
 286     return false;
 287   }
 288
 289   QSqlQuery deleteBuffersQuery(logDb());
 290   deleteBuffersQuery.prepare(queryString("delete_buffers_for_network"));
 291   deleteBuffersQuery.bindValue(":networkid", networkId.toInt());
 292   safeExec(deleteBuffersQuery);
 293   if(!watchQuery(deleteBuffersQuery)) {
 294     if(withTransaction)
 295       logDb().rollback();
 296     return false;
 297   }
 298
 299   QSqlQuery deleteServersQuery(logDb());
 300   deleteServersQuery.prepare(queryString("delete_ircservers_for_network"));
 301   deleteServersQuery.bindValue(":networkid", networkId.toInt());
 302   safeExec(deleteServersQuery);
 303   if(!watchQuery(deleteServersQuery)) {
 304     if(withTransaction)
 305       logDb().rollback();
 306     return false;
 307   }
 308
 309   QSqlQuery deleteNetworkQuery(logDb());
 310   deleteNetworkQuery.prepare(queryString("delete_network"));
 311   deleteNetworkQuery.bindValue(":networkid", networkId.toInt());
 312   safeExec(deleteNetworkQuery);
 313   if(!watchQuery(deleteNetworkQuery)) {
 314     if(withTransaction)
 315       logDb().rollback();
 316     return false;
 317   }
 318
 319   logDb().commit();
 320   return true;
 321 }
 322
 323 QList<NetworkInfo> SqliteStorage::networks(UserId user) {
 324   QList<NetworkInfo> nets;
 325
 326   QSqlQuery networksQuery(logDb());
 327   networksQuery.prepare(queryString("select_networks_for_user"));
 328   networksQuery.bindValue(":userid", user.toInt());
 329
 330   QSqlQuery serversQuery(logDb());
 331   serversQuery.prepare(queryString("select_servers_for_network"));
 332
 333   safeExec(networksQuery);
 334   if(!watchQuery(networksQuery))
 335     return nets;
 336
 337   while(networksQuery.next()) {
 338     NetworkInfo net;
 339     net.networkId = networksQuery.value(0).toInt();
 340     net.networkName = networksQuery.value(1).toString();
 341     net.identity = networksQuery.value(2).toInt();
 342     net.codecForServer = networksQuery.value(3).toString().toAscii();
 343     net.codecForEncoding = networksQuery.value(4).toString().toAscii();
 344     net.codecForDecoding = networksQuery.value(5).toString().toAscii();
 345     net.useRandomServer = networksQuery.value(6).toInt() == 1 ? true : false;
 346     net.perform = networksQuery.value(7).toString().split("\n");
 347     net.useAutoIdentify = networksQuery.value(8).toInt() == 1 ? true : false;
 348     net.autoIdentifyService = networksQuery.value(9).toString();
 349     net.autoIdentifyPassword = networksQuery.value(10).toString();
 350     net.useAutoReconnect = networksQuery.value(11).toInt() == 1 ? true : false;
 351     net.autoReconnectInterval = networksQuery.value(12).toUInt();
 352     net.autoReconnectRetries = networksQuery.value(13).toInt();
 353     net.unlimitedReconnectRetries = networksQuery.value(14).toInt() == 1 ? true : false;
 354     net.rejoinChannels = networksQuery.value(15).toInt() == 1 ? true : false;
 355
 356     serversQuery.bindValue(":networkid", net.networkId.toInt());
 357     safeExec(serversQuery);
 358     if(!watchQuery(serversQuery))
 359       return nets;
 360
 361     QVariantList servers;
 362     while(serversQuery.next()) {
 363       QVariantMap server;
 364       server["Host"] = serversQuery.value(0).toString();
 365       server["Port"] = serversQuery.value(1).toInt();
 366       server["Password"] = serversQuery.value(2).toString();
 367       server["UseSSL"] = serversQuery.value(3).toInt() == 1 ? true : false;
 368       servers << server;
 369     }
 370     net.serverList = servers;
 371     nets << net;
 372   }
 373   return nets;
 374 }
 375
 376 bool SqliteStorage::isValidNetwork(UserId user, const NetworkId &networkId) {
 377   QSqlQuery query(logDb());
 378   query.prepare(queryString("select_networkExists"));
 379   query.bindValue(":userid", user.toInt());
 380   query.bindValue(":networkid", networkId.toInt());
 381   safeExec(query);
 382
 383   watchQuery(query); // there should not occur any errors
 384   if(!query.first())
 385     return false;
 386
 387   Q_ASSERT(!query.next());
 388   return true;
 389 }
 390
 391 bool SqliteStorage::isValidBuffer(const UserId &user, const BufferId &bufferId) {
 392   QSqlQuery query(logDb());
 393   query.prepare(queryString("select_bufferExists"));
 394   query.bindValue(":userid", user.toInt());
 395   query.bindValue(":bufferid", bufferId.toInt());
 396   safeExec(query);
 397
 398   watchQuery(query);
 399   if(!query.first())
 400     return false;
 401
 402   Q_ASSERT(!query.next());
 403   return true;
 404 }
 405
 406 NetworkId SqliteStorage::getNetworkId(UserId user, const QString &network) {
 407   QSqlQuery query(logDb());
 408   query.prepare("SELECT networkid FROM network "
 409                 "WHERE userid = :userid AND networkname = :networkname");
 410   query.bindValue(":userid", user.toInt());
 411   query.bindValue(":networkname", network);
 412   safeExec(query);
 413
 414   if(query.first())
 415     return query.value(0).toInt();
 416   else
 417     return NetworkId();
 418 }
 419
 420 QList<NetworkId> SqliteStorage::connectedNetworks(UserId user) {
 421   QList<NetworkId> connectedNets;
 422   QSqlQuery query(logDb());
 423   query.prepare(queryString("select_connected_networks"));
 424   query.bindValue(":userid", user.toInt());
 425   safeExec(query);
 426   watchQuery(query);
 427
 428   while(query.next()) {
 429     connectedNets << query.value(0).toInt();
 430   }
 431
 432   return connectedNets;
 433 }
 434
 435 void SqliteStorage::setNetworkConnected(UserId user, const NetworkId &networkId, bool isConnected) {
 436   QSqlQuery query(logDb());
 437   query.prepare(queryString("update_network_connected"));
 438   query.bindValue(":userid", user.toInt());
 439   query.bindValue(":networkid", networkId.toInt());
 440   query.bindValue(":connected", isConnected ? 1 : 0);
 441   safeExec(query);
 442   watchQuery(query);
 443 }
 444
 445 QHash<QString, QString> SqliteStorage::persistentChannels(UserId user, const NetworkId &networkId) {
 446   QHash<QString, QString> persistentChans;
 447   QSqlQuery query(logDb());
 448   query.prepare(queryString("select_persistent_channels"));
 449   query.bindValue(":userid", user.toInt());
 450   query.bindValue(":networkid", networkId.toInt());
 451   safeExec(query);
 452   watchQuery(query);
 453
 454   while(query.next()) {
 455     persistentChans[query.value(0).toString()] = query.value(1).toString();
 456   }
 457
 458   return persistentChans;
 459 }
 460
 461 void SqliteStorage::setChannelPersistent(UserId user, const NetworkId &networkId, const QString &channel, bool isJoined) {
 462   QSqlQuery query(logDb());
 463   query.prepare(queryString("update_buffer_persistent_channel"));
 464   query.bindValue(":userid", user.toInt());
 465   query.bindValue(":networkId", networkId.toInt());
 466   query.bindValue(":buffercname", channel.toLower());
 467   query.bindValue(":joined", isJoined ? 1 : 0);
 468   safeExec(query);
 469   watchQuery(query);
 470 }
 471
 472 void SqliteStorage::setPersistentChannelKey(UserId user, const NetworkId &networkId, const QString &channel, const QString &key) {
 473   QSqlQuery query(logDb());
 474   query.prepare(queryString("update_buffer_set_channel_key"));
 475   query.bindValue(":userid", user.toInt());
 476   query.bindValue(":networkId", networkId.toInt());
 477   query.bindValue(":buffercname", channel.toLower());
 478   query.bindValue(":key", key);
 479   safeExec(query);
 480   watchQuery(query);
 481 }
 482
 483
 484 void SqliteStorage::createBuffer(UserId user, const NetworkId &networkId, BufferInfo::Type type, const QString &buffer) {
 485   QSqlQuery query(logDb());
 486   query.prepare(queryString("insert_buffer"));
 487   query.bindValue(":userid", user.toInt());
 488   query.bindValue(":networkid", networkId.toInt());
 489   query.bindValue(":buffertype", (int)type);
 490   query.bindValue(":buffername", buffer);
 491   query.bindValue(":buffercname", buffer.toLower());
 492   safeExec(query);
 493
 494   watchQuery(query);
 495 }
 496
 497 BufferInfo SqliteStorage::getBufferInfo(UserId user, const NetworkId &networkId, BufferInfo::Type type, const QString &buffer) {
 498   QSqlQuery query(logDb());
 499   query.prepare(queryString("select_bufferByName"));
 500   query.bindValue(":networkid", networkId.toInt());
 501   query.bindValue(":userid", user.toInt());
 502   query.bindValue(":buffercname", buffer.toLower());
 503   safeExec(query);
 504
 505   if(!query.first()) {
 506     createBuffer(user, networkId, type, buffer);
 507     safeExec(query);
 508     if(!query.first()) {
 509       watchQuery(query);
 510       qWarning() << "unable to create BufferInfo for:" << user << networkId << buffer;
 511       return BufferInfo();
 512     }
 513   }
 514
 515   BufferInfo bufferInfo = BufferInfo(query.value(0).toInt(), networkId, (BufferInfo::Type)query.value(1).toInt(), 0, buffer);
 516   if(query.next()) {
 517     qCritical() << "SqliteStorage::getBufferInfo(): received more then one Buffer!";
 518     qCritical() << "         Query:" << query.lastQuery();
 519     qCritical() << "  bound Values:";
 520     QList<QVariant> list = query.boundValues().values();
 521     for (int i = 0; i < list.size(); ++i)
 522       qCritical() << i << ":" << list.at(i).toString().toAscii().data();
 523     Q_ASSERT(false);
 524   }
 525
 526   return bufferInfo;
 527 }
 528
 529 BufferInfo SqliteStorage::getBufferInfo(UserId user, const BufferId &bufferId) {
 530   QSqlQuery query(logDb());
 531   query.prepare(queryString("select_buffer_by_id"));
 532   query.bindValue(":userid", user.toInt());
 533   query.bindValue(":bufferid", bufferId.toInt());
 534   safeExec(query);
 535   if(!watchQuery(query))
 536     return BufferInfo();
 537
 538   if(!query.first())
 539     return BufferInfo();
 540
 541   BufferInfo bufferInfo(query.value(0).toInt(), query.value(1).toInt(), (BufferInfo::Type)query.value(2).toInt(), 0, query.value(4).toString());
 542   Q_ASSERT(!query.next());
 543
 544   return bufferInfo;
 545 }
 546
 547 QList<BufferInfo> SqliteStorage::requestBuffers(UserId user) {
 548   QList<BufferInfo> bufferlist;
 549   QSqlQuery query(logDb());
 550   query.prepare(queryString("select_buffers"));
 551   query.bindValue(":userid", user.toInt());
 552
 553   safeExec(query);
 554   watchQuery(query);
 555   while(query.next()) {
 556     bufferlist << BufferInfo(query.value(0).toInt(), query.value(1).toInt(), (BufferInfo::Type)query.value(2).toInt(), query.value(3).toInt(), query.value(4).toString());
 557   }
 558   return bufferlist;
 559 }
 560
 561 QList<BufferId> SqliteStorage::requestBufferIdsForNetwork(UserId user, NetworkId networkId) {
 562   QList<BufferId> bufferList;
 563   QSqlQuery query(logDb());
 564   query.prepare(queryString("select_buffers_for_network"));
 565   query.bindValue(":networkid", networkId.toInt());
 566   query.bindValue(":userid", user.toInt());
 567
 568   safeExec(query);
 569   watchQuery(query);
 570   while(query.next()) {
 571     bufferList << BufferId(query.value(0).toInt());
 572   }
 573   return bufferList;
 574 }
 575
 576 bool SqliteStorage::removeBuffer(const UserId &user, const BufferId &bufferId) {
 577   if(!isValidBuffer(user, bufferId))
 578     return false;
 579
 580   QSqlQuery delBacklogQuery(logDb());
 581   delBacklogQuery.prepare(queryString("delete_backlog_for_buffer"));
 582   delBacklogQuery.bindValue(":bufferid", bufferId.toInt());
 583   safeExec(delBacklogQuery);
 584   if(!watchQuery(delBacklogQuery))
 585     return false;
 586
 587   QSqlQuery delBufferQuery(logDb());
 588   delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
 589   delBufferQuery.bindValue(":bufferid", bufferId.toInt());
 590   safeExec(delBufferQuery);
 591   if(!watchQuery(delBufferQuery))
 592     return false;
 593
 594   return true;
 595 }
 596
 597 BufferId SqliteStorage::renameBuffer(const UserId &user, const NetworkId &networkId, const QString &newName, const QString &oldName) {
 598   // check if such a buffer exists...
 599   QSqlQuery existsQuery(logDb());
 600   existsQuery.prepare(queryString("select_bufferByName"));
 601   existsQuery.bindValue(":networkid", networkId.toInt());
 602   existsQuery.bindValue(":userid", user.toInt());
 603   existsQuery.bindValue(":buffercname", oldName.toLower());
 604   safeExec(existsQuery);
 605   if(!watchQuery(existsQuery))
 606     return false;
 607
 608   if(!existsQuery.first())
 609     return false;
 610
 611   const int bufferid = existsQuery.value(0).toInt();
 612
 613   Q_ASSERT(!existsQuery.next());
 614
 615   // ... and if the new name is still free.
 616   existsQuery.bindValue(":networkid", networkId.toInt());
 617   existsQuery.bindValue(":userid", user.toInt());
 618   existsQuery.bindValue(":buffercname", newName.toLower());
 619   safeExec(existsQuery);
 620   if(!watchQuery(existsQuery))
 621     return false;
 622
 623   if(existsQuery.first())
 624     return false;
 625
 626   QSqlQuery renameBufferQuery(logDb());
 627   renameBufferQuery.prepare(queryString("update_buffer_name"));
 628   renameBufferQuery.bindValue(":buffername", newName);
 629   renameBufferQuery.bindValue(":buffercname", newName.toLower());
 630   renameBufferQuery.bindValue(":bufferid", bufferid);
 631   safeExec(renameBufferQuery);
 632   if(watchQuery(existsQuery))
 633     return BufferId(bufferid);
 634   else
 635     return BufferId();
 636 }
 637
 638 void SqliteStorage::setBufferLastSeenMsg(UserId user, const BufferId &bufferId, const MsgId &msgId) {
 639   QSqlQuery query(logDb());
 640   query.prepare(queryString("update_buffer_lastseen"));
 641
 642   query.bindValue(":userid", user.toInt());
 643   query.bindValue(":bufferid", bufferId.toInt());
 644   query.bindValue(":lastseenmsgid", msgId.toInt());
 645   safeExec(query);
 646   watchQuery(query);
 647 }
 648
 649 QHash<BufferId, MsgId> SqliteStorage::bufferLastSeenMsgIds(UserId user) {
 650   QHash<BufferId, MsgId> lastSeenHash;
 651   QSqlQuery query(logDb());
 652   query.prepare(queryString("select_buffer_lastseen_messages"));
 653   query.bindValue(":userid", user.toInt());
 654   safeExec(query);
 655   if(!watchQuery(query))
 656     return lastSeenHash;
 657
 658   while(query.next()) {
 659     lastSeenHash[query.value(0).toInt()] = query.value(1).toInt();
 660   }
 661   return lastSeenHash;
 662 }
 663
 664 MsgId SqliteStorage::logMessage(Message msg) {
 665   QSqlQuery logMessageQuery(logDb());
 666   logMessageQuery.prepare(queryString("insert_message"));
 667
 668   logMessageQuery.bindValue(":time", msg.timestamp().toTime_t());
 669   logMessageQuery.bindValue(":bufferid", msg.bufferInfo().bufferId().toInt());
 670   logMessageQuery.bindValue(":type", msg.type());
 671   logMessageQuery.bindValue(":flags", (int)msg.flags());
 672   logMessageQuery.bindValue(":sender", msg.sender());
 673   logMessageQuery.bindValue(":message", msg.contents());
 674   safeExec(logMessageQuery);
 675
 676   if(logMessageQuery.lastError().isValid()) {
 677     // constraint violation - must be NOT NULL constraint - probably the sender is missing...
 678     if(logMessageQuery.lastError().number() == 19) {
 679       QSqlQuery addSenderQuery(logDb());
 680       addSenderQuery.prepare(queryString("insert_sender"));
 681       addSenderQuery.bindValue(":sender", msg.sender());
 682       safeExec(addSenderQuery);
 683       safeExec(logMessageQuery);
 684       if(!watchQuery(logMessageQuery))
 685         return 0;
 686     } else {
 687       watchQuery(logMessageQuery);
 688     }
 689   }
 690
 691   MsgId msgId = logMessageQuery.lastInsertId().toInt();
 692   Q_ASSERT(msgId.isValid());
 693   return msgId;
 694 }
 695
 696 QList<Message> SqliteStorage::requestMsgs(UserId user, BufferId bufferId, MsgId first, MsgId last, int limit) {
 697   QList<Message> messagelist;
 698
 699   BufferInfo bufferInfo = getBufferInfo(user, bufferId);
 700   if(!bufferInfo.isValid())
 701     return messagelist;
 702
 703   QSqlQuery query(logDb());
 704   if(last == -1) {
 705     query.prepare(queryString("select_messagesNew"));
 706   } else {
 707     query.prepare(queryString("select_messages"));
 708     query.bindValue(":lastmsg", last.toInt());
 709   }
 710
 711   query.bindValue(":bufferid", bufferId.toInt());
 712   query.bindValue(":firstmsg", first.toInt());
 713   query.bindValue(":limit", limit);
 714   safeExec(query);
 715
 716   watchQuery(query);
 717
 718   while(query.next()) {
 719     Message msg(QDateTime::fromTime_t(query.value(1).toInt()),
 720                 bufferInfo,
 721                 (Message::Type)query.value(2).toUInt(),
 722                 query.value(5).toString(),
 723                 query.value(4).toString(),
 724                 (Message::Flags)query.value(3).toUInt());
 725     msg.setMsgId(query.value(0).toInt());
 726     messagelist << msg;
 727   }
 728   return messagelist;
 729 }
 730
 731 QList<Message> SqliteStorage::requestAllMsgs(UserId user, MsgId first, MsgId last, int limit) {
 732   QList<Message> messagelist;
 733
 734   QHash<BufferId, BufferInfo> bufferInfoHash;
 735   foreach(BufferInfo bufferInfo, requestBuffers(user)) {
 736     bufferInfoHash[bufferInfo.bufferId()] = bufferInfo;
 737   }
 738
 739   QSqlQuery query(logDb());
 740   if(last == -1) {
 741     query.prepare(queryString("select_messagesAllNew"));
 742   } else {
 743     query.prepare(queryString("select_messagesAll"));
 744     query.bindValue(":lastmsg", last.toInt());
 745   }
 746   query.bindValue(":userid", user.toInt());
 747   query.bindValue(":firstmsg", first.toInt());
 748   query.bindValue(":limit", limit);
 749   safeExec(query);
 750
 751   watchQuery(query);
 752
 753   while(query.next()) {
 754     Message msg(QDateTime::fromTime_t(query.value(2).toInt()),
 755                 bufferInfoHash[query.value(1).toInt()],
 756                 (Message::Type)query.value(3).toUInt(),
 757                 query.value(6).toString(),
 758                 query.value(5).toString(),
 759                 (Message::Flags)query.value(4).toUInt());
 760     msg.setMsgId(query.value(0).toInt());
 761     messagelist << msg;
 762   }
 763
 764   return messagelist;
 765 }
 766
 767 QString SqliteStorage::backlogFile() {
 768   return quasselDir().absolutePath() + "/quassel-storage.sqlite";
 769 }
 770
 771 bool SqliteStorage::safeExec(QSqlQuery &query, int retryCount) {
 772   query.exec();
 773
 774   if(!query.lastError().isValid())
 775     return true;
 776
 777   switch(query.lastError().number()) {
 778   case 5: // SQLITE_BUSY         5   /* The database file is locked */
 779   case 6: // SQLITE_LOCKED       6   /* A table in the database is locked */
 780     if(retryCount < _maxRetryCount)
 781       return safeExec(query, retryCount + 1);
 782   default:
 783     return false;
 784   }
 785 }