diff --git a/autotests/server/partstreamertest.cpp b/autotests/server/partstreamertest.cpp
index bc111c008..5e51c00c4 100644
--- a/autotests/server/partstreamertest.cpp
+++ b/autotests/server/partstreamertest.cpp
@@ -1,282 +1,283 @@
 /*
  * Copyright (C) 2014  Daniel Vrátil <dvratil@redhat.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
 
 #include <QObject>
 
 #include "fakeakonadiserver.h"
 #include "fakeconnection.h"
 #include "aktest.h"
 #include "entities.h"
 
 #include <private/standarddirs_p.h>
 #include <private/externalpartstorage_p.h>
 
 #include "storage/partstreamer.h"
 #include <storage/parthelper.h>
 
 #include <QTest>
 #include <QSettings>
 #include <QDir>
 
 #include <private/scope_p.h>
 
 using namespace Akonadi;
 using namespace Akonadi::Server;
 
 Q_DECLARE_METATYPE(Akonadi::Server::PimItem)
 Q_DECLARE_METATYPE(Akonadi::Server::Part::Storage)
 
 class PartStreamerTest : public QObject
 {
     Q_OBJECT
 
 public:
     PartStreamerTest()
     {
         // Set a very small treshold for easier testing
         const QString serverConfigFile = StandardDirs::serverConfigFile(StandardDirs::ReadWrite);
         QSettings settings(serverConfigFile, QSettings::IniFormat);
         settings.setValue(QStringLiteral("General/SizeThreshold"), 5);
 
         try {
             FakeAkonadiServer::instance()->init();
         } catch (const FakeAkonadiServerException &e) {
             qWarning() << "Server exception: " << e.what();
             qFatal("Fake Akonadi Server failed to start up, aborting test");
         }
     }
 
     ~PartStreamerTest()
     {
         FakeAkonadiServer::instance()->quit();
     }
 
     Protocol::ModifyItemsCommandPtr createCommand(const PimItem &item)
     {
         auto cmd = Protocol::ModifyItemsCommandPtr::create(item.id());
         cmd->setParts({ "PLD:DATA" });
         return cmd;
     }
 
 private Q_SLOTS:
     void testStreamer_data()
     {
         QTest::addColumn<TestScenario::List>("scenarios");
         QTest::addColumn<QByteArray>("expectedPartName");
         QTest::addColumn<QByteArray>("expectedPartData");
         QTest::addColumn<QByteArray>("expectedFileData");
         QTest::addColumn<qint64>("expectedPartSize");
         QTest::addColumn<bool>("expectedChanged");
         QTest::addColumn<Part::Storage>("storage");
         QTest::addColumn<PimItem>("pimItem");
 
         PimItem item;
         item.setCollectionId(Collection::retrieveByName(QStringLiteral("Col A")).id());
         item.setMimeType(MimeType::retrieveByName(QStringLiteral("application/octet-stream")));
         item.setSize(1); // this will not match reality during the test, but that does not matter, as
         // that's not the subject of this test
         QVERIFY(item.insert());
 
         qint64 partId = -1;
         Part::List parts = Part::retrieveAll();
         if (parts.isEmpty()) {
             partId = 0;
         } else {
             partId = parts.last().id() + 1;
         }
 
         // Order of these tests matters!
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 3)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", "123"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 1));
 
             QTest::newRow("item 1, internal") << scenarios << QByteArray("PLD:DATA") << QByteArray("123") << QByteArray() << 3ll << true << Part::Internal << item;
         }
 
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 9)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data, QStringLiteral("%1_r0").arg(partId)))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 2));
 
             QTest::newRow("item 1, change to external") << scenarios << QByteArray("PLD:DATA") << QByteArray("15_r0") << QByteArray("123456789") << 9ll << true << Part::External << item;
         }
 
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 9)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data, QStringLiteral("%1_r1").arg(partId)))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 3));
 
             QTest::newRow("item 1, update external") << scenarios << QByteArray("PLD:DATA") << QByteArray("15_r1") << QByteArray("987654321") << 9ll << true << Part::External << item;
         }
 
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 9)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data, QStringLiteral("%1_r2").arg(partId)))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 4));
 
             QTest::newRow("item 1, external, no change") << scenarios << QByteArray("PLD:DATA") << QByteArray("15_r2") << QByteArray("987654321") << 9ll << false << Part::External << item;
         }
 
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 4)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", "1234"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 5));
 
             QTest::newRow("item 1, change to internal") << scenarios << QByteArray("PLD:DATA") << QByteArray("1234") << QByteArray() << 4ll << true << Part::Internal << item;
         }
 
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 4)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", "1234"))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item.id(), 6));
 
             QTest::newRow("item 1, internal, no change") << scenarios << QByteArray("PLD:DATA") << QByteArray("1234") << QByteArray() << 4ll << false << Part::Internal << item;
         }
 
         // Insert new item
         PimItem item2 = item;
         QVERIFY(item2.insert());
 
         const QString foreignPath = FakeAkonadiServer::basePath() + QStringLiteral("/tmp/foreignPayloadFile");
         {
             TestScenario::List scenarios;
             scenarios << FakeAkonadiServer::loginScenario()
                       << TestScenario::create(5, TestScenario::ClientCmd, createCommand(item2))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::MetaData))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", Protocol::PartMetaData("PLD:DATA", 3, 0, Protocol::PartMetaData::Foreign)))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::StreamPayloadCommandPtr::create("PLD:DATA", Protocol::StreamPayloadCommand::Data))
                       << TestScenario::create(5, TestScenario::ClientCmd, Protocol::StreamPayloadResponsePtr::create("PLD:DATA", foreignPath.toUtf8()))
                       << TestScenario::create(5, TestScenario::ServerCmd, Protocol::ModifyItemsResponsePtr::create(item2.id(), 1));
 
             QTest::newRow("item 2, new foreign part") << scenarios << QByteArray("PLD:DATA") << foreignPath.toUtf8() << QByteArray("123") << 3ll << false << Part::Foreign << item2;
         }
     }
 
     void testStreamer()
     {
         QFETCH(TestScenario::List, scenarios);
         QFETCH(QByteArray, expectedPartName);
         QFETCH(QByteArray, expectedPartData);
         QFETCH(QByteArray, expectedFileData);
         QFETCH(qint64, expectedPartSize);
         QFETCH(Part::Storage, storage);
         QFETCH(PimItem, pimItem);
 
         if (storage == Part::External) {
             // Create the payload file now, since don't have means to react
             // directly to the streaming command
             QFile file(ExternalPartStorage::resolveAbsolutePath(expectedPartData));
             file.open(QIODevice::WriteOnly);
             file.write(expectedFileData);
             file.close();
         } else if (storage == Part::Foreign) {
             // Create the foreign payload file
             QDir().mkpath(FakeAkonadiServer::basePath() + QStringLiteral("/tmp"));
             QFile file(QString::fromUtf8(expectedPartData));
             file.open(QIODevice::WriteOnly);
             file.write(expectedFileData);
             file.close();
         }
 
         FakeAkonadiServer::instance()->setScenarios(scenarios);
         FakeAkonadiServer::instance()->runTest();
 
         PimItem item = PimItem::retrieveById(pimItem.id());
         const QVector<Part> parts = item.parts();
         QVERIFY(parts.count() == 1);
         const Part part = parts[0];
         QCOMPARE(part.datasize(), expectedPartSize);
         QCOMPARE(part.storage(), storage);
         const QByteArray data = part.data();
 
         if (storage == Part::External) {
             QCOMPARE(data, expectedPartData);
             QFile file(ExternalPartStorage::resolveAbsolutePath(data));
             QVERIFY(file.exists());
             QCOMPARE(file.size(), expectedPartSize);
             QVERIFY(file.open(QIODevice::ReadOnly));
 
             const QByteArray fileData = file.readAll();
             QCOMPARE(fileData, expectedFileData);
 
             // Make sure no previous versions are left behind in file_db_data
             const int revision = data.mid(data.indexOf("_r") + 2).toInt();
             for (int i = 0; i < revision; ++i) {
                 const QByteArray fileName = QByteArray::number(part.id()) + "_r" + QByteArray::number(i);
                 const QString filePath = ExternalPartStorage::resolveAbsolutePath(fileName);
-                QVERIFY2(!QFile::exists(filePath), qPrintable(filePath));
+                // TRY because the deletion happens in another thread
+                QTRY_VERIFY2(!QFile::exists(filePath), qPrintable(filePath));
             }
         } else if (storage == Part::Foreign) {
             QCOMPARE(data, expectedPartData);
             QFile file(QString::fromUtf8(data));
             QVERIFY(file.exists());
             QCOMPARE(file.size(), expectedPartSize);
             QVERIFY(file.open(QIODevice::ReadOnly));
 
             const QByteArray fileData = file.readAll();
             QCOMPARE(fileData, expectedFileData);
         } else {
             QCOMPARE(data, expectedPartData);
 
             // Make sure nothing is left behind in file_db_data
             // TODO: we have no way of knowing what is the last revision
             for (int i = 0; i <= 100; ++i) {
                 const QByteArray fileName = QByteArray::number(part.id()) + "_r" + QByteArray::number(i);
                 const QString filePath = ExternalPartStorage::resolveAbsolutePath(fileName);
-                QVERIFY2(!QFile::exists(filePath), qPrintable(filePath));
+                QTRY_VERIFY2(!QFile::exists(filePath), qPrintable(filePath));
             }
         }
     }
 
 };
 
 AKTEST_FAKESERVER_MAIN(PartStreamerTest)
 
 #include "partstreamertest.moc"
diff --git a/cmake/modules/AkonadiMacros.cmake b/cmake/modules/AkonadiMacros.cmake
index 524d815ad..e783a15a0 100644
--- a/cmake/modules/AkonadiMacros.cmake
+++ b/cmake/modules/AkonadiMacros.cmake
@@ -1,107 +1,108 @@
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
 # 3. The name of the author may not be used to endorse or promote products 
 #    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 # Internal server macros
 function(akonadi_run_xsltproc)
     if (NOT XSLTPROC_EXECUTABLE)
         message(FATAL_ERROR "xsltproc executable not found but needed by AKONADI_RUN_XSLTPROC()")
     endif()
 
     set(options )
     set(oneValueArgs XSL XML CLASSNAME BASENAME)
-    set(multiValueArgs )
+    set(multiValueArgs DEPENDS)
     cmake_parse_arguments(XSLT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
     if (NOT XSLT_XSL)
         message(FATAL_ERROR "Required argument XSL missing in AKONADI_RUN_XSLTPROC() call")
     endif()
     if (NOT XSLT_XML)
         message(FATAL_ERROR "Required argument XML missing in AKONADI_RUN_XSLTPROC() call")
     endif()
     if (NOT XSLT_BASENAME)
         message(FATAL_ERROR "Required argument BASENAME missing in AKONADI_RUN_XSLTPROC() call")
     endif()
 
     # Workaround xsltproc struggling with spaces in filepaths on Windows
     file(RELATIVE_PATH xsl_relpath ${CMAKE_CURRENT_BINARY_DIR} ${XSLT_XSL})
     file(RELATIVE_PATH xml_relpath ${CMAKE_CURRENT_BINARY_DIR} ${XSLT_XML})
 
     set(extra_params )
     if (XSLT_CLASSNAME)
         set(extra_params --stringparam className ${XSLT_CLASSNAME})
     endif()
 
     add_custom_command(
         OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${XSLT_BASENAME}.h
             ${CMAKE_CURRENT_BINARY_DIR}/${XSLT_BASENAME}.cpp
         COMMAND ${XSLTPROC_EXECUTABLE}
             --output ${XSLT_BASENAME}.h
             --stringparam code header
             --stringparam fileName ${XSLT_BASENAME}
             ${extra_params}
             ${xsl_relpath}
             ${xml_relpath}
         COMMAND ${XSLTPROC_EXECUTABLE}
             --output ${XSLT_BASENAME}.cpp
             --stringparam code source
             --stringparam fileName ${XSLT_BASENAME}
             ${extra_params}
             ${xsl_relpath}
             ${xml_relpath}
         DEPENDS ${XSLT_XSL}
             ${XSLT_XML}
+            ${XSLT_DEPENDS}
     )
 
     set_property(SOURCE
         ${CMAKE_CURRENT_BINARY_DIR}/${XSLT_BASENAME}.cpp
         ${CMAKE_CURRENT_BINARY_DIR}/${XSLT_BASENAME}.h
         PROPERTY SKIP_AUTOMOC TRUE
     )
 endfunction()
 
 macro(akonadi_generate_schema _schemaXml _className _fileBaseName)
     if (NOT XSLTPROC_EXECUTABLE)
         message(FATAL_ERROR "xsltproc executable not found but needed by AKONADI_GENERATE_SCHEMA()")
     endif()
 
     akonadi_run_xsltproc(
         XSL ${Akonadi_SOURCE_DIR}/src/server/storage/schema.xsl
         XML ${_schemaXml}
         CLASSNAME ${_className}
         BASENAME ${_fileBaseName}
     )
 endmacro()
 
 function(akonadi_add_xmllint_test)
     if (NOT XMLLINT_EXECUTABLE)
         message(FATAL_ERROR "xmllint executable not found but needed by AKONADI_ADD_XMLLINT_SCHEMA()")
     endif()
 
     set(options )
     set(oneValueArgs XML XSD)
     set(multiValueArgs )
     cmake_parse_arguments(TEST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     file(RELATIVE_PATH xsd_relpath ${CMAKE_CURRENT_BINARY_DIR} ${TEST_XSD})
     file(RELATIVE_PATH xml_relpath ${CMAKE_CURRENT_BINARY_DIR} ${TEST_XML})
     add_test(${TEST_UNPARSED_ARGUMENTS} ${XMLLINT_EXECUTABLE} --noout --schema ${xsd_relpath} ${xml_relpath})
 endfunction()
diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt
index db636c104..0f035e949 100644
--- a/src/server/CMakeLists.txt
+++ b/src/server/CMakeLists.txt
@@ -1,196 +1,198 @@
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR})
 
 if(MYSQLD_EXECUTABLE)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMYSQLD_EXECUTABLE=\"\\\"${MYSQLD_EXECUTABLE}\\\"\"")
 endif()
 
 if(POSTGRES_PATH)
   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPOSTGRES_PATH=\"\\\"${POSTGRES_PATH}\\\"\"")
 endif()
 
 ########### next target ###############
 set(AKONADI_DB_SCHEMA "${CMAKE_CURRENT_SOURCE_DIR}/storage/akonadidb.xml")
 
 akonadi_run_xsltproc(
     XSL ${CMAKE_CURRENT_SOURCE_DIR}/storage/entities.xsl
     XML ${AKONADI_DB_SCHEMA}
     BASENAME entities
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/storage/entities-source.xsl ${CMAKE_CURRENT_SOURCE_DIR}/storage/entities-header.xsl
 )
 
 akonadi_run_xsltproc(
     XSL ${Akonadi_SOURCE_DIR}/src/server/storage/schema.xsl
     XML ${AKONADI_DB_SCHEMA}
     CLASSNAME AkonadiSchema
     BASENAME akonadischema
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/storage/schema-source.xsl ${CMAKE_CURRENT_SOURCE_DIR}/storage/schema-header.xsl
 )
 
 akonadi_add_xmllint_test(
     akonadidb-xmllint
     XSD ${CMAKE_CURRENT_SOURCE_DIR}/storage/akonadidb.xsd
     XML ${AKONADI_DB_SCHEMA}
 )
 akonadi_add_xmllint_test(
     akonadidbupdate-xmllint
     XSD ${CMAKE_CURRENT_SOURCE_DIR}/storage/akonadidb.xsd
     XML ${AKONADI_DB_SCHEMA}
 )
 
 set(libakonadiserver_SRCS
     akonadi.cpp
     aggregatedfetchscope.cpp
     aklocalserver.cpp
     akthread.cpp
     commandcontext.cpp
     connection.cpp
     collectionscheduler.cpp
     dbusconnectionpool.cpp
     handler.cpp
     handlerhelper.cpp
     intervalcheck.cpp
     collectionreferencemanager.cpp
     handler/collectioncopyhandler.cpp
     handler/collectioncreatehandler.cpp
     handler/collectiondeletehandler.cpp
     handler/collectionfetchhandler.cpp
     handler/collectionmodifyhandler.cpp
     handler/collectionmovehandler.cpp
     handler/collectionstatsfetchhandler.cpp
     handler/itemcopyhandler.cpp
     handler/itemcreatehandler.cpp
     handler/itemdeletehandler.cpp
     handler/itemfetchhandler.cpp
     handler/itemfetchhelper.cpp
     handler/itemlinkhandler.cpp
     handler/itemmodifyhandler.cpp
     handler/itemmovehandler.cpp
     handler/loginhandler.cpp
     handler/logouthandler.cpp
     handler/relationfetchhandler.cpp
     handler/relationmodifyhandler.cpp
     handler/relationremovehandler.cpp
     handler/resourceselecthandler.cpp
     handler/searchhandler.cpp
     handler/searchhelper.cpp
     handler/searchcreatehandler.cpp
     handler/searchresulthandler.cpp
     handler/tagcreatehandler.cpp
     handler/tagdeletehandler.cpp
     handler/tagfetchhandler.cpp
     handler/tagfetchhelper.cpp
     handler/tagmodifyhandler.cpp
     handler/transactionhandler.cpp
     search/agentsearchengine.cpp
     search/agentsearchinstance.cpp
     search/searchtaskmanager.cpp
     search/searchrequest.cpp
     search/searchmanager.cpp
 
     storage/collectionqueryhelper.cpp
     storage/collectionstatistics.cpp
     storage/entity.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/entities.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/akonadischema.cpp
     storage/datastore.cpp
     storage/dbconfig.cpp
     storage/dbconfigmysql.cpp
     storage/dbconfigpostgresql.cpp
     storage/dbconfigsqlite.cpp
     storage/dbexception.cpp
     storage/dbinitializer.cpp
     storage/dbinitializer_p.cpp
     storage/dbintrospector.cpp
     storage/dbintrospector_impl.cpp
     storage/dbupdater.cpp
     storage/dbtype.cpp
     storage/itemqueryhelper.cpp
     storage/itemretriever.cpp
     storage/itemretrievalmanager.cpp
     storage/itemretrievaljob.cpp
     storage/notificationcollector.cpp
     storage/parthelper.cpp
     storage/parttypehelper.cpp
     storage/query.cpp
     storage/querybuilder.cpp
     storage/querycache.cpp
     storage/queryhelper.cpp
     storage/schematypes.cpp
     storage/tagqueryhelper.cpp
     storage/transaction.cpp
     storage/parthelper.cpp
     storage/partstreamer.cpp
     storage/storagedebugger.cpp
     tracer.cpp
     utils.cpp
     dbustracer.cpp
     filetracer.cpp
     notificationmanager.cpp
     notificationsubscriber.cpp
     resourcemanager.cpp
     cachecleaner.cpp
     debuginterface.cpp
     preprocessorinstance.cpp
     preprocessormanager.cpp
     storagejanitor.cpp
 )
 
 set(akonadiserver_SRCS
     main.cpp
 )
 ecm_qt_declare_logging_category(akonadiserver_SRCS HEADER akonadiserver_debug.h IDENTIFIER AKONADISERVER_LOG CATEGORY_NAME org.kde.pim.akonadiserver)
 ecm_qt_declare_logging_category(akonadiserver_SRCS HEADER akonadiserver_search_debug.h IDENTIFIER AKONADISERVER_SEARCH_LOG CATEGORY_NAME org.kde.pim.akonadiserver.search)
 qt5_generate_dbus_interface(debuginterface.h org.freedesktop.Akonadi.DebugInterface.xml)
 
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.TracerNotification.xml dbustracer.h Akonadi::Server::DBusTracer)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Tracer.xml tracer.h Akonadi::Server::Tracer)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Server.xml akonadi.h Akonadi::Server::AkonadiServer)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.StorageDebugger.xml storage/storagedebugger.h Akonadi::Server::StorageDebugger)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Akonadi.DebugInterface.xml debuginterface.h Akonadi::Server::DebugInterface)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.ResourceManager.xml resourcemanager.h Akonadi::Server::ResourceManager)
 qt5_add_dbus_adaptor(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.PreprocessorManager.xml preprocessormanager.h Akonadi::Server::PreprocessorManager)
 qt5_add_dbus_interface(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.AgentManager.xml agentmanagerinterface)
 qt5_add_dbus_interface(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Resource.xml resourceinterface)
 qt5_add_dbus_interface(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Preprocessor.xml preprocessorinterface)
 qt5_add_dbus_interface(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Agent.Control.xml agentcontrolinterface)
 qt5_add_dbus_interface(libakonadiserver_SRCS ${Akonadi_SOURCE_DIR}/src/interfaces/org.freedesktop.Akonadi.Agent.Search.xml agentsearchinterface)
 
 qt5_add_resources(libakonadiserver_SRCS storage/akonadidb.qrc)
 
 add_library(libakonadiserver STATIC ${libakonadiserver_SRCS})
 set_target_properties(libakonadiserver PROPERTIES OUTPUT_NAME akonadiserver)
 target_link_libraries(libakonadiserver
     akonadi_shared
     KF5AkonadiPrivate
     Qt5::Core
     Qt5::Network
     Qt5::Sql
     Qt5::DBus
     Qt5::Xml
 )
 
 add_executable(akonadiserver ${akonadiserver_SRCS})
 set_target_properties(akonadiserver PROPERTIES OUTPUT_NAME akonadiserver)
 target_link_libraries(akonadiserver
     libakonadiserver
     KF5::CoreAddons
 )
 
 install(TARGETS akonadiserver
         ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}
 )
 
 install(FILES
   storage/mysql-global.conf
   storage/mysql-global-mobile.conf
   DESTINATION ${CONFIG_INSTALL_DIR}/akonadi
 )
 
 install(FILES
   search/abstractsearchplugin.h
   DESTINATION ${KF5_INCLUDE_INSTALL_DIR}/akonadi
 )
 
 ## DBus XML files
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Akonadi.DebugInterface.xml
         DESTINATION ${AKONADI_DBUS_INTERFACES_INSTALL_DIR}
 )
diff --git a/src/server/storage/entities-source.xsl b/src/server/storage/entities-source.xsl
index faf078943..05bbf4ceb 100644
--- a/src/server/storage/entities-source.xsl
+++ b/src/server/storage/entities-source.xsl
@@ -1,786 +1,772 @@
 <!--
     Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 -->
 
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                 version="1.0">
 
 <!-- table class source template -->
 <xsl:template name="table-source">
 <xsl:variable name="className"><xsl:value-of select="@name"/></xsl:variable>
 <xsl:variable name="tableName"><xsl:value-of select="@name"/>Table</xsl:variable>
 <xsl:variable name="entityName"><xsl:value-of select="@name"/></xsl:variable>
 
 // private class
 class <xsl:value-of select="$className"/>::Private : public QSharedData
 {
 public:
     Private() : QSharedData()
     <!-- BEGIN Variable Initializers - order as Variable Declarations below -->
     <xsl:for-each select="column[@type = 'qint64' and @name != 'id']">
       , <xsl:value-of select="@name"/>(<xsl:choose><xsl:when test="@default"><xsl:value-of select="@default"/></xsl:when><xsl:otherwise>0</xsl:otherwise></xsl:choose>)
     </xsl:for-each>
     <xsl:if test="column[@type = 'QDateTime']">
     </xsl:if>
     <xsl:for-each select="column[@type = 'QString']">
       , <xsl:value-of select="@name"/>()
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'QByteArray']">
       , <xsl:value-of select="@name"/>()
     </xsl:for-each>
     <xsl:if test="column[@type = 'QDateTime']">
     // on non-wince, QDateTime is one int
     <xsl:for-each select="column[@type = 'QDateTime']">
       , <xsl:value-of select="@name"/>()
     </xsl:for-each>
     </xsl:if>
     <xsl:for-each select="column[@type = 'int']">
       , <xsl:value-of select="@name"/>(<xsl:choose><xsl:when test="@default"><xsl:value-of select="@default"/></xsl:when><xsl:otherwise>0</xsl:otherwise></xsl:choose>)
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'bool']">
       , <xsl:value-of select="@name"/>(<xsl:choose><xsl:when test="@default"><xsl:value-of select="@default"/></xsl:when><xsl:otherwise>false</xsl:otherwise></xsl:choose>)
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'enum']">
       , <xsl:value-of select="@name"/>(<xsl:choose><xsl:when test="@default"><xsl:value-of select="@default"/></xsl:when><xsl:otherwise>0</xsl:otherwise></xsl:choose>)
     </xsl:for-each>
     <xsl:for-each select="column[@name != 'id']">
       , <xsl:value-of select="@name"/>_changed(false)
     </xsl:for-each>
     <!-- END Variable Initializers - order as Variable Declarations below -->
     {}
 
     <!-- BEGIN Variable Declarations - order by decreasing sizeof() -->
     <xsl:for-each select="column[@type = 'qint64' and @name != 'id']">
     qint64 <xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:if test="column[@type = 'QDateTime']">
     </xsl:if>
     <xsl:for-each select="column[@type = 'QString']">
     QString <xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'QByteArray']">
     QByteArray <xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:if test="column[@type = 'QDateTime']">
     // on non-wince, QDateTime is one int
     <xsl:for-each select="column[@type = 'QDateTime']">
     QDateTime <xsl:value-of select="@name"/>;
     </xsl:for-each>
     </xsl:if>
     <xsl:for-each select="column[@type = 'int']">
     int <xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'bool']">
     bool <xsl:value-of select="@name"/> : 1;
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'Tristate']">
     Tristate <xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:for-each select="column[@type = 'enum']">
     <xsl:value-of select="@enumType"/><xsl:text> </xsl:text><xsl:value-of select="@name"/>;
     </xsl:for-each>
     <xsl:for-each select="column[@name != 'id']">
     bool <xsl:value-of select="@name"/>_changed : 1;
     </xsl:for-each>
     <!-- END Variable Declarations - order by decreasing sizeof() -->
 
     static void addToCache(const <xsl:value-of select="$className"/> &amp;entry);
 
     // cache
     static QAtomicInt cacheEnabled;
     static QMutex cacheMutex;
     <xsl:if test="column[@name = 'id']">
     static QHash&lt;qint64, <xsl:value-of select="$className"/>&gt; idCache;
     </xsl:if>
     <xsl:if test="column[@name = 'name']">
     static QHash&lt;<xsl:value-of select="column[@name = 'name']/@type"/>, <xsl:value-of select="$className"/>&gt; nameCache;
     </xsl:if>
 };
 
 
 // static members
 QAtomicInt <xsl:value-of select="$className"/>::Private::cacheEnabled(0);
 QMutex <xsl:value-of select="$className"/>::Private::cacheMutex;
 <xsl:if test="column[@name = 'id']">
 QHash&lt;qint64, <xsl:value-of select="$className"/>&gt; <xsl:value-of select="$className"/>::Private::idCache;
 </xsl:if>
 <xsl:if test="column[@name = 'name']">
 QHash&lt;<xsl:value-of select="column[@name = 'name']/@type"/>, <xsl:value-of select="$className"/>&gt; <xsl:value-of select="$className"/>::Private::nameCache;
 </xsl:if>
 
 
 void <xsl:value-of select="$className"/>::Private::addToCache(const <xsl:value-of select="$className"/> &amp;entry)
 {
     Q_ASSERT(cacheEnabled);
     Q_UNUSED(entry); <!-- in case the table has neither an id nor name column -->
     QMutexLocker lock(&amp;cacheMutex);
     <xsl:if test="column[@name = 'id']">
     idCache.insert(entry.id(), entry);
     </xsl:if>
     <xsl:if test="column[@name = 'name']">
       <xsl:choose>
         <xsl:when test="$className = 'PartType'">
         <!-- special case for PartType, which is identified as "NS:NAME" -->
     nameCache.insert(entry.ns() + QLatin1Char(':') + entry.name(), entry);
         </xsl:when>
         <xsl:otherwise>
     nameCache.insert(entry.name(), entry);
         </xsl:otherwise>
       </xsl:choose>
     </xsl:if>
 }
 
 
 // constructor
 <xsl:value-of select="$className"/>::<xsl:value-of select="$className"/>() : Entity(),
     d(new Private)
 {
 }
 
 <xsl:value-of select="$className"/>::<xsl:value-of select="$className"/>(
   <xsl:for-each select="column[@name != 'id']">
     <xsl:call-template name="argument"/><xsl:if test="position() != last()">, </xsl:if>
   </xsl:for-each>
 ) :
     Entity(),
     d(new Private)
 {
 <xsl:for-each select="column[@name != 'id']">
     d-&gt;<xsl:value-of select="@name"/> = <xsl:value-of select="@name"/>;
     d-&gt;<xsl:value-of select="@name"/>_changed = true;
 </xsl:for-each>
 }
 
 <xsl:if test="column[@name = 'id']">
 <xsl:value-of select="$className"/>::<xsl:value-of select="$className"/>(
   <xsl:for-each select="column">
     <xsl:call-template name="argument"/><xsl:if test="position() != last()">, </xsl:if>
   </xsl:for-each>
 ) :
     Entity(id),
     d(new Private)
 {
 <xsl:for-each select="column[@name != 'id']">
     d-&gt;<xsl:value-of select="@name"/> = <xsl:value-of select="@name"/>;
     d-&gt;<xsl:value-of select="@name"/>_changed = true;
 </xsl:for-each>
 }
 </xsl:if>
 
 <xsl:value-of select="$className"/>::<xsl:value-of select="$className"/>(const <xsl:value-of select="$className"/> &amp;other)
     : Entity(other), d(other.d)
 {
 }
 
 // destructor
 <xsl:value-of select="$className"/>::~<xsl:value-of select="$className"/>() {}
 
 // assignment operator
 <xsl:value-of select="$className"/>&amp; <xsl:value-of select="$className"/>::operator=(const <xsl:value-of select="$className"/> &amp;other)
 {
     if (this != &amp;other) {
         d = other.d;
         setId(other.id());
     }
     return *this;
 }
 
 // comparisson operator
 bool <xsl:value-of select="$className"/>::operator==(const <xsl:value-of select="$className"/> &amp;other) const
 {
     return id() == other.id();
 }
 
 // accessor methods
 <xsl:for-each select="column[@name != 'id']">
 <xsl:call-template name="data-type"/><xsl:text> </xsl:text><xsl:value-of select="$className"/>::<xsl:value-of select="@name"/>() const
 {
     <xsl:text>return d-&gt;</xsl:text><xsl:value-of select="@name"/>;
 }
 
 void <xsl:value-of select="$className"/>::<xsl:call-template name="setter-signature"/>
 {
     d-&gt;<xsl:value-of select="@name"/> = <xsl:value-of select="@name"/>;
     d-&gt;<xsl:value-of select="@name"/>_changed = true;
 }
 
 </xsl:for-each>
 
 // SQL table information
 <xsl:text>QString </xsl:text><xsl:value-of select="$className"/>::tableName()
 {
     static const QString tableName = QStringLiteral("<xsl:value-of select="$tableName"/>");
     return tableName;
 }
 
 QStringList <xsl:value-of select="$className"/>::columnNames()
 {
     static const QStringList columns = {
         <xsl:for-each select="column">
         <xsl:value-of select="@name"/>Column()
         <xsl:if test="position() != last()">,</xsl:if>
         </xsl:for-each>
     };
     return columns;
 }
 
 QStringList <xsl:value-of select="$className"/>::fullColumnNames()
 {
     static const QStringList columns = {
         <xsl:for-each select="column">
         <xsl:value-of select="@name"/>FullColumnName()
         <xsl:if test="position() != last()">,</xsl:if>
         </xsl:for-each>
     };
     return columns;
 }
 
 <xsl:for-each select="column">
 QString <xsl:value-of select="$className"/>::<xsl:value-of select="@name"/>Column()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="@name"/>");
     return column;
 }
 
 QString <xsl:value-of select="$className"/>::<xsl:value-of select="@name"/>FullColumnName()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="$tableName"/>.<xsl:value-of select="@name"/>");
     return column;
 }
 </xsl:for-each>
 
 
 // count records
 int <xsl:value-of select="$className"/>::count(const QString &amp;column, const QVariant &amp;value)
 {
     return Entity::count&lt;<xsl:value-of select="$className"/>&gt;(column, value);
 }
 
 // check existence
 <xsl:if test="column[@name = 'id']">
 bool <xsl:value-of select="$className"/>::exists(qint64 id)
 {
     if (Private::cacheEnabled) {
         QMutexLocker lock(&amp;Private::cacheMutex);
         if (Private::idCache.contains(id)) {
             return true;
         }
     }
     return count(idColumn(), id) > 0;
 }
 </xsl:if>
 <xsl:if test="column[@name = 'name']">
 bool <xsl:value-of select="$className"/>::exists(const <xsl:value-of select="column[@name = 'name']/@type"/> &amp;name)
 {
     if (Private::cacheEnabled) {
         QMutexLocker lock(&amp;Private::cacheMutex);
         if (Private::nameCache.contains(name)) {
             return true;
         }
     }
     return count(nameColumn(), name) > 0;
 }
 </xsl:if>
 
 
 // result extraction
 QVector&lt;<xsl:value-of select="$className"/>&gt; <xsl:value-of select="$className"/>::extractResult(QSqlQuery &amp;query)
 {
     QVector&lt;<xsl:value-of select="$className"/>&gt; rv;
     if (query.driver()->hasFeature(QSqlDriver::QuerySize)) {
         rv.reserve(query.size());
     }
     while (query.next()) {
         rv.append(<xsl:value-of select="$className"/>(
         <xsl:for-each select="column">
               (query.isNull(<xsl:value-of select="position() - 1"/>)
                 ? <xsl:call-template name="data-type"/>()
                 <xsl:text>: </xsl:text>
                 <xsl:choose>
                 <xsl:when test="starts-with(@type,'QString')">
                   <xsl:text>Utils::variantToString(query.value(</xsl:text><xsl:value-of select="position() - 1"/><xsl:text>))</xsl:text>
                 </xsl:when>
                 <xsl:when test="starts-with(@type, 'enum')">
                   <xsl:text>static_cast&lt;</xsl:text><xsl:value-of select="@enumType"/>&gt;(query.value(<xsl:value-of select="position() - 1"/><xsl:text>).value&lt;int&gt;())</xsl:text>
                 </xsl:when>
                 <xsl:otherwise>
                   <xsl:text>query.value(</xsl:text><xsl:value-of select="position() - 1"/>).value&lt;<xsl:value-of select="@type"/>&gt;<xsl:text>()</xsl:text>
                 </xsl:otherwise>
               </xsl:choose>
               <xsl:text>)</xsl:text><xsl:if test="position() != last()"><xsl:text>,</xsl:text></xsl:if>
             </xsl:for-each>
             ));
     }
     query.finish();
     return rv;
 }
 
 // data retrieval
 <xsl:if test="column[@name='id']">
 <xsl:value-of select="$className"/><xsl:text> </xsl:text><xsl:value-of select="$className"/>::retrieveById(qint64 id)
 {
     <xsl:call-template name="data-retrieval">
       <xsl:with-param name="key">id</xsl:with-param>
       <xsl:with-param name="cache">idCache</xsl:with-param>
     </xsl:call-template>
 }
 
 </xsl:if>
 <xsl:if test="column[@name = 'name'] and $className != 'PartType'">
 <xsl:value-of select="$className"/><xsl:text> </xsl:text><xsl:value-of select="$className"/>::retrieveByName(const <xsl:value-of select="column[@name = 'name']/@type"/> &amp;name)
 {
     <xsl:call-template name="data-retrieval">
       <xsl:with-param name="key">name</xsl:with-param>
       <xsl:with-param name="cache">nameCache</xsl:with-param>
     </xsl:call-template>
 }
 
 <xsl:value-of select="$className"/><xsl:text> </xsl:text><xsl:value-of select="$className"/>::retrieveByNameOrCreate(const <xsl:value-of select="column[@name = 'name']/@type"/> &amp;name)
 {
-    static QMutex lock;
-    auto rv = retrieveByName(name);
-    if (rv.isValid()) {
-        return rv;
-    }
+  static QMutex lock;
+  QMutexLocker locker(&amp;lock);
+  auto rv = retrieveByName(name);
+  if (rv.isValid()) {
+    return rv;
+  }
 
-    if (lock.tryLock()) {
-        rv.setName(name);
-        if (!rv.insert()) {
-            lock.unlock();
-            return <xsl:value-of select="$className"/>();
-        }
+  rv.setName(name);
+  if (!rv.insert()) {
+    return <xsl:value-of select="$className"/>();
+  }
 
-        if (Private::cacheEnabled) {
-            Private::addToCache(rv);
-        }
-        lock.unlock();
-        return rv;
-    }
-
-    lock.lock();
-    lock.unlock();
-    return retrieveByName(name);
+  if (Private::cacheEnabled) {
+    Private::addToCache(rv);
+  }
+  return rv;
 }
 </xsl:if>
 
 <xsl:if test="column[@name = 'name'] and $className = 'PartType'">
 <xsl:text>PartType PartType::retrieveByFQName(const QString &amp;ns, const QString &amp;name)</xsl:text>
 {
     const QString fqname = ns + QLatin1Char(':') + name;
     <xsl:call-template name="data-retrieval">
       <xsl:with-param name="key">ns</xsl:with-param>
       <xsl:with-param name="key2">name</xsl:with-param>
       <xsl:with-param name="lookupKey">fqname</xsl:with-param>
       <xsl:with-param name="cache">nameCache</xsl:with-param>
     </xsl:call-template>
 }
 
 <xsl:text>PartType PartType::retrieveByFQNameOrCreate(const QString &amp;ns, const QString &amp;name)</xsl:text>
 {
-    static QMutex lock;
-    PartType rv = retrieveByFQName(ns, name);
-    if (rv.isValid()) {
-        return rv;
-    }
-
-    if (lock.tryLock()) {
-        rv.setNs(ns);
-        rv.setName(name);
-        if (!rv.insert()) {
-            lock.unlock();
-            return PartType();
-        }
-
-        if (Private::cacheEnabled) {
-            Private::addToCache(rv);
-        }
-        lock.unlock();
-        return rv;
-    }
-
-    lock.lock();
-    lock.unlock();
-    return retrieveByFQName(ns, name);
+  static QMutex lock;
+  QMutexLocker locker(&amp;lock);
+  PartType rv = retrieveByFQName(ns, name);
+  if (rv.isValid()) {
+    return rv;
+  }
+
+  rv.setNs(ns);
+  rv.setName(name);
+  if (!rv.insert()) {
+    return PartType();
+  }
+
+  if (Private::cacheEnabled) {
+    Private::addToCache(rv);
+  }
+  return rv;
 }
 </xsl:if>
 
 QVector&lt;<xsl:value-of select="$className"/>&gt; <xsl:value-of select="$className"/>::retrieveAll()
 {
     QSqlDatabase db = DataStore::self()->database();
     if (!db.isOpen()) {
         return {};
     }
 
     QueryBuilder qb(tableName(), QueryBuilder::Select);
     qb.addColumns(columnNames());
     if (!qb.exec()) {
         qCWarning(AKONADISERVER_LOG) &lt;&lt; "Error during selection of all records from table" &lt;&lt; tableName()
                                      &lt;&lt; qb.query().lastError().text() &lt;&lt; qb.query().lastQuery();
         return {};
     }
     return extractResult(qb.query());
 }
 
 QVector&lt;<xsl:value-of select="$className"/>&gt; <xsl:value-of select="$className"/>::retrieveFiltered(const QString &amp;key, const QVariant &amp;value)
 {
     QSqlDatabase db = DataStore::self()->database();
     if (!db.isOpen()) {
         return {};
     }
 
     SelectQueryBuilder&lt;<xsl:value-of select="$className"/>&gt; qb;
     if (value.isNull()) {
         qb.addValueCondition(key, Query::Is, QVariant());
     } else {
         qb.addValueCondition(key, Query::Equals, value);
     }
     if (!qb.exec()) {
         qCWarning(AKONADISERVER_LOG) &lt;&lt; "Error during selection of records from table" &lt;&lt; tableName()
                                      &lt;&lt; "filtered by" &lt;&lt; key &lt;&lt; "=" &lt;&lt; value
                                      &lt;&lt; qb.query().lastError().text();
         return {};
     }
     return qb.result();
 }
 
 // data retrieval for referenced tables
 <xsl:for-each select="column[@refTable != '']">
 <xsl:variable name="method-name"><xsl:call-template name="method-name-n1"/></xsl:variable>
 <xsl:value-of select="@refTable"/><xsl:text> </xsl:text><xsl:value-of select="$className"/>::<xsl:value-of select="$method-name"/>() const
 {
     return <xsl:value-of select="@refTable"/>::retrieveById(<xsl:value-of select="@name"/>());
 }
 
 void <xsl:value-of select="$className"/>::
     set<xsl:call-template name="uppercase-first"><xsl:with-param name="argument"><xsl:value-of select="$method-name"/></xsl:with-param></xsl:call-template>
     (const <xsl:value-of select="@refTable"/> &amp;value)
 {
     d-&gt;<xsl:value-of select="@name"/> = value.id();
     d-&gt;<xsl:value-of select="@name"/>_changed = true;
 }
 </xsl:for-each>
 
 // data retrieval for inverse referenced tables
 <xsl:for-each select="reference">
 QVector&lt;<xsl:value-of select="@table"/>&gt; <xsl:value-of select="$className"/>::<xsl:value-of select="@name"/>() const
 {
     return <xsl:value-of select="@table"/>::retrieveFiltered(<xsl:value-of select="@table"/>::<xsl:value-of select="@key"/>Column(), id());
 }
 </xsl:for-each>
 
 <!-- methods for n:m relations -->
 <xsl:for-each select="../relation[@table1 = $entityName]">
 <xsl:variable name="relationName"><xsl:value-of select="@table1"/><xsl:value-of select="@table2"/>Relation</xsl:variable>
 <xsl:variable name="rightSideClass"><xsl:value-of select="@table2"/></xsl:variable>
 <xsl:variable name="rightSideEntity"><xsl:value-of select="@table2"/></xsl:variable>
 
 // data retrieval for n:m relations
 QVector&lt;<xsl:value-of select="$rightSideClass"/>&gt; <xsl:value-of select="$className"/>::<xsl:value-of select="concat(translate(substring(@table2,1,1),'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'), substring(@table2,2))"/>s() const
 {
     QSqlDatabase db = DataStore::self()->database();
     if (!db.isOpen()) {
         return {};
     }
 
     QueryBuilder qb(<xsl:value-of select="$rightSideClass"/>::tableName(), QueryBuilder::Select);
     static const QStringList columns = {
     <xsl:for-each select="/database/table[@name = $rightSideEntity]/column">
         <xsl:value-of select="$rightSideClass"/>::<xsl:value-of select="@name"/>FullColumnName()
         <xsl:if test="position() != last()">,</xsl:if>
     </xsl:for-each>
     };
     qb.addColumns(columns);
     qb.addJoin(QueryBuilder::InnerJoin, <xsl:value-of select="$relationName"/>::tableName(),
             <xsl:value-of select="$relationName"/>::rightFullColumnName(),
             <xsl:value-of select="$rightSideClass"/>::<xsl:value-of select="@column2"/>FullColumnName());
     qb.addValueCondition(<xsl:value-of select="$relationName"/>::leftFullColumnName(), Query::Equals, id());
 
     if (!qb.exec()) {
         qCWarning(AKONADISERVER_LOG) &lt;&lt; "Error during selection of records from table <xsl:value-of select="@table1"/><xsl:value-of select="@table2"/>Relation"
                                      &lt;&lt; qb.query().lastError().text();
         return {};
     }
 
     return <xsl:value-of select="$rightSideClass"/>::extractResult(qb.query());
 }
 
 // manipulate n:m relations
 bool <xsl:value-of select="$className"/>::relatesTo<xsl:value-of select="@table2"/>(const <xsl:value-of select="$rightSideClass"/> &amp;value) const
 {
     return Entity::relatesTo&lt;<xsl:value-of select="$relationName"/>&gt;(id(), value.id());
 }
 
 bool <xsl:value-of select="$className"/>::relatesTo<xsl:value-of select="@table2"/>(qint64 leftId, qint64 rightId)
 {
     return Entity::relatesTo&lt;<xsl:value-of select="$relationName"/>&gt;(leftId, rightId);
 }
 
 bool <xsl:value-of select="$className"/>::add<xsl:value-of select="@table2"/>(const <xsl:value-of select="$rightSideClass"/> &amp;value) const
 {
     return Entity::addToRelation&lt;<xsl:value-of select="$relationName"/>&gt;(id(), value.id());
 }
 
 bool <xsl:value-of select="$className"/>::add<xsl:value-of select="@table2"/>(qint64 leftId, qint64 rightId)
 {
     return Entity::addToRelation&lt;<xsl:value-of select="$relationName"/>&gt;(leftId, rightId);
 }
 
 bool <xsl:value-of select="$className"/>::remove<xsl:value-of select="@table2"/>(const <xsl:value-of select="$rightSideClass"/> &amp;value) const
 {
     return Entity::removeFromRelation&lt;<xsl:value-of select="$relationName"/>&gt;(id(), value.id());
 }
 
 bool <xsl:value-of select="$className"/>::remove<xsl:value-of select="@table2"/>(qint64 leftId, qint64 rightId)
 {
     return Entity::removeFromRelation&lt;<xsl:value-of select="$relationName"/>&gt;(leftId, rightId);
 }
 
 bool <xsl:value-of select="$className"/>::clear<xsl:value-of select="@table2"/>s() const
 {
     return Entity::clearRelation&lt;<xsl:value-of select="$relationName"/>&gt;(id());
 }
 
 bool <xsl:value-of select="$className"/>::clear<xsl:value-of select="@table2"/>s(qint64 id)
 {
     return Entity::clearRelation&lt;<xsl:value-of select="$relationName"/>&gt;(id);
 }
 
 </xsl:for-each>
 
 #ifndef QT_NO_DEBUG_STREAM
 // debug stream operator
 QDebug &amp;operator&lt;&lt;(QDebug &amp;d, const <xsl:value-of select="$className"/> &amp;entity)
 {
     d &lt;&lt; "[<xsl:value-of select="$className"/>: "
     <xsl:for-each select="column">
         &lt;&lt; "<xsl:value-of select="@name"/> = " &lt;&lt;
         <xsl:choose>
         <xsl:when test="starts-with(@type, 'enum')">
         static_cast&lt;int&gt;(entity.<xsl:value-of select="@name"/>())
         </xsl:when>
         <xsl:otherwise>
         entity.<xsl:value-of select="@name"/>()
         </xsl:otherwise>
       </xsl:choose>
       <xsl:if test="position() != last()">&lt;&lt; ", "</xsl:if>
     </xsl:for-each>
         &lt;&lt; "]";
     return d;
 }
 #endif
 
 // inserting new data
 bool <xsl:value-of select="$className"/>::insert(qint64* insertId)
 {
     QSqlDatabase db = DataStore::self()->database();
     if (!db.isOpen()) {
         return false;
     }
 
     QueryBuilder qb(tableName(), QueryBuilder::Insert);
     <xsl:if test="@identificationColumn">
     qb.setIdentificationColumn(QLatin1String("<xsl:value-of select="@identificationColumn"/>"));
     </xsl:if>
     <xsl:for-each select="column[@name != 'id']">
       <xsl:variable name="refColumn"><xsl:value-of select="@refColumn"/></xsl:variable>
       <xsl:if test="$refColumn = 'id'">
     if (d-&gt;<xsl:value-of select="@name"/>_changed  &amp;&amp; d-&gt;<xsl:value-of select="@name"/> &gt; 0) {
         qb.setColumnValue( <xsl:value-of select="@name"/>Column(), this-&gt;<xsl:value-of select="@name"/>() );
     }
       </xsl:if>
       <xsl:if test="$refColumn != 'id'">
     if (d-&gt;<xsl:value-of select="@name"/>_changed) {
         <xsl:choose>
           <xsl:when test="starts-with(@type, 'enum')">
         qb.setColumnValue(<xsl:value-of select="@name"/>Column(), static_cast&lt;int&gt;(this-&gt;<xsl:value-of select="@name"/>()));
           </xsl:when>
           <xsl:otherwise>
         qb.setColumnValue(<xsl:value-of select="@name"/>Column(), this-&gt;<xsl:value-of select="@name"/>());
           </xsl:otherwise>
         </xsl:choose>
     }
       </xsl:if>
     </xsl:for-each>
 
     if (!qb.exec()) {
         qCWarning(AKONADISERVER_LOG) &lt;&lt; "Error during insertion into table" &lt;&lt; tableName()
                                      &lt;&lt; qb.query().lastError().text();
         return false;
     }
 
     setId(qb.insertId());
     if (insertId) {
         *insertId = id();
     }
     return true;
 }
 
 bool <xsl:value-of select="$className"/>::hasPendingChanges() const
 {
       return false
       <xsl:for-each select="column[@name != 'id']">
         || d-&gt;<xsl:value-of select="@name"/>_changed
       </xsl:for-each>;
 }
 
 // update existing data
 bool <xsl:value-of select="$className"/>::update()
 {
     invalidateCache();
     QSqlDatabase db = DataStore::self()->database();
     if (!db.isOpen()) {
         return false;
     }
 
     QueryBuilder qb(tableName(), QueryBuilder::Update);
 
     <xsl:for-each select="column[@name != 'id']">
     <xsl:variable name="refColumn"><xsl:value-of select="@refColumn"/></xsl:variable>
     if (d-&gt;<xsl:value-of select="@name"/>_changed) {
         <xsl:if test="$refColumn = 'id'">
         if (d-&gt;<xsl:value-of select="@name"/> &lt;= 0) {
             qb.setColumnValue(<xsl:value-of select="@name"/>Column(), QVariant());
         } else {
         </xsl:if>
         <xsl:choose>
             <xsl:when test="starts-with(@type, 'enum')">
             qb.setColumnValue(<xsl:value-of select="@name"/>Column(), static_cast&lt;int&gt;(this-&gt;<xsl:value-of select="@name"/>()));
             </xsl:when>
             <xsl:otherwise>
             qb.setColumnValue(<xsl:value-of select="@name"/>Column(), this-&gt;<xsl:value-of select="@name"/>());
             </xsl:otherwise>
         </xsl:choose>
         <xsl:if test="$refColumn = 'id'">
         }
         </xsl:if>
     }
     </xsl:for-each>
 
     <xsl:if test="column[@name = 'id']">
     qb.addValueCondition(idColumn(), Query::Equals, id());
     </xsl:if>
 
     if (!qb.exec()) {
         qCWarning(AKONADISERVER_LOG) &lt;&lt; "Error during updating record with id" &lt;&lt; id()
                                      &lt;&lt; " in table" &lt;&lt; tableName() &lt;&lt; qb.query().lastError().text();
         return false;
     }
     return true;
 }
 
 // delete records
 bool <xsl:value-of select="$className"/>::remove(const QString &amp;column, const QVariant &amp;value)
 {
     invalidateCompleteCache();
     return Entity::remove&lt;<xsl:value-of select="$className"/>&gt;(column, value);
 }
 
 <xsl:if test="column[@name = 'id']">
 bool <xsl:value-of select="$className"/>::remove()
 {
     invalidateCache();
     return Entity::remove&lt;<xsl:value-of select="$className"/>&gt;(idColumn(), id());
 }
 
 bool <xsl:value-of select="$className"/>::remove(qint64 id)
 {
     return remove(idColumn(), id);
 }
 </xsl:if>
 
 // cache stuff
 void <xsl:value-of select="$className"/>::invalidateCache() const
 {
     if (Private::cacheEnabled) {
         QMutexLocker lock(&amp;Private::cacheMutex);
         <xsl:if test="column[@name = 'id']">
         Private::idCache.remove(id());
         </xsl:if>
         <xsl:if test="column[@name = 'name']">
           <xsl:choose>
             <xsl:when test="$className = 'PartType'">
             <!-- Special handling for PartType, which is identified as "NS:NAME" -->
         Private::nameCache.remove(ns() + QLatin1Char(':') + name());
             </xsl:when>
             <xsl:otherwise>
         Private::nameCache.remove(name());
             </xsl:otherwise>
           </xsl:choose>
         </xsl:if>
     }
 }
 
 void <xsl:value-of select="$className"/>::invalidateCompleteCache()
 {
     if (Private::cacheEnabled) {
         QMutexLocker lock(&amp;Private::cacheMutex);
         <xsl:if test="column[@name = 'id']">
         Private::idCache.clear();
         </xsl:if>
         <xsl:if test="column[@name = 'name']">
         Private::nameCache.clear();
         </xsl:if>
     }
 }
 
 void <xsl:value-of select="$className"/>::enableCache(bool enable)
 {
     Private::cacheEnabled = enable;
 }
 
 </xsl:template>
 
 
 <!-- relation class source template -->
 <xsl:template name="relation-source">
 <xsl:variable name="className"><xsl:value-of select="@table1"/><xsl:value-of select="@table2"/>Relation</xsl:variable>
 <xsl:variable name="tableName"><xsl:value-of select="@table1"/><xsl:value-of select="@table2"/>Relation</xsl:variable>
 
 // SQL table information
 QString <xsl:value-of select="$className"/>::tableName()
 {
     static const QString table = QStringLiteral("<xsl:value-of select="$tableName"/>" );
     return table;
 }
 
 QString <xsl:value-of select="$className"/>::leftColumn()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="@table1"/>_<xsl:value-of select="@column1"/>");
     return column;
 }
 
 QString <xsl:value-of select="$className"/>::leftFullColumnName()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="$tableName"/>.<xsl:value-of select="@table1"/>_<xsl:value-of select="@column1"/>");
     return column;
 }
 
 QString <xsl:value-of select="$className"/>::rightColumn()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="@table2"/>_<xsl:value-of select="@column2"/>");
     return column;
 }
 
 QString <xsl:value-of select="$className"/>::rightFullColumnName()
 {
     static const QString column = QStringLiteral("<xsl:value-of select="$tableName"/>.<xsl:value-of select="@table2"/>_<xsl:value-of select="@column2"/>");
     return column;
 }
 </xsl:template>
 
 </xsl:stylesheet>