X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fpostgresqlstorage.cpp;h=59d6f772ec7216956dc834c4c1868c7cec6ca071;hp=96805baf5b1f635e2d105705ca013f4120e33cb2;hb=644837b45714e41246a8fd10fc6efc0e129280ff;hpb=b9828e0dd235964b8e2e97f844f4bed3476d3bd4

diff --git a/src/core/postgresqlstorage.cpp b/src/core/postgresqlstorage.cpp
index 96805baf..59d6f772 100644
--- a/src/core/postgresqlstorage.cpp
+++ b/src/core/postgresqlstorage.cpp
@@ -26,8 +26,6 @@
 #include "network.h"
 #include "quassel.h"
 
-int PostgreSqlStorage::_maxRetryCount = 150; // yes this is a large number... only other way to "handle" this is bailing out...
-
 PostgreSqlStorage::PostgreSqlStorage(QObject *parent)
   : AbstractSqlStorage(parent),
     _port(-1)
@@ -37,7 +35,20 @@ PostgreSqlStorage::PostgreSqlStorage(QObject *parent)
 PostgreSqlStorage::~PostgreSqlStorage() {
 }
 
+AbstractSqlMigrationWriter *PostgreSqlStorage::createMigrationWriter() {
+  PostgreSqlMigrationWriter *writer = new PostgreSqlMigrationWriter();
+  QVariantMap properties;
+  properties["Username"] = _userName;
+  properties["Password"] = _password;
+  properties["Hostname"] = _hostName;
+  properties["Port"] = _port;
+  properties["Database"] = _databaseName;
+  writer->setConnectionProperties(properties);
+  return writer;
+}
+
 bool PostgreSqlStorage::isAvailable() const {
+  qDebug() << QSqlDatabase::drivers();
   if(!QSqlDatabase::isDriverAvailable("QPSQL")) return false;
   return true;
 }
@@ -51,16 +62,30 @@ QString PostgreSqlStorage::description() const {
   return tr("PostgreSQL Turbo Bomber HD!");
 }
 
