+ QSqlDatabase::removeDatabase(name());
+}
+
+
+// ========================================
+// AbstractSqlMigrator
+// ========================================
+AbstractSqlMigrator::AbstractSqlMigrator()
+ : _query(0)
+{
+}
+
+
+void AbstractSqlMigrator::newQuery(const QString &query, QSqlDatabase db)
+{
+ Q_ASSERT(!_query);
+ _query = new QSqlQuery(db);
+ _query->prepare(query);
+}
+
+
+void AbstractSqlMigrator::resetQuery()
+{
+ delete _query;
+ _query = 0;
+}
+
+
+bool AbstractSqlMigrator::exec()
+{
+ Q_ASSERT(_query);
+ _query->exec();
+ return !_query->lastError().isValid();
+}
+
+
+QString AbstractSqlMigrator::migrationObject(MigrationObject moType)
+{
+ switch (moType) {
+ case QuasselUser:
+ return "QuasselUser";
+ case Sender:
+ return "Sender";
+ case Identity:
+ return "Identity";
+ case IdentityNick:
+ return "IdentityNick";
+ case Network:
+ return "Network";
+ case Buffer:
+ return "Buffer";
+ case Backlog:
+ return "Backlog";
+ case IrcServer:
+ return "IrcServer";
+ case UserSetting:
+ return "UserSetting";
+ };
+ return QString();
+}
+
+
+QVariantList AbstractSqlMigrator::boundValues()
+{
+ QVariantList values;
+ if (!_query)
+ return values;
+
+ int numValues = _query->boundValues().count();
+ for (int i = 0; i < numValues; i++) {
+ values << _query->boundValue(i);
+ }
+ return values;
+}
+
+
+void AbstractSqlMigrator::dumpStatus()
+{
+ qWarning() << " executed Query:";
+ qWarning() << qPrintable(executedQuery());
+ qWarning() << " bound Values:";
+ QList<QVariant> list = boundValues();
+ for (int i = 0; i < list.size(); ++i)
+ qWarning() << i << ": " << list.at(i).toString().toLatin1().data();
+ qWarning() << " Error Number:" << lastError().number();
+ qWarning() << " Error Message:" << lastError().text();
+}
+
+
+// ========================================
+// AbstractSqlMigrationReader
+// ========================================
+AbstractSqlMigrationReader::AbstractSqlMigrationReader()
+ : AbstractSqlMigrator(),
+ _writer(0)
+{
+}
+
+
+bool AbstractSqlMigrationReader::migrateTo(AbstractSqlMigrationWriter *writer)
+{
+ if (!transaction()) {
+ qWarning() << "AbstractSqlMigrationReader::migrateTo(): unable to start reader's transaction!";
+ return false;
+ }
+ if (!writer->transaction()) {
+ qWarning() << "AbstractSqlMigrationReader::migrateTo(): unable to start writer's transaction!";
+ rollback(); // close the reader transaction;
+ return false;
+ }
+
+ _writer = writer;
+
+ // due to the incompatibility across Migration objects we can't run this in a loop... :/
+ QuasselUserMO quasselUserMo;
+ if (!transferMo(QuasselUser, quasselUserMo))
+ return false;
+
+ IdentityMO identityMo;
+ if (!transferMo(Identity, identityMo))
+ return false;
+
+ IdentityNickMO identityNickMo;
+ if (!transferMo(IdentityNick, identityNickMo))
+ return false;
+
+ NetworkMO networkMo;
+ if (!transferMo(Network, networkMo))
+ return false;
+
+ BufferMO bufferMo;
+ if (!transferMo(Buffer, bufferMo))
+ return false;
+
+ SenderMO senderMo;
+ if (!transferMo(Sender, senderMo))
+ return false;
+
+ BacklogMO backlogMo;
+ if (!transferMo(Backlog, backlogMo))
+ return false;
+
+ IrcServerMO ircServerMo;
+ if (!transferMo(IrcServer, ircServerMo))
+ return false;
+
+ UserSettingMO userSettingMo;
+ if (!transferMo(UserSetting, userSettingMo))
+ return false;
+
+ if (!_writer->postProcess())
+ abortMigration();
+ return finalizeMigration();
+}
+
+
+void AbstractSqlMigrationReader::abortMigration(const QString &errorMsg)
+{
+ qWarning() << "Migration Failed!";
+ if (!errorMsg.isNull()) {
+ qWarning() << qPrintable(errorMsg);
+ }
+ if (lastError().isValid()) {
+ qWarning() << "ReaderError:";
+ dumpStatus();
+ }
+
+ if (_writer->lastError().isValid()) {
+ qWarning() << "WriterError:";
+ _writer->dumpStatus();
+ }
+
+ rollback();
+ _writer->rollback();
+ _writer = 0;
+}
+
+
+bool AbstractSqlMigrationReader::finalizeMigration()
+{
+ resetQuery();
+ _writer->resetQuery();
+
+ commit();
+ if (!_writer->commit()) {
+ _writer = 0;
+ return false;
+ }
+ _writer = 0;
+ return true;
+}
+
+
+template<typename T>
+bool AbstractSqlMigrationReader::transferMo(MigrationObject moType, T &mo)
+{
+ resetQuery();
+ _writer->resetQuery();
+
+ if (!prepareQuery(moType)) {
+ abortMigration(QString("AbstractSqlMigrationReader::migrateTo(): unable to prepare reader query of type %1!").arg(AbstractSqlMigrator::migrationObject(moType)));
+ return false;
+ }
+ if (!_writer->prepareQuery(moType)) {
+ abortMigration(QString("AbstractSqlMigrationReader::migrateTo(): unable to prepare writer query of type %1!").arg(AbstractSqlMigrator::migrationObject(moType)));
+ return false;
+ }
+
+ qDebug() << qPrintable(QString("Transferring %1...").arg(AbstractSqlMigrator::migrationObject(moType)));
+ int i = 0;
+ QFile file;
+ file.open(stdout, QIODevice::WriteOnly);
+
+ while (readMo(mo)) {
+ if (!_writer->writeMo(mo)) {
+ abortMigration(QString("AbstractSqlMigrationReader::transferMo(): unable to transfer Migratable Object of type %1!").arg(AbstractSqlMigrator::migrationObject(moType)));
+ return false;
+ }
+ i++;
+ if (i % 1000 == 0) {
+ file.write("*");
+ file.flush();
+ }
+ }
+ if (i > 1000) {
+ file.write("\n");
+ file.flush();
+ }
+
+ qDebug() << "Done.";
+ return true;