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