-QVariantMap PostgreSqlStorage::setupKeys() const {
+QStringList PostgreSqlStorage::setupKeys() const {
+  QStringList keys;
+  keys << "Username"
+       << "Password"
+       << "Hostname"
+       << "Port"
+       << "Database";
+  return keys;
+}
+QVariantMap PostgreSqlStorage::setupDefaults() const {
   QVariantMap map;
   map["Username"] = QVariant(QString("quassel"));
-  map["Password"] = QVariant(QString());
   map["Hostname"] = QVariant(QString("localhost"));
   map["Port"] = QVariant(5432);
   map["Database"] = QVariant(QString("quassel"));
   return map;
 }
 
+void PostgreSqlStorage::initDbSession(QSqlDatabase &db) {
+  // this blows... but unfortunately Qt's PG driver forces us to this...
+  db.exec("set standard_conforming_strings = off");
+  db.exec("set escape_string_warning = off");
+}
+
 void PostgreSqlStorage::setConnectionProperties(const QVariantMap &properties) {
   _userName = properties["Username"].toString();
   _password = properties["Password"].toString();
@@ -125,12 +150,13 @@ UserId PostgreSqlStorage::addUser(const QString &user, const QString &password)
   return uid;
 }
 
-void PostgreSqlStorage::updateUser(UserId user, const QString &password) {
+bool PostgreSqlStorage::updateUser(UserId user, const QString &password) {
   QSqlQuery query(logDb());
   query.prepare(queryString("update_userpassword"));
   query.bindValue(":userid", user.toInt());
   query.bindValue(":password", cryptedPassword(password));
   safeExec(query);
+  return query.numRowsAffected() != 0;
 }
 
 void PostgreSqlStorage::renameUser(UserId user, const QString &newName) {
@@ -156,6 +182,19 @@ UserId PostgreSqlStorage::validateUser(const QString &user, const QString &passw
   }
 }
 
+UserId PostgreSqlStorage::getUserId(const QString &user) {
+  QSqlQuery query(logDb());
+  query.prepare(queryString("select_userid"));
+  query.bindValue(":username", user);
+  safeExec(query);
+
+  if(query.first()) {
+    return query.value(0).toInt();
+  } else {
+    return 0;
+  }
+}
+
 UserId PostgreSqlStorage::internalUser() {
   QSqlQuery query(logDb());
   query.prepare(queryString("select_internaluser"));
@@ -276,7 +315,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);
 
@@ -299,7 +338,7 @@ IdentityId PostgreSqlStorage::createIdentity(UserId user, CoreIdentity &identity
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::createIdentity(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::createIdentity(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return IdentityId();
   }
@@ -382,7 +421,7 @@ bool PostgreSqlStorage::updateIdentity(UserId user, const CoreIdentity &identity
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::updateIdentity(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::updateIdentity(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return false;
   }
@@ -488,7 +527,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()) {
@@ -511,7 +550,7 @@ NetworkId PostgreSqlStorage::createNetwork(UserId user, const NetworkInfo &info)
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::updateNetwork(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::createNetwork(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return NetworkId();
   }
@@ -520,7 +559,7 @@ NetworkId PostgreSqlStorage::createNetwork(UserId user, const NetworkInfo &info)
 
 void PostgreSqlStorage::bindNetworkInfo(QSqlQuery &query, const NetworkInfo &info) {
   query.bindValue(":networkname", info.networkName);
-  query.bindValue(":identityid", info.identity.toInt());
+  query.bindValue(":identityid", info.identity.isValid() ? info.identity.toInt() : QVariant());
   query.bindValue(":encodingcodec", QString(info.codecForEncoding));
   query.bindValue(":decodingcodec", QString(info.codecForDecoding));
   query.bindValue(":servercodec", QString(info.codecForServer));
@@ -529,6 +568,9 @@ void PostgreSqlStorage::bindNetworkInfo(QSqlQuery &query, const NetworkInfo &inf
   query.bindValue(":useautoidentify", info.useAutoIdentify);
   query.bindValue(":autoidentifyservice", info.autoIdentifyService);
   query.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
+  query.bindValue(":usesasl", info.useSasl);
+  query.bindValue(":saslaccount", info.saslAccount);
+  query.bindValue(":saslpassword", info.saslPassword);
   query.bindValue(":useautoreconnect", info.useAutoReconnect);
   query.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
   query.bindValue(":autoreconnectretries", info.autoReconnectRetries);
@@ -598,7 +640,7 @@ bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
   }
 
   if(!db.commit()) {
-    qWarning() << "PostgreSqlStorage::updateNetwork(): commiting data failed!";
+    qWarning() << "PostgreSqlStorage::updateNetwork(): committing data failed!";
     qWarning() << " -" << qPrintable(db.lastError().text());
     return false;
   }
@@ -668,6 +710,9 @@ QList<NetworkInfo> PostgreSqlStorage::networks(UserId user) {
     net.autoReconnectRetries = networksQuery.value(13).toInt();
     net.unlimitedReconnectRetries = networksQuery.value(14).toBool();
     net.rejoinChannels = networksQuery.value(15).toBool();
+    net.useSasl = networksQuery.value(16).toBool();
+    net.saslAccount = networksQuery.value(17).toString();
+    net.saslPassword = networksQuery.value(18).toString();
 
     serversQuery.bindValue(":networkid", net.networkId.toInt());
     safeExec(serversQuery);
@@ -868,6 +913,8 @@ BufferInfo PostgreSqlStorage::bufferInfo(UserId user, const NetworkId &networkId
   createQuery.bindValue(":buffertype", (int)type);
   createQuery.bindValue(":buffername", buffer);
   createQuery.bindValue(":buffercname", buffer.toLower());
+  createQuery.bindValue(":joined", type & BufferInfo::ChannelBuffer ? true : false);
+
   safeExec(createQuery);
 
   if(createQuery.lastError().isValid()) {
@@ -973,7 +1020,7 @@ bool PostgreSqlStorage::removeBuffer(const UserId &user, const BufferId &bufferI
     return false;
   case 1:
     db.commit();
-    return false;
+    return true;
   default:
     // there was more then one buffer deleted...
     qWarning() << "PostgreSqlStorage::removeBuffer(): Userid" << user << "BufferId" << "caused deletion of" << numRows << "Buffers! Rolling back transaction...";
@@ -1009,7 +1056,7 @@ bool PostgreSqlStorage::renameBuffer(const UserId &user, const BufferId &bufferI
     return false;
   case 1:
     db.commit();
-    return false;
+    return true;
   default:
     // there was more then one buffer deleted...
     qWarning() << "PostgreSqlStorage::renameBuffer(): Userid" << user << "BufferId" << "affected" << numRows << "Buffers! Rolling back transaction...";
@@ -1027,7 +1074,7 @@ bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const Buffer
   }
 
   QSqlQuery checkQuery(db);
-  checkQuery.prepare("SELECT count(*) FROM buffer"
+  checkQuery.prepare("SELECT count(*) FROM buffer "
 		     "WHERE userid = :userid AND bufferid IN (:buffer1, :buffer2)");
   checkQuery.bindValue(":userid", user.toInt());
   checkQuery.bindValue(":buffer1", bufferId1.toInt());
@@ -1055,6 +1102,7 @@ bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const Buffer
 
   QSqlQuery delBufferQuery(logDb());
   delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
+  delBufferQuery.bindValue(":userid", user.toInt());
   delBufferQuery.bindValue(":bufferid", bufferId2.toInt());
   safeExec(delBufferQuery);
   if(!watchQuery(delBufferQuery)) {
@@ -1104,6 +1152,44 @@ QHash<BufferId, MsgId> PostgreSqlStorage::bufferLastSeenMsgIds(UserId user) {
   return lastSeenHash;
 }
 
+void PostgreSqlStorage::setBufferMarkerLineMsg(UserId user, const BufferId &bufferId, const MsgId &msgId) {
+  QSqlQuery query(logDb());
+  query.prepare(queryString("update_buffer_markerlinemsgid"));
+
+  query.bindValue(":userid", user.toInt());
+  query.bindValue(":bufferid", bufferId.toInt());
+  query.bindValue(":markerlinemsgid", msgId.toInt());
+  safeExec(query);
+  watchQuery(query);
+}
+
+QHash<BufferId, MsgId> PostgreSqlStorage::bufferMarkerLineMsgIds(UserId user) {
+  QHash<BufferId, MsgId> markerLineHash;
+
+  QSqlDatabase db = logDb();
+  if(!beginReadOnlyTransaction(db)) {
+    qWarning() << "PostgreSqlStorage::bufferMarkerLineMsgIds(): cannot start read only transaction!";
+    qWarning() << " -" << qPrintable(db.lastError().text());
+    return markerLineHash;
+  }
+
+  QSqlQuery query(db);
+  query.prepare(queryString("select_buffer_markerlinemsgids"));
+  query.bindValue(":userid", user.toInt());
+  safeExec(query);
+  if(!watchQuery(query)) {
+    db.rollback();
+    return markerLineHash;
+  }
+
+  while(query.next()) {
+    markerLineHash[query.value(0).toInt()] = query.value(1).toInt();
+  }
+
+  db.commit();
+  return markerLineHash;
+}
+
 bool PostgreSqlStorage::logMessage(Message &msg) {
   QSqlDatabase db = logDb();
   if(!db.transaction()) {
@@ -1120,7 +1206,7 @@ bool PostgreSqlStorage::logMessage(Message &msg) {
   }
 
   QVariantList params;
-  params << msg.timestamp().toTime_t()
+  params << msg.timestamp()
 	 << msg.bufferInfo().bufferId().toInt()
 	 << msg.type()
 	 << (int)msg.flags()
@@ -1133,6 +1219,12 @@ bool PostgreSqlStorage::logMessage(Message &msg) {
     db.rollback();
     db.transaction();
 
+    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;
+    }
 
     // it's possible that the sender was already added by another thread
     // since the insert might fail we're setting a savepoint
@@ -1204,7 +1296,7 @@ bool PostgreSqlStorage::logMessages(MessageList &msgs) {
   for(int i = 0; i < msgs.count(); i++) {
     Message &msg = msgs[i];
     QVariantList params;
-    params << msg.timestamp().toTime_t()
+    params << msg.timestamp()
 	   << msg.bufferInfo().bufferId().toInt()
 	   << msg.type()
 	   << (int)msg.flags()
@@ -1249,31 +1341,49 @@ QList<Message> PostgreSqlStorage::requestMsgs(UserId user, BufferId bufferId, Ms
     return messagelist;
   }
 
-  QSqlQuery query(db);
+  QString queryName;
+  QVariantList params;
   if(last == -1 && first == -1) {
-    query.prepare(queryString("select_messages"));
+    queryName = "select_messages";
   } else if(last == -1) {
-    query.prepare(queryString("select_messagesNewerThan"));
-    query.bindValue(":firstmsg", first.toInt());
+    queryName = "select_messagesNewerThan";
+    params << first.toInt();
   } else {
-    query.prepare(queryString("select_messagesRange"));
-    query.bindValue(":lastmsg", last.toInt());
-    query.bindValue(":firstmsg", first.toInt());
+    queryName = "select_messagesRange";
+    params << first.toInt();
+    params << last.toInt();
   }
-  query.bindValue(":bufferid", bufferId.toInt());
-  safeExec(query);
+  params << bufferId.toInt();
+  if(limit != -1)
+    params << limit;
+  else
+    params << "ALL";
+
+  if(!prepareQuery(queryName, queryString(queryName), db)) {
+    qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString(queryName);
+    qWarning() << "  Error:" << db.lastError().text();
+    db.rollback();
+    return messagelist;
+  }
+
+  QSqlQuery query = executePreparedQuery(queryName, params, db);
+
   if(!watchQuery(query)) {
+    qDebug() << "select_messages failed";
     db.rollback();
     return messagelist;
   }
 
-  for(int i = 0; i < limit && query.next(); i++) {
-    Message msg(QDateTime::fromTime_t(query.value(1).toInt()),
-                bufferInfo,
-                (Message::Type)query.value(2).toUInt(),
-                query.value(5).toString(),
-                query.value(4).toString(),
-                (Message::Flags)query.value(3).toUInt());
+  QDateTime timestamp;
+  while(query.next()) {
+    timestamp = query.value(1).toDateTime();
+    timestamp.setTimeSpec(Qt::UTC);
+    Message msg(timestamp,
+		bufferInfo,
+		(Message::Type)query.value(2).toUInt(),
+		query.value(5).toString(),
+		query.value(4).toString(),
+		(Message::Flags)query.value(3).toUInt());
     msg.setMsgId(query.value(0).toInt());
     messagelist << msg;
   }
@@ -1313,8 +1423,11 @@ QList<Message> PostgreSqlStorage::requestAllMsgs(UserId user, MsgId first, MsgId
     return messagelist;
   }
 
+  QDateTime timestamp;
   for(int i = 0; i < limit && query.next(); i++) {
-    Message msg(QDateTime::fromTime_t(query.value(2).toInt()),
+    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(),
@@ -1377,7 +1490,7 @@ bool PostgreSqlStorage::prepareQuery(const QString &handle, const QString &query
 QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const QVariantList &params, const QSqlDatabase &db) {
   if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
     qWarning() << "PostgreSqlStorage::executePreparedQuery() no prepared Query with handle" << handle << "on Database" << db.connectionName();
-    return QSqlQuery();
+    return QSqlQuery(db);
   }
 
   QSqlDriver *driver = db.driver();
@@ -1407,7 +1520,7 @@ QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const Q
 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();
+    return QSqlQuery(db);
   }
 
   QSqlField field;
@@ -1433,3 +1546,205 @@ void PostgreSqlStorage::deallocateQuery(const QString &handle, const QSqlDatabas
   db.exec(QString("DEALLOCATE %1").arg(queryId));
 }
 
+// ========================================
+//  PostgreSqlMigrationWriter
+// ========================================
+PostgreSqlMigrationWriter::PostgreSqlMigrationWriter()
+  : PostgreSqlStorage()
+{
+}
+
+bool PostgreSqlMigrationWriter::prepareQuery(MigrationObject mo) {
+  QString query;
+  switch(mo) {
+  case QuasselUser:
+    query = queryString("migrate_write_quasseluser");
+    break;
+  case Sender:
+    query = queryString("migrate_write_sender");
+    break;
+  case Identity:
+    _validIdentities.clear();
+    query = queryString("migrate_write_identity");
+    break;
+  case IdentityNick:
+    query = queryString("migrate_write_identity_nick");
+    break;
+  case Network:
+    query = queryString("migrate_write_network");
+    break;
+  case Buffer:
+    query = queryString("migrate_write_buffer");
+    break;
+  case Backlog:
+    query = queryString("migrate_write_backlog");
+    break;
+  case IrcServer:
+    query = queryString("migrate_write_ircserver");
+    break;
+  case UserSetting:
+    query = queryString("migrate_write_usersetting");
+    break;
+  }
+  newQuery(query, logDb());
+  return true;
+}
+
+//bool PostgreSqlMigrationWriter::writeUser(const QuasselUserMO &user) {
+bool PostgreSqlMigrationWriter::writeMo(const QuasselUserMO &user) {
+  bindValue(0, user.id.toInt());
+  bindValue(1, user.username);
+  bindValue(2, user.password);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeSender(const SenderMO &sender) {
+bool PostgreSqlMigrationWriter::writeMo(const SenderMO &sender) {
+  bindValue(0, sender.senderId);
+  bindValue(1, sender.sender);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeIdentity(const IdentityMO &identity) {
+bool PostgreSqlMigrationWriter::writeMo(const IdentityMO &identity) {
+  _validIdentities << identity.id.toInt();
+  bindValue(0, identity.id.toInt());
+  bindValue(1, identity.userid.toInt());
+  bindValue(2, identity.identityname);
+  bindValue(3, identity.realname);
+  bindValue(4, identity.awayNick);
+  bindValue(5, identity.awayNickEnabled);
+  bindValue(6, identity.awayReason);
+  bindValue(7, identity.awayReasonEnabled);
+  bindValue(8, identity.autoAwayEnabled);
+  bindValue(9, identity.autoAwayTime);
+  bindValue(10, identity.autoAwayReason);
+  bindValue(11, identity.autoAwayReasonEnabled);
+  bindValue(12, identity.detachAwayEnabled);
+  bindValue(13, identity.detachAwayReason);
+  bindValue(14, identity.detchAwayReasonEnabled);
+  bindValue(15, identity.ident);
+  bindValue(16, identity.kickReason);
+  bindValue(17, identity.partReason);
+  bindValue(18, identity.quitReason);
+  bindValue(19, identity.sslCert);
+  bindValue(20, identity.sslKey);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeIdentityNick(const IdentityNickMO &identityNick) {
+bool PostgreSqlMigrationWriter::writeMo(const IdentityNickMO &identityNick) {
+  bindValue(0, identityNick.nickid);
+  bindValue(1, identityNick.identityId.toInt());
+  bindValue(2, identityNick.nick);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeNetwork(const NetworkMO &network) {
+bool PostgreSqlMigrationWriter::writeMo(const NetworkMO &network) {
+  bindValue(0, network.networkid.toInt());
+  bindValue(1, network.userid.toInt());
+  bindValue(2, network.networkname);
+  if(_validIdentities.contains(network.identityid.toInt()))
+    bindValue(3, network.identityid.toInt());
+  else
+    bindValue(3, QVariant());
+  bindValue(4, network.encodingcodec);
+  bindValue(5, network.decodingcodec);
+  bindValue(6, network.servercodec);
+  bindValue(7, network.userandomserver);
+  bindValue(8, network.perform);
+  bindValue(9, network.useautoidentify);
+  bindValue(10, network.autoidentifyservice);
+  bindValue(11, network.autoidentifypassword);
+  bindValue(12, network.useautoreconnect);
+  bindValue(13, network.autoreconnectinterval);
+  bindValue(14, network.autoreconnectretries);
+  bindValue(15, network.unlimitedconnectretries);
+  bindValue(16, network.rejoinchannels);
+  bindValue(17, network.connected);
+  bindValue(18, network.usermode);
+  bindValue(19, network.awaymessage);
+  bindValue(20, network.attachperform);
+  bindValue(21, network.detachperform);
+  bindValue(22, network.usesasl);
+  bindValue(23, network.saslaccount);
+  bindValue(24, network.saslpassword);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeBuffer(const BufferMO &buffer) {
+bool PostgreSqlMigrationWriter::writeMo(const BufferMO &buffer) {
+  bindValue(0, buffer.bufferid.toInt());
+  bindValue(1, buffer.userid.toInt());
+  bindValue(2, buffer.groupid);
+  bindValue(3, buffer.networkid.toInt());
+  bindValue(4, buffer.buffername);
+  bindValue(5, buffer.buffercname);
+  bindValue(6, (int)buffer.buffertype);
+  bindValue(7, buffer.lastseenmsgid);
+  bindValue(8, buffer.markerlinemsgid);
+  bindValue(9, buffer.key);
+  bindValue(10, buffer.joined);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeBacklog(const BacklogMO &backlog) {
+bool PostgreSqlMigrationWriter::writeMo(const BacklogMO &backlog) {
+  bindValue(0, backlog.messageid.toInt());
+  bindValue(1, backlog.time);
+  bindValue(2, backlog.bufferid.toInt());
+  bindValue(3, backlog.type);
+  bindValue(4, (int)backlog.flags);
+  bindValue(5, backlog.senderid);
+  bindValue(6, backlog.message);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeIrcServer(const IrcServerMO &ircserver) {
+bool PostgreSqlMigrationWriter::writeMo(const IrcServerMO &ircserver) {
+  bindValue(0, ircserver.serverid);
+  bindValue(1, ircserver.userid.toInt());
+  bindValue(2, ircserver.networkid.toInt());
+  bindValue(3, ircserver.hostname);
+  bindValue(4, ircserver.port);
+  bindValue(5, ircserver.password);
+  bindValue(6, ircserver.ssl);
+  bindValue(7, ircserver.sslversion);
+  bindValue(8, ircserver.useproxy);
+  bindValue(9, ircserver.proxytype);
+  bindValue(10, ircserver.proxyhost);
+  bindValue(11, ircserver.proxyport);
+  bindValue(12, ircserver.proxyuser);
+  bindValue(13, ircserver.proxypass);
+  return exec();
+}
+
+//bool PostgreSqlMigrationWriter::writeUserSetting(const UserSettingMO &userSetting) {
+bool PostgreSqlMigrationWriter::writeMo(const UserSettingMO &userSetting) {
+  bindValue(0, userSetting.userid.toInt());
+  bindValue(1, userSetting.settingname);
+  bindValue(2, userSetting.settingvalue);
+  return exec();
+}
+
+bool PostgreSqlMigrationWriter::postProcess() {
+  QSqlDatabase db = logDb();
+  QList<Sequence> sequences;
+  sequences << Sequence("backlog", "messageid")
+	    << Sequence("buffer", "bufferid")
+	    << Sequence("identity", "identityid")
+	    << Sequence("identity_nick", "nickid")
+	    << Sequence("ircserver", "serverid")
+	    << Sequence("network", "networkid")
+	    << Sequence("quasseluser", "userid")
+	    << Sequence("sender", "senderid");
+  QList<Sequence>::const_iterator iter;
+  for(iter = sequences.constBegin(); iter != sequences.constEnd(); iter++) {
+    resetQuery();
+    newQuery(QString("SELECT setval('%1_%2_seq', max(%2)) FROM %1").arg(iter->table, iter->field), db);
+    if(!exec())
+      return false;
+  }
+  return true;
+}