diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..894cbff
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+Makefile*
+build*
+*.o
+moc_*.*
+*.moc
+ui_*.*
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..7967b27
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,107 @@
+project(sqlatelib)
+set(SQLATE_LIBRARY_VERSION 0)
+set(SQLATE_LIBRARY_SO_VERSION 1)
+
+cmake_minimum_required(VERSION 2.8)
+set(CMAKE_AUTOMOC true)
+option(SQL_ENABLE_NETWORK_WATCHER "Enable the watcher threads for SQL queries over the network. The default is disabled." FALSE)
+
+if (SQL_ENABLE_NETWORK_WATCHER)
+    add_definitions(-DSQL_ENABLE_NETWORK_WATCHER)
+endif ()
+
+if (ANDROID)
+  find_host_package(Qt4 REQUIRED)
+  include(Android)
+else (ANDROID)
+  find_package(Qt4 REQUIRED)
+endif()
+
+find_package(Boost 1.40 REQUIRED)
+add_definitions( -DBOOST_MPL_LIMIT_VECTOR_SIZE=50 -DBOOST_MPL_CFG_NO_PREPROCESSED_HEADERS )
+add_definitions( -DQT_STRICT_ITERATORS )
+add_definitions( -DQT_NO_CAST_FROM_ASCII )
+add_definitions( -DQT_NO_CAST_TO_ASCII )
+add_definitions( -DQT_NO_CAST_FROM_BYTEARRAY )
+add_definitions( -DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS)
+
+enable_testing()
+
+if(APPLE)
+    set(BIN_INSTALL_DIR ".")
+    # No LIB_INSTALL_DIR on APPLE, we use BundleUtilities instead.
+    # No PLUGIN_INSTALL_DIR on APPLE, we use BundleUtilities instead.
+    # If the install directory is the default then set to a child dir
+    # of the the binary install. Otherwise we assume the user has specified
+    # a CMAKE_INSTALL_PREFIX define
+    # FIXME: there must be a better way of detecting the default vs user set
+    if(CMAKE_INSTALL_PREFIX MATCHES "/usr/local")
+        set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/bin")
+    endif()
+elseif(WIN32)
+    set(BIN_INSTALL_DIR ".")
+    set(LIB_INSTALL_DIR ".")
+    set(PLUGIN_INSTALL_DIR "plugins")
+elseif(NOT ANDROID)
+    set(BIN_INSTALL_DIR "bin")
+    set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)")
+    set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}")
+    set(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/plugins")
+endif()
+
+include_directories( ${CMAKE_SOURCE_DIR}
+    ${CMAKE_BINARY_DIR}
+    ${QT_INCLUDES})
+
+set(SQLATE_SRCS
+    kdthreadrunner.cpp
+    SqlCondition.cpp
+    SqlQuery.cpp
+    SqlQueryBuilderBase.cpp
+    SqlConditionalQueryBuilderBase.cpp
+    SqlDeleteQueryBuilder.cpp
+    SqlSelectQueryBuilder.cpp
+    SqlInsertQueryBuilder.cpp
+    SqlUpdateQueryBuilder.cpp
+    SqlCreateTable.cpp
+    SqlSchema.cpp
+    SqlTransaction.cpp
+    SqlMonitor.cpp
+    SqlQueryManager.cpp
+    SqlQueryWatcher.cpp
+    SqlUtils.cpp
+    PostgresSchema.cpp
+    SchemaUpdater.cpp
+    SqlQueryCache.cpp
+)
+
+qt4_add_resources(sql_resources SqlResources.qrc )
+
+add_library(sqlate SHARED ${SQLATE_SRCS} ${sql_resources})
+
+if (NOT ANDROID)
+set_target_properties(sqlate PROPERTIES
+        VERSION ${SQLATE_LIBRARY_VERSION}
+        SOVERSION ${SQLATE_LIBRARY_SO_VERSION}
+)
+endif()
+
+set_target_properties(sqlate PROPERTIES
+        DEFINE_SYMBOL SQLATE_BUILD_SQLATE_LIB
+)
+
+target_link_libraries(sqlate ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTSQL_LIBRARY})
+
+if(NOT APPLE AND NOT ANDROID)
+    install(TARGETS sqlate RUNTIME DESTINATION ${BIN_INSTALL_DIR} LIBRARY DESTINATION ${LIB_INSTALL_DIR})
+endif()
+
+add_executable(sqlschema2dot sqlschema2dot.cpp)
+target_link_libraries(sqlschema2dot  ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTSQL_LIBRARY} sqlate)
+
+add_custom_target(schema-graph
+    ${CMAKE_CURRENT_BINARY_DIR}/sqlschema2dot > sqlschema.dot &&
+    dot -Tpng sqlschema.dot > sqlschema.png
+)
+
+add_subdirectory(tests)
diff --git a/PostgresSchema.cpp b/PostgresSchema.cpp
new file mode 100644
index 0000000..8f8dac2
--- /dev/null
+++ b/PostgresSchema.cpp
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2012 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+ * Author: Volker Krause <volker.krause@kdab.com>
+ */
+
+#include "PostgresSchema.h"
+
+namespace Sql {
+
+DEFINE_SCHEMA( POSTGRES_SCHEMA )
+
+}
\ No newline at end of file
diff --git a/PostgresSchema.h b/PostgresSchema.h
new file mode 100644
index 0000000..b71e402
--- /dev/null
+++ b/PostgresSchema.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2012 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+ * Author: Volker Krause <volker.krause@kdab.com>
+ */
+
+#ifndef POSTGRESSCHEMA_H
+#define POSTGRESSCHEMA_H
+
+#include "SqlSchema_p.h"
+#include "sqlate_export.h"
+
+#include <QDateTime>
+
+/**
+ * Schema definition for the PostgreSQL system tables to the extend we need to access them
+ * @note Do not use this in combination with the create table query builder!
+ */
+namespace Sql {
+
+TABLE( PgUser, SQLATE_EXPORT ) {
+    SQL_NAME( "pg_user" );
+    COLUMN( usename, QString, Null );
+    COLUMN( usesysid, int, Null );
+    COLUMN( usecreatedb, bool, Null );
+    COLUMN( usesuper, bool, Null );
+    COLUMN( usecatupd, bool, Null );
+    COLUMN( userepl, bool, Null );
+    COLUMN( passwd, QString, Null );
+    COLUMN( valuntil, QDateTime, Null );
+    typedef boost::mpl::vector<usenameType, usesysidType, usecreatedbType, usesuperType, usecatupdType, usereplType, passwdType, valuntilType> columns;
+};
+
+TABLE( PgGroup, SQLATE_EXPORT ) {
+    SQL_NAME( "pg_group" );
+    COLUMN( groname, QString, Null );
+    COLUMN( grosysid, int, Null );
+    typedef boost::mpl::vector<gronameType, grosysidType> columns;
+};
+
+TABLE( PgAuthMembers, SQLATE_EXPORT ) {
+    SQL_NAME( "pg_auth_members" );
+    COLUMN( roleid, int, NotNull );
+    COLUMN( member, int, NotNull );
+    COLUMN( grantor, int, NotNull );
+    COLUMN( admin_option, bool, NotNull );
+    typedef boost::mpl::vector<roleidType, memberType, grantorType, admin_optionType> columns;
+};
+
+#define POSTGRES_SCHEMA (PgUser)(PgGroup)(PgAuthMembers)
+
+DECLARE_SCHEMA( PostgresSchema, POSTGRES_SCHEMA );
+
+}
+
+#endif
\ No newline at end of file
diff --git a/SchemaUpdater.cpp b/SchemaUpdater.cpp
new file mode 100644
index 0000000..a28b45b
--- /dev/null
+++ b/SchemaUpdater.cpp
@@ -0,0 +1,56 @@
+#include "SchemaUpdater.h"
+
+#include "sql.h"
+#include "SqlQuery.h"
+#include "SqlUtils.h"
+
+#include <QDebug>
+
+using namespace Sql;
+
+SchemaUpdaterBase::SchemaUpdaterBase (int targetVersion, const QString & pluginName /* = QString()*/ , QWidget* parentWidget /*= 0*/, QObject *parent /*= 0*/) :
+    QObject( parent ),
+    m_parentWidget(parentWidget),
+    m_currentVersion(-1),
+    m_targetVersion(targetVersion),
+    m_pluginName(pluginName)
+{
+}
+
+QVector<SchemaUpdaterBase::UpdateInfo> SchemaUpdaterBase::pendingUpdates(const QDir & dir) const
+{
+    QVector<UpdateInfo> updates;
+    updates.reserve(m_targetVersion - m_currentVersion);
+
+    for ( int i = m_currentVersion + 1; i <= m_targetVersion; ++i ) {
+        UpdateInfo info;
+        info.version = i;
+        const QString fileName = QString::fromLatin1("%1.sql").arg(i);
+        if (dir.exists(fileName)) {
+            info.updateFile = dir.absoluteFilePath(fileName);
+            updates.push_back(info);
+        }
+    }
+    return updates;
+}
+
+void SchemaUpdaterBase::execUpdate ( const QString& updateFile )
+{
+    QFile file(updateFile);
+    if (file.open(QFile::ReadOnly | QIODevice::Text)) {
+        QTextStream stream(&file);
+        foreach ( QString statement, SqlUtils::splitQueries(stream.readAll()) ) {
+            SqlUtils::stripComments(statement);
+            if (statement.isEmpty())
+                continue;
+
+            SqlQuery query;
+            query.exec(statement);
+        }
+    } else {
+        // coming from a QRC file, always readable...
+        qFatal("unable to open %s", qPrintable(updateFile));
+    }
+}
+
+#include "moc_SchemaUpdater.cpp"
diff --git a/SchemaUpdater.h b/SchemaUpdater.h
new file mode 100644
index 0000000..a05f482
--- /dev/null
+++ b/SchemaUpdater.h
@@ -0,0 +1,298 @@
+#ifndef SCHEMAUPDATER_H
+#define SCHEMAUPDATER_H
+#include "sqlate_export.h"
+
+#include "SqlCreateTable.h"
+#include "SqlUtils.h"
+#include "SqlExceptions.h"
+#include "SqlQueryCache.h"
+#include "SqlUpdateQueryBuilder.h"
+#include "SqlTransaction.h"
+
+#include <QMessageBox>
+#include <QApplication>
+#include <QVector>
+#include <QString>
+#include <QObject>
+#include <QDir>
+
+
+/**
+ * @internal
+ * Methods for performing the database schema upgrade.
+ * Connect the signals defined in here to the log window.
+ *
+ * @note Use SchemaUpdater instead!
+ */
+
+class SQLATE_EXPORT SchemaUpdaterBase : public QObject
+{
+    Q_OBJECT
+public:
+    /**
+     * @param targetVersion The version we want to upgrade to.
+     * @param parentWidget widget used as dialog parent
+     */
+    explicit SchemaUpdaterBase( int targetVersion, const QString & pluginName = QString(), QWidget* parentWidget = 0, QObject *parent = 0 );
+
+    /**
+     * Returns @c true if the schema needs to be updated.
+     * @param the table in which the version of the schema is stored
+     * @note 1 table for the main app, 1 table for each plugin
+     */
+    virtual bool needsUpdate() const = 0;
+
+    /**
+     * Executes all necessary database schema updates.
+     * @param interactive Ask user for confirmation.
+     */
+    virtual void execUpdates(bool interactive) = 0;
+
+
+signals:
+    void infoMessage(const QString &msg) const;
+    void successMessage(const QString &msg) const;
+    void errorMessage(const QString &msg) const;
+
+protected:
+    virtual void createMissingTables() = 0;
+    virtual void createMissingColumns() = 0;
+    virtual void createRulesPermissionsAndTriggers() = 0;
+
+    struct UpdateInfo {
+        int version;
+        QString updateFile;
+    };
+
+    /**
+     * Lists all necessary updates to execute
+     * @param dir: the directory containing the scripts files
+     */
+    QVector<UpdateInfo> pendingUpdates(const QDir & dir) const;
+
+    /**
+     * Executes a single update step.
+     * @throws SqlException on query errors.
+     */
+    void execUpdate(const QString &updateFile);
+
+    QWidget *m_parentWidget;
+    mutable int m_currentVersion;
+    const int m_targetVersion;
+    QString m_pluginName;
+};
+
+
+namespace detail {
+
+/**
+ * Helper class for MPL iteration to create missing columns.
+ * @internal
+ */
+struct missing_column_creator
+{
+    explicit missing_column_creator( const QSqlDatabase &db ) : m_db( db ) {}
+
+    /**
+     * Determines the missing columns and creates them.
+     * @tparam Table The table type.
+     */
+    template <typename Table>
+    void operator() ( const Table &table )
+    {
+        typedef QPair<QString, QVariant::Type> StringTypePair;
+        const QVector<StringTypePair> existingColumns = SqlUtils::columnsOfTable(table, m_db);
+
+        QStringList columnNames;
+        Sql::detail::sql_name_accumulator nameAccu( columnNames );
+        boost::mpl::for_each<typename Table::columns, Sql::detail::wrap<boost::mpl::placeholders::_1> >( nameAccu );
+
+        QStringList columnStatements;
+        Sql::detail::column_creator stmtAccu( columnStatements );
+        boost::mpl::for_each<typename Table::columns, Sql::detail::wrap<boost::mpl::placeholders::_1> >( stmtAccu );
+
+        Q_ASSERT(columnNames.size() == columnStatements.size());
+        for ( QStringList::const_iterator it = columnNames.constBegin(), it2 = columnStatements.constBegin(); it != columnNames.constEnd(); ++it, ++it2 ) {
+            bool found = false;
+            foreach ( const StringTypePair &existinCol, existingColumns ) {
+                if ( existinCol.first.toLower() == (*it).toLower() ) {
+                    found = true;
+                    break;
+                }
+            }
+            if (found)
+                continue;
+
+            QString alterStmt = QLatin1Literal("ALTER TABLE ") % Table::tableName() % QLatin1Literal(" ADD COLUMN ") % *it2;
+            SqlQuery query(m_db);
+            query.exec(alterStmt);
+        }
+    }
+
+    QSqlDatabase m_db;
+};
+
+
+} // detail
+
+
+/**
+ * Database schema updater.
+ * Additionally to SchemaUpdaterBase this also adds missing tables and columns based on the given schema.
+ */
+template <typename Schema, typename tableVersion>
+class SchemaUpdater : public SchemaUpdaterBase
+{
+public:
+    /**
+     * @param targetVersion The version we want to upgrade to.
+     * @param parentWidget widget used as dialog parent
+     */
+    explicit SchemaUpdater( int targetVersion, const QString & pluginName = QString(), QWidget* parentWidget = 0, QObject *parent = 0 ) :
+        SchemaUpdaterBase(targetVersion,pluginName, parentWidget, parent)
+        {}
+
+    /**
+     * Returns @c true if the schema needs to be updated.
+     * @param the table in which the version of the schema is stored
+     * @note 1 table for the main app, 1 table for each plugin
+     */
+    bool needsUpdate() const
+   {
+       tableVersion table;
+       if (m_currentVersion >= 0)
+           return m_currentVersion < m_targetVersion;
+
+       try {
+           SqlQuery q = select( table.version ).from( table );
+           q.exec();
+           if (q.next()) {
+               m_currentVersion = q.value(0).toInt();
+               Q_ASSERT(m_currentVersion >= 0);
+               return m_currentVersion < m_targetVersion;
+           }
+       } catch (const SqlException& e) {
+            emit errorMessage( QObject::tr("<html>There was an error while checking the database version. This is a critical error, the application will terminate.<br/>\
+                                 The error was: <b>%1</b>.</html>").arg(e.error().text()) );
+             QApplication::exit(1);
+             return false;
+       }
+
+       Q_ASSERT(false); // this case is caught way earlier
+       return true;
+   }
+
+    /**
+     * Executes all necessary database schema updates.
+     * @param interactive Ask user for confirmation.
+     */
+    void execUpdates(bool interactive)
+    {
+        SqlQueryCache::setEnabled(false);
+
+        tableVersion table;
+        const QString schemaName = m_pluginName.isNull()?tr("Main application"):m_pluginName;
+        if (!needsUpdate()) {
+            emit successMessage(QObject::tr("schema is up-to-date for %1.").arg(schemaName));
+            return;
+        }
+        emit errorMessage(QObject::tr("schema is outdated for %1.").arg(schemaName));
+
+        if (interactive && QMessageBox::warning( m_parentWidget, QObject::tr("Database Schema Update Required"),
+                QObject::tr("An update to the database schema is required to proceed. Such an update can take considerable time and will require updates to all client installations as well. "
+                            "Also, ensure you have current backups before proceeding."), QMessageBox::Apply | QMessageBox::Abort, QMessageBox::Abort)
+            != QMessageBox::Apply)
+        {
+            QApplication::quit();
+            return;
+        }
+
+        // step 1: auto-create missing tables
+        try {
+            createMissingTables();
+        } catch (const SqlException &e) {
+            emit errorMessage(QObject::tr("Database schema update failed during creation of new tables: %1.").arg(e.error().text()));
+            QApplication::exit(1);
+            return;
+        }
+
+        // step 2 auto-create missing columns, if the previous step succeeded this must not fail due to missing tables
+        try {
+            createMissingColumns();
+        } catch (const SqlException &e) {
+            emit errorMessage(QObject::tr("Database schema update failed during creation of new columns: %1.").arg(e.error().text()));
+            QApplication::exit(1);
+            return;
+        }
+
+        // step 3: run custom update scripts
+        foreach (const UpdateInfo &update, pendingUpdates(QDir(QString::fromLatin1(":/%1schemaUpdates/").arg(m_pluginName)))) {
+            try {
+                emit infoMessage(QObject::tr("Upgrading schema to version %1...").arg(update.version));
+                SqlTransaction t;
+
+                execUpdate(update.updateFile);
+
+                SqlUpdateQueryBuilder qb;
+                qb.setTable(table);
+                qb.addColumnValue(table.version, update.version);
+                qb.exec();
+
+                t.commit();
+                m_currentVersion = update.version;
+                emit successMessage(QObject::tr("Schema successfully upgraded to version %1").arg(update.version));
+            } catch (const SqlException &e) {
+                emit errorMessage(QObject::tr("Schema update failed to version %1. The error was '%2'.").arg(update.version).arg(e.error().text()));
+                QApplication::exit(1);
+                return;
+            }
+        }
+
+        // step 3 create the rules/triggers for tables. Must be done at the end, after the tables are fully updated
+        try {
+            createRulesPermissionsAndTriggers();
+        } catch (const SqlException &e) {
+            emit errorMessage(QObject::tr("Database schema update failed during creation of new columns: %1").arg(e.error().text()));
+            QApplication::exit(1);
+            return;
+        }
+       
+        // step 4: if necessary increase the version number beyond what the custom updates did, in case the latest version
+        // only included automatic changes.
+        if (m_currentVersion < m_targetVersion) {
+            try {
+                SqlUpdateQueryBuilder qb;
+                qb.setTable(table);
+                qb.addColumnValue(table.version, m_targetVersion);
+                qb.exec();
+                m_currentVersion = m_targetVersion;
+            } catch (const SqlException &e) {
+                emit errorMessage(QObject::tr("The database schema version number could not be updated: %1.").arg(e.error().text()));
+                QApplication::exit(1);
+                return;
+            }
+        }
+
+        SqlQueryCache::setEnabled(true);
+    }
+
+protected:
+    void createMissingTables()
+    {
+        Sql::createMissingTables<Schema>(QSqlDatabase::database());
+    }
+
+    void createMissingColumns()
+    {
+        ::detail::missing_column_creator creator(QSqlDatabase::database());
+        boost::mpl::for_each<Schema>( creator );
+    }
+    
+    void createRulesPermissionsAndTriggers()
+    {
+        Sql::createRulesPermissionsAndTriggers<Schema>(QSqlDatabase::database());
+    }
+};
+
+
+#endif // SCHEMAUPDATER_H
diff --git a/Sql.h b/Sql.h
new file mode 100644
index 0000000..f7bde59
--- /dev/null
+++ b/Sql.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQL_H
+#define SQL_H
+
+/**
+ * @file Sql.h
+ * Convenience include for all the SQL template stuff
+ * Preferably include this file instead of any of the other ones directly,
+ * since this one cleans up a bunch of otherwise leaked macros.
+ */
+
+/**
+ * @namespace Sql
+ * Sql access classes and templates, including the database schema definition.
+ */
+
+#include "SqlSchema.h"
+#include "SqlCreateTable.h"
+#include "SqlSelect.h"
+
+// macro cleanup
+#undef SQL_NAME
+#undef COLUMN
+#undef COLUMN_ALIAS
+#undef FOREIGN_KEY
+#undef TABLE
+#undef LOOKUP_TABLE
+#undef RELATION
+#undef RECURSIVE_RELATION
+#undef DECLARE_SCHEMA
+#undef DEFINE_SCHEMA
+#undef DECLARE_SCHEMA_MAKE_TYPE
+#undef DEFINE_SCHEMA_MAKE_DEF
+
+#endif
diff --git a/SqlCondition.cpp b/SqlCondition.cpp
new file mode 100644
index 0000000..814aacc
--- /dev/null
+++ b/SqlCondition.cpp
@@ -0,0 +1,92 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlCondition.h"
+
+SqlCondition::SqlCondition(SqlCondition::LogicOperator op) :
+  m_compareOp( Equals ),
+  m_logicOp( op ),
+  m_isCaseSensitive( true )
+{
+}
+
+void SqlCondition::addValueCondition(const QString& column, SqlCondition::CompareOperator op, const QVariant& value)
+{
+    Q_ASSERT( !column.isEmpty() );
+    SqlCondition c;
+    c.m_compareOp = op;
+    if ( (!m_isCaseSensitive) && value.type() == QVariant::String )
+    {
+        c.m_comparedValue = value.toString().toLower();
+        c.m_column = QString::fromLatin1( "LOWER( %1 ) " ).arg( column );
+    }
+    else
+    {
+        c.m_comparedValue = value;
+        c.m_column = column;
+    }
+    m_subConditions.push_back( c );
+}
+
+void SqlCondition::addPlaceholderCondition(const QString& column, SqlCondition::CompareOperator op, const QString& placeholder)
+{
+    Q_ASSERT( !column.isEmpty() );
+    Q_ASSERT( placeholder.size() >= 2 );
+    Q_ASSERT( placeholder.startsWith( QLatin1Char( ':' ) ) );
+    Q_ASSERT( !placeholder.at( 1 ).isDigit() );
+    SqlCondition c;
+    c.m_compareOp = op;
+    if ( m_isCaseSensitive )
+    {
+        c.m_placeholder = placeholder;
+        c.m_column = column;
+    }
+    else
+    {
+        c.m_placeholder = placeholder.toLower();
+        c.m_column = QString::fromLatin1( "LOWER( %1 ) " ).arg( column );
+    }
+    m_subConditions.push_back( c );
+}
+
+void SqlCondition::addColumnCondition(const QString& column, SqlCondition::CompareOperator op, const QString& column2)
+{
+  Q_ASSERT( !column.isEmpty() );
+  Q_ASSERT( !column2.isEmpty() );
+  SqlCondition c;
+  c.m_column = column;
+  c.m_comparedColumn = column2;
+  c.m_compareOp = op;
+  m_subConditions.push_back( c );
+}
+
+void SqlCondition::addCondition(const SqlCondition& condition)
+{
+    m_subConditions.push_back( condition );
+}
+
+void SqlCondition::setLogicOperator(SqlCondition::LogicOperator op)
+{
+    m_logicOp = op;
+}
+
+QVector< SqlCondition > SqlCondition::subConditions() const
+{
+    return m_subConditions;
+}
+
+bool SqlCondition::hasSubConditions() const
+{
+    return !m_subConditions.isEmpty();
+}
+
+void SqlCondition::setCaseSensitive( const bool isCaseSensitive )
+{
+    m_isCaseSensitive = isCaseSensitive;
+}
+
+bool SqlCondition::isCaseSensitive() const
+{
+    return m_isCaseSensitive;
+}
diff --git a/SqlCondition.h b/SqlCondition.h
new file mode 100644
index 0000000..a07c23c
--- /dev/null
+++ b/SqlCondition.h
@@ -0,0 +1,159 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+
+#ifndef SQLCONDITION_H
+#define SQLCONDITION_H
+
+#include "sqlate_export.h"
+#include "SqlInternals_p.h"
+
+#include <QString>
+#include <QVariant>
+#include <QVector>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+/** SQL NULL type, to allow using NULL in template code, rather than falling back to QVariant(). */
+struct SqlNullType {};
+static const SqlNullType SqlNull = {}; // "Null" is already in use, also in the Sql namespace, so we have to settle for this
+
+/** SQL now type, to allow using server-side current date/time in template code, rahter than hardcoded SQL strings or client-side time. */
+struct SqlNowType {};
+static const SqlNowType SqlNow = {};
+Q_DECLARE_METATYPE(SqlNowType)
+
+/** Dummy type for compile time warnings about usage of client side time. */
+struct UsageOfClientSideTime {};
+
+
+/** Represents a part of a SQL WHERE expression. */
+class SQLATE_EXPORT SqlCondition
+{
+public:
+    /** Compare operators to be used in query conditions. */
+    enum CompareOperator {
+        Equals,
+        NotEquals,
+        Is,
+        IsNot,
+        Less,
+        LessOrEqual,
+        Greater,
+        GreaterOrEqual,
+        Like
+    };
+
+    /** Logic operation to combine multiple conditions. */
+    enum LogicOperator {
+        And,
+        Or
+    };
+
+    /** Create an empty condition, with sub-queries combined using @p op. */
+    explicit SqlCondition( LogicOperator op = And );
+
+    /**
+      Add a condition which compares a column with a given fixed value.
+      @param column The column that should be compared.
+      @param op The operator used for comparison
+      @param value The value @p column is compared to.
+    */
+    void addValueCondition( const QString &column, CompareOperator op, const QVariant &value );
+    template <typename Column>
+    inline void addValueCondition( const Column &column, CompareOperator op, const typename Column::type &value )
+    {
+        Sql::warning<boost::is_same<typename Column::type, QDateTime>, UsageOfClientSideTime>::print();
+        addValueCondition( column.name(), op, QVariant::fromValue<typename Column::type>(value));
+    }
+    template <typename Column>
+    inline void addValueCondition( const Column &column, CompareOperator op, SqlNullType )
+    {
+        // asserting on Column::notNull is too strict, this can be used in combination with outer joins!
+        //BOOST_MPL_ASSERT(( boost::mpl::not_<typename Column::notNull> ));
+        // TODO idealy we would also static assert on op == Is[Not]
+        addValueCondition( column.name(), op, QVariant() );
+    }
+    template <typename Column>
+    inline void addValueCondition( const Column &column, CompareOperator op, SqlNowType now )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<typename Column::type, QDateTime> ));
+        // TODO this could also be restricted to less/greater than operations
+        addValueCondition( column.name(), op, QVariant::fromValue(now) );
+    }
+
+    /**
+     * Same as addValueCondition, but for defered value binding.
+     * @param column The column that should be compared.
+     * @param op The operator used for comparison.
+     * @param placeholder A placeholder (with leading ':'), not starting with a number.
+     */
+    void addPlaceholderCondition( const QString &column, CompareOperator op, const QString &placeholder );
+    template <typename Column>
+    inline void addPlaceholderCondition( const Column &column, CompareOperator op, const QString &placeholder )
+    {
+        addPlaceholderCondition( column.name(), op, placeholder );
+    }
+
+    /**
+      Add a condition which compares a column with another column.
+      @param column The column that should be compared.
+      @param op The operator used for comparison.
+      @param column2 The column @p column is compared to.
+    */
+    void addColumnCondition( const QString &column, CompareOperator op, const QString &column2 );
+    template <typename Column1, typename Column2>
+    inline void addColumnCondition( const Column1 &column1, CompareOperator op, const Column2 &column2 )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<typename Column1::type, typename Column2::type> ));
+        addColumnCondition(column1.name(), op, column2.name());
+    }
+
+    /**
+      Set the case sensitive flag. This is defaulted to true and must be set before calling @func addCondition() or @func addPlaceholderCondition().
+      @param isCasesensitive the operands are converted to the same case before comparison
+    */
+    void setCaseSensitive( const bool isCaseSensitive );
+    /**
+      returns the value of the case sensitive flag.
+    */
+    bool isCaseSensitive() const;
+
+    /**
+      Add a nested condition.
+    */
+    void addCondition( const SqlCondition &condition );
+
+    /**
+      Set how sub-conditions should be combined, default is And.
+    */
+    void setLogicOperator( LogicOperator op );
+
+    /**
+     * For nested conditions, this returns the list of sub-conditions.
+     */
+    QVector<SqlCondition> subConditions() const;
+
+    /**
+     * Checks if this condition has sub-conditions.
+     */
+    bool hasSubConditions() const;
+
+private:
+    friend class SqlConditionalQueryBuilderBase;
+    QVector<SqlCondition> m_subConditions;
+    QString m_column;
+    QString m_comparedColumn;
+    QString m_placeholder;
+    QVariant m_comparedValue;
+    CompareOperator m_compareOp;
+    LogicOperator m_logicOp;
+    bool m_isCaseSensitive;
+};
+
+Q_DECLARE_TYPEINFO( SqlCondition, Q_MOVABLE_TYPE );
+
+#endif
diff --git a/SqlConditionalQueryBuilderBase.cpp b/SqlConditionalQueryBuilderBase.cpp
new file mode 100644
index 0000000..30df21d
--- /dev/null
+++ b/SqlConditionalQueryBuilderBase.cpp
@@ -0,0 +1,85 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlConditionalQueryBuilderBase.h"
+
+#include "SqlExceptions.h"
+
+#include <QStringList>
+
+SqlConditionalQueryBuilderBase::SqlConditionalQueryBuilderBase(const QSqlDatabase& db) :
+    SqlQueryBuilderBase( db ),
+    m_bindedValuesOffset(0)
+{
+}
+
+SqlCondition& SqlConditionalQueryBuilderBase::whereCondition()
+{
+    return m_whereCondition;
+}
+
+QString SqlConditionalQueryBuilderBase::registerBindValue(const QVariant& value)
+{
+    m_bindValues.push_back( value );
+    return QLatin1Char( ':' ) + QString::number( m_bindedValuesOffset + m_bindValues.size() - 1 );
+
+}
+
+static QString logicOperatorToString( SqlCondition::LogicOperator op )
+{
+    switch ( op ) {
+        case SqlCondition::And: return QLatin1String( " AND " );
+        case SqlCondition::Or:  return QLatin1String( " OR " );
+    }
+    qFatal( "Unknown logic operator" );
+    return QString();
+}
+
+static QString compareOperatorToString( SqlCondition::CompareOperator op )
+{
+    switch ( op ) {
+        case SqlCondition::Equals: return QLatin1String( " = " );
+        case SqlCondition::NotEquals: return QLatin1String( " <> " );
+        case SqlCondition::Is: return QLatin1String( " IS " );
+        case SqlCondition::IsNot: return QLatin1String( " IS NOT " );
+        case SqlCondition::Less: return QLatin1String( " < " );
+        case SqlCondition::LessOrEqual: return QLatin1String( " <= " );
+        case SqlCondition::Greater: return QLatin1String( " > " );
+        case SqlCondition::GreaterOrEqual: return QLatin1String( " >= " );
+        case SqlCondition::Like: return QLatin1String( " LIKE " );
+    }
+    qFatal( "Unknown compare operator." );
+    return QString();
+}
+
+QString SqlConditionalQueryBuilderBase::conditionToString(const SqlCondition& condition)
+{
+  if ( condition.hasSubConditions() ) {
+    QStringList conds;
+    foreach ( const SqlCondition &c, condition.subConditions() )
+      conds << conditionToString( c );
+    if ( conds.size() == 1 )
+        return conds.first();
+    return QLatin1Char( '(' ) + conds.join( logicOperatorToString( condition.m_logicOp ) ) + QLatin1Char( ')' );
+  } else {
+    QString stmt = condition.m_column;
+    stmt += compareOperatorToString( condition.m_compareOp );
+    if ( condition.m_comparedColumn.isEmpty() ) {
+      if ( condition.m_comparedValue.isValid() ) {
+          if ( condition.m_comparedValue.userType() == qMetaTypeId<SqlNowType>() )
+              stmt += currentDateTime();
+          else
+              stmt += registerBindValue( condition.m_comparedValue );
+      } else if ( !condition.m_placeholder.isEmpty() ) {
+          stmt += condition.m_placeholder;
+      } else {
+        stmt += QLatin1String( "NULL" );
+      }
+    } else {
+      stmt += condition.m_comparedColumn;
+    }
+    return stmt;
+  }
+}
+
diff --git a/SqlConditionalQueryBuilderBase.h b/SqlConditionalQueryBuilderBase.h
new file mode 100644
index 0000000..a6e32b1
--- /dev/null
+++ b/SqlConditionalQueryBuilderBase.h
@@ -0,0 +1,41 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+
+#ifndef SQLCONDITIONALQUERYBUILDERBASE_H
+#define SQLCONDITIONALQUERYBUILDERBASE_H
+
+#include "SqlQueryBuilderBase.h"
+
+#include "SqlCondition.h"
+#include "sqlate_export.h"
+
+/** Base class for query builders operating having a WHERE condition.
+ */
+class SQLATE_EXPORT SqlConditionalQueryBuilderBase : public SqlQueryBuilderBase
+{
+public:
+    /// Create a new query builder for the given database
+    explicit SqlConditionalQueryBuilderBase( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /// access to the top-level WHERE condition
+    SqlCondition& whereCondition();
+
+protected:
+    /** Register a bound value, to be replaced after query preparation
+     *  @param value The value to bind
+     *  @return A unique placeholder to use in the query.
+     */
+    QString registerBindValue( const QVariant &value );
+
+    QString conditionToString( const SqlCondition &condition );
+
+protected:
+    SqlCondition m_whereCondition;
+    QVector<QVariant> m_bindValues;
+    int m_bindedValuesOffset; //holds the parameters offset
+
+};
+
+#endif
diff --git a/SqlCreateRule.h b/SqlCreateRule.h
new file mode 100644
index 0000000..2834b48
--- /dev/null
+++ b/SqlCreateRule.h
@@ -0,0 +1,128 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Benoit Dumas <benoit.dumas@com>
+*/
+#ifndef SQLCREATERULE_H
+#define SQLCREATERULE_H
+
+#include "SqlInternals_p.h"
+#include "SqlSchema_p.h"
+#include "SqlQuery.h"
+#include "SqlUtils.h"
+
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#include <QStringList>
+
+/**
+ * @file SqlCreateRule.h
+ * Classes and functions to create tables rules based on the schema definition in SqlSchema.h
+ */
+
+namespace Sql {
+
+namespace detail {
+
+/**
+ * Table-wise notification rule creator.
+ * @internal
+ */
+struct notification_rule_creator {
+    notification_rule_creator( QStringList &stmts ) : m_stmts( stmts ) {}
+    template <typename T>
+    void operator()( wrap<T> ) {
+        if ( T::is_lookup_table::value || T::is_relation::value )
+            return;
+        const QStringList ops = QStringList() << QLatin1String( "Insert" ) << QLatin1String( "Update" ) << QLatin1String( "Delete" );
+        foreach ( const QString& op, ops ) {
+            const QString stmt = QLatin1Literal( "CREATE OR REPLACE RULE " )
+                            % T::tableName()
+                            % QLatin1Literal( "Notification" ) % op % QLatin1Literal( "Rule AS ON " )
+                            % op.toUpper() % QLatin1Literal( " TO " )
+                            % T::tableName()
+                            % QLatin1Literal( " DO ALSO NOTIFY " )
+                            % T::tableName()
+                            % QLatin1Literal( "Changed" );
+            m_stmts.push_back( stmt );
+        }
+    }
+    QStringList &m_stmts;
+};
+
+/**
+ * Column-wise notification rule creator.
+ * @internal
+ */
+struct column_notification_rule_creator {
+    column_notification_rule_creator( QStringList &stmts ) : m_stmts( stmts ) {}
+    template <typename T>
+    void operator()( wrap<T> ) {
+        if( T::notify::value ) //notify with the corresponding column content ( as the notify channel) when a row is modified
+        {
+            //be sure to have unique rule name and stay within the allowed name size. We don't care that it's cryptic as it isn't used anywhere. so use Uuids.
+            QString ruleID = QUuid::createUuid().toString();
+            ruleID.replace(QLatin1Char('{'), QLatin1Char('\"'));
+            ruleID.replace(QLatin1Char('}'), QLatin1Char('\"'));
+
+            const QString identifier = SqlUtils::createIdentifier(T::table::sqlName() % QLatin1Literal( "_" ) % T::sqlName());
+            const QString stmt = QLatin1Literal( "CREATE OR REPLACE RULE " )
+                    % ruleID % QLatin1Literal( " AS ON UPDATE TO " )
+                    % T::table::sqlName()
+                    % QLatin1Literal( " DO ALSO SELECT pg_notify(CAST (OLD." ) %  T::sqlName()
+                    % QLatin1Literal( " AS text) || '_") % identifier % QLatin1Literal( "','')");
+            m_stmts.push_back( stmt );
+        }
+    }
+    QStringList &m_stmts;
+};
+
+/**
+ * Table-wise notification rule creator (create statements for each Notify-enabled column in all tables).
+ * @internal
+ */
+struct table_notification_rule_creator {
+    table_notification_rule_creator( QStringList &stmts ) : m_stmts( stmts ) {}
+    template <typename T>
+    void operator()( wrap<T> ) {
+        boost::mpl::for_each<typename T::columns, detail::wrap<boost::mpl::placeholders::_1> >( column_notification_rule_creator( m_stmts ) );
+    }
+    QStringList &m_stmts;
+};
+
+}
+
+/**
+ * Returns a list of CREATE RULE statements to create notification rules for all mutable tables.
+ * @tparam Schema A MPL sequence of tables.
+ * @returns A list of SQL statements to create notification rules for all mutable tables.
+ */
+template<typename Schema>
+QStringList createNotificationRuleStatements()
+{
+    QStringList statements;
+    boost::mpl::for_each<Schema, detail::wrap<boost::mpl::placeholders::_1> >( detail::notification_rule_creator( statements ) );
+    boost::mpl::for_each<Schema, detail::wrap<boost::mpl::placeholders::_1> >( detail::table_notification_rule_creator( statements ) );
+
+    return statements;
+}
+
+/**
+ * Create all table change notification rules.
+ * @tparam Schema A MPL sequence of tables.
+ * @param db The database to create the tables in
+ * @throws SqlException in case of a database error
+ */
+template <typename Schema>
+void createNotificationRules( const QSqlDatabase &db )
+{
+    foreach ( const QString &stmt, Sql::createNotificationRuleStatements<Schema>() ) {
+        SqlQuery q( db );
+        q.exec( stmt );
+    }
+}
+
+}
+
+#endif
diff --git a/SqlCreateTable.cpp b/SqlCreateTable.cpp
new file mode 100644
index 0000000..71b3eb4
--- /dev/null
+++ b/SqlCreateTable.cpp
@@ -0,0 +1,70 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#include "SqlCreateTable.h"
+
+namespace Sql {
+namespace detail {
+
+QString sqlType( wrap<QString>, int size )
+{
+    if ( size > 0 )
+        return QLatin1Literal( "VARCHAR(" ) % QString::number( size ) % QLatin1Literal( ")" );
+    return QLatin1String( "TEXT" );
+}
+
+QString sqlType( wrap<bool>, int size )
+{
+    Q_ASSERT( size == -1 );
+    return QLatin1String( "BOOLEAN" );
+}
+
+QString sqlType( wrap<QUuid>, int size )
+{
+    Q_ASSERT( size == -1 );
+    return QLatin1String( "UUID" );
+}
+
+QString sqlType( wrap<int>, int size )
+{
+    Q_UNUSED( size );
+    /// \todo in theory there are different sized integer types
+    return QLatin1String( "INTEGER" );
+}
+
+QString sqlType( wrap<QDateTime>, int size )
+{
+    Q_ASSERT( size == -1 );
+    return QLatin1String( "TIMESTAMP WITH TIME ZONE" );
+}
+
+QString sqlType( wrap<QTime>, int size )
+{
+    Q_ASSERT( size == -1 );
+    return QLatin1String( "TIME" );
+}
+
+QString sqlType( wrap<QDate>, int size ) {
+    Q_ASSERT( size == -1 );
+    return QLatin1String( "DATE" );
+}
+
+QString sqlType( wrap<QByteArray>, int size )
+{
+    Q_UNUSED( size );
+    // ???
+    return QLatin1String( "BYTEA" );
+}
+
+QString sqlType(Sql::detail::wrap< float > , int size)
+{
+    Q_UNUSED(size);
+    return QLatin1String("REAL");
+}
+
+
+} // namespace detail
+
+} // namespace Sql
diff --git a/SqlCreateTable.h b/SqlCreateTable.h
new file mode 100644
index 0000000..c8f35c9
--- /dev/null
+++ b/SqlCreateTable.h
@@ -0,0 +1,383 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQL_CREATETABLE_H
+#define SQL_CREATETABLE_H
+
+#include "sqlate_export.h"
+#include "SqlInternals_p.h"
+#include "SqlSchema_p.h"
+#include "SqlQuery.h"
+#include "SqlInsertQueryBuilder.h"
+#include "SqlGrantPermission.h"
+#include "SqlCreateRule.h"
+
+#include <QDateTime>
+#include <QTime>
+#include <QStringBuilder>
+#include <QStringList>
+#include <QUuid>
+#include <QVariant>
+#include <QSqlDatabase>
+
+#include <boost/bind.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#include <algorithm>
+
+/**
+ * @file SqlCreateTable.h
+ * Classes and functions to create tables based on the schema definition in SqlSchema.h
+ */
+
+namespace Sql {
+
+template<typename T> QString createTableStatement();
+template<typename T> QStringList createTableTriggerStatements();
+
+namespace detail {
+
+/** Type to string conversion. */
+SQLATE_EXPORT QString sqlType( wrap<QString>, int size );
+SQLATE_EXPORT QString sqlType( wrap<bool>, int size );
+SQLATE_EXPORT QString sqlType( wrap<QUuid>, int size );
+SQLATE_EXPORT QString sqlType( wrap<int>, int size );
+SQLATE_EXPORT QString sqlType( wrap<QDateTime>, int size );
+SQLATE_EXPORT QString sqlType( wrap<QTime>, int size );
+SQLATE_EXPORT QString sqlType( wrap<QDate>, int size );
+SQLATE_EXPORT QString sqlType( wrap<QByteArray>, int size );
+SQLATE_EXPORT QString sqlType( wrap<float>, int size );
+
+/**
+ * Helper class to build a list of SQL names from tables or columns.
+ * @internal
+ */
+struct sql_name_accumulator
+{
+    explicit sql_name_accumulator( QStringList &nameList ) : m_names( nameList ) {};
+    template <typename T> void operator() ( wrap<T> )
+    {
+        m_names.push_back( T::sqlName() );
+    }
+    QStringList &m_names;
+};
+
+/**
+ * Helper class to create a single column statement in a create table command.
+ * @internal
+ */
+struct column_creator
+{
+    explicit column_creator( QStringList &c ) : cols( c ) {}
+
+    /**
+     * Creates the column statement.
+     * @tparam C The column type
+     */
+    template<typename C> void operator()( wrap<C> )
+    {
+        QString colStmt = C::sqlName() % QLatin1Char( ' ' ) % sqlType( detail::wrap<typename C::type>(), C::size );
+        if ( C::primaryKey::value ) {
+            colStmt += QLatin1String( " PRIMARY KEY" );
+        } else {
+            if ( C::unique::value )
+                colStmt += QLatin1String( " UNIQUE" );
+            if ( C::notNull::value )
+                colStmt += QLatin1String( " NOT NULL" );
+        }
+        if ( C::useDefault::value ) {
+            // FIXME: this is a huge over-simplification
+            // stringification of values depends on the type (e.g. quoting for strings)
+            // also, we probably want defaults different than the values created by the default ctor
+            const QVariant v = QVariant::fromValue<typename C::type>( typename C::type() );
+            colStmt += QLatin1Literal( " DEFAULT " ) % v.toString();
+        }
+        colStmt += referenceStatement<C>( typename C::hasForeignKey() );
+        cols.push_back( colStmt );
+    }
+
+    /**
+     * Creates foreign key reference statement.
+     * @tparam C The column type.
+     */
+    template<typename C> QString referenceStatement( boost::mpl::false_ ) { return QString(); }
+    template<typename C> QString referenceStatement( boost::mpl::true_ )
+    {
+        QString refStmt = QLatin1Literal( " REFERENCES " )
+            % C::referenced_column::table::tableName()
+            % QLatin1Literal( " (" )
+            % C::referenced_column::sqlName()
+            % QLatin1Char( ')' );
+        BOOST_MPL_ASSERT(( boost::mpl::not_<boost::mpl::and_<typename C::onDeleteCascade, typename C::onDeleteRestrict> > ));
+        if ( C::onDeleteCascade::value )
+            refStmt += QLatin1String(" ON DELETE CASCADE");
+        else if ( C::onDeleteRestrict::value )
+            refStmt += QLatin1String(" ON DELETE RESTRICT");
+        return refStmt;
+    }
+
+    QStringList &cols;
+};
+
+/**
+ * Helper class to create table constraint statements.
+ * @internal
+ */
+struct table_constraint_creator
+{
+    explicit table_constraint_creator( QStringList &statements ) : m_statements( statements ) {};
+
+    /** Create multi-column uniqueness constraints.
+     * @tparam T MPL sequence of unique columns.
+     * @todo Optional safety check: Check if all those columns are in the same table
+     */
+    template <typename T>
+    void operator() ( UniqueConstraint<T> )
+    {
+        QStringList cols;
+        sql_name_accumulator accu( cols );
+        boost::mpl::for_each<T, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+        m_statements.push_back( QLatin1Literal( "UNIQUE( " ) % cols.join( QLatin1String( ", " ) ) % QLatin1Literal( " )" ) );
+    }
+
+    QStringList &m_statements;
+};
+
+/**
+ * Helper class to create per column trigger statements, to disallow UPDATE on a column
+ * @internal
+ */
+struct column_trigger_creator
+{
+    explicit column_trigger_creator( QStringList &t ) : triggers( t ) {}
+
+    /**
+     * Creates the triggers for columns
+     * @tparam C The column type
+     */
+    template<typename C> void operator()( wrap<C> )
+    {
+
+        C::sqlName() % QLatin1Char( ' ' ) % sqlType( detail::wrap<typename C::type>(), C::size );
+        if ( C::onUserUpdateRestrict::value || C::primaryKey::value ) {
+            QString triggerName = C::name();
+            triggerName.replace( QLatin1Char('.'), QLatin1Char('_') );
+            QString stmt = QLatin1Literal("DROP TRIGGER IF EXISTS no_column_update_") % triggerName %
+                           QLatin1Literal(" on ") % C::table::sqlName();
+            triggers.push_back( stmt );            
+            stmt = QLatin1Literal("CREATE TRIGGER no_column_update_") % triggerName %
+                              QLatin1Literal(" BEFORE UPDATE on ") % C::table::sqlName() %
+                              QLatin1Literal(" FOR EACH ROW WHEN (OLD.") % C::sqlName() %
+                              QLatin1Literal(" IS DISTINCT FROM NEW.") % C::sqlName() %
+                              QLatin1Literal(" ) EXECUTE PROCEDURE is_administrator()");
+            triggers.push_back( stmt );
+        }
+    }
+
+    QStringList &triggers;
+};
+
+
+/**
+ * Helper class to create table creation statements.
+ * @internal
+ */
+struct table_creator
+{
+    explicit table_creator( QStringList & statements ) : m_statements( statements ) {};
+
+    /**
+     * Create the table creation statement for table @p T.
+     * @tparam T The table type.
+     */
+    template <typename T>
+    void operator() ( wrap<T> )
+    {
+        m_statements.push_back( Sql::createTableStatement<T>() );
+    }
+
+    QStringList &m_statements;
+};
+
+/**
+ * Helper class to create table trigger statements.
+ * @internal
+ */
+struct table_trigger_creator
+{
+    explicit table_trigger_creator( QStringList & statements ) : m_statements( statements ) {};
+
+    /**
+     * Create the table creation statement for table @p T.
+     * @tparam T The table type.
+     */
+    template <typename T>
+    void operator() ( wrap<T> )
+    {
+        m_statements.append( Sql::createTableTriggerStatements<T>() );
+    }
+
+    QStringList &m_statements;
+};
+} // detail
+
+
+/**
+ * Returns the CREATE TABLE SQL command for a given table.
+ * @internal For unit testing only
+ * @tparam T The table type.
+ */
+template <typename T>
+QString createTableStatement()
+{
+    QStringList cols;
+    detail::column_creator accu( cols );
+    boost::mpl::for_each<typename T::columns, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+
+    detail::table_constraint_creator accu2( cols );
+    boost::mpl::for_each<typename T::constraints>( accu2 );
+
+    return QLatin1Literal( "CREATE TABLE " ) % T::tableName() % QLatin1Literal( " (\n" ) % cols.join( QLatin1String( ",\n" ) ) % QLatin1Literal( "\n)" );
+}
+
+template <typename T>
+QString createTableStatement( const T & ) { return createTableStatement<T>(); }
+
+/**
+ * Returns a list of CREATE TABLE statements for a list of tables.
+ * @internal For unit testing only
+ * @tparam Tables A MPL sequence of tables.
+ */
+template <typename Tables>
+QStringList createTableStatements()
+{
+    QStringList tabs;
+    detail::table_creator accu( tabs );
+    boost::mpl::for_each<Tables, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+    return accu.m_statements;
+}
+
+
+/**
+ * Create the trigger statements for a single table.
+ */
+template <typename T>
+QStringList createTableTriggerStatements()
+{
+    QStringList triggers;
+    detail::column_trigger_creator accu( triggers );
+    boost::mpl::for_each<typename T::columns, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+
+    return triggers;
+}
+
+template <typename T>
+QStringList createTableTriggerStatements( const T & ) { return createTableTriggerStatements<T>(); }
+
+/**
+ * Returns a list of DROP TRIGGER / CREATE TRIGGER statements for a list of tables.
+ * @tparam Tables A MPL sequence of tables.
+ */
+template <typename Tables>
+QStringList createTableTriggers()
+{
+    QStringList tabs;
+    detail::table_trigger_creator accu( tabs );
+    boost::mpl::for_each<Tables, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+    return accu.m_statements;
+}
+
+/**
+ * Returns a list of table names in the given schema.
+ * @tparam Tables A MPL sequence of tables.
+ * @returns A list of table names in @p Tables
+ */
+template <typename Tables>
+QStringList tableNames()
+{
+    QStringList tableNames;
+    boost::mpl::for_each<Tables, detail::wrap<boost::mpl::placeholders::_1> >( detail::sql_name_accumulator( tableNames ) );
+    return tableNames;
+}
+
+/**
+ * Creates all rules, permissions and triggers for the tables in @p Tables in the database @p db
+ * @tparam Tables A MPL squence of tables.
+ * @param db The database to create the tables in.
+ * @throws SqlException in case of a database error
+ */
+template <typename Tables>
+void createRulesPermissionsAndTriggers( const QSqlDatabase &db = QSqlDatabase::database() )
+{
+    Sql::createNotificationRules<Tables>( db );
+    Sql::grantPermissions<Tables>( db );
+    foreach ( const QString &stmt, Sql::createTableTriggers<Tables>() ) {
+        SqlQuery q( db );
+        q.exec( stmt );
+    }
+}
+
+
+/**
+ * Create all tables in @p Tables in the database @p db.
+ * @tparam Tables A MPL sequence of tables.
+ * @param db The database to create the tables in
+ * @throws SqlException in case of a database error
+ */
+template <typename Tables>
+void createTables( const QSqlDatabase &db )
+{
+    foreach ( const QString &stmt, Sql::createTableStatements<Tables>() ) {
+        SqlQuery q( db );
+        q.exec( stmt );
+    }
+    
+    Sql::createRulesPermissionsAndTriggers<Tables>( db );
+}
+
+/**
+ * set the database version in the database
+ * @param The verison table to set
+ */
+template <typename Table>
+void setVersion( const Table& table, const QSqlDatabase &db , int version)
+{
+    SqlInsertQueryBuilder qb( db );
+    qb.setTable( table );
+    qb.addColumnValue( table.version, version );
+    qb.exec();
+}
+
+
+/**
+ * Creates all tables in @p Tables in the database @p db <b>if</b> a tables with the same name does not already exist.
+ * @tparam Tables A MPL squence of tables.
+ * @param db The database to create the tables in.
+ * @throws SqlException in case of a database error
+ */
+template <typename Tables>
+void createMissingTables( const QSqlDatabase &db = QSqlDatabase::database() )
+{
+    QStringList existingTables = db.tables();
+    std::transform(existingTables.begin(), existingTables.end(), existingTables.begin(), boost::bind(&QString::toLower, _1));
+    QStringList newTables = Sql::tableNames<Tables>();
+    std::transform(newTables.begin(), newTables.end(), newTables.begin(), boost::bind(&QString::toLower, _1));
+    const QStringList newTableStmts = Sql::createTableStatements<Tables>();
+    Q_ASSERT( newTables.size() == newTableStmts.size() );
+    for ( QStringList::const_iterator it = newTables.constBegin(), it2 = newTableStmts.constBegin(); it != newTables.constEnd(); ++it, ++it2 ) {
+        if ( existingTables.contains( *it ) )
+            continue;
+        SqlQuery q( db );
+        q.exec( *it2 );
+    }
+}
+
+}
+
+#endif
diff --git a/SqlDeleteQueryBuilder.cpp b/SqlDeleteQueryBuilder.cpp
new file mode 100644
index 0000000..b5d683a
--- /dev/null
+++ b/SqlDeleteQueryBuilder.cpp
@@ -0,0 +1,57 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+#include "SqlDeleteQueryBuilder.h"
+#include "SqlExceptions.h"
+
+#include "Sql.h"
+
+#include <QUuid>
+
+SqlDeleteQueryBuilder::SqlDeleteQueryBuilder(const QSqlDatabase& db) :
+  SqlConditionalQueryBuilderBase( db ),
+  m_includeSubTables( true )
+{
+}
+
+void SqlDeleteQueryBuilder::setIncludeSubTables(bool includeSubTables)
+{
+    m_includeSubTables = includeSubTables;
+}
+
+SqlQuery& SqlDeleteQueryBuilder::query()
+{
+    if ( !m_assembled ) {
+        QStringList cols;
+        m_queryString = QLatin1String( "DELETE FROM " );
+        if ( !m_includeSubTables ) {
+            m_queryString += QLatin1String( "ONLY " );
+        }
+        m_queryString += m_table;
+
+        m_bindValues.clear();
+        if ( m_whereCondition.hasSubConditions() ) {
+            m_queryString += QLatin1String( " WHERE " );
+            m_queryString += conditionToString( m_whereCondition );
+        }
+
+        m_queryString = m_queryString.trimmed();
+        m_assembled = true;
+
+#ifndef QUERYBUILDER_UNITTEST
+        m_query = prepareQuery( m_queryString );
+
+        for ( int i = 0; i < m_bindValues.size(); ++i ) {
+            const QVariant value = m_bindValues.at( i );
+            // FIXME: similar code in the other query builders, we probably want that in the base class
+            if ( qstrcmp( value.typeName(), QMetaType::typeName( qMetaTypeId<QUuid>() ) ) == 0 )
+                m_query.bindValue( QLatin1Char( ':' ) + QString::number( i ), value.value<QUuid>().toString() ); // Qt SQL drivers don't handle QUuid
+            else
+                m_query.bindValue( QLatin1Char( ':' ) + QString::number( i ), value );
+        }
+#endif
+    }
+    return m_query;
+}
+
diff --git a/SqlDeleteQueryBuilder.h b/SqlDeleteQueryBuilder.h
new file mode 100644
index 0000000..319cfb9
--- /dev/null
+++ b/SqlDeleteQueryBuilder.h
@@ -0,0 +1,36 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLDELETEQUERYBUILDER_H
+#define SQLDELETEQUERYBUILDER_H
+
+#include "SqlConditionalQueryBuilderBase.h"
+#include "sqlate_export.h"
+
+/** API to create DELETE queries in a safe way from code, without the risk of
+ *  introducing SQL injection vulnerabilities or typos.
+ */
+class SQLATE_EXPORT SqlDeleteQueryBuilder : public SqlConditionalQueryBuilderBase
+{
+public:
+    /// Create a new query builder for the given database
+    explicit SqlDeleteQueryBuilder( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /**
+     * If @p includeSubTables is true all the tables inheriting from the specified
+     * table are deleted. If false, only the table is deleted using
+     * DELETE <b>ONLY</b> &lt;tableName&gt;
+     */
+    void setIncludeSubTables( bool includeSubTables  );
+
+    /// Returns the created query object, when called first, the query object is assembled and prepared
+    /// The method throws an SqlException if there is an error preparing the query.
+    SqlQuery& query();
+
+private:
+    friend class DeleteQueryBuilderTest;
+    bool m_includeSubTables;
+};
+
+#endif
diff --git a/SqlExceptions.h b/SqlExceptions.h
new file mode 100644
index 0000000..c5f133c
--- /dev/null
+++ b/SqlExceptions.h
@@ -0,0 +1,29 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLEXCEPTIONS_H
+#define SQLEXCEPTIONS_H
+
+#include "sqlate_export.h"
+
+#include <exception>
+#include <QSqlError>
+
+
+class SQLATE_EXPORT SqlException : public std::exception {
+public:    
+    SqlException(const QSqlError& error) throw() : m_error( error ) {}
+    virtual ~SqlException() throw(){};
+    
+    virtual const char* what() const throw() {
+       return m_error.text().toLatin1().constData(); 
+    }   
+    
+    QSqlError error() const {return m_error;}
+    
+private:
+    QSqlError m_error;
+};
+
+#endif
diff --git a/SqlGlobal.h b/SqlGlobal.h
new file mode 100644
index 0000000..37c1906
--- /dev/null
+++ b/SqlGlobal.h
@@ -0,0 +1,26 @@
+#ifndef SQLATE_GLOBAL_H
+#define SQLATE_GLOBAL_H
+
+#include <QDebug>
+#include <QUuid>
+
+#include <boost/static_assert.hpp>
+
+#define SQLATE_DEFAULT_SERVER_PORT 5432
+
+#define SQLDEBUG  qDebug() << QString::fromLatin1("%1:%2").arg(QLatin1String( __FILE__ )).arg(__LINE__ ) << QLatin1String( ": " )
+
+
+namespace Sql {
+ /** A memory-layout compatible version of QUuid that can be statically initialized. */
+struct StaticUuid {
+    uint   data1;
+    ushort data2;
+    ushort data3;
+    uchar  data4[8];
+    operator const QUuid &() const { return *reinterpret_cast<const QUuid*>(this); }
+};
+
+BOOST_STATIC_ASSERT( sizeof(QUuid) == sizeof(StaticUuid) );
+}
+#endif
diff --git a/SqlGrantPermission.h b/SqlGrantPermission.h
new file mode 100644
index 0000000..043ea7a
--- /dev/null
+++ b/SqlGrantPermission.h
@@ -0,0 +1,88 @@
+/*
+* Copyright (C) 2012-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLGRANTPERMISSION_H
+#define SQLGRANTPERMISSION_H
+
+#include "SqlInternals_p.h"
+#include "SqlSchema_p.h"
+#include "SqlQuery.h"
+
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#include <QStringList>
+
+/**
+ * @file SqlGrantPermission.h
+ * Classes and functions to grant tables rights based on the schema definition in SqlSchema.h
+ */
+
+namespace Sql {
+
+namespace detail {
+
+/**
+ * Permission statement creator.
+ * @internal
+ */
+struct permission_statement_creator {
+    permission_statement_creator( QStringList &stmts ) : m_stmts( stmts ) {}
+    template <typename T>
+    void operator()( wrap<T> ) {
+        QString stmt = QLatin1Literal("GRANT SELECT, INSERT, UPDATE, DELETE ON ") % T::tableName() % QLatin1Literal(" TO GROUP sqladmins");
+        m_stmts.push_back( stmt );
+        QStringList allowedOperations;
+        allowedOperations << QLatin1String("SELECT");
+        if ( !T::is_restricted::value ) { 
+            if ( T::delete_rows::value) {
+                allowedOperations << QLatin1String("DELETE");
+            }
+            if ( T::update_rows::value) {
+                allowedOperations << QLatin1String("UPDATE");
+            }
+            if ( T::insert_rows::value) {
+                allowedOperations << QLatin1String("INSERT");
+            }
+        }
+        stmt = QLatin1Literal("GRANT ") % allowedOperations.join(QLatin1String(", ")) %  QLatin1Literal(" ON ") % T::tableName() % QLatin1Literal(" TO GROUP sqlusers");
+        m_stmts.push_back( stmt );
+
+    }
+    QStringList &m_stmts;
+};
+
+}
+
+/**
+ * Returns a list of GRANT ... ON ... TO ... statements for all mutable tables.
+ * @tparam Schema A MPL sequence of tables.
+ * @returns A list of SQL statements to give rights to the tables.
+ */
+template<typename Schema>
+QStringList createPermissionStatements()
+{
+    QStringList statements;
+    boost::mpl::for_each<Schema, detail::wrap<boost::mpl::placeholders::_1> >( detail::permission_statement_creator( statements ) );
+    return statements;
+}
+
+/**
+ * Set up permissings for all tables from a Schema.
+ * @tparam Schema A MPL sequence of tables.
+ * @param db The database to create the tables in
+ * @throws SqlException in case of a database error
+ */
+template <typename Schema>
+void grantPermissions( const QSqlDatabase &db )
+{
+    foreach ( const QString &stmt, Sql::createPermissionStatements<Schema>() ) {
+        SqlQuery q( db );
+        q.exec( stmt );
+    }
+}
+
+}
+
+#endif
diff --git a/SqlGraphviz.h b/SqlGraphviz.h
new file mode 100644
index 0000000..4f10db9
--- /dev/null
+++ b/SqlGraphviz.h
@@ -0,0 +1,150 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLGRAPHVIZ_H
+#define SQLGRAPHVIZ_H
+
+#include "SqlSchema_p.h"
+#include "SqlInternals_p.h"
+#include "SqlCreateTable.h"
+
+#include <QDateTime>
+#include <QStringBuilder>
+#include <QStringList>
+#include <QUuid>
+
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/size.hpp>
+
+/**
+ * @file SqlGraphviz.h
+ * Dump the database schema into a dot file for visualization.
+ */
+
+namespace Sql {
+
+namespace detail {
+
+/**
+ * Helper class to dump a single column to dot format.
+ * @internal
+ * @tparam C The column type
+ */
+struct column_dot_creator
+{
+    column_dot_creator( QStringList &c, QStringList &edges ) : cols( c ), m_edges( edges ) {}
+
+    template<typename C> void operator()( wrap<C> )
+    {
+        const QString colStmt =
+            QLatin1Literal( "<TR><TD ALIGN=\"LEFT\" PORT=\"" ) % C::sqlName() % QLatin1Literal( "\"><I>" )
+            % sqlType( wrap<typename C::type>(), C::size )
+            % QLatin1Literal( "</I>: " )
+            % C::sqlName() % QLatin1Literal( "</TD></TR>" );
+        foreignKeyEdge<C>( typename C::hasForeignKey() );
+        cols.push_back( colStmt );
+    }
+
+    /**
+     * Creates a graph edge for foreign key references.
+     * @tparam C The column type.
+     */
+    template<typename C> void foreignKeyEdge( boost::mpl::false_ ) {}
+    template<typename C> void foreignKeyEdge( boost::mpl::true_ )
+    {
+        QString edge = C::table::tableName() % QLatin1Literal( ":" ) % C::sqlName()
+            % QLatin1Literal( " -> " )
+            % C::referenced_column::table::tableName() % QLatin1Literal( ":" ) % C::referenced_column::sqlName()
+            % QLatin1Literal( "[label=\"n:1\"];\n" );
+        m_edges.push_back( edge );
+    }
+
+    QStringList &cols;
+    QStringList &m_edges;
+};
+
+/**
+ * Helper class to create table nodes in dot format
+ * @internal
+ * @tparam T The table type.
+ */
+struct table_dot_creator
+{
+    table_dot_creator( QStringList & nodes, QStringList &edges ) : m_nodes( nodes ), m_edges( edges ) {};
+
+    template <typename T>
+    void operator() ( wrap<T> )
+    {
+        if ( T::is_lookup_table::value ) {
+            makeNode<T>( QLatin1String( "lightyellow" ) );
+        } else if ( !T::is_relation::value ) {
+            makeNode<T>( QLatin1String( "lightsteelblue" ) );
+        }
+        if ( T::is_relation::value && boost::mpl::size<typename T::columns>::value > 2 )
+            makeNode<T>( QLatin1String( "lightgray" ) );
+        else
+            makeRelationEdge<T>( typename T::is_relation() );
+    }
+
+    template <typename T>
+    void makeNode( const QString &color )
+    {
+        QStringList cols;
+        detail::column_dot_creator accu( cols, m_edges );
+        boost::mpl::for_each<typename T::columns, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+
+        m_nodes.push_back(
+            T::tableName()
+            % QLatin1Literal( "[label=<<TABLE BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" PORT=\"1\" BGCOLOR=\"" )
+            % color
+            % QLatin1Literal( "\">" )
+            % QLatin1Literal( "<TR><TD BORDER=\"1\" ALIGN=\"CENTER\"><B>" )
+            % T::tableName()
+            % QLatin1Literal( "</B></TD></TR>" ) % cols.join( QLatin1String( " " ) ) % QLatin1Literal( "</TABLE>>];\n" )
+        );
+    }
+
+    template <typename T>
+    void makeRelationEdge( boost::mpl::false_ ) {}
+    template <typename T>
+    void makeRelationEdge( boost::mpl::true_ )
+    {
+        m_edges.push_back( T::leftType::referenced_column::table::tableName() % QLatin1Literal( ":" ) % T::leftType::referenced_column::sqlName()
+            % QLatin1Literal( " -> " )
+            % T::rightType::referenced_column::table::tableName() % QLatin1Literal( ":" ) % T::rightType::referenced_column::sqlName()
+            % QLatin1Literal( "[label=\"n:m\" dir=both arrowtail=normal];\n" )
+        );
+    }
+
+    QStringList &m_nodes;
+    QStringList &m_edges;
+};
+
+} // detail
+
+
+/**
+ * Returns a dot representation of the database schema
+ * @tparam Tables A MPL sequence of tables.
+ */
+template <typename Tables>
+QString schemaToDot()
+{
+    QStringList nodes;
+    QStringList edges;
+    detail::table_dot_creator accu( nodes, edges );
+    boost::mpl::for_each<Tables, detail::wrap<boost::mpl::placeholders::_1> >( accu );
+    return QLatin1Literal( "digraph \"Database Schema\" {\n"
+                           "graph [rankdir=\"LR\" fontsize=\"10\"]\n"
+                           "node [fontsize=\"10\" shape=\"plaintext\"]\n"
+                           "edge [fontsize=\"10\"]\n" ) %
+            nodes.join( QLatin1String( "\n" ) ) %
+            edges.join( QLatin1String( "\n" ) ) %
+            QLatin1Literal( "}\n" );
+}
+
+}
+
+#endif
diff --git a/SqlInsertQueryBuilder.cpp b/SqlInsertQueryBuilder.cpp
new file mode 100644
index 0000000..223eda3
--- /dev/null
+++ b/SqlInsertQueryBuilder.cpp
@@ -0,0 +1,89 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*         Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlInsertQueryBuilder.h"
+
+#include "SqlExceptions.h"
+#include "Sql.h"
+
+SqlInsertQueryBuilder::SqlInsertQueryBuilder(const QSqlDatabase& db) :
+  SqlQueryBuilderBase( db )
+{
+}
+
+void SqlInsertQueryBuilder::addColumnValue(const QString& columnName, const QVariant& value)
+{
+    m_columns.push_back( qMakePair( columnName, value ) );
+}
+
+void SqlInsertQueryBuilder::addAllValues(const QVector< QVariant >& values)
+{
+    Q_FOREACH( const QVariant &value, values ) {
+        addColumnValue( QLatin1String( "" ), value );
+    }
+}
+
+void SqlInsertQueryBuilder::addDefaultValues()
+{
+    m_columns.clear();
+}
+
+
+SqlQuery& SqlInsertQueryBuilder::query()
+{
+    if ( !m_assembled ) {
+        typedef QPair<QString, QVariant> ColumnValuePair;
+        m_columnNames.clear();
+        m_values.clear();
+        foreach ( const ColumnValuePair &col, m_columns ) {
+            m_columnNames.push_back( col.first );
+            m_values.push_back( col.second );
+        }
+
+        m_queryString = QLatin1String( "INSERT INTO " );
+        m_queryString += m_table;
+#ifndef QUERYBUILDER_UNITTEST
+        bool bindValues = false;
+#endif
+        if ( m_columns.isEmpty() ) { //default values
+            m_queryString += QLatin1String(" DEFAULT VALUES");
+        } else {
+            if ( !m_columnNames.join( QLatin1String("") ).trimmed().isEmpty() ) { //columns specified
+              m_queryString += QLatin1String( " (" );
+              Q_FOREACH( const QString& column, m_columnNames ) {
+                  m_queryString += column + QLatin1String( "," );
+              }
+              m_queryString[ m_queryString.length() -1 ] = QLatin1Char(')');
+            }
+
+            m_queryString += QLatin1String( " VALUES (" );
+            for (int i = 0; i < m_values.size(); ++i ) {
+                if (m_values.at(i).userType() == qMetaTypeId<SqlNowType>())
+                    m_queryString += currentDateTime() % QLatin1Char(',');
+                else
+                    m_queryString += QString::fromLatin1(  ":%1," ).arg(i);
+            }
+            m_queryString[ m_queryString.length() -1 ] = QLatin1Char(')');
+#ifndef QUERYBUILDER_UNITTEST
+            bindValues = true;
+#endif
+        }
+
+        m_assembled = true;
+
+#ifndef QUERYBUILDER_UNITTEST
+        m_query = prepareQuery( m_queryString );
+
+        if ( bindValues ) {
+            for ( int i = 0; i < m_values.size(); ++i ) {
+                const QVariant value = m_values.at( i );
+                bindValue( i, value );
+            }
+        }
+#endif
+    }
+    return m_query;
+}
+
diff --git a/SqlInsertQueryBuilder.h b/SqlInsertQueryBuilder.h
new file mode 100644
index 0000000..ccb73c7
--- /dev/null
+++ b/SqlInsertQueryBuilder.h
@@ -0,0 +1,69 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*         Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLINSERTQUERYBUILDER_H
+#define SQLINSERTQUERYBUILDER_H
+
+#include "sqlate_export.h"
+#include "SqlQueryBuilderBase.h"
+#include "SqlInternals_p.h"
+
+#include <QDateTime>
+#include <QStringList>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+/** API to create INSERT queries in a safe way from code, without the risk of
+ *  introducing SQL injection vulnerabilities or typos.
+ */
+class SQLATE_EXPORT SqlInsertQueryBuilder : public SqlQueryBuilderBase
+{
+public:
+
+    /// Create a new query builder for the given database
+    explicit SqlInsertQueryBuilder( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /// INSERT INTO table ( @p columnName , ... ) VALUES( @p value )
+    void addColumnValue( const QString &columnName, const QVariant &value );
+
+    template <typename Column>
+    void addColumnValue( const Column &, const typename Column::type &value )
+    {
+        Sql::warning<boost::is_same<typename Column::type, QDateTime>, UsageOfClientSideTime>::print();
+        addColumnValue( Column::sqlName(), QVariant::fromValue( value ) );
+    }
+    template <typename Column>
+    void addColumnValue( const Column &, SqlNullType )
+    {
+        BOOST_MPL_ASSERT(( boost::mpl::not_<typename Column::notNull> ));
+        addColumnValue( Column::sqlName(), QVariant() );
+    }
+    template <typename Column>
+    void addColumnValue( const Column &, SqlNowType now )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<typename Column::type, QDateTime> ));
+        addColumnValue( Column::sqlName(), QVariant::fromValue(now) );
+    }
+
+    /// INSERT INTO table VALUES ( @p values )...
+    void addAllValues( const QVector<QVariant> &values );
+
+    /// INSERT INTO ... DEFAULT VALUES
+    void addDefaultValues();
+
+    /// Returns the created query object, when called first, the query object is assembled and prepared
+    SqlQuery& query();
+
+private:      
+    friend class InsertQueryBuilderTest;
+    QVector<QPair<QString, QVariant> > m_columns;
+    
+    QStringList m_columnNames; //holds the column names, used for unit testing
+    QVector<QVariant> m_values; //holds the inserted values, used for unit testing    
+};
+
+#endif
diff --git a/SqlInternals_p.h b/SqlInternals_p.h
new file mode 100644
index 0000000..4aefa8f
--- /dev/null
+++ b/SqlInternals_p.h
@@ -0,0 +1,84 @@
+/*
+* Copyright (C) 2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLINTERNALS_P_H
+#define SQLINTERNALS_P_H
+
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/push_back.hpp>
+
+/**
+ * @file SqlInternals_p.h
+ * Shared internals between the various Sql related templates.
+ */
+
+namespace Sql {
+
+namespace detail {
+
+/**
+ * type wrapper to avoid instantiation of concrete types
+ * @tparam T The type to wrap
+ * @internal
+ */
+template <typename T> struct wrap {};
+
+/** Empty type for eg. not yet specified parts of a query. */
+struct missing {};
+
+}
+
+/**
+ * Metafunctions for concatenating two MPL vectors.
+ * @tparam V1 First vector
+ * @tparam V2 Second vector
+ * @returns V1 + V2
+ */
+template <typename V1, typename V2>
+struct append : boost::mpl::fold<
+    V2,
+    V1,
+    boost::mpl::push_back<boost::mpl::placeholders::_,boost::mpl::placeholders::_>
+>
+{};
+
+
+namespace detail {
+
+/**
+ * Implementation details for the conditional compiler warning generator template below.
+ * @internal
+ */
+template <bool B>
+struct warning_helper {
+    typedef unsigned int signed_or_unsigned_int;
+};
+template <>
+struct warning_helper<true> {
+    typedef signed int signed_or_unsigned_int;
+};
+
+}
+
+/**
+ * Triggers a conditional compiler warning.
+ * @tparam Condition A MPL boolean meta-type, the warning if generated when evaluating to @c true.
+ * @tparam Message A message to be included in the output. Needs to be a defined symbol.
+ * @note requires sign comparison warnings being enabled.
+ */
+template <typename Condition, typename Message>
+struct warning {
+    static inline void print() {
+        const typename detail::warning_helper<Condition::value>::signed_or_unsigned_int a = 0;
+        const unsigned int b = 0;
+        const bool c = (a != b);
+        (void) c;
+    }
+};
+
+
+}
+
+#endif
diff --git a/SqlMonitor.cpp b/SqlMonitor.cpp
new file mode 100644
index 0000000..4617d02
--- /dev/null
+++ b/SqlMonitor.cpp
@@ -0,0 +1,72 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#include "SqlMonitor.h"
+#include "SqlQueryManager.h"
+
+
+#include <QSqlDriver>
+#include <QStringBuilder>
+
+#include <QVariant>
+
+SqlMonitor::SqlMonitor( const QSqlDatabase& db, QObject *parent ): QObject(parent), m_db(db)
+{
+    connect( db.driver(), SIGNAL(notification(QString)), SLOT(notificationReceived(QString)) );
+    SqlQueryManager::instance()->registerMonitor(this);
+}
+
+SqlMonitor::~SqlMonitor()
+{
+    SqlQueryManager::instance()->unregisterMonitor(this);
+}
+
+
+void SqlMonitor::setMonitorTables( const QStringList& tables )
+{
+    foreach( const QString &table, tables ) {
+        const QString notification = table.toLower() % QLatin1Literal( "changed" );
+        if ( m_tables.contains( notification ) )
+            continue;
+        m_tables.push_back( notification );
+        subscribe(notification);
+    }
+}
+
+bool SqlMonitor::subscribe( const QString& notification )
+{
+    if ( m_db.driver()->subscribedToNotifications().contains( notification ) )
+        return false;
+    m_db.driver()->subscribeToNotification( notification );
+    return true;
+}
+
+void SqlMonitor::notificationReceived( const QString& notification )
+{
+    if ( m_tables.contains(notification.toLower()) )
+        emit tablesChanged();
+    else if ( m_monitoredValues.contains(notification) )
+        emit notify(notification);
+}
+
+void SqlMonitor::resubscribe()
+{
+    foreach( const QString &notification, m_tables ) {
+        m_db.driver()->subscribeToNotification( notification );
+    }
+    foreach( const QString &notification, m_monitoredValues ) {
+        m_db.driver()->subscribeToNotification( notification );
+    }
+}
+
+void SqlMonitor::unsubscribeValuesNotifications()
+{
+    foreach( const QString &notification, m_monitoredValues ) {
+        m_db.driver()->unsubscribeFromNotification( notification );
+    }
+    m_monitoredValues.clear();
+}
+
+#include "moc_SqlMonitor.cpp"
diff --git a/SqlMonitor.h b/SqlMonitor.h
new file mode 100644
index 0000000..eb3087d
--- /dev/null
+++ b/SqlMonitor.h
@@ -0,0 +1,125 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#ifndef SQL_MONITOR_H
+#define SQL_MONITOR_H
+
+#include <QObject>
+#include <QSqlDatabase>
+#include <QStringList>
+
+#include "sqlate_export.h"
+#include "SqlUtils.h"
+
+#include <boost/preprocessor/repetition.hpp>
+
+/**
+ * Helper class for monitoring a set up tables for changes.
+ */
+class SQLATE_EXPORT SqlMonitor : public QObject
+{
+    Q_OBJECT
+public:
+    /**
+     * Creates a table monitor for the given database.
+     * @param db The database on which we want to monitor tables.
+     * @param parent The parent object.
+     */
+    explicit SqlMonitor( const QSqlDatabase& db, QObject* parent = 0 );
+
+    virtual ~SqlMonitor();
+
+    /**
+     * Set a list of table names to monitor.
+     * @param tables List of table names.
+     */
+    void setMonitorTables( const QStringList &tables );
+
+
+    /**
+     * Monitor a row and emits a signal carrying the content of a selected column when an UPDATE is performed on this row.
+     * @note you need to declare the column as "notification ready" in the SQL schema, using the flag "Notify"
+     *
+     * @param table the table in which we want the row to be monitored
+     * @param column the monitored column
+     *
+     */
+    template <typename T>
+    bool addValueMonitor( const T&, const QVariant& value)
+    {
+        QString processedValue = value.toString();
+        //remove braces in case of an uuid
+        if(processedValue.contains(QLatin1Char('{')) && processedValue.contains(QLatin1Char('}')))
+        {
+            processedValue.remove(QLatin1Char('{'));
+            processedValue.remove(QLatin1Char('}'));
+        }
+
+        const QString identifier = SqlUtils::createIdentifier(T::table::sqlName() + QLatin1Char( '_' ) + T::sqlName());
+        const QString notification = QString::fromLatin1("%1_%2")
+                .arg(processedValue)
+                .arg(identifier);
+        m_monitoredValues << notification; //maybe it's already registered in another instance of the monitor, just add it in the list in this case
+        if(subscribe(notification))
+        {
+            return true;
+        }
+        else return false;
+    }
+
+    /**
+     * @brief Subscribes again to the monitored notifications. Used after an unexpected database disconnection.
+     **/
+    void resubscribe();
+
+    /**
+     * @brief Unsubscribe from all "values" notifications
+     **/
+    void unsubscribeValuesNotifications();
+
+    QSqlDatabase database() const { return m_db; }
+
+    QStringList monitoredTables() const { return m_tables; }
+    QStringList monitoredValues() const { return m_monitoredValues; }
+
+
+#ifndef SQL_MONITOR_MAX_SIZE
+#define SQL_MONITOR_MAX_SIZE 15
+#endif
+
+#define CONST_REF(z, n, unused) const T ## n &
+#define TABLE_NAME(z, n, unused) << T ## n ::tableName()
+#define MONITOR_IMPL(z, n, unused) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+    void setMonitorTables( BOOST_PP_ENUM(n, CONST_REF, ~) ) { \
+        setMonitorTables( QStringList() BOOST_PP_REPEAT(n, TABLE_NAME, ~) ); \
+    }
+BOOST_PP_REPEAT_FROM_TO(1, SQL_MONITOR_MAX_SIZE, MONITOR_IMPL, ~)
+
+#undef MONITOR_IMPL
+#undef CONST_REF
+#undef TABLE_NAME
+
+
+Q_SIGNALS:
+    /**
+     * Emitted when any of the monitored tables changed.
+     */
+    void tablesChanged();
+
+    void notify( const QString &notification );
+
+private Q_SLOTS:
+    void notificationReceived( const QString &notification );
+
+private:    
+    bool subscribe( const QString& notification );
+
+    QSqlDatabase m_db;
+    QStringList m_tables;
+    QStringList m_monitoredValues;
+};
+
+#endif
diff --git a/SqlQuery.cpp b/SqlQuery.cpp
new file mode 100644
index 0000000..861b3af
--- /dev/null
+++ b/SqlQuery.cpp
@@ -0,0 +1,141 @@
+#include "SqlQuery.h"
+#include "SqlExceptions.h"
+#include "SqlQueryManager.h"
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+#include "SqlQueryWatcher.h"
+#include "kdthreadrunner.h"
+#endif
+
+#include <QSqlDatabase>
+#include <QDebug>
+#include <QVariant>
+
+SqlQuery::SqlQuery(const QString &query /*= QString()*/, const QSqlDatabase& db /*= QSqlDatabase()*/ ) :
+    QSqlQuery( db ), m_db( db )
+{
+    m_connectionName = db.connectionName();
+
+    SqlQueryManager::instance()->registerQuery(this);
+    if ( !query.isEmpty() )
+        exec( query );
+}
+
+SqlQuery::SqlQuery(const QSqlDatabase& db) :
+    QSqlQuery( db ), m_db(db)
+{
+    m_connectionName = db.connectionName();
+    SqlQueryManager::instance()->registerQuery(this);
+}
+
+SqlQuery::SqlQuery(const SqlQuery &other ) :
+    QSqlQuery( other ), m_db(other.m_db)
+{
+    m_connectionName = m_db.connectionName();
+    SqlQueryManager::instance()->registerQuery(this);
+}
+
+SqlQuery::~SqlQuery()
+{
+    SqlQueryManager::instance()->unregisterQuery(this);
+}
+
+SqlQuery& SqlQuery::operator=(const SqlQuery& other)
+{
+    QSqlQuery::operator=(other);
+    m_db = other.m_db;
+    m_connectionName = m_db.connectionName();
+//Debug line that helps finding leaking queries. It is intentionally not a SQLDEBUG.
+//     qDebug() << "operator= " <<  lastQuery() << this;
+    return *this;
+}
+
+void SqlQuery::exec()
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    KDThreadRunner<SqlQueryWatcherHelper> watcher;
+    SqlQueryWatcherHelper* helper = watcher.startThread();
+#endif
+
+    bool result = QSqlQuery::exec();
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    QMetaObject::invokeMethod( helper, "quit", Qt::QueuedConnection );
+    watcher.wait();
+#endif
+
+    if (!result && ( !m_db.isOpen() || !m_db.isValid() ) ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db);  //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        result = QSqlQuery::exec();
+    }
+
+    if ( !result ) {
+        qWarning() << Q_FUNC_INFO << "Exec failed: " << this << QSqlQuery::lastError() << " query was: " << QSqlQuery::lastQuery()
+        << ", executed query: " << QSqlQuery::executedQuery() << " bound values: "<< QSqlQuery::boundValues().values();
+//         qWarning() << "Database status: " << m_db.isOpen() << m_db.isValid() << m_db.isOpenError();
+        throw SqlException( QSqlQuery::lastError() );
+    }
+}
+
+void SqlQuery::exec(const QString& query)
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    KDThreadRunner<SqlQueryWatcherHelper> watcher;
+    SqlQueryWatcherHelper* helper = watcher.startThread();
+#endif
+
+    bool result = QSqlQuery::exec( query );
+    if (!result && ( !m_db.isOpen() || !m_db.isValid() ) ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db);  //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        result = QSqlQuery::exec();
+    }
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    QMetaObject::invokeMethod( helper, "quit", Qt::QueuedConnection );
+    watcher.wait();
+#endif
+
+    if ( !result ) {
+        qWarning() << Q_FUNC_INFO << "Exec(query) failed: " << this << QSqlQuery::lastError() << " query was: " << QSqlQuery::lastQuery()
+        << ", executed query: " << QSqlQuery::executedQuery()  << " bound values: "<< QSqlQuery::boundValues().values();
+//         qWarning() << "Database status: " << m_db.isOpen() << m_db.isValid() << m_db.isOpenError();
+        throw SqlException( QSqlQuery::lastError() );
+    }
+}
+
+void SqlQuery::prepare(const QString& query)
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    KDThreadRunner<SqlQueryWatcherHelper> watcher;
+    SqlQueryWatcherHelper* helper = watcher.startThread();
+#endif
+
+    bool result = QSqlQuery::prepare( query );
+    if (!result && ( !m_db.isOpen() || !m_db.isValid() ) ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db);  //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        result = QSqlQuery::prepare( query );
+    }
+
+#ifdef SQLATE_ENABLE_NETWORK_WATCHER
+    QMetaObject::invokeMethod( helper, "quit", Qt::QueuedConnection );
+    watcher.wait();
+#endif
+
+    if ( !result ) {
+        qWarning() << Q_FUNC_INFO << "Prepare failed: " << this << QSqlQuery::lastError() << " query was: " << QSqlQuery::lastQuery()
+        << ", executed query: " << QSqlQuery::executedQuery()  << " bound values: "<< QSqlQuery::boundValues().values();
+//         qWarning() << "Database status: " << m_db.isOpen() << m_db.isValid() << m_db.isOpenError();
+        throw SqlException( QSqlQuery::lastError() );
+    }
+}
+
+bool SqlQuery::prepareWithoutCheck(const QString& query)
+{
+    return QSqlQuery::prepare(query);
+}
diff --git a/SqlQuery.h b/SqlQuery.h
new file mode 100644
index 0000000..4f6856a
--- /dev/null
+++ b/SqlQuery.h
@@ -0,0 +1,58 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+*/
+
+/*!
+  * This is the class that should be used in place of all QSqlQuery
+  * This was we can keep a check on all queries and authenticate
+  * appropriately.
+  *
+  * WARNING: Do NOT cast a SqlQuery to QSqlQuery and call
+  * prepare or exec on it, as it will not call the SqlQuery variants!
+  */
+
+#ifndef SQLQUERY_H
+#define SQLQUERY_H
+
+#include "sqlate_export.h"
+
+#include <QSqlQuery>
+
+class SQLATE_EXPORT SqlQuery : public QSqlQuery
+{
+public:
+    /// @todo Really we should be abstracting all this
+    // So this class decides which database to use, i.e. the lookup or main etc
+    // When we implement this, move these members to private to pick up where
+    // they are used
+    SqlQuery (const QString &query = QString(), const QSqlDatabase& db = QSqlDatabase::database() );
+    SqlQuery (const QSqlDatabase& db );
+    SqlQuery (const SqlQuery & other );
+
+    ~SqlQuery();
+
+    //NOTE: not that nice they overload non-virtual methods, so beware when casting a SqlQuery to QSqlQuery
+    // In short: do not cast.
+    void exec();
+    void exec( const QString &query );
+    void prepare( const QString &query );
+
+    /**
+     * @brief Prepare the query without checking if the connection to the database is alive.
+     *  This should not be called from anywhere, but the SqlQueryManager::checkDbIsAlive to avoid
+     *  multiple checking.
+     * @param query the query to prepare
+     * @return bool true if succeed, false if there was some error. See QSqlQuery::prepare.
+     **/
+    bool prepareWithoutCheck( const QString &query );
+
+    QString connectionName() const { return m_connectionName; }
+
+    SqlQuery& operator=(const SqlQuery& other);
+
+private:
+    QSqlDatabase m_db;
+    QString m_connectionName;
+};
+
+#endif
diff --git a/SqlQueryBuilderBase.cpp b/SqlQueryBuilderBase.cpp
new file mode 100644
index 0000000..726ac9c
--- /dev/null
+++ b/SqlQueryBuilderBase.cpp
@@ -0,0 +1,74 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlQueryBuilderBase.h"
+
+#include "SqlExceptions.h"
+#include "SqlSchema.h"
+#include "SqlCondition.h"
+#include "SqlQueryCache.h"
+
+SqlQueryBuilderBase::SqlQueryBuilderBase(const QSqlDatabase& db) :
+  m_db( db ),
+  m_query( db ),
+  m_assembled( false )
+{
+}
+
+
+
+SqlQueryBuilderBase::~SqlQueryBuilderBase()
+{
+}
+
+
+void SqlQueryBuilderBase::setTable(const QString& tableName)
+{
+    m_table = tableName;
+}
+
+void SqlQueryBuilderBase::invalidateQuery()
+{
+    m_assembled = false;
+}
+
+void SqlQueryBuilderBase::exec()
+{
+    query().exec();
+}
+
+void SqlQueryBuilderBase::bindValue(int placeholderIndex, const QVariant& value)
+{
+    const QString placeholder = QLatin1Char(':') + QString::number( placeholderIndex );
+
+    if (value.userType() == qMetaTypeId<QUuid>()) {
+         // Qt SQL drivers don't handle QUuid
+        m_query.bindValue( placeholder, value.value<QUuid>().toString() );
+    }
+
+    else if (value.userType() == qMetaTypeId<SqlNowType>()) {
+        // don't create any bindings for the SqlNow dummytype, it has been handled when assembling the query string already
+    }
+
+    else {
+        m_query.bindValue( placeholder, value );
+    }
+}
+
+QString SqlQueryBuilderBase::currentDateTime() const
+{
+    return QLatin1String("now()");
+}
+
+SqlQuery SqlQueryBuilderBase::prepareQuery(const QString& sqlStatement)
+{
+    if (SqlQueryCache::contains(m_db.connectionName(), sqlStatement)) {
+        return SqlQueryCache::query(m_db.connectionName(), sqlStatement);
+    }
+
+    SqlQuery q( m_db );
+    q.prepare( sqlStatement );
+    SqlQueryCache::insert(m_db.connectionName(), sqlStatement, q);
+    return q;
+}
diff --git a/SqlQueryBuilderBase.h b/SqlQueryBuilderBase.h
new file mode 100644
index 0000000..6deae18
--- /dev/null
+++ b/SqlQueryBuilderBase.h
@@ -0,0 +1,69 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLQUERYBUILDERBASE_H
+#define SQLQUERYBUILDERBASE_H
+#include "SqlQuery.h"
+
+#include "SqlCondition.h"
+#include "sqlate_export.h"
+#include "SqlGlobal.h"
+
+/** Abstract base class for SQL query builders. All builders should inherit from this class.
+ */
+class SQLATE_EXPORT SqlQueryBuilderBase
+{
+public:
+    /// Create a new query builder for the given database
+    explicit SqlQueryBuilderBase( const QSqlDatabase &db = QSqlDatabase::database() );
+    virtual ~SqlQueryBuilderBase();
+    /// ... FROM @p tableName ...
+    void setTable( const QString &tableName );
+    void setTable( const QLatin1String &tableName ) { setTable( QString( tableName ) ); }
+    template <typename Table>
+    void setTable( const Table & = Table() )
+    {
+        setTable( Table::sqlName() );
+    }
+
+    /// Creates the query object and executes the query. The method throws an SqlException on error.
+    virtual void exec();
+
+    /// Returns the created query object, when called first, the query object is assembled and prepared
+    /// Subclasses must implement this method. The method throws an SqlException if there is an error preparing
+    /// the query.
+    virtual SqlQuery& query() = 0;
+
+    /// Resets the internal status to "not assembled", meaning the query() call will assemble the query again.
+    /// This makes possible to modify an already existing builder object after query() was used.
+    void invalidateQuery();
+
+protected:
+    /** Binds @p value to placeholder @p placeholderIndex in m_query.
+     *  Unlike the similar methods in QSqlQuery this also applies transformations to handle types not supported
+     *  by QtSQL, such as UUID.
+     *  @note This assumes the use of named bindings in the form ":&lt;index&gt;".
+     */
+    void bindValue( int placeholderIndex, const QVariant &value );
+
+    /** Returns the SQL expression returning the current date/time on the server depending on the used database backend. */
+    QString currentDateTime() const;
+
+    /** Returns a prepared query for the given @p sqlStatement.
+     *  Unlike calling SqlQuery::prepare() manually, this will re-use cached prepared queries.
+     *  @throw SqlException if query preparation failed
+     */
+    SqlQuery prepareQuery( const QString &sqlStatement );
+
+protected:
+    friend class SelectQueryBuilderTest;
+    friend class SelectTest;
+    QSqlDatabase m_db;
+    QString m_table;
+    SqlQuery m_query;
+    QString m_queryString; // hold the assembled query string, used for unit testing
+    bool m_assembled;
+};
+
+#endif
diff --git a/SqlQueryCache.cpp b/SqlQueryCache.cpp
new file mode 100644
index 0000000..6ee2818
--- /dev/null
+++ b/SqlQueryCache.cpp
@@ -0,0 +1,40 @@
+/*
+* Copyright (C) 2012-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlQueryCache.h"
+
+#include "SqlQuery.h"
+#include <QHash>
+
+static QHash<QString, QHash<QString, SqlQuery> > g_queryCache;
+static bool g_queryCacheEnabled = true;
+
+bool SqlQueryCache::contains(const QString &dbConnectionName, const QString& queryStatement)
+{
+    if (!g_queryCacheEnabled)
+        return false;
+    return g_queryCache.contains(dbConnectionName) && g_queryCache.value(dbConnectionName).contains(queryStatement);
+}
+
+SqlQuery SqlQueryCache::query(const QString &dbConnectionName, const QString& queryStatement)
+{
+    return g_queryCache.value(dbConnectionName).value(queryStatement);
+}
+
+void SqlQueryCache::insert(const QString &dbConnectionName, const QString& queryStatement, const SqlQuery& query)
+{
+    if (g_queryCacheEnabled)
+        g_queryCache[dbConnectionName].insert(queryStatement, query);
+}
+
+void SqlQueryCache::clear()
+{
+    g_queryCache.clear();
+}
+
+void SqlQueryCache::setEnabled(bool enable)
+{
+    g_queryCacheEnabled = enable;
+    clear();
+}
diff --git a/SqlQueryCache.h b/SqlQueryCache.h
new file mode 100644
index 0000000..37a0e47
--- /dev/null
+++ b/SqlQueryCache.h
@@ -0,0 +1,34 @@
+/*
+* Copyright (C) 2012-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLQUERYCACHE_H
+#define SQLQUERYCACHE_H
+
+#include "sqlate_export.h"
+
+class QString;
+class SqlQuery;
+
+/**
+ * A per-connection cache prepared query cache.
+ */
+namespace SqlQueryCache
+{
+    /// Check whether the query @p queryStatement is cached already.
+    SQLATE_EXPORT bool contains( const QString& dbConnectionName, const QString& queryStatement );
+
+    /// Returns the cached (and prepared) query for @p queryStatement.
+    SQLATE_EXPORT SqlQuery query( const QString& dbConnectionName, const QString& queryStatement );
+
+    /// Insert @p query into the cache for @p queryStatement.
+    SQLATE_EXPORT void insert( const QString& dbConnectionName, const QString& queryStatement, const SqlQuery& query );
+
+    /// Clears the cache, must be called whenever the corresponding database connection is dropped.
+    SQLATE_EXPORT void clear();
+
+    /// Enables/disables the query cache. This can be used to temporarily disable caching while changing the db layout.
+    SQLATE_EXPORT void setEnabled( bool enable );
+}
+
+#endif
diff --git a/SqlQueryManager.cpp b/SqlQueryManager.cpp
new file mode 100644
index 0000000..13ff116
--- /dev/null
+++ b/SqlQueryManager.cpp
@@ -0,0 +1,172 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#include "SqlQueryManager.h"
+#include "SqlQuery.h"
+#include "SqlMonitor.h"
+#include "SqlQueryCache.h"
+
+#include <QApplication>
+#include <QMap>
+#include <QMessageBox>
+#include <QDebug>
+#include <QSqlDriver>
+#include <QThread>
+#include <QVariant>
+#include <QMutex>
+
+Q_GLOBAL_STATIC(QMutex, queryMutex)
+Q_GLOBAL_STATIC(QMutex, monitorMutex)
+
+SqlQueryManager* SqlQueryManager::s_instance = 0;
+
+SqlQueryManager* SqlQueryManager::instance()
+{
+  if (!s_instance)
+      s_instance = new SqlQueryManager();
+  return s_instance;
+}
+
+
+SqlQueryManager::SqlQueryManager()
+{
+}
+
+SqlQueryManager::~SqlQueryManager()
+{
+    s_instance = 0;
+}
+
+void SqlQueryManager::registerQuery(SqlQuery* query)
+{
+    QMutexLocker locker( queryMutex() );
+    m_queries.append(query);
+//Debug line that helps finding leaking queries. It is intentionally not a SQLDEBUG.
+//     qDebug() << "Registered query: " << query->lastQuery() << query;
+}
+
+void SqlQueryManager::unregisterQuery(SqlQuery* query)
+{
+    QMutexLocker locker( queryMutex() );
+    m_queries.removeAll(query);
+//Debug line that helps finding leaking queries. It is intentionally not a SQLDEBUG.
+//     qDebug() << "Unregistered query: " << query->lastQuery() << query;
+}
+
+void SqlQueryManager::registerMonitor(SqlMonitor* monitor)
+{
+    QMutexLocker locker( monitorMutex() );
+    m_monitors.append(monitor);
+}
+
+void SqlQueryManager::unregisterMonitor(SqlMonitor* monitor)
+{
+    QMutexLocker locker( monitorMutex() );
+    m_monitors.removeAll(monitor);
+}
+
+int SqlQueryManager::queryCount() const
+{
+   QMutexLocker locker( queryMutex() );
+   return m_queries.size();
+}
+
+void SqlQueryManager::printQueries() const
+{
+    QMutexLocker locker( queryMutex() );
+    //The debug lines are intentionally qDebug and not SQLDEBUG
+    qDebug() << "Live queries: ";
+    Q_FOREACH(SqlQuery *query, m_queries) {
+        qDebug() << query->lastQuery();
+    }
+}
+
+int SqlQueryManager::monitorCount() const
+{
+    QMutexLocker locker( monitorMutex() );
+    return m_monitors.size();
+}
+
+void SqlQueryManager::printMonitors() const
+{
+    QMutexLocker locker( monitorMutex() );
+    //The debug lines are intentionally qDebug and not SQLDEBUG
+    qDebug() << "Active monitors: ";
+    Q_FOREACH(SqlMonitor *monitor, m_monitors) {
+        qDebug() << "Tables: " << monitor->monitoredTables() << " Values: " << monitor->monitoredValues();
+    }
+}
+
+
+void SqlQueryManager::checkDbIsAlive(QSqlDatabase& db)
+{
+    QMutexLocker queryLocker( queryMutex() );
+    QMutexLocker monitorLocker( monitorMutex() );
+
+//     qDebug() << Q_FUNC_INFO << db.isOpen() << db.isValid() << ( !db.isOpen() || !db.isValid() );
+
+    //store all the queries and their bound values
+    QMap<SqlQuery*, QMap<QString, QVariant> > allBoundValues;
+    Q_FOREACH(SqlQuery* q, m_queries) {
+        if (q->connectionName() != db.connectionName() )
+            continue;
+        allBoundValues[q] = q->boundValues();
+    }
+    int retryCount = 0;
+    while ( !db.isOpen() || !db.isValid() ) {
+        if ( QThread::currentThread() == QCoreApplication::instance()->thread() ) {
+#if 0
+          if  ( QMessageBox::question( 0, QObject::tr("Database connection error"),
+            QObject::tr("<qt>The database is not available.<br/><br/>Press <b>Retry</b> to try again or <b>Abort</b> to terminate the application.<br />\
+            Unsaved changes are lost if you Abort.\
+            <br/><br/>If the problem persist, please inform your system administrator.</qt>"), QMessageBox::Retry | QMessageBox::Abort, QMessageBox::Retry ) == QMessageBox::Abort ) {
+              ::exit(1) ;
+           }
+#endif
+            ::exit(1);
+        }
+        retryCount++;
+        if (retryCount > 10 ) { //give up at some point
+            return;
+        }
+
+       if ( db.open() ) {
+        SqlQueryCache::clear(); // reconnected, so all cached queries are now invalid
+        //if the connection was dropped and recreated all the prepared queries are invalid, so we need to reconstruct them
+        //using the lastQuery() string and the saved bound values
+        Q_FOREACH(SqlQuery* q, m_queries ) {
+            if (q->connectionName() != db.connectionName() )
+                continue;
+            if ( !q->lastQuery().isEmpty() ) {
+                QString str = q->lastQuery();
+//                 qDebug() << "Prepare query again: " << q << str;
+                q->prepareWithoutCheck( str ); //TODO: this generates a runtime warning as the old stored query (prepare) cannot be cleaned up as it got lost. I have no idea what to do.
+                QMap<QString, QVariant> boundValues = allBoundValues[q];
+                QMap<QString, QVariant>::const_iterator it;
+                for (it = boundValues.constBegin(); it != boundValues.constEnd(); ++it) {
+                    q->bindValue( it.key(), it.value() );
+                }
+            }
+        }
+
+        //unsubscribe from all the notifications. Important to do it here for all notifications of the db, as
+        //the QPSQL implementation will not recreate the QSocketNotifier otherwise and we will not get any notifications
+        QStringList notifications = db.driver()->subscribedToNotifications();
+        Q_FOREACH(QString notification, notifications) {
+            db.driver()->unsubscribeFromNotification(notification);
+        }
+        //subscribe again to the db notifications
+        Q_FOREACH(SqlMonitor* monitor, m_monitors ) {
+            if (monitor->database().connectionName() != db.connectionName() )
+            continue;
+           monitor->resubscribe();
+        }
+       }
+    }
+}
+
+
+
+
diff --git a/SqlQueryManager.h b/SqlQueryManager.h
new file mode 100644
index 0000000..70c167c
--- /dev/null
+++ b/SqlQueryManager.h
@@ -0,0 +1,66 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#ifndef SQLQUERYMANAGER_H
+#define SQLQUERYMANAGER_H
+#include "sqlate_export.h"
+
+#include <QList>
+
+class SqlMonitor;
+class QSqlDatabase;
+class SqlQuery;
+
+/**
+ * @brief Keeps track of queries and handles unexpected database disconnections.
+ **/
+class SQLATE_EXPORT SqlQueryManager
+{
+
+public:
+    /**
+     * @brief Get an instance to the singleton object.
+     *
+     * @return SqlQueryManager*
+     **/
+    static SqlQueryManager* instance();
+
+    /**
+     * @brief Check if the database connection is still alive. If it is not, show a warning and offer
+     * the user to retry the SQL command or abort it. Abort aborts the whole application.
+     * Note that using this function might NOT detect the disconnection all the time, sometimes
+     * it detects only if there was a query run that failed. It is advised to call the function
+     * before executing/preparing a query or running other SQL commands and run once more
+     * if the command fails to test if the error was because the database connection is dropped.
+     * When SqlQuery or SqlTransaction is used there is no need to call the method,
+     * they do it themselves.
+     **/
+    void checkDbIsAlive( QSqlDatabase& db );
+
+    void registerQuery(SqlQuery* query);
+    void unregisterQuery(SqlQuery* query);
+
+    void registerMonitor(SqlMonitor *monitor);
+    void unregisterMonitor(SqlMonitor *monitor);
+
+    int  queryCount() const;
+
+    int monitorCount() const;
+
+    void printQueries() const;
+
+    void printMonitors() const;
+
+    ~SqlQueryManager();
+
+private:
+    SqlQueryManager();
+
+    static SqlQueryManager*  s_instance;
+    QList<SqlQuery*> m_queries; ///<the list of stored queries
+    QList<SqlMonitor*> m_monitors; ///<the list of stored notification monitor s
+};
+
+#endif 
diff --git a/SqlQueryWatcher.cpp b/SqlQueryWatcher.cpp
new file mode 100644
index 0000000..19b1371
--- /dev/null
+++ b/SqlQueryWatcher.cpp
@@ -0,0 +1,90 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#include "SqlQueryWatcher.h"
+
+#include <QDebug>
+#include <QTimer>
+#include <QEventLoop>
+#include <QProcess>
+#include <QMutex>
+
+#ifdef Q_OS_WIN
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
+
+#define SQL_NETWORK_TIMEOUT 30 //define how many seconds do we wait for a query finishes until the network error dialog is shown
+
+QMutex mutex;
+static bool s_dialogVisible = false;
+
+SqlQueryWatcherHelper::SqlQueryWatcherHelper(QObject* runner):QObject(0)
+{
+//     qDebug() << Q_FUNC_INFO << this;
+    m_process = 0;
+    m_timer = new QTimer();
+    m_timer->setSingleShot(true);
+    connect( m_timer, SIGNAL(timeout()), SLOT(timerExpired()) );
+    m_timer->start( SQL_NETWORK_TIMEOUT*1000 );
+}
+
+SqlQueryWatcherHelper::~SqlQueryWatcherHelper()
+{
+//     qDebug() << Q_FUNC_INFO << this;
+    delete m_timer;
+    if ( m_process ) {
+        m_process->terminate();
+        m_process->kill();
+        m_process->waitForFinished();
+    }
+    emit endWatcher();
+}
+
+void SqlQueryWatcherHelper::dialogHidden()
+{
+    QMutexLocker locker(&mutex);
+    s_dialogVisible = false;
+}
+
+
+void SqlQueryWatcherHelper::timerExpired()
+{
+    QMutexLocker locker(&mutex);
+    if ( s_dialogVisible )
+        return;
+    s_dialogVisible = true;
+    qDebug() << Q_FUNC_INFO << this;
+    m_process = new QProcess(this);
+    connect( m_process, SIGNAL(finished(int)), this, SLOT(dialogHidden()) );
+    QStringList args;
+    args << QLatin1String("-pid");
+#ifdef Q_OS_WIN
+    args << QString::number( _getpid() );
+#else
+    args << QString::number( ::getpid() );
+#endif
+
+    m_process->start( QLatin1String("queryWatcherHelper"), args );
+    m_process->waitForStarted();
+    if ( m_process->state() != QProcess::Running ) { //try to start from the build dir
+        m_process->start( QLatin1String("src/helpers/queryWatcherHelper"), args );
+        m_process->waitForStarted();
+        if ( m_process->state() != QProcess::Running ) { //try to start from the build dir
+            qWarning() << "Timer expired, query was too slow! Possible network error detected.";
+        }
+    }
+}
+
+
+void SqlQueryWatcherHelper::quit()
+{
+//     qDebug() << Q_FUNC_INFO;
+    thread()->quit();
+//     metaObject()->invokeMethod(thread(), "quit", Qt::DirectConnection);
+}
+
+#include "moc_SqlQueryWatcher.cpp"
diff --git a/SqlQueryWatcher.h b/SqlQueryWatcher.h
new file mode 100644
index 0000000..275e7a6
--- /dev/null
+++ b/SqlQueryWatcher.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#ifndef SQLQUERYWATCHER_H
+#define SQLQUERYWATCHER_H
+
+#include "sqlate_export.h"
+
+#include <QThread>
+
+class QTimer;
+class QProcess;
+
+/** The actual watcher class, instantiated from a KDThreadRunner thread */
+class SQLATE_EXPORT SqlQueryWatcherHelper : public QObject {
+Q_OBJECT
+public:
+    SqlQueryWatcherHelper(QObject* runner);
+    virtual ~SqlQueryWatcherHelper();
+
+public Q_SLOTS:
+    void quit();
+
+private Q_SLOTS:
+    void timerExpired();
+    void dialogHidden();
+
+Q_SIGNALS:
+     void endWatcher();   
+    
+private:
+    QTimer *m_timer;
+    QProcess *m_process;
+};
+
+#endif 
diff --git a/SqlResources.qrc b/SqlResources.qrc
new file mode 100644
index 0000000..0b7e7ad
--- /dev/null
+++ b/SqlResources.qrc
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/sql">
+        <file>procedures/pre-create/ACLTriggerFunctions.tsp</file>
+    </qresource>
+</RCC>
diff --git a/SqlSchema.cpp b/SqlSchema.cpp
new file mode 100644
index 0000000..02b1b57
--- /dev/null
+++ b/SqlSchema.cpp
@@ -0,0 +1,7 @@
+#include "SqlSchema.h"
+
+namespace Sql {
+
+
+
+}
diff --git a/SqlSchema.h b/SqlSchema.h
new file mode 100644
index 0000000..0e60ef0
--- /dev/null
+++ b/SqlSchema.h
@@ -0,0 +1,23 @@
+#ifndef SQLSCHEMA_H
+#define SQLSCHEMA_H
+
+#include "SqlSchema_p.h"
+
+#include <QUuid>
+#include <QVariant>
+
+Q_DECLARE_METATYPE( QUuid )
+Q_DECLARE_METATYPE( QList<QUuid> )
+
+
+/**
+ * @file SqlSchema.h
+ * Database schema definition
+ */
+
+namespace Sql {
+
+
+}
+
+#endif
diff --git a/SqlSchema_p.h b/SqlSchema_p.h
new file mode 100644
index 0000000..cb40fa3
--- /dev/null
+++ b/SqlSchema_p.h
@@ -0,0 +1,311 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLSCHEMA_P_H
+#define SQLSCHEMA_P_H
+
+#include "SqlInternals_p.h"
+#include "sqlate_export.h"
+#include <QLatin1Literal>
+#include <QUuid>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/preprocessor/seq.hpp>
+
+/**
+ * @file SqlSchema_p.h
+ * Database schema related internal classes and functions.
+ */
+
+
+/** Stringification of SQL identifier names, used in table and column classes. */
+#define SQL_NAME( x ) \
+   static QString sqlName() { return QLatin1String(x); }
+
+/** Convenience macro to create column types.
+ *  Use inside a table declaration.
+ */
+#define COLUMN( name, type, ... ) \
+    struct name ## Type : Column< name ## Type, type , ## __VA_ARGS__ > { SQL_NAME( #name ) } name
+
+/** Convenience macro to create a column alias.
+  * Use inside a table definition to asign a different name to an existing column.
+  */
+#define COLUMN_ALIAS( column, alias ) \
+    typedef column ## Type alias ## Type; \
+    alias ## Type alias
+
+/** Convenience macro for creating foreign key columns with the default legacy fk_[table]_[col] name.
+ *  Use inside a table declaration.
+ */
+#define FOREIGN_KEY( name, fkTab, fkCol, ... ) \
+    struct name ## Type : ForeignKey< name ## Type, fkTab ## Type :: fkCol ## Type , ## __VA_ARGS__ > { \
+        static QString sqlName() { return QLatin1Literal( "fk_" ) % referenced_column::table::tableName() % QLatin1Char('_' ) % referenced_column::sqlName(); } \
+    } name
+
+/** Convenience macro for creating foreign key columns .
+ *  Use inside a table declaration.
+ */
+#define NAMED_FOREIGN_KEY( name, fkTab, fkCol, ... ) \
+    struct name ## Type : ForeignKey< name ## Type, fkTab ## Type :: fkCol ## Type , ## __VA_ARGS__ > { SQL_NAME( #name ) } name
+
+/** Convenience macro to create a table with non-updatable rows type. Put after one of the TABLE macros.*/
+#define NO_USER_UPDATE \
+    typedef boost::mpl::false_ update_rows;
+
+/** Convenience macro to create a table with non-deletable rows type. Put after one of the TABLE macros.*/
+#define NO_USER_DELETE \
+    typedef boost::mpl::false_ delete_rows;
+
+/** Convenience macro to create a table with non-insertable rows type. Put after one of the TABLE macros.*/
+#define NO_USER_INSERT \
+    typedef boost::mpl::false_ insert_rows;
+
+/** Convenience macro to create a restricted table type: only SELECT is allowed. Put after one of the TABLE macros.
+ * Same as using NO_USER_UPDATE, NO_USER_DELETE, NO_USER_INSERT together
+ */
+#define ONLY_USER_SELECT \
+    typedef boost::mpl::true_ is_restricted;
+
+/** Convenience macro to create a table type. */
+#define TABLE( name, _EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : Table< name ## Type >
+
+/** Convenience macro to create a lookup table type. */
+#define LOOKUP_TABLE( name, _EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : LookupTable< name ## Type >
+
+/** Convenience macro to create a n:m helper table type. */
+#define RELATION( name, leftTab, leftCol, rightTab, rightCol,_EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : Relation< name ## Type, leftTab ## Type :: leftCol ## Type, rightTab ## Type :: rightCol ## Type>
+
+/** Convenience macro to create a n:m helper table type. */
+#define UNIQUE_RELATION( name, leftTab, leftCol, rightTab, rightCol,_EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : UniqueRelation< name ## Type, leftTab ## Type :: leftCol ## Type, rightTab ## Type :: rightCol ## Type>
+
+/** Convenience macro to create a recursive n:m helper table type. */
+#define RECURSIVE_RELATION( name, tab, col, _EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : RecursiveRelation< name ## Type, tab ## Type :: col ## Type >
+
+/** Convenience macro to create a recursive n:m helper table type. */
+#define UNIQUE_RECURSIVE_RELATION( name, tab, col, _EXPORT ) \
+    struct name ## Type; \
+    extern _EXPORT name ## Type name; \
+    struct name ## Type : UniqueRecursiveRelation< name ## Type, tab ## Type :: col ## Type >
+
+/** Convenience macro to create the schema declaration. */
+#define DECLARE_SCHEMA_MAKE_TYPE( r, unused, i, t ) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(t, Type)
+#define DECLARE_SCHEMA( name, seq ) typedef boost::mpl::vector<BOOST_PP_SEQ_FOR_EACH_I(DECLARE_SCHEMA_MAKE_TYPE, ~, seq)> name
+
+/** Convenience macro to create the schema definition. */
+#define DEFINE_SCHEMA_MAKE_DEF( r, unused, t ) BOOST_PP_CAT(t, Type) t;
+#define DEFINE_SCHEMA( seq ) BOOST_PP_SEQ_FOR_EACH(DEFINE_SCHEMA_MAKE_DEF, ~, seq)
+
+
+namespace Sql {
+
+/**
+ * Properties of SQL columns.
+ */
+enum ColumnProperties
+{
+    Null = 0, ///< column can be NULL
+    NotNull = 1, ///< column must not be NULL
+    Unique = 2, ///< column content must be unique
+    PrimaryKey = 4 | NotNull | Unique, ///< column is the primary key
+    Default = 8, ///< Use default value
+    OnDeleteCascade = 16, ///< For foreign key constraints, cascade on deletion.
+    OnDeleteRestrict = 32, ///< for foreign key constraints, restrict deletion.
+    OnUserUpdateRestrict = 64, ///< Restrict update for regular users. For this to work there must be an is_administrator() stored procedure that checks if the current user is administrator or not.
+    Notify = 128 ///< When an UPDATE is made on a row, emit a signal containing the content of the column for this row, and an encoded string corresponding to the column name.
+};
+
+/**
+ * Multi-column uniqeness table constraint.
+ * @tparam ColList An MPL sequence of columns whose tuple needs to be unique table-wide
+ */
+template <typename ColList>
+struct UniqueConstraint
+{
+    typedef ColList columns;
+};
+
+
+/**
+ * Base class for SQL table types.
+ * @tparam DerivedTable CRTP
+ */
+template<typename DerivedTable>
+struct Table
+{
+    typedef boost::mpl::false_ is_lookup_table;
+    typedef boost::mpl::false_ is_relation;
+    typedef boost::mpl::false_ is_restricted; //regular users can only select it
+    typedef boost::mpl::true_ delete_rows;    //regular users can delete rows from it. _is_restricted takes precendece
+    typedef boost::mpl::true_ update_rows;    //regular users can update rows from it. _is_restricted takes precendece
+    typedef boost::mpl::true_ insert_rows;    //regular users can insert rows from it. _is_restricted takes precendece
+
+    /**
+     * Base class for SQL columns of table @p DerivedTable
+     * @tparam Derived CRTP
+     * @tparam ColumnType The C++ data type of this column
+     * @tparam P Column property flags
+     * @tparam Size The maximum size of the column (-1 for unrestricted)
+     */
+    template <typename Derived, typename ColumnType, int P = Sql::Null, int Size = -1>
+    struct Column
+    {
+        /** C++ type of this column. */
+        typedef ColumnType type;
+        /** The table this column is in. */
+        typedef DerivedTable table;
+        /** The maximum size of this column, -1 means no restrictions. */
+        static const int size = Size;
+
+        /** For identification of column classes in WhereExpr operators. */
+        typedef boost::mpl::true_ is_column;
+
+        typedef boost::mpl::false_ hasForeignKey;
+        typedef typename boost::mpl::if_c<(P & NotNull) != 0, boost::mpl::true_, boost::mpl::false_>::type notNull;
+        typedef typename boost::mpl::if_c<(P & Unique) != 0, boost::mpl::true_, boost::mpl::false_>::type unique;
+        typedef typename boost::mpl::if_c<((P & PrimaryKey) == PrimaryKey), boost::mpl::true_, boost::mpl::false_>::type primaryKey;
+        typedef typename boost::mpl::if_c<(P & Default) != 0, boost::mpl::true_, boost::mpl::false_>::type useDefault;
+        typedef typename boost::mpl::if_c<(P & OnUserUpdateRestrict) != 0, boost::mpl::true_, boost::mpl::false_>::type onUserUpdateRestrict;
+        typedef typename boost::mpl::if_c<(P & Notify) != 0, boost::mpl::true_, boost::mpl::false_>::type notify;
+
+        /** Returns the fully qualified name of this column, ie. "tableName.columnName". */
+        static QString name() { return DerivedTable::sqlName() % QLatin1Char('.') % Derived::sqlName(); }
+    };
+
+    /**
+     * Base class for SQL foreign key columns of table @p DerivedTable.
+     * @tparam Derived CRTP
+     * @tparam ForeignColumn Type of the column this one is a reference on.
+     * @tparam P Property flags.
+     */
+    template <typename Derived, typename ForeignColumn, int P = Sql::NotNull>
+    struct ForeignKey : Column<Derived, typename ForeignColumn::type, P>
+    {
+        typedef ForeignColumn referenced_column;
+        typedef boost::mpl::true_ hasForeignKey;
+
+        typedef typename boost::mpl::if_c<(P & OnDeleteCascade) != 0, boost::mpl::true_, boost::mpl::false_>::type onDeleteCascade;
+        typedef typename boost::mpl::if_c<(P & OnDeleteRestrict) != 0, boost::mpl::true_, boost::mpl::false_>::type onDeleteRestrict;
+    };
+
+    /** Returns the SQL identifier of this table. */
+    static QString tableName() { return DerivedTable::sqlName(); }
+
+    /** Sequence of table constraints. */
+    typedef boost::mpl::vector<> constraints;
+    typedef constraints baseConstraints;
+};
+
+/**
+ * Base class for lookup tables
+ * @tparam DerivedTable CRTP
+ */
+template<typename DerivedTable>
+struct LookupTable : Table<DerivedTable>
+{
+    typedef boost::mpl::true_ is_lookup_table;
+    typedef boost::mpl::true_ is_restricted;
+    typedef Table<DerivedTable> base_type; // needed for MSVC to compile the follow lines...
+    struct idType : base_type::template Column<idType, QUuid, Sql::PrimaryKey> { SQL_NAME( "id" ) } id;
+    struct shortDescriptionType : base_type::template Column<shortDescriptionType, QString, Null, 128> { SQL_NAME( "short_desc" ) } shortDescription;
+    struct descriptionType : base_type::template Column<descriptionType, QString, Null, 255> { SQL_NAME( "description" ) } description;
+    typedef boost::mpl::vector<idType, shortDescriptionType, descriptionType> columns;
+    typedef columns baseColumns;
+};
+
+/**
+ * Base class for n:m relation tables
+ * @tparam DerivedTable CRTP
+ * @tparam LeftColumn Column type of the lhs of the mapping.
+ * @tparam RightColumn Column type of the rhs of the mapping.
+ */
+template<typename DerivedTable, typename LeftColumn, typename RightColumn>
+struct Relation : Table<DerivedTable>
+{
+    typedef boost::mpl::true_ is_relation;
+    typedef Table<DerivedTable> base_type;
+    struct leftType : base_type::template ForeignKey<leftType, LeftColumn>
+    {
+        static QString sqlName() { return QLatin1Literal( "fk_" ) % LeftColumn::table::sqlName() % QLatin1Char('_' ) % LeftColumn::sqlName(); }
+    } left;
+    struct rightType : base_type::template ForeignKey<rightType, RightColumn>
+    {
+        static QString sqlName() { return QLatin1Literal( "fk_" ) % RightColumn::table::sqlName() % QLatin1Char('_' ) % RightColumn::sqlName(); }
+    } right;
+
+    typedef boost::mpl::vector<leftType, rightType> columns;
+    typedef columns baseColumns;
+};
+
+/**
+ * Convenience class for unique n:m releation helper classes.
+ * @see Relataion
+ */
+template <typename DerivedTable, typename LeftColumn, typename RightColumn>
+struct UniqueRelation : Relation<DerivedTable, LeftColumn, RightColumn>
+{
+    typedef Relation<DerivedTable, LeftColumn, RightColumn> base_type; // needed for MSVC to compile the follow lines...
+    typedef boost::mpl::vector< UniqueConstraint< typename base_type::columns > > constraints;
+};
+
+/**
+ * Base class recursive n:m relation tables
+ * Basically a Relation pointing to the same column with both sides of the mapping.
+ * @tparam DerivedTable CRTP
+ * @tparam ColumnT The column this mapping works on.
+ */
+template<typename DerivedTable, typename ColumnT>
+struct RecursiveRelation : Table<DerivedTable>
+{
+    typedef boost::mpl::true_ is_relation;
+    typedef Table<DerivedTable> base_type;
+    struct leftType : base_type::template ForeignKey<leftType, ColumnT>
+    {
+        static QString sqlName() { return QLatin1Literal( "fk_" ) % ColumnT::table::sqlName() % QLatin1Char('_') % ColumnT::sqlName(); }
+    } left;
+    struct rightType : base_type::template ForeignKey<rightType, ColumnT>
+    {
+        static QString sqlName() { return QLatin1Literal( "fk_" ) % ColumnT::table::sqlName() % QLatin1Char('_') % ColumnT::sqlName() % QLatin1Literal("_link"); }
+    } right;
+
+    typedef boost::mpl::vector<leftType, rightType> columns;
+    typedef columns baseColumns;
+};
+
+/**
+ * Convenience class for unique recursive n:m releation helper classes.
+ * @see RecursiveRelataion
+ */
+template <typename DerivedTable, typename ColumnT>
+struct UniqueRecursiveRelation : RecursiveRelation<DerivedTable, ColumnT>
+{
+    typedef RecursiveRelation<DerivedTable, ColumnT> base_type;
+    typedef boost::mpl::vector< UniqueConstraint< typename base_type::columns > > constraints;
+};
+
+
+}
+
+#endif
diff --git a/SqlSelect.h b/SqlSelect.h
new file mode 100644
index 0000000..1b77634
--- /dev/null
+++ b/SqlSelect.h
@@ -0,0 +1,595 @@
+/*
+* Copyright (C) 2011-2013 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*         Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQL_SELECT_H
+#define SQL_SELECT_H
+
+#include "SqlInternals_p.h"
+#include "SqlSchema_p.h"
+#include "SqlCondition.h"
+#include "SqlSelectQueryBuilder.h"
+#include "SqlGlobal.h"
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/static_assert.hpp>
+
+/**
+ * @file SqlSelect.h
+ * Select query expression templates.
+ */
+
+namespace Sql {
+
+template <typename SubConditionList, SqlCondition::LogicOperator> struct ConditionExpr;
+template <typename Lhs, SqlCondition::CompareOperator, typename Rhs> struct ConditionColumnLeaf;
+template <typename Lhs, SqlCondition::CompareOperator, typename Rhs> struct ConditionValueLeaf;
+template <typename Lhs, SqlCondition::CompareOperator, typename Rhs> struct ConditionPlaceholderLeaf;
+
+namespace detail {
+
+/**
+ * MPL for_each accumulator to add columns to the query builder.
+ * @internal
+ */
+struct columns_to_querybuilder
+{
+    explicit columns_to_querybuilder( SqlSelectQueryBuilder &qb ) : m_qb( qb ) {}
+    template<typename C> void operator()( wrap<C> )
+    {
+        m_qb.addColumn( C::name() );
+    }
+
+    SqlSelectQueryBuilder &m_qb;
+};
+
+/**
+ * MPL for_each accumulator to add group by columnt to the query builder.
+ * @internal
+ */
+struct groupby_to_querybuilder
+{
+    explicit groupby_to_querybuilder( SqlSelectQueryBuilder &qb ) : m_qb( qb ) {}
+    template <typename C> void operator() ( wrap<C> )
+    {
+        m_qb.addGroupColumn( C::name() );
+    }
+    SqlSelectQueryBuilder &m_qb;
+};
+
+/**
+ * Add a ConditionLeaf to an existing SqlCondition for SQL code generation.
+ * @internal
+ */
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+void append_condition( SqlCondition &cond, const ConditionColumnLeaf<Lhs, Comp, Rhs> & )
+{
+    cond.addColumnCondition( Lhs(), Comp, Rhs() );
+}
+
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+void append_condition( SqlCondition &cond, const ConditionValueLeaf<Lhs, Comp, Rhs> &leaf )
+{
+    cond.addValueCondition( Lhs::name(), Comp, leaf.value );
+}
+
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+void append_condition( SqlCondition &cond, const ConditionPlaceholderLeaf<Lhs, Comp, Rhs> &leaf )
+{
+    cond.addPlaceholderCondition( Lhs::name(), Comp, leaf.placeholder );
+}
+
+/**
+ * Metafunction to identify condition expressions.
+ * @internal
+ */
+template <typename T>
+struct is_condition_expr : boost::mpl::false_ {};
+
+template <typename SubConditionList, SqlCondition::LogicOperator Op>
+struct is_condition_expr<ConditionExpr<SubConditionList, Op> > : boost::mpl::true_ {};
+
+/**
+ * Metafunction to wrap a single condition leaf into an condition expression.
+ * @tparam T a condition leaf or a condition expression
+ * @internal
+ */
+template <typename T>
+struct wrap_condition_leaf
+{
+    typedef typename boost::mpl::if_<is_condition_expr<T>, T, ConditionExpr<boost::mpl::vector<T>, SqlCondition::And> >::type type;
+};
+
+template <typename T>
+typename boost::enable_if<is_condition_expr<T>, void>::type
+assign_condition( SqlCondition &cond, const T &expr ) { cond = expr.condition; }
+
+template <typename T>
+typename boost::disable_if<is_condition_expr<T>, void>::type
+assign_condition( SqlCondition &cond, const T &leaf ) { append_condition( cond, leaf ); }
+
+/**
+ * Container for runtime information of joins.
+ * @internal
+ */
+struct JoinInfo {
+    SqlSelectQueryBuilder::JoinType type;
+    QString table;
+    SqlCondition condition;
+};
+
+/**
+ * Container for runtime information about ordering
+ * @internal
+ */
+struct OrderInfo {
+    QString column;
+    Qt::SortOrder order;
+};
+
+}
+
+/**
+ * Represents a single node in a conditional expression
+ * @internal
+ * @tparam Derived CRTP
+ * @tparam Lhs Left hand side statement
+ * @tparam Comp Comparator type
+ * @tparam Rhs Right hand side statement
+ */
+template <template <typename, SqlCondition::CompareOperator, typename> class Derived, typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+struct ConditionLeaf
+{
+    ConditionLeaf() {}
+
+    /**
+     * Logic operators for combining two leafs.
+     */
+    template <typename ConditionLeaf2>
+    ConditionExpr<boost::mpl::vector<Derived<Lhs, Comp, Rhs>, ConditionLeaf2>, SqlCondition::And> operator&&( const ConditionLeaf2& l2 ) const
+    {
+        ConditionExpr<boost::mpl::vector<Derived<Lhs, Comp, Rhs>, ConditionLeaf2>, SqlCondition::And> newCond;
+        newCond.condition.setLogicOperator( SqlCondition::And );
+        detail::append_condition( newCond.condition, *static_cast<const Derived<Lhs, Comp, Rhs>*>( this ) );
+        detail::append_condition( newCond.condition, l2 );
+        return newCond;
+    }
+
+    template <typename ConditionLeaf2>
+    ConditionExpr<boost::mpl::vector<Derived<Lhs, Comp, Rhs>, ConditionLeaf2>, SqlCondition::Or> operator||( const ConditionLeaf2& l2 ) const
+    {
+        ConditionExpr<boost::mpl::vector<Derived<Lhs, Comp, Rhs>, ConditionLeaf2>, SqlCondition::Or> newCond;
+        newCond.condition.setLogicOperator( SqlCondition::Or );
+        detail::append_condition( newCond.condition, *static_cast<const Derived<Lhs, Comp, Rhs>*>( this ) );
+        detail::append_condition( newCond.condition, l2 );
+        return newCond;
+    }
+};
+
+/**
+ * Represents a single column condition.
+ * @internal
+ */
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+struct ConditionColumnLeaf : ConditionLeaf<ConditionColumnLeaf, Lhs, Comp, Rhs> {};
+
+/**
+ * Represents a single value condition.
+ * @internal
+ */
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs>
+struct ConditionValueLeaf : ConditionLeaf<ConditionValueLeaf, Lhs, Comp, Rhs>
+{
+    QVariant value;
+};
+
+/**
+ * Represents a single placeholder condition.
+ * @internal
+ */
+template <typename Lhs, SqlCondition::CompareOperator Comp, typename Rhs = detail::missing>
+struct ConditionPlaceholderLeaf : ConditionLeaf<ConditionPlaceholderLeaf, Lhs, Comp, Rhs>
+{
+    QString placeholder;
+};
+
+/**
+ * Create a placeholder in conditional expressions for later binding.
+ * @param name The placeholder name.
+ */
+struct placeholder {
+    explicit placeholder( const QString &name ) : m_name( name ) {}
+    explicit placeholder( const char* name ) : m_name( QString::fromLatin1( name ) ) {}
+
+    QString m_name;
+};
+
+/**
+ * Represents a complex conditional expression
+ * @internal
+ * @tparam SubConditionList A MPL sequence of conditions
+ * @tparam LogicOp The logical operator used to combine those conditions
+ */
+template <typename SubConditionList, SqlCondition::LogicOperator LogicOp>
+struct ConditionExpr
+{
+    /**
+     * Logic operators to add another leaf.
+     */
+    template <typename Leaf2>
+    typename boost::enable_if_c<(LogicOp == SqlCondition::And), ConditionExpr<typename boost::mpl::push_back<SubConditionList, Leaf2>::type, LogicOp> >::type
+    operator&&( const Leaf2 &l2 )
+    {
+        ConditionExpr<typename boost::mpl::push_back<SubConditionList, Leaf2>::type, LogicOp> newCond;
+        newCond.condition = condition;
+        detail::append_condition( newCond.condition, l2 );
+        return newCond;
+    }
+
+    template <typename Leaf2>
+    typename boost::enable_if_c<(LogicOp == SqlCondition::Or), ConditionExpr<typename boost::mpl::push_back<SubConditionList, Leaf2>::type, LogicOp> >::type
+    operator||( const Leaf2 &l2 )
+    {
+        ConditionExpr<typename boost::mpl::push_back<SubConditionList, Leaf2>::type, LogicOp> newCond;
+        newCond.condition = condition;
+        detail::append_condition( newCond.condition, l2 );
+        return newCond;
+    }
+
+    SqlCondition condition;
+};
+
+
+/*
+ * Operators for creating ConditionLeaf instances based on at least one column object.
+ */
+
+template <typename ColumnT>
+typename boost::enable_if<typename ColumnT::is_column, ConditionValueLeaf<ColumnT, SqlCondition::Equals, typename ColumnT::type> >::type
+operator==( const ColumnT &, const typename ColumnT::type& value )
+{
+    ConditionValueLeaf<ColumnT, SqlCondition::Equals, typename ColumnT::type> newCond;
+    newCond.value = QVariant::fromValue( value );
+    return newCond;
+}
+
+
+template <typename ColumnT1, typename ColumnT2>
+typename boost::enable_if<boost::mpl::and_<typename ColumnT1::is_column, typename ColumnT2::is_column>, ConditionColumnLeaf<ColumnT1, SqlCondition::Equals, ColumnT2> >::type
+operator==( const ColumnT1&, const ColumnT2& )
+{
+    BOOST_MPL_ASSERT(( boost::is_same<typename ColumnT1::type, typename ColumnT2::type> )); // only compare columns of the same type
+    return ConditionColumnLeaf<ColumnT1, SqlCondition::Equals, ColumnT2>();
+}
+
+template <typename ColumnT1>
+typename boost::enable_if<typename ColumnT1::is_column, ConditionPlaceholderLeaf<ColumnT1, SqlCondition::Equals> >::type
+operator==( const ColumnT1& , const placeholder &p )
+{
+    ConditionPlaceholderLeaf<ColumnT1, SqlCondition::Equals> c;
+    c.placeholder = p.m_name;
+    return c;
+}
+
+/**
+ * Create column IS NOT NULL condition.
+ * @tparam ColumnT The column type.
+ */
+template <typename ColumnT>
+ConditionValueLeaf<ColumnT, SqlCondition::IsNot, QVariant>
+isNotNull( const ColumnT & )
+{
+    return ConditionValueLeaf<ColumnT, SqlCondition::IsNot, QVariant>();
+}
+
+/**
+ * Create column IS NULL condition.
+ * @tparam ColumnT The column type.
+ */
+template <typename ColumnT>
+ConditionValueLeaf<ColumnT, SqlCondition::Is, QVariant>
+isNull( const ColumnT & )
+{
+    BOOST_MPL_ASSERT(( boost::mpl::not_<typename ColumnT::notNull> )); // IS NULL conditions on NOT NULL columns don't make sense
+    return ConditionValueLeaf<ColumnT, SqlCondition::Is, QVariant>();
+}
+
+/**
+ * Creates a LIKE condition.
+ * @tparam ColumnT The column type to match the pattern against, must have a string type.
+ */
+template <typename ColumnT>
+ConditionValueLeaf<ColumnT, SqlCondition::Like, QString>
+like( const ColumnT &, const QString &pattern )
+{
+    BOOST_MPL_ASSERT(( boost::is_same<typename ColumnT::type, QString> )); // pattern matching only works for strings
+    ConditionValueLeaf<ColumnT, SqlCondition::Like, QString> c;
+    c.value = pattern;
+    return c;
+}
+
+
+/**
+ * Represents a JOIN statement
+ * @internal
+ * @tparam TableT The table to join with
+ * @tparam JoinCond The condition to join on
+ */
+template <typename TableT, typename JoinCond>
+struct JoinExpr
+{
+};
+
+
+/**
+ * Represents a SELECT statement
+ * @internal
+ * @tparam ColumnList A MPL sequence of selected column types.
+ * @tparam TableT The table type selected from.
+ * @tparam JoinList A list of join expressions
+ * @tparam GroupByList A MPL sequence of columns to group.
+ * @tparam WhereExprT The WHERE expression.
+ */
+template <typename ColumnList, typename TableT, typename JoinList, typename WhereExprT,
+          typename GroupByList = boost::mpl::vector<>,
+          typename SortList = boost::mpl::vector<> >
+struct SelectExpr
+{
+    /**
+     * Empty ctor.
+     */
+    SelectExpr() {}
+
+    /**
+     * "Copy" ctor.
+     */
+    template <typename OtherColumnList, typename OtherTableT, typename OtherJoinList, typename OtherWhereExprT, typename OtherGroupByList, typename OtherSortList>
+    explicit
+    SelectExpr( const SelectExpr<OtherColumnList, OtherTableT, OtherJoinList, OtherWhereExprT, OtherGroupByList, OtherSortList> &other )
+    {
+        whereCondition = other.whereCondition;
+        joinInfos = other.joinInfos;
+        orderInfos = other.orderInfos;
+    }
+
+    /**
+     * Creates the FROM part of a SELECT statement.
+     * @tparam T The table type to select from
+     */
+    template <typename T>
+    SelectExpr<ColumnList, T, JoinList, WhereExprT, GroupByList, SortList> from( const T& )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<TableT, detail::missing> )); // only one from allowed
+        return SelectExpr<ColumnList, T, JoinList, WhereExprT, GroupByList, SortList>();
+    }
+
+    /**
+     * Create the WHERE part of a SELECT statement.
+     * @tparam W The where experession
+     */
+    template <typename W>
+    SelectExpr<ColumnList, TableT, JoinList, typename detail::wrap_condition_leaf<W>::type, GroupByList, SortList> where( const W& cond )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<WhereExprT, detail::missing> )); // only one where allowed
+        SelectExpr<ColumnList, TableT, JoinList, typename detail::wrap_condition_leaf<W>::type, GroupByList, SortList> s( *this );
+        detail::assign_condition( s.whereCondition, cond );
+        return s;
+    }
+
+    /**
+     * Add a JOIN expression
+     * @tparam T The table to join.
+     * @tparam JoinCond The condition to join on.
+     */
+    #define MAKE_JOIN_METHOD( methodName, joinType ) \
+    template <typename T, typename JoinCond> \
+    SelectExpr<ColumnList, TableT, typename boost::mpl::push_back<JoinList, JoinExpr<T, JoinCond> >::type , WhereExprT, GroupByList, SortList> \
+    methodName ( const T&, const JoinCond &cond ) \
+    { \
+        BOOST_MPL_ASSERT(( boost::is_same<WhereExprT, detail::missing> )); /* join comes before WHERE */ \
+        SelectExpr<ColumnList, TableT, typename boost::mpl::push_back<JoinList, JoinExpr<T, JoinCond> >::type, WhereExprT, GroupByList, SortList> s( *this ); \
+        detail::JoinInfo ji; \
+        ji.type = SqlSelectQueryBuilder:: joinType; \
+        ji.table = T::tableName(); \
+        detail::assign_condition( ji.condition, cond ); \
+        s.joinInfos.push_back( ji ); \
+        return s; \
+    }
+    MAKE_JOIN_METHOD( innerJoin, InnerJoin )
+    MAKE_JOIN_METHOD( leftOuterJoin, LeftOuterJoin )
+    MAKE_JOIN_METHOD( rightOuterJoin, RightOuterJoin )
+    MAKE_JOIN_METHOD( fullOuterJoin, FullOuterJoin )
+    MAKE_JOIN_METHOD( crossJoin, CrossJoin )
+    #undef MAKE_JOIN_METHOD
+
+    /**
+     * Add GROUP BY expressions.
+     * @tparam Tn Column to group.
+     */
+    #ifndef SQL_GROUP_BY_MAX_SIZE
+    #define SQL_GROUP_BY_MAX_SIZE 5
+    #endif
+    #define CONST_REF(z, n, unused) const T ## n &
+    #define GROUP_BY_IMPL(z, n, unused) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+    SelectExpr<ColumnList, TableT, JoinList, WhereExprT, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)>, SortList> \
+    groupBy( BOOST_PP_ENUM(n, CONST_REF, ~) ) \
+    { \
+        BOOST_MPL_ASSERT(( boost::mpl::not_<boost::is_same<TableT, detail::missing> > )); /* FROM comes before GROUP BY */ \
+        BOOST_STATIC_ASSERT(( boost::mpl::size<GroupByList>::value == 0 )); /* only one GROUP BY */ \
+        return SelectExpr<ColumnList, TableT, JoinList, WhereExprT, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)>, SortList>( *this ); \
+    }
+    BOOST_PP_REPEAT_FROM_TO(1, SQL_GROUP_BY_MAX_SIZE, GROUP_BY_IMPL, ~)
+
+    #undef GROUP_BY_IMPL
+    #undef CONST_REF
+
+
+    /**
+     * Add ORDER BY expressions.
+     */
+    #ifndef SQL_ORDER_BY_MAX_SIZE
+    #define SQL_ORDER_BY_MAX_SIZE 3
+    #endif
+
+    #define RECORD_ORDER_INFO(z, n, unused) \
+    { \
+        detail::OrderInfo oi; \
+        oi.column = T ## n :: name(); \
+        oi.order = Qt::AscendingOrder; \
+        s.orderInfos.push_back( oi ); \
+    }
+    #define CONST_REF(z, n, unused) const T ## n &
+    #define ORDER_BY_IMPL(z, n, unused) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+    SelectExpr<ColumnList, TableT, JoinList, WhereExprT, GroupByList, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)> > orderBy( \
+        BOOST_PP_ENUM(n, CONST_REF, ~) ) \
+    { \
+        BOOST_MPL_ASSERT(( boost::mpl::not_<boost::is_same<TableT, detail::missing> > )); /* FROM comes before ORDER BY */ \
+        BOOST_STATIC_ASSERT(( boost::mpl::size<SortList>::value == 0 )); /* only one ORDER BY */ \
+        SelectExpr<ColumnList, TableT, JoinList, WhereExprT, GroupByList, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)> > s( *this ); \
+        BOOST_PP_REPEAT(n, RECORD_ORDER_INFO, ~) \
+        return s; \
+    }
+    BOOST_PP_REPEAT_FROM_TO(1, SQL_ORDER_BY_MAX_SIZE, ORDER_BY_IMPL, ~)
+
+    #undef ORDER_BY_IMPL
+    #undef CONST_REF
+    #undef RECORD_ORDER_INFO
+
+    #define RECORD_ORDER_INFO(z, n, unused) \
+    { \
+        detail::OrderInfo oi; \
+        oi.column = T ## n :: name(); \
+        oi.order = order ## n; \
+        s.orderInfos.push_back( oi ); \
+    }
+    #define CONST_REF_AND_ORDER(z, n, unused) const T ## n &, Qt::SortOrder order ## n
+    #define ORDER_BY_IMPL(z, n, unused) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+    SelectExpr<ColumnList, TableT, JoinList, WhereExprT, GroupByList, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)> > orderBy( \
+        BOOST_PP_ENUM(n, CONST_REF_AND_ORDER, ~) ) \
+    { \
+        BOOST_MPL_ASSERT(( boost::mpl::not_<boost::is_same<TableT, detail::missing> > )); /* FROM comes before ORDER BY */ \
+        BOOST_STATIC_ASSERT(( boost::mpl::size<SortList>::value == 0 )); /* only one ORDER BY */ \
+        SelectExpr<ColumnList, TableT, JoinList, WhereExprT, GroupByList, boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)> > s( *this ); \
+        BOOST_PP_REPEAT(n, RECORD_ORDER_INFO, ~) \
+        return s; \
+    }
+    BOOST_PP_REPEAT_FROM_TO(1, SQL_ORDER_BY_MAX_SIZE, ORDER_BY_IMPL, ~)
+
+    #undef ORDER_BY_IMPL
+    #undef CONST_REF_AND_ORDER
+    #undef RECORD_ORDER_INFO
+
+    /**
+     * @internal
+     * for unit testing access only
+     */
+    SqlSelectQueryBuilder queryBuilder() const
+    {
+        SqlSelectQueryBuilder qb;
+        boost::mpl::for_each<ColumnList, detail::wrap<boost::mpl::placeholders::_1> >( detail::columns_to_querybuilder( qb ) );
+        qb.setTable<TableT>();
+        foreach ( const detail::JoinInfo& ji, joinInfos )
+            qb.addJoin( ji.type, ji.table, ji.condition );
+        qb.whereCondition() = whereCondition;
+        boost::mpl::for_each<GroupByList, detail::wrap<boost::mpl::placeholders::_1> >( detail::groupby_to_querybuilder( qb ) );
+        foreach ( const detail::OrderInfo &oi, orderInfos )
+            qb.addSortColumn( oi.column, oi.order );
+        return qb;
+    }
+
+    /**
+     * Returns a prepared QSqlQuery ready for execution.
+     */
+    operator SqlQuery() const
+    {
+        return queryBuilder().query();
+    }
+
+    /**
+     * Returns the pre-filled dynamic query builder.
+     * This is useful if intermediate queries have to be stored for extension etc.
+     * Since we don't have support for the auto keyword everywhere yet, that's currently our best option.
+     */
+    operator SqlSelectQueryBuilder() const
+    {
+        return queryBuilder();
+    }
+
+    SqlCondition whereCondition;
+    QVector<detail::JoinInfo> joinInfos;
+    QVector<detail::OrderInfo> orderInfos;
+};
+
+
+/**
+ * Creates a SELECT statement.
+ * @tparam ColumnList A MPL sequence of the columns to select
+ */
+
+#ifndef SQL_SELECT_MAX_SIZE
+#define SQL_SELECT_MAX_SIZE 45
+#endif
+
+#define CONST_REF(z, n, unused) const T ## n &
+#define SELECT_IMPL(z, n, unused) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+    SelectExpr<boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)>,\
+        detail::missing, boost::mpl::vector<>, detail::missing> select( \
+    BOOST_PP_ENUM(n, CONST_REF, ~) ) { \
+        return SelectExpr<boost::mpl::vector<BOOST_PP_ENUM_PARAMS(n, T)>, detail::missing, boost::mpl::vector<>, detail::missing>(); \
+    }
+BOOST_PP_REPEAT_FROM_TO(1, SQL_SELECT_MAX_SIZE, SELECT_IMPL, ~)
+
+#undef SELECT_IMPL
+#undef CONST_REF
+
+//Operators to fix compilation under MSVC10, that picks up the wrong overloads
+
+template <typename T> typename boost::enable_if<boost::is_enum<T>, bool>::type
+operator==(int lhs, T rhs)
+{
+	return lhs == (int)rhs;
+}
+
+template <typename T> typename boost::enable_if<boost::is_enum<T>, bool>::type
+operator==(T lhs, int rhs )
+{
+	return rhs == (int)lhs;
+}
+
+inline bool operator==(QMapData::Node* lhs, QMap<QString, QString>::iterator rhs )
+{
+  return lhs == (QMapData::Node*)rhs;
+}
+
+inline bool operator==(QMapData::Node* lhs, QMap<QUuid, QUuid>::iterator rhs )
+{
+  return lhs == (QMapData::Node*)rhs;
+}
+
+inline bool operator==(QStringList lhs, QStringList rhs )
+{
+  return lhs.operator==(rhs);
+}
+
+inline bool operator==(const QUuid &lhs, const Sql::StaticUuid &rhs)
+{
+    return lhs.operator==(rhs);
+}
+
+}
+
+#endif
diff --git a/SqlSelectQueryBuilder.cpp b/SqlSelectQueryBuilder.cpp
new file mode 100644
index 0000000..2363e63
--- /dev/null
+++ b/SqlSelectQueryBuilder.cpp
@@ -0,0 +1,212 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#include "SqlSelectQueryBuilder.h"
+
+#include "SqlExceptions.h"
+#include "SqlSchema.h"
+#include "SqlGlobal.h"
+
+SqlSelectQueryBuilder::SqlSelectQueryBuilder(const QSqlDatabase& db) :
+    SqlConditionalQueryBuilderBase( db ),
+    m_lockNoWait( false ),
+    m_distinct( false ),
+    m_limitOffset( -1 ),
+    m_limitLength( -1 )
+{
+}
+
+void SqlSelectQueryBuilder::addColumn(const QString& columnName, const QString& label)
+{
+    m_columns.push_back( qMakePair( columnName, label ) );
+}
+
+void SqlSelectQueryBuilder::addAllColumns()
+{
+    addColumn( QString::fromLatin1( "*" ) );
+}
+
+void SqlSelectQueryBuilder::addCurrentTimeStampColumn()
+{
+    addColumn( currentDateTime() );
+}
+
+void SqlSelectQueryBuilder::addJoin(SqlSelectQueryBuilder::JoinType joinType, const QString& table, const SqlCondition& condition)
+{
+    JoinInfo j;
+    j.type = joinType;
+    j.table = table;
+    j.condition = condition;
+    m_joins.push_back( j );
+}
+
+void SqlSelectQueryBuilder::addJoin(SqlSelectQueryBuilder::JoinType joinType, const QString& table, const QString& column1, const QString& column2)
+{
+    SqlCondition c;
+    c.addColumnCondition( column1, SqlCondition::Equals, column2 );
+    addJoin( joinType, table, c );
+}
+
+void SqlSelectQueryBuilder::addSortColumn(const QString& column, Qt::SortOrder sortOrder)
+{
+    m_sortColumns.push_back( qMakePair( column, sortOrder ) );
+}
+
+void SqlSelectQueryBuilder::removeSortColumn(const QString& column)
+{
+    QVector<QPair<QString, Qt::SortOrder> >::iterator it = m_sortColumns.begin();
+    while (it != m_sortColumns.end() ) {
+        const QString columnName = (*it).first;
+        if ( columnName == column ) {
+            m_sortColumns.erase(it);
+            break;
+        }
+    }
+}
+
+static QString orderToString( Qt::SortOrder order )
+{
+    switch ( order ) {
+    case Qt::AscendingOrder: return QLatin1String( " ASC" );
+    case Qt::DescendingOrder: return QLatin1String( " DESC" );
+    };
+    qFatal( "Unknown sort order" );
+    return QString();
+}
+
+void SqlSelectQueryBuilder::addGroupColumn(const QString& column)
+{
+    m_groupColumns.push_back( column );
+}
+
+static QString joinTypeToString( SqlSelectQueryBuilder::JoinType j )
+{
+    switch ( j ) {
+    case SqlSelectQueryBuilder::InnerJoin: return QLatin1String( " INNER JOIN " );
+    case SqlSelectQueryBuilder::LeftOuterJoin: return QLatin1String( " LEFT OUTER JOIN " );
+    case SqlSelectQueryBuilder::RightOuterJoin: return QLatin1String( " RIGHT OUTER JOIN " );
+    case SqlSelectQueryBuilder::FullOuterJoin: return QLatin1String( " FULL OUTER JOIN " );
+    case SqlSelectQueryBuilder::CrossJoin: return QLatin1String( " CROSS JOIN " );
+    }
+    qFatal( "Unknown join type" );
+    return QString();
+}
+
+SqlQuery& SqlSelectQueryBuilder::query()
+{
+    if ( !m_assembled ) {
+        m_queryString = toString();
+        m_assembled = true;
+        prepareQuery();
+    }
+    return m_query;
+}
+
+void SqlSelectQueryBuilder::prepareQuery()
+{
+#ifndef QUERYBUILDER_UNITTEST
+    m_query = SqlQueryBuilderBase::prepareQuery( m_queryString );
+    for ( int i = 0; i < m_bindValues.size(); ++i ) {
+        const QVariant value = m_bindValues.at( i );
+        bindValue( i, value );
+    }
+#endif
+}
+
+QString SqlSelectQueryBuilder::toString()
+{
+
+    QString queryString;
+
+    QStringList cols;
+    typedef QPair<QString, QString> StringPair;
+    foreach ( const StringPair &col, m_columns ) {
+        if ( col.second.isEmpty() )
+            cols.push_back( col.first );
+        else {
+            QString quotedAs = col.second;
+            quotedAs.replace( QLatin1String( "\"" ), QLatin1String( "\\\"" ) );
+            cols.push_back( col.first + QLatin1String( " AS \"" ) + quotedAs + QLatin1Char( '"' ) );
+        }
+    }
+
+    queryString = QLatin1String( "SELECT " );
+    if(m_distinct)
+        queryString += QLatin1String( "DISTINCT " );
+    if (!m_distinctOn.isEmpty()) {
+        Q_ASSERT(!m_distinct);
+        queryString += QLatin1Literal( "DISTINCT ON(" ) % m_distinctOn % QLatin1Literal( ") " );
+    }
+    queryString += cols.join( QLatin1String( ", " ) );
+    if ( !m_table.isEmpty() ) {
+        queryString += QLatin1String( " FROM " );
+        queryString += m_table;
+    }
+    foreach ( const JoinInfo &j, m_joins ) {
+        queryString += joinTypeToString( j.type );
+        queryString += j.table;
+        queryString += QLatin1String( " ON " );
+        queryString += conditionToString( j.condition );
+    }
+    if ( m_whereCondition.hasSubConditions() ) {
+        queryString += QLatin1String( " WHERE " );
+        queryString += conditionToString( m_whereCondition );
+    }
+
+    if ( !m_groupColumns.isEmpty() ) {
+        queryString += QLatin1String( " GROUP BY " );
+        queryString += m_groupColumns.join( QLatin1String( ", " ) );
+    }
+
+    if ( !m_sortColumns.isEmpty() ) {
+        queryString += QLatin1String( " ORDER BY " );
+        QStringList sortCols;
+        typedef QPair<QString, Qt::SortOrder> StringOrderPair;
+        foreach ( const StringOrderPair &sortCol, m_sortColumns )
+            sortCols.push_back( sortCol.first + orderToString( sortCol.second ) );
+        queryString += sortCols.join( QLatin1String( ", " ) );
+    }
+
+    if ( !m_lockTablesForUpdate.isEmpty() ) {
+        queryString += QLatin1String( " FOR UPDATE OF " );
+        queryString += m_lockTablesForUpdate.join( QLatin1String( ", " ) );
+        if ( m_lockNoWait )
+            queryString += QLatin1String( " NOWAIT" );
+    }
+    if ( m_limitOffset != -1 ) {
+        queryString += QString::fromLatin1( " OFFSET %1 LIMIT %2" ).arg( m_limitOffset ).arg( m_limitLength );
+    }
+
+    return queryString;
+}
+
+QVector<QVariant> SqlSelectQueryBuilder::bindValuesList()
+{
+    return m_bindValues;
+}
+
+void SqlSelectQueryBuilder::combineQueries(SqlSelectQueryBuilder &query1, SqlSelectQueryBuilder &query2, const UnionType type)
+{
+    if ( !m_assembled && m_bindValues.isEmpty() && m_queryString == QString()) {
+        const QString unionName = (type == UnionAll) ? QLatin1String(" UNION ALL "):QLatin1String( " UNION " );
+        const QString query1String = query1.toString();
+        query2.m_bindedValuesOffset = query1.m_bindValues.size();
+        m_queryString = query1String + unionName +  query2.toString();
+        m_assembled = true;
+        m_bindValues = query1.bindValuesList() + query2.bindValuesList();
+        prepareQuery();
+    }
+    else {
+        SQLDEBUG << "WARNING: you tried to combine queries in a non-empty SqlSelectQueryBuilder, the queries weren't combined. (SqlSelectQueryBuilder stays inchanged).";
+    }
+}
+
+void SqlSelectQueryBuilder::addLimit(uint offset, uint length)
+{
+    m_limitOffset = offset;
+    m_limitLength = length;
+}
+
diff --git a/SqlSelectQueryBuilder.h b/SqlSelectQueryBuilder.h
new file mode 100644
index 0000000..c22bee6
--- /dev/null
+++ b/SqlSelectQueryBuilder.h
@@ -0,0 +1,218 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+
+#ifndef SQLSELECTQUERYBUILDER_H
+#define SQLSELECTQUERYBUILDER_H
+#include "SqlConditionalQueryBuilderBase.h"
+#include "SqlCondition.h"
+#include "sqlate_export.h"
+
+#include <QStringList>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+/** API to create SELECT queries in a safe way from code, without the risk of
+ *  introducing SQL injection vulnerabilities or typos.
+ */
+class SQLATE_EXPORT SqlSelectQueryBuilder : public SqlConditionalQueryBuilderBase
+{
+public:
+    enum JoinType {
+        InnerJoin,
+        LeftOuterJoin,
+        RightOuterJoin,
+        FullOuterJoin,
+        CrossJoin
+    };
+
+    enum LockMode {
+        NoLock,
+        Lock,
+        TryLock
+    };
+
+    enum UnionType {
+        Union,
+        UnionAll
+    };
+
+    /// Create a new query builder for the given database
+    explicit SqlSelectQueryBuilder( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /// Use SELECT DISTINCT
+    void setDistinct( const bool flag=true ) { m_distinct = flag; }
+
+    /// Use SELECT DISTINCT ON(...), PostgreSQL-only
+    /// mutually exclusive with setDistinct()
+    void setDistinctOn( const QString &distinctExpr ) { m_distinctOn = distinctExpr; }
+
+    /// Get the current distinct query status
+    bool distinct() { return m_distinct; }
+
+    /// SELECT @p columnName AS @p label, ...
+    void addColumn( const QString &columnName, const QString &label = QString() );
+    template <typename Column>
+    inline void addColumn( const Column &column, const QString &label = QString() )
+    {
+        addColumn( column.name(), label );
+    }
+    // disambiguation overload for the above methods, taking this away finds QLatin1String usage, which indicates manual column names...
+    inline void addColumn( const QLatin1String &column, const QString &label = QString() )
+    {
+        addColumn(QString(column), label );
+    }
+
+    /**
+     * Adds an arbitrary expression as column to the result set.
+     * Essentially the same as the above, but don't use this for selecting a single unmodified column.
+     */
+    inline void addColumnExpression( const QString &expression, const QString &label = QString() )
+    {
+        addColumn( expression, label );
+    }
+
+    /// SELECT * FROM ...
+    void addAllColumns();
+
+    /// SELECT currentDateTime() - server time see base class.
+    void addCurrentTimeStampColumn();
+    /**
+     * Join a table to the query.
+     * @param joinType The type of JOIN you want to add.
+     * @param table The table to join.
+     * @param condition the ON condition for this join.
+     */
+    void addJoin( JoinType joinType, const QString &table, const SqlCondition &condition );
+    template <typename Table>
+    inline void addJoin( JoinType joinType, const Table &table, const SqlCondition &condition )
+    {
+        addJoin( joinType, table.tableName(), condition );
+    }
+
+    /**
+     * Join a table to the query.
+     * This is a convenience method to create simple joins like e.g. 'LEFT JOIN t ON c1 = c2'.
+     * @param joinType The type of JOIN you want to add.
+     * @param table The table to join.
+     * @param col1 The first column for the ON statement.
+     * @param col2 The second column for the ON statement.
+     */
+    void addJoin( JoinType joinType, const QString &table, const QString &column1, const QString &column2 );
+    template <typename Table, typename Column1, typename Column2>
+    inline void addJoin( JoinType joinType, const Table &table, const Column1 &column1, const Column2 &column2 )
+    {
+        BOOST_MPL_ASSERT(( boost::mpl::or_<boost::is_same<Table, typename Column1::table>, boost::is_same<Table, typename Column2::table> > ));
+        SqlCondition c;
+        c.addColumnCondition( column1, SqlCondition::Equals, column2 ); // this also checks that the types of both columns are equal
+        addJoin( joinType, table, c );
+    }
+
+    /// ... ORDER BY @p column @p sortOrder ...
+    void addSortColumn( const QString& column, Qt::SortOrder sortOrder = Qt::AscendingOrder );
+    template <typename Column>
+    inline void addSortColumn( const Column &column, Qt::SortOrder sortOrder = Qt::AscendingOrder )
+    {
+        addSortColumn( column.name(), sortOrder );
+    }
+
+    /// ... remove ORDER BY @p column ...
+    void removeSortColumn( const QString& column);
+    template <typename Column>
+    inline void removeSortColumn( const Column &column )
+    {
+        removeSortColumn( column.name() );
+    }
+
+    /// ... GROUP BY @p column ...
+    void addGroupColumn( const QString& column );
+    template <typename Column>
+    inline void addGroupColumn( const Column & column )
+    {
+        addGroupColumn( column.name() );
+    }
+
+    /// Returns the created query object, when called first, the query object is assembled and prepared
+    /*reimp*/ SqlQuery& query();
+
+    /**
+     * @brief Limit the query results
+     *
+     * @param offset starting offset
+     * @param length max numbers of returned items
+     **/
+    void addLimit(uint offset, uint length);
+
+public:
+    /**
+     * Select and add a exclusive row lock on the result set.
+     * The query will block until existing row locks have been released.
+     * @note The locks with stay active until the end of the transaction.
+     * @tparam Table The table to lock rows on (needs to be in the sub-set of tables specified in FROM or JOIN)
+     */
+    template <typename Table>
+    inline void lockExclusive( const Table &table )
+    {
+        m_lockTablesForUpdate.push_back(table.tableName());
+        m_lockNoWait = false;
+    }
+
+    /**
+     * Select and add a exclusive row lock on the result set.
+     * The query will fail if other row locks exist on the result set.
+     * @note The locks with stay active until the end of the transaction.
+     * @tparam Table The table to lock rows on (needs to be in the sub-set of tables specified in FROM or JOIN)
+     */
+public:
+    template <typename Table>
+    inline void tryLockExclusive( const Table &table )
+    {
+        m_lockTablesForUpdate.push_back(table.tableName());
+        m_lockNoWait = true;
+    }
+
+    /**
+     * Create a composed query out of two. (see UNION keyword (SQL))
+     * @param the queries to join together
+     * @param the type of union
+     */
+    void combineQueries(SqlSelectQueryBuilder &query1, SqlSelectQueryBuilder &query2, const UnionType type = Union );
+
+private:
+    friend class SelectQueryBuilderTest;
+    friend class SelectTest;
+
+    /**
+     * return the query as a formatted string
+     */
+    QString toString();
+
+    /**
+     * return the builder as a SqlQuery. The method throws an SqlException on error.
+     */
+    void prepareQuery();
+
+    QVector<QVariant> bindValuesList();
+
+    QVector<QPair<QString, QString> > m_columns;
+    struct JoinInfo {
+        JoinType type;
+        QString table;
+        SqlCondition condition;
+    };
+    QVector<JoinInfo> m_joins;
+    QVector<QPair<QString, Qt::SortOrder> > m_sortColumns;
+    QStringList m_groupColumns;
+    QStringList m_lockTablesForUpdate;
+    QString m_distinctOn;
+    bool m_lockNoWait;
+    bool m_distinct;
+    uint m_limitOffset;
+    uint m_limitLength;
+};
+
+#endif
diff --git a/SqlTransaction.cpp b/SqlTransaction.cpp
new file mode 100644
index 0000000..f0e8a44
--- /dev/null
+++ b/SqlTransaction.cpp
@@ -0,0 +1,65 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#include "SqlTransaction.h"
+#include "SqlExceptions.h"
+#include "SqlQueryManager.h"
+
+#include <QSqlDriver>
+
+QHash<QString, int> SqlTransaction::m_refCounts;
+
+SqlTransaction::SqlTransaction(const QSqlDatabase& db) : m_db( db ), m_disarmed( false )
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+    Q_ASSERT( db.driver()->hasFeature( QSqlDriver::Transactions ) );
+    if ( m_refCounts.value( m_db.connectionName() ) == 0 && !m_db.transaction() ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db); //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        if ( m_refCounts.value( m_db.connectionName() ) == 0 && !m_db.transaction() )
+            throw SqlException( m_db.lastError() );
+    }
+    m_refCounts[m_db.connectionName()]++;
+}
+
+SqlTransaction::~SqlTransaction()
+{
+    if ( m_disarmed )
+        return;
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+    if ( m_refCounts.value( m_db.connectionName() ) == 1 )
+        m_db.rollback();
+    m_refCounts[m_db.connectionName()]--;
+}
+
+void SqlTransaction::commit()
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+    Q_ASSERT( m_refCounts.value( m_db.connectionName() ) > 0 );
+    if ( m_refCounts.value( m_db.connectionName() ) == 1 && !m_db.commit() ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db);  //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        if ( m_refCounts.value( m_db.connectionName() ) == 1 && !m_db.commit() )
+            throw SqlException( m_db.lastError() );
+    }
+    m_refCounts[ m_db.connectionName() ]--;
+    m_disarmed = true;
+}
+
+void SqlTransaction::rollback()
+{
+    SqlQueryManager::instance()->checkDbIsAlive(m_db);
+    Q_ASSERT( m_refCounts.value( m_db.connectionName() ) > 0 );
+    m_refCounts[ m_db.connectionName() ]--;
+    m_disarmed = true;
+    if ( m_refCounts.value( m_db.connectionName() ) == 0 && !m_db.rollback() ) {
+        SqlQueryManager::instance()->checkDbIsAlive(m_db);  //double check is needed, as Qt might not set m_db.isOpen() to false after connection loss if no queries were run meantime.
+        if ( m_refCounts.value( m_db.connectionName() ) == 0 && !m_db.rollback() )
+            throw SqlException( m_db.lastError() );
+    }
+}
+
+int SqlTransaction::transactionsCount()
+{
+    return m_refCounts.size();
+}
diff --git a/SqlTransaction.h b/SqlTransaction.h
new file mode 100644
index 0000000..bd3400b
--- /dev/null
+++ b/SqlTransaction.h
@@ -0,0 +1,59 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLTRANSACTION_H
+#define SQLTRANSACTION_H
+
+#include "sqlate_export.h"
+#include <QSqlDatabase>
+#include <QHash>
+
+/**
+ * Simple RAII class for transaction handling.
+ * @note this is not (yet) thread-safe!
+ */
+class SQLATE_EXPORT SqlTransaction
+{
+public:
+    /**
+     * Starts a transaction on the given database.
+     * @throws SqlException if starting the transaction failed
+     */
+    explicit SqlTransaction( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /**
+     * Rolls back a still ongoing transaction, unless commit() has been called explicitly.
+     * @note Does not throw on error.
+     */
+    ~SqlTransaction();
+
+    /**
+     * Commit this transaction.
+     * @throws SqlException if committing failed.
+     */
+    void commit();
+
+    /**
+     * Rolls back this transaction.
+     * @throws SqlException if rolling back failed
+     */
+    void rollback();
+
+    /**
+     *@Static method that returns the number of transactions being run.
+     *That allow us to make sure at least a transaction is running.
+     *
+     */
+
+    static int transactionsCount();
+
+private:
+    Q_DISABLE_COPY( SqlTransaction )
+    QSqlDatabase m_db;
+    static QHash<QString, int> m_refCounts;
+    bool m_disarmed;
+};
+
+#endif
diff --git a/SqlUpdateQueryBuilder.cpp b/SqlUpdateQueryBuilder.cpp
new file mode 100644
index 0000000..dedcebd
--- /dev/null
+++ b/SqlUpdateQueryBuilder.cpp
@@ -0,0 +1,80 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*         Volker Krause <volker.krause@kdab.com>
+*/
+#include "SqlUpdateQueryBuilder.h"
+#include "SqlExceptions.h"
+
+#include "Sql.h"
+
+SqlUpdateQueryBuilder::SqlUpdateQueryBuilder(const QSqlDatabase& db) :
+  SqlConditionalQueryBuilderBase( db ),
+  m_includeSubTables( true )
+{
+}
+
+void SqlUpdateQueryBuilder::addColumnValue(const QString& columnName, const QVariant& value)
+{
+    m_columns.push_back( qMakePair( columnName, value ) );
+}
+
+void SqlUpdateQueryBuilder::setIncludesubTales(bool includeSubTables)
+{
+    m_includeSubTables = includeSubTables;
+}
+
+SqlQuery& SqlUpdateQueryBuilder::query()
+{
+    if ( !m_assembled ) {
+        QStringList cols;
+        m_queryString = QLatin1String( "UPDATE " );
+        if (!m_includeSubTables) {
+            m_queryString += QLatin1String( "ONLY " );
+        }
+        m_queryString += m_table;
+
+        m_queryString += QLatin1String( " SET " );
+        m_bindValues.clear();
+        typedef QPair<QString, QVariant> ColumnValuePair;
+        foreach ( const ColumnValuePair &col, m_columns ) {
+            m_queryString += col.first;
+            m_queryString += QLatin1String( " = " );
+            if ( col.second.userType() == qMetaTypeId<SqlNowType>() )
+                m_queryString += currentDateTime();
+            else
+                m_queryString += registerBindValue( col.second );
+            m_queryString += QLatin1String(", ");
+        }
+        if ( m_queryString.endsWith( QLatin1String(", ") ) )
+            m_queryString.remove( m_queryString.length() - 2, 2);
+
+        if ( m_whereCondition.hasSubConditions() ) {
+            m_queryString += QLatin1String( " WHERE " );
+            m_queryString += conditionToString( m_whereCondition );
+        }
+
+        m_queryString = m_queryString.trimmed();
+        m_assembled = true;
+
+#ifndef QUERYBUILDER_UNITTEST
+        m_query = prepareQuery( m_queryString );
+
+        for ( int i = 0; i < m_bindValues.size(); ++i ) {
+            const QVariant value = m_bindValues.at( i );
+            bindValue( i, value );
+        }
+#endif
+    }
+    return m_query;
+}
+
+QStringList SqlUpdateQueryBuilder::columnNames() const
+{
+    QStringList names;
+    typedef QPair<QString, QVariant> ColumnValuePair;
+    foreach ( const ColumnValuePair &col, m_columns ) {
+        names << col.first;
+    }
+    return names;
+}
diff --git a/SqlUpdateQueryBuilder.h b/SqlUpdateQueryBuilder.h
new file mode 100644
index 0000000..e899f2b
--- /dev/null
+++ b/SqlUpdateQueryBuilder.h
@@ -0,0 +1,66 @@
+/*
+* Copyright (C) 2011-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Andras Mantia <andras.mantia@kdab.com>
+*         Volker Krause <volker.krause@kdab.com>
+*/
+#ifndef SQLUPDATEQUERYBUILDER_H
+#define SQLUPDATEQUERYBUILDER_H
+
+#include "sqlate_export.h"
+#include "SqlConditionalQueryBuilderBase.h"
+#include "SqlInternals_p.h"
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+
+/** API to create UPDATE queries in a safe way from code, without the risk of
+ *  introducing SQL injection vulnerabilities or typos.
+ */
+class SQLATE_EXPORT SqlUpdateQueryBuilder : public SqlConditionalQueryBuilderBase
+{
+public:
+    /// Create a new query builder for the given database
+    explicit SqlUpdateQueryBuilder( const QSqlDatabase &db = QSqlDatabase::database() );
+
+    /// UPDATE ... SET @p columnName = @p value, ...
+    void addColumnValue( const QString &columnName, const QVariant &value );
+
+    template <typename Column>
+    void addColumnValue( const Column &, const typename Column::type &value )
+    {
+        Sql::warning<boost::is_same<typename Column::type, QDateTime>, UsageOfClientSideTime>::print();
+        addColumnValue( Column::sqlName(), QVariant::fromValue( value ) );
+    }
+    template <typename Column>
+    void addColumnValue( const Column &, SqlNullType )
+    {
+        BOOST_MPL_ASSERT(( boost::mpl::not_<typename Column::notNull> ));
+        addColumnValue( Column::sqlName(), QVariant() );
+    }
+    template <typename Column>
+    void addColumnValue( const Column &, SqlNowType now )
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<typename Column::type, QDateTime> ));
+        addColumnValue( Column::sqlName(), QVariant::fromValue(now) );
+    }
+
+    /**
+     * If @p includeSubTables is false, the query will be UPDATE <b>ONLY</b> &lt;tableName&gt;
+     * The default is @c true.
+     */
+    void setIncludesubTales( bool includeSubTables );
+
+    /// Returns the created query object, when called first, the query object is assembled and prepared
+    /// The method throws an SqlException if there is an error preparing the query.
+    SqlQuery& query();
+
+private:
+    QStringList columnNames() const; //used for testing
+
+private:
+    friend class UpdateQueryBuilderTest;
+    QVector<QPair<QString, QVariant> > m_columns;
+    bool m_includeSubTables;
+};
+
+#endif
diff --git a/SqlUtils.cpp b/SqlUtils.cpp
new file mode 100644
index 0000000..ad59933
--- /dev/null
+++ b/SqlUtils.cpp
@@ -0,0 +1,86 @@
+/*
+* Copyright (C) 2012-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#include "SqlUtils.h"
+#include "SqlTransaction.h"
+#include "SqlExceptions.h"
+#include "SqlGlobal.h"
+
+#include <QRegExp>
+#include <QString>
+#include <QStringList>
+#include <QSqlError>
+
+void SqlUtils::stripComments ( QString& query )
+{
+    QRegExp re(QLatin1String( "--.+([\n\r]{1,2};?|$)" ));
+    re.setMinimal(true);
+    query.remove( re );
+    query = query.trimmed();
+}
+
+QStringList SqlUtils::splitQueries ( const QString& queries )
+{
+    return queries.split(QLatin1String( ";\n" ), QString::SkipEmptyParts);
+}
+
+QString SqlUtils::batchExec(const QString& sql,
+                            const QString& connectionName/*=QSqlDatabase::defaultConnection*/) {
+    QString errorText;
+    if ( sql.size() > 0 ) {
+        const QStringList stmts = splitQueries(sql);
+        QSqlDatabase db = QSqlDatabase::database(connectionName);
+
+        if ( stmts.count() == 0 )
+            return QString();
+
+        SqlTransaction transaction( db );
+
+        for (int i=0; i < stmts.count(); i++) {
+            QString sqlstmt = stmts.at(i);
+
+            stripComments(sqlstmt);
+
+            if (sqlstmt.size() < 3 ) {
+                //SQLDEBUG << "#" << i << ") SKIPPING small statement: " << sqlstmt;
+                break;
+            }
+
+            //SQLDEBUG << QString("POST # %1 %2").arg(i).arg(sqlstmt);
+
+            QSqlQuery q = db.exec( sqlstmt );
+            if (q.lastError().type() != QSqlError::NoError) {
+                errorText = QObject::tr("Error in one of the batch statements. %1").arg(q.lastError().text());
+
+                qCritical() << QString::fromLatin1("%1.\nStatement: %2").arg(errorText).arg(sqlstmt);
+                return errorText;
+            }
+        }
+        transaction.commit();
+        return QString();
+    }
+    else {
+        errorText = QObject::tr("SQL statement passed was empty!!");
+        return errorText;
+    }
+}
+
+bool SqlUtils::isLockError(const QSqlError& error)
+{
+    if (error.type() == QSqlError::StatementError &&
+        ( error.text().contains(QLatin1String("(55P03)")) || //the actual error code, not translated. needs patched QPSQL driver
+          error.text().contains(QLatin1String("could not obtain lock")) )
+       )
+    {
+        return true;
+    }
+    return false;
+}
+
+QString SqlUtils::createIdentifier(const QString& text)
+{
+    uint hash = qHash(text);
+    return QString::number(hash, 16);
+}
diff --git a/SqlUtils.h b/SqlUtils.h
new file mode 100644
index 0000000..1599400
--- /dev/null
+++ b/SqlUtils.h
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) 2012-2013 Klaralavdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+* Author: Volker Krause <volker.krause@kdab.com>
+*         Andras Mantia <andras.mantia@kdab.com>
+*/
+#ifndef SQLUTILS_H
+#define SQLUTILS_H
+
+#include "sqlate_export.h"
+
+#include "SqlSelectQueryBuilder.h"
+
+#include <QSqlField>
+#include <QSqlRecord>
+
+class QStringList;
+class QString;
+class QSqlError;
+
+/**
+ * Misc helper functions around SQL/database access.
+ */
+namespace SqlUtils
+{
+    /**
+     * Strips out comments from an SQL string.
+     */
+    SQLATE_EXPORT void stripComments(QString &query);
+
+    /**
+     * Splits a list of SQL statements provided in one string into a list of statements.
+     */
+    SQLATE_EXPORT QStringList splitQueries(const QString &queries);
+
+    /**
+     * Executes SQL commands from a string.
+     */
+    SQLATE_EXPORT QString batchExec(const QString& sql, const QString& connectionName/*=QSqlDatabase::defaultConnection*/);
+
+    /**
+     * Returns a list of name/type pairs describing the columns in table @p table.
+     * @throws SqlExeception in case of a database error.
+     */
+    template <typename T>
+    inline QVector<QPair<QString, QVariant::Type> > columnsOfTable( const T &table, const QSqlDatabase &db = QSqlDatabase::database() )
+    {
+        SqlSelectQueryBuilder qb( db );
+        qb.setTable( table );
+        qb.addAllColumns();
+        qb.exec();
+        const QSqlRecord record = qb.query().record();
+        QVector<QPair<QString, QVariant::Type> > columns;
+        for (int i = 0; i < record.count(); ++i) {
+            const QSqlField field = record.field(i);
+            columns.push_back(qMakePair(field.name(), field.type()));
+        }
+        return columns;
+    }
+
+    /** Returns true if the error can be identified as a lock error (cannot obtain lock on a table).
+     * Returning false doesn't mean that is is not a lock error, it just means it couldn't
+     * be identified as a lock error 100% sure.
+     */
+    SQLATE_EXPORT bool isLockError(const QSqlError& error);
+
+    /**
+     * @brief creates a short unique identifier to identify postgres signals.
+     */
+    SQLATE_EXPORT QString createIdentifier(const QString& text);
+
+}
+
+#endif
diff --git a/kdthreadrunner.cpp b/kdthreadrunner.cpp
new file mode 100644
index 0000000..51c0ff2
--- /dev/null
+++ b/kdthreadrunner.cpp
@@ -0,0 +1,274 @@
+#include "kdthreadrunner.h"
+
+#include <QSemaphore>
+
+class KDThreadRunnerBase::Private
+{
+public:
+    Private()
+        : m_impl( 0 )
+    {
+    }
+
+    QObject* m_impl;
+    QSemaphore m_waitStarted;
+    QMutex m_startThreadMutex;
+};
+
+KDThreadRunnerBase::KDThreadRunnerBase( QObject * p )
+    : QThread( p )
+{
+}
+
+KDThreadRunnerBase::~KDThreadRunnerBase()
+{
+}
+
+void KDThreadRunnerBase::doStart( Priority prio )
+{
+    start( prio );
+    d->m_waitStarted.acquire(); // wait for T to be created by run()
+}
+
+void KDThreadRunnerBase::doExec()
+{
+    // Tell startThread that we have created T
+    d->m_waitStarted.release();
+
+    exec();
+}
+
+void KDThreadRunnerBase::setImpl( QObject * i )
+{
+    d->m_impl = i;
+}
+
+QObject* KDThreadRunnerBase::impl() const
+{
+    return d->m_impl;
+}
+
+QMutex* KDThreadRunnerBase::internalStartThreadMutex()
+{
+    return & d->m_startThreadMutex;
+}
+
+
+/*!
+  \class KDThreadRunner:
+  \ingroup core
+  \brief Convenience class for starting QThreads that use signals/slots
+  \since_c 2.2
+
+  Unexpected behavior occurs when using slots or timers in a QThread subclass
+  (since the QThread, as a QObject, belongs to the main thread).
+  So better forget that QThread derives from QObject,
+  and not use signals and slots inside a thread subclass.
+
+  To solve this problem, you can use KDThreadRunner<T>.
+  KDThreadRunner represents a thread (using QThread).
+  The implementation of the thread should not be done in a subclass of
+  QThread however, but in a separate object of type T.
+
+  T should be a QObject subclass, it will be created inside the thread
+  (so you can do all the initializations in the constructor)
+  and the thread will have an event loop so for instance timers will work.
+  To stop the thread, call quit() on the KDThreadRunner (from the outside),
+  or thread()->quit() from the inside of the T class.
+
+  Your constructor for the class T can be defined to take a QObject* parameter
+  or a KDThreadRunner<T>* parameter, which will be set to the threadrunner instance,
+  but in any case, the constructor should not call ": QObject(parent)",
+  it should be an object without a parent. It will be deleted when the
+  thread quits. The parameter is simply the threadrunner instance, it can be ignored
+  if T doesn't need it.
+*/
+
+/*!
+  \fn KDThreadRunner::KDThreadRunner( QObject * parent )
+
+  Constructor. \a parent is passed to the base class constructor.
+*/
+
+/*!
+  \fn KDThreadRunner::startThread( Priority prio )
+
+  Call this function if you need access to the instance of T
+  (otherwise call QThread::start()). \a prio is passed to
+  QThread::start().
+
+  \note If the payload class quits the eventloop very quickly,
+  startThread() might return a pointer to an already deleted object.
+
+  \sa QThread::start, QThread::Priority
+*/
+
+
+#ifdef KDTOOLSCORE_UNITTESTS
+
+#include <QCoreApplication>
+#include <QPointer>
+#include <QSemaphore>
+#include <KDUnitTest/Test>
+
+QSemaphore slotCalledSemaphore;
+
+// these don't need mutex protection, since they are correctly
+// sequenced by thread starts and joins:
+static bool instanceTestFailedInCtor = false;
+static bool instanceTestFailedInSlot = false;
+static bool threadAffinityTestFailedInCtor = false;
+static bool threadAffinityTestFailedInSlot = false;
+static bool threadAffinityTestFailedInReceiver = false;
+
+class TestThreadImpl : public QObject
+{
+    Q_OBJECT
+public:
+    explicit TestThreadImpl(QObject* runner)
+        : QObject() // no parent!
+    {
+        if ( thread() != runner )
+            threadAffinityTestFailedInCtor = true;
+        if ( thread() == QCoreApplication::instance()->thread() )
+            instanceTestFailedInCtor = true;
+    }
+
+Q_SIGNALS:
+    void slotCalled();
+
+private Q_SLOTS:
+    void slotInThread()
+    {
+        if ( QThread::currentThread() == thread() ) // so that the test would fail also in release mode
+            if ( QThread::currentThread() != QCoreApplication::instance()->thread() )
+                emit slotCalled();
+            else
+                instanceTestFailedInSlot = true;
+        else
+            threadAffinityTestFailedInSlot = true;
+        slotCalledSemaphore.release();
+        thread()->quit();
+    }
+};
+
+class Emitter : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Emitter( QObject * p=0 )
+        : QObject( p )
+    {}
+    void emitSignal() { emit theSignal(); }
+
+Q_SIGNALS:
+    void theSignal();
+};
+
+class Receiver : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Receiver( QObject * p=0 )
+        : QObject( p ),
+          m_slotCalledCount( 0 )
+    {
+    }
+    
+    int slotCalledCount() const 
+    { 
+        return m_slotCalledCount;
+    }
+
+private Q_SLOTS:
+    void theSlot()
+    {
+        if ( thread() == QThread::currentThread() )
+            ++m_slotCalledCount;
+        else
+            threadAffinityTestFailedInReceiver = true;
+    }
+
+private:
+    int m_slotCalledCount;
+};
+
+#include "kdthreadrunner.moc"
+
+KDAB_UNITTEST_SIMPLE( KDThreadRunner, "kdcoretools" ) {
+
+    const int JOIN_TIMEOUT = 10000; // 10s
+
+    KDThreadRunner<TestThreadImpl> threadRunner;
+    Emitter emitter; // an object in the gui thread
+    Receiver receiver; // this one needs to store the call-count - the impl might be dead after acquire
+
+    {
+        instanceTestFailedInSlot = instanceTestFailedInCtor = threadAffinityTestFailedInSlot = threadAffinityTestFailedInCtor = threadAffinityTestFailedInReceiver = false;
+        TestThreadImpl* impl = threadRunner.startThread();
+        assertNotNull( impl );
+        QPointer<QObject> guard(impl);
+        assertTrue( threadRunner.isRunning() );
+        assertEqual( emitter.thread(), QCoreApplication::instance()->thread() );
+
+        // Check that we can't call startThread while it's running
+        TestThreadImpl* impl2 = threadRunner.startThread();
+        assertEqual( impl, impl2 );
+
+        bool connectOk = QObject::connect( &emitter, SIGNAL(theSignal()), impl, SLOT(slotInThread()) );
+        assertTrue( connectOk );
+        connectOk = QObject::connect( impl, SIGNAL(slotCalled()), &receiver, SLOT(theSlot()) );
+        assertTrue( connectOk );
+        emitter.emitSignal();
+        slotCalledSemaphore.acquire();
+        assertTrue( threadRunner.wait( JOIN_TIMEOUT ) );
+        QCoreApplication::processEvents();
+#ifndef Q_WS_MAC // KDTO-187
+        assertEqual( receiver.slotCalledCount(), 1 );
+#endif
+        assertFalse( threadRunner.isRunning() );
+        assertNull( guard );
+
+        assertFalse( instanceTestFailedInCtor );
+        assertFalse( instanceTestFailedInSlot );
+        assertFalse( threadAffinityTestFailedInCtor );
+        assertFalse( threadAffinityTestFailedInSlot );
+        assertFalse( threadAffinityTestFailedInReceiver );
+    }
+
+    // Now do it all again so that we test restarting the thread again (KDTO-178)
+    {
+        instanceTestFailedInSlot = instanceTestFailedInCtor = threadAffinityTestFailedInSlot = threadAffinityTestFailedInCtor = threadAffinityTestFailedInReceiver = false;
+        TestThreadImpl* impl = threadRunner.startThread();
+        assertNotNull( impl );
+        QPointer<QObject> guard(impl);
+        assertTrue( threadRunner.isRunning() );
+        assertEqual( emitter.thread(), QCoreApplication::instance()->thread() );
+
+        // Check that we can't call startThread while it's running
+        TestThreadImpl* impl2 = threadRunner.startThread();
+        assertEqual( impl, impl2 );
+
+        bool connectOk = QObject::connect( &emitter, SIGNAL(theSignal()), impl, SLOT(slotInThread()) );
+        assertTrue( connectOk );
+        connectOk = QObject::connect( impl, SIGNAL(slotCalled()), &receiver, SLOT(theSlot()) );
+        assertTrue( connectOk );
+        emitter.emitSignal();
+        slotCalledSemaphore.acquire();
+        assertTrue( threadRunner.wait( JOIN_TIMEOUT ) );
+        QCoreApplication::processEvents();
+#ifndef Q_WS_MAC // KDTO-187
+        assertEqual( receiver.slotCalledCount(), 2 );
+#endif
+        assertFalse( threadRunner.isRunning() );
+        assertNull( guard );
+
+        assertFalse( instanceTestFailedInCtor );
+        assertFalse( instanceTestFailedInSlot );
+        assertFalse( threadAffinityTestFailedInCtor );
+        assertFalse( threadAffinityTestFailedInSlot );
+        assertFalse( threadAffinityTestFailedInReceiver );
+    }
+}
+
+#endif // KDTOOLSCORE_UNITTESTS
diff --git a/kdthreadrunner.h b/kdthreadrunner.h
new file mode 100644
index 0000000..fb5152a
--- /dev/null
+++ b/kdthreadrunner.h
@@ -0,0 +1,61 @@
+#ifndef __KDTOOLSCORE_KDTHREADRUNNER_H__
+#define __KDTOOLSCORE_KDTHREADRUNNER_H__
+
+#include <QMutexLocker>
+#include <QtCore/QThread>
+
+#include "pimpl_ptr.h"
+#include "sqlate_export.h"
+
+class SQLATE_EXPORT KDThreadRunnerBase : public QThread
+{
+public:
+    ~KDThreadRunnerBase();
+
+protected:
+    explicit KDThreadRunnerBase( QObject* parent = 0 );
+    void doStart( Priority prio );
+    void doExec();
+
+    void setImpl( QObject* );
+    QObject* impl() const;
+
+    QMutex* internalStartThreadMutex();
+
+private:
+    class Private;
+    kdtools::pimpl_ptr< Private > d;
+};
+
+template <class T>
+class SQLATE_EXPORT KDThreadRunner
+#ifdef DOXYGEN_RUN
+ : public QThread
+#else
+ : public KDThreadRunnerBase
+#endif
+{
+public:
+    explicit KDThreadRunner( QObject * p=0 )
+        : KDThreadRunnerBase( p ) {}
+
+    T * startThread( Priority prio = InheritPriority ) {
+        QMutexLocker locker( this->internalStartThreadMutex() );
+        if ( !this->impl() ) {
+            this->doStart( prio );
+        }
+        return static_cast<T*>( this->impl() );
+    }
+
+protected:
+    /*! \reimp */ void run()
+    {
+        // impl is created in the thread so that m_impl->thread()==this
+        T t(this);
+        this->setImpl( &t );
+        this->doExec();
+        this->setImpl( 0 );
+    }
+};
+
+#endif
diff --git a/kdtoolsglobal.h b/kdtoolsglobal.h
new file mode 100644
index 0000000..c355e70
--- /dev/null
+++ b/kdtoolsglobal.h
@@ -0,0 +1,124 @@
+#ifndef __KDTOOLS_KDTOOLSGLOBAL_H__
+#define __KDTOOLS_KDTOOLSGLOBAL_H__
+
+#include <QtCore/QtGlobal>
+
+#define KDAB_DISABLE_COPY( x ) private: x( const x & ); x & operator=( const x & )
+
+#ifdef KDTOOLS_SHARED
+#  ifdef BUILD_SHARED_KDTOOLSCORE
+#    define KDTOOLSCORE_EXPORT Q_DECL_EXPORT
+#  else
+#    define KDTOOLSCORE_EXPORT Q_DECL_IMPORT
+#  endif
+#  ifdef BUILD_SHARED_KDTOOLSGUI
+#    define KDTOOLSGUI_EXPORT Q_DECL_EXPORT
+#  else
+#    define KDTOOLSGUI_EXPORT Q_DECL_IMPORT
+#  endif
+#  ifdef BUILD_SHARED_KDTOOLSXML
+#    define KDTOOLSXML_EXPORT Q_DECL_EXPORT
+#  else
+#    define KDTOOLSXML_EXPORT Q_DECL_IMPORT
+#  endif
+#  ifdef BUILD_SHARED_KDUPDATER
+#    define KDTOOLS_UPDATER_EXPORT    Q_DECL_EXPORT
+#  else
+#    define KDTOOLS_UPDATER_EXPORT    Q_DECL_IMPORT
+#  endif
+#else // KDTOOLS_SHARED
+#  define KDTOOLSCORE_EXPORT
+#  define KDTOOLSGUI_EXPORT
+#  define KDTOOLSXML_EXPORT
+#  define KDTOOLS_UPDATER_EXPORT
+#endif // KDTOOLS_SHARED
+
+#define MAKEINCLUDES_EXPORT
+
+#define DOXYGEN_PROPERTY( x )
+#ifdef DOXYGEN_RUN
+# define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( func ) operator unspecified_bool_type() const { return func; }
+# define KDAB_USING_SAFE_BOOL_OPERATOR( Class ) operator unspecified_bool_type() const;
+#else
+# define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_IMPL( func, access )              \
+    access: struct __safe_bool_dummy__ { void nonnull() {} };           \
+        typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \
+    public:                                                             \
+        operator unspecified_bool_type() const {                        \
+            return ( func ) ? &__safe_bool_dummy__::nonnull : 0 ;       \
+        }
+# define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( func ) \
+    KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_IMPL( func, private )
+# if defined(__clang__)
+   // KDT3: use this one for all compilers
+#  define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_BASE( func )        \
+    KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_IMPL( func, protected )
+# else
+   // KDT3: is this needed for binary compatibility on Windows?
+#  define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_BASE( func )        \
+    KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR_IMPL( func, private )
+#endif
+#define KDAB_USING_SAFE_BOOL_OPERATOR( Class ) \
+    using Class::operator Class::unspecified_bool_type;
+#endif
+
+#define KDTOOLS_MAKE_RELATION_OPERATORS( Class, linkage )             \
+    linkage bool operator>( const Class & lhs, const Class & rhs ) {  \
+        return operator<( rhs, lhs );                                 \
+    }                                                                 \
+    linkage bool operator!=( const Class & lhs, const Class & rhs ) { \
+        return !operator==( lhs, rhs );                               \
+    }                                                                 \
+    linkage bool operator<=( const Class & lhs, const Class & rhs ) { \
+        return !operator>( lhs, rhs );                                \
+    }                                                                 \
+    linkage bool operator>=( const Class & lhs, const Class & rhs ) { \
+        return !operator<( lhs, rhs );                                \
+    }
+
+template <typename T>
+inline T & __kdtools__dereference_for_methodcall( T & o ) {
+    return o;
+}
+
+template <typename T>
+inline T & __kdtools__dereference_for_methodcall( T * o ) {
+    return *o;
+}
+
+#define KDAB_SET_OBJECT_NAME( x ) __kdtools__dereference_for_methodcall( x ).setObjectName( QLatin1String( #x ) )
+
+KDTOOLSCORE_EXPORT bool _kdCheckQtVersion_impl( int major, int minor=0, int patchlevel=0 );
+static inline bool kdCheckQtVersion( unsigned int major, unsigned int minor=0, unsigned int patchlevel=0 ) {
+    return (major<<16|minor<<8|patchlevel) <= static_cast<unsigned int>(QT_VERSION)
+	|| _kdCheckQtVersion_impl( major, minor, patchlevel );
+}
+
+#define KDTOOLS_DECLARE_PRIVATE_BASE( Class )                        \
+protected:                                                           \
+    class Private;                                                   \
+    Private * d_func() { return _d; }                                \
+    const Private * d_func() const { return _d; }                    \
+    Class( Private * _d_, bool b ) : _d( _d_ ) { init(b); }          \
+private:                                                             \
+    void init(bool);                                                 \
+private:                                                             \
+    Private * _d
+
+#define KDTOOLS_DECLARE_PRIVATE_DERIVED( Class, Base )                  \
+protected:                                                              \
+    class Private;                                                      \
+    Private * d_func() {                                                \
+        return reinterpret_cast<Private*>( Base::d_func() );            \
+    }                                                                   \
+    const Private * d_func() const {                                    \
+        return reinterpret_cast<const Private*>( Base::d_func() );      \
+    }                                                                   \
+    Class( Private * _d_, bool b )                                      \
+        : Base( reinterpret_cast<Base::Private*>(_d_), b ) { init(b); } \
+private:                                                                \
+    void init(bool)
+
+
+#endif /* __KDTOOLS_KDTOOLSGLOBAL_H__ */
+
diff --git a/pimpl_ptr.h b/pimpl_ptr.h
new file mode 100644
index 0000000..b7227c7
--- /dev/null
+++ b/pimpl_ptr.h
@@ -0,0 +1,55 @@
+#ifndef __KDTOOLSCORE__PIMPL_PTR_H__
+#define __KDTOOLSCORE__PIMPL_PTR_H__
+
+#include "kdtoolsglobal.h"
+
+#ifndef DOXYGEN_RUN
+namespace kdtools {
+#endif
+
+    template <typename T>
+    class MAKEINCLUDES_EXPORT pimpl_ptr {
+        KDAB_DISABLE_COPY( pimpl_ptr );
+        T * d;
+    public:
+        pimpl_ptr() : d( new T ) {}
+        explicit pimpl_ptr( T * t ) : d( t ) {}
+        ~pimpl_ptr() { delete d; d = 0; }
+
+        void swap( pimpl_ptr & other ) {
+            T * const tmp = d;
+            d = other.d;
+            other.d = tmp;
+        }
+
+        T * get() { return d; }
+        const T * get() const { return d; }
+
+        T * operator->() { return get(); }
+        const T * operator->() const { return get(); }
+
+        T & operator*() { return *get(); }
+        const T & operator*() const { return *get(); }
+
+        KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( get() )
+    };
+
+    template <typename T>
+    inline void swap( pimpl_ptr<T> & lhs, pimpl_ptr<T> & rhs ) {
+        lhs.swap( rhs );
+    }
+
+    // these are not implemented, so's we can catch their use at
+    // link-time. Leaving them undeclared would open up a comparison
+    // via operator unspecified-bool-type().
+    template <typename T, typename S>
+    void operator==( const pimpl_ptr<T> &, const pimpl_ptr<S> & );
+    template <typename T, typename S>
+    void operator!=( const pimpl_ptr<T> &, const pimpl_ptr<S> & );
+
+#ifndef DOXYGEN_RUN
+} // namespace kdtools
+#endif
+
+#endif /* __KDTOOLSCORE__PIMPL_PTR_H__ */
+
diff --git a/procedures/pre-create/ACLTriggerFunctions.tsp b/procedures/pre-create/ACLTriggerFunctions.tsp
new file mode 100644
index 0000000..288f3ab
--- /dev/null
+++ b/procedures/pre-create/ACLTriggerFunctions.tsp
@@ -0,0 +1,19 @@
+-- Functions and triggers to restrict access to tables, columns, rows, etc.
+
+-- Function to check if the current user is member of sqladmins group
+CREATE OR REPLACE FUNCTION is_administrator()
+    RETURNS trigger AS $BODY$
+    DECLARE
+        var_rolname varchar(50);
+    BEGIN
+        SELECT ROLNAME INTO var_rolname FROM PG_USER JOIN PG_AUTH_MEMBERS ON (PG_USER.USESYSID=PG_AUTH_MEMBERS.MEMBER) JOIN PG_ROLES ON (PG_ROLES.OID=PG_AUTH_MEMBERS.ROLEID AND PG_ROLES.rolname='sqladmins') WHERE PG_USER.USENAME=current_user;
+        IF FOUND THEN
+            RETURN NEW;
+        ELSE
+            RAISE EXCEPTION 'user is not in sqladmins group';
+        END IF;
+    END;
+$BODY$
+  LANGUAGE plpgsql VOLATILE
+  COST 100;
+ALTER FUNCTION is_administrator() OWNER TO postgres;
diff --git a/sqlate_export.h b/sqlate_export.h
new file mode 100644
index 0000000..562632b
--- /dev/null
+++ b/sqlate_export.h
@@ -0,0 +1,20 @@
+#ifndef SQLATEEXPORT_H
+#define SQLATEEXPORT_H
+
+#include <qglobal.h>
+
+# ifdef SQLATE_STATICLIB
+#  undef SQLATE_SHAREDLIB
+#  define SQLATE_EXPORT
+# else
+#  ifndef SQLATE_EXPORT
+#   ifdef SQLATE_BUILD_SQLATE_LIB
+#    define SQLATE_EXPORT Q_DECL_EXPORT
+#   else
+#    define SQLATE_EXPORT Q_DECL_IMPORT
+#   endif
+#  endif
+# endif
+
+#endif
+
diff --git a/sqlschema2dot.cpp b/sqlschema2dot.cpp
new file mode 100644
index 0000000..ec38992
--- /dev/null
+++ b/sqlschema2dot.cpp
@@ -0,0 +1,10 @@
+#include "SqlGraphviz.h"
+#include "SqlSchema.h"
+
+#include <iostream>
+
+int main( int, char** )
+{
+//     std::cout << qPrintable( Sql::schemaToDot<Sql::Schema>() ) << std::endl;
+    return 0;
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..0591166
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,41 @@
+site_name(HOSTNAME)
+string(REPLACE "-" "_" HOSTNAME ${HOSTNAME})
+string(REPLACE "." "_" HOSTNAME ${HOSTNAME})
+
+include_directories(${CMAKE_BINARY_DIR}/tests ${CMAKE_SOURCE_DIR})
+
+set(testcommon_srcs testbase.cpp testschema.cpp )
+add_library(testcommon STATIC ${testcommon_srcs})
+
+macro(add_sql_unittest _source)
+  set(_test ${_source})
+  get_filename_component(_name ${_source} NAME_WE)
+
+  add_executable(${_name} ${_source})
+  add_test(NAME sql-${_name} COMMAND ${_name})
+  target_link_libraries(${_name} sqlate testcommon ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTTEST_LIBRARY} ${QT_QTSQL_LIBRARY})
+endmacro()
+
+#macro for test needing db access (they derive from TestBase)
+macro(add_sql_unittest_testbase _source)
+  set(_test ${_source})
+  get_filename_component(_name ${_source} NAME_WE)
+  add_executable(${_name} ${_source})
+
+  add_test(NAME sql-${_name} COMMAND ${_name})
+  set_tests_properties(sql-${_name} PROPERTIES ENVIRONMENT "SQLATE_DATABASE_HOST=sqlate-postgres;SQLATE_DATABASE_NAME=sqlate_test_${HOSTNAME}")
+  target_link_libraries(${_name} ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY}
+      ${QT_QTSQL_LIBRARY} sqlate testcommon)
+endmacro()
+
+add_sql_unittest(schematest.cpp)
+add_sql_unittest(createtabletest.cpp)
+add_sql_unittest(createruletest.cpp)
+add_sql_unittest(sqlutilstest.cpp)
+
+add_sql_unittest_testbase(selectquerybuildertest.cpp)
+add_sql_unittest_testbase(insertquerybuildertest.cpp)
+add_sql_unittest_testbase(updatequerybuildertest.cpp)
+add_sql_unittest_testbase(deletequerybuildertest.cpp)
+add_sql_unittest_testbase(selecttest.cpp)
+add_sql_unittest_testbase(schemaupdatetest.cpp)
diff --git a/tests/NewSchema.h b/tests/NewSchema.h
new file mode 100644
index 0000000..4ca52f5
--- /dev/null
+++ b/tests/NewSchema.h
@@ -0,0 +1,42 @@
+#ifndef SCHEMAUPDATETEST_NEW_SCHEME_H
+#define SCHEMAUPDATETEST_NEW_SCHEME_H
+
+#include "SqlSchema_p.h"
+
+#include <QUuid>
+#include <QVariant>
+
+#define NO_EXPORT
+
+using namespace Sql;
+
+namespace NewSql {
+
+TABLE( Version, NO_EXPORT ) {
+    SQL_NAME( "tblVersion" );
+    COLUMN( version, int, NotNull );
+    typedef boost::mpl::vector<versionType> columns;
+};
+
+TABLE( Existing, NO_EXPORT ) {
+    SQL_NAME( "tblExisting" );
+    COLUMN( id, QUuid, PrimaryKey );
+    COLUMN( column1, QString, NotNull, 128 );  // <-- column changed constraint to NotNull
+    COLUMN( column2, int, Null );              // <-- new column
+    typedef boost::mpl::vector<idType, column1Type, column2Type> columns;
+};
+
+TABLE( New, NO_EXPORT ) {
+    SQL_NAME( "tblNew" );
+    COLUMN( id, QUuid, PrimaryKey );
+    COLUMN( column1, QString, Null, 42 );
+    typedef boost::mpl::vector<idType, column1Type> columns;
+};
+
+
+#define NEWSCHEMA (Version)(Existing)(New)
+DECLARE_SCHEMA( NewSchema, NEWSCHEMA );
+
+}
+
+#endif
diff --git a/tests/OldSchema.h b/tests/OldSchema.h
new file mode 100644
index 0000000..f7ae423
--- /dev/null
+++ b/tests/OldSchema.h
@@ -0,0 +1,33 @@
+#ifndef SCHEMAUPDATETEST_OLD_SCHEME_H
+#define SCHEMAUPDATETEST_OLD_SCHEME_H
+
+#include "SqlSchema_p.h"
+
+#include <QUuid>
+#include <QVariant>
+
+#define NO_EXPORT
+
+using namespace Sql;
+
+namespace OldSql {
+
+TABLE( Version, NO_EXPORT ) {
+    SQL_NAME( "tblVersion" );
+    COLUMN( version, int, NotNull );
+    typedef boost::mpl::vector<versionType> columns;
+};
+
+TABLE( Existing, NO_EXPORT ) {
+    SQL_NAME( "tblExisting" );
+    COLUMN( id, QUuid, PrimaryKey );
+    COLUMN( column1, QString, Null, 128 );
+    typedef boost::mpl::vector<idType, column1Type> columns;
+};
+
+#define OLDSCHEMA (Version)(Existing)
+DECLARE_SCHEMA( OldSchema, OLDSCHEMA );
+
+}
+
+#endif
diff --git a/tests/README.tests b/tests/README.tests
new file mode 100644
index 0000000..0ac8b73
--- /dev/null
+++ b/tests/README.tests
@@ -0,0 +1,6 @@
+Some of the tests need a database to be run, so a test database server is needed or they will fail.
+Curently the requirements are:
+- Postgres database running at "sqlate-postgres" address if run from ctest/make test or on localhost if run manually
+- Postgres must accept non-encrypted connections to the default port 5432
+- there must be an account "sqlate.user" with password "sql123456" and having superuser rights (so it is better to use an isolated test postgres install)
+- there must be an "sqladmins" and "sqlusers" group and the "sqlate.user" must be part of them. "sqladmins" should have wide rights (e.g superuser rights)
diff --git a/tests/createruletest.cpp b/tests/createruletest.cpp
new file mode 100644
index 0000000..9e020bc
--- /dev/null
+++ b/tests/createruletest.cpp
@@ -0,0 +1,36 @@
+#include "testschema.h"
+#include "Sql.h"
+#include "SqlCreateRule.h"
+#include "SqlGlobal.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+class CreateRuleTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+
+    void testRuleCreation()
+    {
+        const QStringList rules = Sql::createNotificationRuleStatements<Sql::SQLateTestSchema>();
+        SQLDEBUG << rules;
+        //NOTE: the test always takes only the first table, so adapt it if the table order changes in the schema
+        QCOMPARE( rules[0], QLatin1String("CREATE OR REPLACE RULE tblVersionNotificationInsertRule AS ON INSERT TO tblVersion DO ALSO NOTIFY tblVersionChanged") );
+        QCOMPARE( rules[1], QLatin1String("CREATE OR REPLACE RULE tblVersionNotificationUpdateRule AS ON UPDATE TO tblVersion DO ALSO NOTIFY tblVersionChanged") );
+        QCOMPARE( rules[2], QLatin1String("CREATE OR REPLACE RULE tblVersionNotificationDeleteRule AS ON DELETE TO tblVersion DO ALSO NOTIFY tblVersionChanged") );
+
+        //_1b57b54 is the encoded version of the "tblWorkplace.id" column
+       // SQLDEBUG << rules;
+        QRegExp rx(QLatin1String("^CREATE OR REPLACE RULE \"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\" "
+                                 "AS ON UPDATE TO tblWorkplace DO ALSO SELECT pg_notify\\(CAST \\(OLD\\.id AS text\\) \\|\\| '_1b57b54',''\\)$"), Qt::CaseSensitive, QRegExp::RegExp2);
+
+        SQLDEBUG << rules.indexOf(rx);
+        QVERIFY(rules.indexOf(rx) != -1);
+
+    }
+};
+
+QTEST_MAIN( CreateRuleTest )
+
+#include "createruletest.moc"
diff --git a/tests/createtabletest.cpp b/tests/createtabletest.cpp
new file mode 100644
index 0000000..104b3a2
--- /dev/null
+++ b/tests/createtabletest.cpp
@@ -0,0 +1,94 @@
+#include "testschema.h"
+#include "Sql.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+class CreateTableTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void testSingleCreation()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE tblPerson (\n"
+                                            "id UUID PRIMARY KEY,\n"
+                                            "fk_lutPrefix_id UUID NOT NULL REFERENCES lutPrefix (id) ON DELETE RESTRICT,\n"
+                                            "PersonForename VARCHAR(128),\n"
+                                            "PersonSurname VARCHAR(128),\n"
+                                            "PersonSuffix VARCHAR(128),\n"
+                                            "fk_lutPersonGrades_id UUID NOT NULL REFERENCES lutPersonGrades (id) ON DELETE RESTRICT,\n"
+                                            "PersonActive BOOLEAN,\n"
+                                            "HireRights BOOLEAN,\n"
+                                            "UserName VARCHAR(255) UNIQUE\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::Person ), s );
+    }
+
+    void testStandardLookupTable()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE lutDirectorates (\n"
+                                            "id UUID PRIMARY KEY,\n"
+                                            "short_desc VARCHAR(128),\n"
+                                            "description VARCHAR(255)\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::Directorates), s );
+
+    }
+
+    void testExtendedLookupTable()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE lutPersonGrades (\n"
+                                            "id UUID PRIMARY KEY,\n"
+                                            "short_desc VARCHAR(128),\n"
+                                            "description VARCHAR(255),\n"
+                                            "fk_lutPersonRoles_id UUID NOT NULL REFERENCES lutPersonRoles (id) ON DELETE RESTRICT\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::PersonGrades), s );
+    }
+
+    void testStandardRelation()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE rltPersonSubRoles (\n"
+                                            "fk_tblPerson_id UUID NOT NULL REFERENCES tblPerson (id),\n"
+                                            "fk_lutPersonSubRoles_id UUID NOT NULL REFERENCES lutPersonSubRoles (id),\n"
+                                            "UNIQUE( fk_tblPerson_id, fk_lutPersonSubRoles_id )\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::PersonSubRolesRelation ), s );
+    }
+
+    void testExtendedRecursiveRelation()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE rltPersonBossRelation (\n"
+                                            "fk_tblPerson_id UUID NOT NULL REFERENCES tblPerson (id),\n"
+                                            "fk_tblPerson_id_link UUID NOT NULL REFERENCES tblPerson (id),\n"
+                                            "expires TIMESTAMP WITH TIME ZONE,\n"
+                                            "UNIQUE( fk_tblPerson_id, fk_tblPerson_id_link )\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::PersonBossRelation ), s );
+    }
+
+    void testDefault()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE lutPersonRoles (\n"
+                                            "id UUID PRIMARY KEY,\n"
+                                            "short_desc VARCHAR(128),\n"
+                                            "description VARCHAR(255),\n"
+                                            "reportType INTEGER DEFAULT 0\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::PersonRoles ), s );
+    }
+
+    void testUniqueTableConstraint()
+    {
+        QString s = QString::fromLatin1( "CREATE TABLE tblWorkTask (\n"
+                                            "ealStart TIMESTAMP WITH TIME ZONE NOT NULL,\n"
+                                            "ealEnd TIMESTAMP WITH TIME ZONE,\n"
+                                            "foreign_id UUID NOT NULL,\n"
+                                            "UNIQUE( foreign_id, ealEnd )\n)" );
+        QCOMPARE( Sql::createTableStatement( Sql::WorkTask ), s );
+    }
+
+    void testAllCreation()
+    {
+        // mostly to check if that compiles, it finds errrors in incomplete schema declarations
+        /*qDebug() <<*/ Sql::createTableStatements<Sql::SQLateTestSchema>();
+    }
+};
+
+QTEST_MAIN( CreateTableTest )
+
+#include "createtabletest.moc"
diff --git a/tests/deletequerybuildertest.cpp b/tests/deletequerybuildertest.cpp
new file mode 100644
index 0000000..e974c1a
--- /dev/null
+++ b/tests/deletequerybuildertest.cpp
@@ -0,0 +1,64 @@
+#define QUERYBUILDER_UNITTEST
+
+#include "testbase.h"
+#include "testschema.h"
+#include "Sql.h"
+#include "SqlDeleteQueryBuilder.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+Q_DECLARE_METATYPE( SqlDeleteQueryBuilder )
+Q_DECLARE_METATYPE( QVector<QVariant> )
+
+class DeleteQueryBuilderTest : public TestBase
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase() {
+      openDbTest();
+      createEmptyDb();
+    }
+
+    void testQueryBuilder_data()
+    {
+        QTest::addColumn<SqlDeleteQueryBuilder>( "qb" );
+        QTest::addColumn<QString>( "sql" );
+        QTest::addColumn<QVector<QVariant> >( "values" );
+
+        SqlDeleteQueryBuilder qb;
+        QVector<QVariant> values;
+
+        qb.setTable( Sql::Report );
+        QTest::newRow( "Delete table" ) << qb << "DELETE FROM tblReport" << values;
+
+        qb = SqlDeleteQueryBuilder();
+        qb.setTable( Sql::Person );
+        qb.setIncludeSubTables(false);
+        QTest::newRow( "Delete only table" ) << qb << "DELETE FROM ONLY tblPerson" << values;
+
+        qb = SqlDeleteQueryBuilder();
+        qb.setTable( Sql::Workplace );
+        qb.setIncludeSubTables(false);
+        qb.whereCondition().addValueCondition( Sql::Workplace.itemorder, SqlCondition::Equals, 42 );
+        values.clear();
+        values << 42;
+        QTest::newRow( "Delete, where clause, value" ) << qb << "DELETE FROM ONLY tblWorkplace WHERE tblWorkplace.itemorder = :0" << values;
+
+    }
+
+    void testQueryBuilder()
+    {
+        QFETCH( SqlDeleteQueryBuilder, qb );
+        QFETCH( QString, sql );
+        QFETCH( QVector<QVariant>, values );
+
+        qb.query(); // trigger query assembly
+        QCOMPARE( qb.m_queryString, sql );
+        QCOMPARE( qb.m_bindValues, values);
+    }
+};
+
+QTEST_MAIN( DeleteQueryBuilderTest )
+
+#include "deletequerybuildertest.moc"
diff --git a/tests/insertquerybuildertest.cpp b/tests/insertquerybuildertest.cpp
new file mode 100644
index 0000000..9ff9306
--- /dev/null
+++ b/tests/insertquerybuildertest.cpp
@@ -0,0 +1,118 @@
+#define QUERYBUILDER_UNITTEST
+
+#include "test_utils.h"
+#include "testbase.h"
+#include "testschema.h"
+
+#include "Sql.h"
+#include "SqlInsertQueryBuilder.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+#include <algorithm>
+
+using namespace Sql;
+
+Q_DECLARE_METATYPE( SqlInsertQueryBuilder )
+Q_DECLARE_METATYPE( QVector<QVariant> )
+
+class InsertQueryBuilderTest : public TestBase
+{
+    Q_OBJECT
+private Q_SLOTS:
+
+    void initTestCase() {
+      openDbTest();
+      createEmptyDb();
+      QSqlQuery query;
+      QVERIFY(query.exec(QLatin1String("CREATE TABLE table1 (first VARCHAR(128), second INTEGER)")));
+    }
+
+    void testQueryBuilder_data()
+    {
+        QTest::addColumn<SqlInsertQueryBuilder>( "qb" );
+        QTest::addColumn<QString>( "sql" );
+        QTest::addColumn<QStringList >( "columns" );
+        QTest::addColumn<QVector<QVariant> >( "values" );
+
+        SqlInsertQueryBuilder qb;
+        QStringList columns;
+        QVector<QVariant> values;
+
+        qb.setTable( Report );
+        qb.addDefaultValues();
+        QTest::newRow( "Default values" ) << qb << "INSERT INTO tblReport DEFAULT VALUES" << columns << values;
+
+        qb = SqlInsertQueryBuilder();
+        qb.setTable( QL1S("table1"));
+        qb.addColumnValue( QL1S("first"), QL1S("1") );
+        columns.clear();
+        values.clear();
+        columns << QL1S("first");    
+        values << QL1S("1");
+        QTest::newRow( "1 column, string" ) << qb << "INSERT INTO table1 (first) VALUES (:0)" << columns << values;
+
+        qb = SqlInsertQueryBuilder();
+        qb.addColumnValue( QL1S("first"), QL1S("1") );
+        qb.addColumnValue( QL1S("second"), 42 );
+        qb.setTable( QL1S("table1") );
+        
+        columns.clear();
+        values.clear();
+        columns << QL1S("first") << QL1S("second");        
+        values << QL1S("1") << 42;
+        QTest::newRow( "2 columns, string and number" ) << qb << "INSERT INTO table1 (first,second) VALUES (:0,:1)" << columns << values;
+
+        qb = SqlInsertQueryBuilder();
+        qb.addColumnValue( QL1S("first"), QL1S("1") );
+        qb.addColumnValue( QL1S("second"), QVariant() );
+        qb.setTable( QL1S("table1") );
+        columns.clear();
+        values.clear();
+        columns << QL1S("first") << QL1S("second");
+        values << QL1S("1") << QVariant();
+        QTest::newRow( "2 columns, string and number, number is NULL" ) << qb << "INSERT INTO table1 (first,second) VALUES (:0,:1)" << columns << values;
+
+        qb = SqlInsertQueryBuilder();
+        qb.setTable( Person );
+        qb.addColumnValue( Person.id, QUuid("a12352e5-28e1-4873-a2a0-6c83c3c4b75a") );
+        columns.clear();
+        values.clear();
+        columns << QL1S("id");
+        values << QVariant::fromValue( QUuid("a12352e5-28e1-4873-a2a0-6c83c3c4b75a") );
+        QTest::newRow( "1 column, uuid, template" ) << qb << "INSERT INTO tblPerson (id) VALUES (:0)" << columns << values;
+
+        qb = SqlInsertQueryBuilder();
+        qb.setTable( Report );
+        QUuid hoId = QUuid::createUuid();
+        qb.addColumnValue(Report.id, hoId);
+        qb.addColumnValue(Report.ts, SqlNow);
+        qb.addColumnValue(Report.txt, SqlNull);
+        columns.clear();
+        values.clear();
+        columns << QL1S("id") << QL1S("ts") << QL1S("txt");
+        values << QVariant::fromValue( hoId ) << QVariant::fromValue<SqlNowType>(SqlNow) << QVariant();
+        QTest::newRow("server-side now") << qb << "INSERT INTO tblReport (id,ts,txt) VALUES (:0,now(),:2)" << columns << values;
+    }
+
+    void testQueryBuilder()
+    {
+        QFETCH( SqlInsertQueryBuilder, qb );
+        QFETCH( QString, sql );
+        QFETCH( QStringList, columns );
+        QFETCH( QVector<QVariant>, values );
+
+        qb.query(); // trigger query assembly
+        QCOMPARE( qb.m_queryString, sql );
+        QCOMPARE( qb.m_columnNames, columns );
+        qDebug() << qb.m_values << values;
+        // variant comparission for custom types (here, mostly QUuid) doesn't work, so we have to do this manually...
+        QCOMPARE( qb.m_values.size(), values.size() );
+        QVERIFY( std::equal( qb.m_values.begin(), qb.m_values.end(), values.begin(), deepVariantCompare ) );
+    }
+};
+
+QTEST_MAIN( InsertQueryBuilderTest )
+
+#include "insertquerybuildertest.moc"
diff --git a/tests/schemaUpdates/1.sql b/tests/schemaUpdates/1.sql
new file mode 100644
index 0000000..2fd8e1f
--- /dev/null
+++ b/tests/schemaUpdates/1.sql
@@ -0,0 +1 @@
+INVALID!!! WHOEVER EXECUTES THIS WILL FAIL!!! MUHAHAHAHAH
\ No newline at end of file
diff --git a/tests/schemaUpdates/2.sql b/tests/schemaUpdates/2.sql
new file mode 100644
index 0000000..28ead28
--- /dev/null
+++ b/tests/schemaUpdates/2.sql
@@ -0,0 +1,5 @@
+-- Sqlite (which we use for this test) can't handle this...
+-- ALTER TABLE tblExisting COLUMN column1 column1 varchar(128) NOT NULL;
+
+-- so try something else instead that shows this code got executed:
+ALTER TABLE tblExisting ADD COLUMN column3 varchar(32)
diff --git a/tests/schemaUpdates/4.sql b/tests/schemaUpdates/4.sql
new file mode 100644
index 0000000..2fd8e1f
--- /dev/null
+++ b/tests/schemaUpdates/4.sql
@@ -0,0 +1 @@
+INVALID!!! WHOEVER EXECUTES THIS WILL FAIL!!! MUHAHAHAHAH
\ No newline at end of file
diff --git a/tests/schemaUpdates/schemaUpdates.qrc b/tests/schemaUpdates/schemaUpdates.qrc
new file mode 100644
index 0000000..a86ac7a
--- /dev/null
+++ b/tests/schemaUpdates/schemaUpdates.qrc
@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/schemaUpdates">
+        <file>1.sql</file>
+        <file>2.sql</file>
+        <file>4.sql</file>
+    </qresource>
+</RCC>
diff --git a/tests/schematest.cpp b/tests/schematest.cpp
new file mode 100644
index 0000000..865bd5f
--- /dev/null
+++ b/tests/schematest.cpp
@@ -0,0 +1,51 @@
+#include "testschema.h"
+#include "Sql.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+
+class SchemaTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void testIdentifierAccess()
+    {
+        QCOMPARE( Sql::Person.sqlName(), QLatin1String( "tblPerson" ) );
+        QCOMPARE( Sql::PersonType::sqlName(), QLatin1String( "tblPerson" ) );
+        QCOMPARE( Sql::Person.tableName(), QLatin1String( "tblPerson" ) );
+
+        QCOMPARE( Sql::Person.id.sqlName(), QLatin1String( "id" ) );
+        QCOMPARE( Sql::Person.id.name(), QLatin1String( "tblPerson.id" ) );
+        QCOMPARE( Sql::PersonType::idType::name(), QLatin1String( "tblPerson.id" ) );
+    }
+
+    void testTypeAccess()
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<Sql::PersonType::idType::type, QUuid> ));
+        BOOST_MPL_ASSERT(( boost::is_same<Sql::PersonType::PersonGradeType::referenced_column, Sql::PersonGradesType::idType> ));
+    }
+
+    void testColumnPropertyAccess()
+    {
+        BOOST_MPL_ASSERT(( boost::mpl::not_<Sql::PersonType::idType::hasForeignKey> ));
+        BOOST_MPL_ASSERT(( Sql::PersonType::idType::primaryKey ));
+        BOOST_MPL_ASSERT(( Sql::PersonType::idType::notNull ));
+        BOOST_MPL_ASSERT(( boost::mpl::not_<Sql::PersonType::PersonForenameType::notNull> ));
+        BOOST_MPL_ASSERT(( boost::mpl::not_<Sql::PersonType::PersonForenameType::primaryKey> ));
+        BOOST_MPL_ASSERT(( boost::mpl::not_<Sql::PersonType::PersonForenameType::unique> ));
+        BOOST_MPL_ASSERT(( Sql::PersonType::PersonGradeType::hasForeignKey ));
+    }
+
+    void testColumnAliasing()
+    {
+        BOOST_MPL_ASSERT(( boost::is_same<Sql::PersonSubRolesRelationType::leftType, Sql::PersonSubRolesRelationType::fk_tblPerson_idType> ));
+        QCOMPARE( Sql::PersonSubRolesRelation.left.name(), Sql::PersonSubRolesRelation.fk_tblPerson_id.name() );
+    }
+};
+
+QTEST_MAIN( SchemaTest )
+
+#include "schematest.moc"
diff --git a/tests/schemaupdatetest.cpp b/tests/schemaupdatetest.cpp
new file mode 100644
index 0000000..9eabd21
--- /dev/null
+++ b/tests/schemaupdatetest.cpp
@@ -0,0 +1,126 @@
+#include <QtTest/QtTest> //Windows needs it as the first include
+
+#include "testschema.h"
+#include "testbase.h"
+#include "OldSchema.h"
+namespace OldSql {
+    DEFINE_SCHEMA( OLDSCHEMA )
+}
+#include "NewSchema.h"
+namespace NewSql {
+    DEFINE_SCHEMA( NEWSCHEMA )
+}
+
+#include "SqlSchema.h"
+#include "SqlQuery.h"
+#include "SqlSelect.h"
+#include "SchemaUpdater.h"
+#include "SqlInsertQueryBuilder.h"
+#include "SqlUtils.h"
+#include "SqlExceptions.h"
+
+#include <QObject>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QString>
+
+using namespace Sql;
+
+class SchemaUpdateTest : public TestBase
+{
+    Q_OBJECT
+
+    private:
+        int currentVersion()
+        {
+            SqlQuery q = select( Version.version ).from( Version );
+            q.exec();
+            q.next();
+            return q.value(0).toInt();
+        }
+
+        bool containsColumn( const QVector<QPair<QString, QVariant::Type> > & cols, const char* name, QVariant::Type type )
+        {
+            typedef QPair<QString, QVariant::Type> StringTypePair;
+            foreach ( const StringTypePair &c, cols ) {
+                if ( c.first == QLatin1String(name) && c.second == type )
+                    return true;
+            }
+            return false;
+        }
+
+    private slots:
+        void initTestCase()
+        {
+              openDbTest();
+
+              try {
+                  SqlQuery q;
+                  q.exec(QLatin1String("SET client_min_messages TO WARNING;"));
+              } catch ( const SqlException &e ) {
+                  qDebug() << tr("Log messages cannot be turned off: %1").arg( e.error().text() );
+              }
+
+              dropTables();
+
+              executePreCreateScripts(QLatin1String(":/sql"));
+              
+              try {
+              foreach (const QString &stmt, Sql::createTableStatements<OldSql::OldSchema>()) {
+                  SqlQuery q;
+                  q.exec( stmt );
+              }
+              } catch ( const SqlException& e ) {
+                  qDebug() << "SQL Error on table creation: " << e.error().text();
+                  exit(1);
+              }
+
+              SqlInsertQueryBuilder qb;
+              qb.setTable( OldSql::Version );
+              qb.addColumnValue( OldSql::Version.version, 1 );
+              qb.exec();
+
+              try {
+                  SqlQuery q;
+                  q.exec(QLatin1String("SET client_min_messages TO NOTICE;"));
+              } catch ( const SqlException &e ) {
+                  qDebug() << tr("Log messages cannot be turned off: %1").arg( e.error().text() );
+              }
+
+        }
+
+        void testSchemaUpdate()
+        {
+            QCOMPARE( currentVersion(), 1 );
+
+            const QSqlDatabase db = QSqlDatabase::database();
+
+            // already correct version
+            SchemaUpdater<OldSql::OldSchema, VersionType> updater1(1);
+            QVERIFY(!updater1.needsUpdate());
+            updater1.execUpdates(false);
+            QCOMPARE( currentVersion(), 1 );
+            QCOMPARE( db.tables().size(), 2 );
+
+            SchemaUpdater<NewSql::NewSchema, VersionType> updater2(3);
+            QVERIFY(updater2.needsUpdate());
+            updater2.execUpdates(false);
+            QCOMPARE( currentVersion(), 3 );
+            QCOMPARE( db.tables().size(), 3 );
+
+            QVector<QPair<QString, QVariant::Type> > cols = SqlUtils::columnsOfTable( OldSql::Existing, db );
+            QCOMPARE( cols.size(), 3 );
+            QVERIFY( containsColumn( cols, "id", QVariant::String ) );
+            QVERIFY( containsColumn( cols, "column1", QVariant::String ) );
+            QVERIFY( containsColumn( cols, "column2", QVariant::Int ) );
+
+            cols = SqlUtils::columnsOfTable( NewSql::New );
+            QCOMPARE( cols.size(), 2 );
+            QVERIFY( containsColumn( cols, "column1", QVariant::String ) );
+        }
+
+};
+
+QTEST_MAIN( SchemaUpdateTest )
+
+#include "schemaupdatetest.moc"
diff --git a/tests/selectquerybuildertest.cpp b/tests/selectquerybuildertest.cpp
new file mode 100644
index 0000000..2674550
--- /dev/null
+++ b/tests/selectquerybuildertest.cpp
@@ -0,0 +1,174 @@
+#define QUERYBUILDER_UNITTEST
+
+#include "testschema.h"
+#include "Sql.h"
+#include "SqlSelectQueryBuilder.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+#include <QSqlError>
+
+#include "test_utils.h"
+#include "testbase.h"
+
+#define QL1S(x) QString::fromLatin1(x)
+
+Q_DECLARE_METATYPE( SqlSelectQueryBuilder )
+Q_DECLARE_METATYPE( QVector<QVariant> )
+
+using namespace Sql;
+
+class SelectQueryBuilderTest : public TestBase
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase() {
+      openDbTest();
+      createEmptyDb();
+      QSqlQuery query;
+      QVERIFY(query.exec(QLatin1String("CREATE TABLE table1 (col1 VARCHAR(128), col2 VARCHAR(128), col3 VARCHAR(128), col4 VARCHAR(128));")));
+      QVERIFY(query.exec(QLatin1String("CREATE TABLE table2 (col1_2 VARCHAR(128), col2_2 VARCHAR(128), col3_2 VARCHAR(128), col4_2 VARCHAR(128))")));
+      QVERIFY(query.exec(QLatin1String("CREATE TABLE table3 (col1_3 VARCHAR(128), col2_3 VARCHAR(128), col3_3 VARCHAR(128), col4_3 VARCHAR(128))")));
+    }
+
+    void testQueryBuilder_data()
+    {
+        QTest::addColumn<SqlSelectQueryBuilder>( "qb" );
+        QTest::addColumn<QString>( "sql" );
+        QTest::addColumn<QVector<QVariant> >( "bindVals" );
+        SqlSelectQueryBuilder qb;
+
+        qb.setTable( QL1S("table1") );
+        qb.addColumn( QL1S("col1") );
+        QTest::newRow( "1 column" ) << qb << "SELECT col1 FROM table1" << QVector<QVariant>();
+
+        qb.addColumn( QL1S( "col2" ) );
+        QTest::newRow( "2 columns" ) << qb << "SELECT col1, col2 FROM table1" << QVector<QVariant>();
+
+        qb.addColumn( QL1S( "col3" ), QL1S( "foo" ) );
+        QTest::newRow( "3 columns with 1 alias" ) << qb << "SELECT col1, col2, col3 AS \"foo\" FROM table1" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( QL1S( "table1" ) );
+        qb.addSortColumn( QL1S("col1") );
+        QTest::newRow( "sort 1 col" ) << qb << "SELECT * FROM table1 ORDER BY col1 ASC" << QVector<QVariant>();
+
+        qb.addSortColumn( QL1S("col2"), Qt::DescendingOrder );
+        QTest::newRow( "sort 2 cols" ) << qb << "SELECT * FROM table1 ORDER BY col1 ASC, col2 DESC" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( Workplace );
+        qb.whereCondition().addValueCondition( Workplace.itemorder, SqlCondition::Equals, 42 );
+        QTest::newRow( "single where" ) << qb << "SELECT * FROM tblWorkplace WHERE tblWorkplace.itemorder = :0" << (QVector<QVariant>() << 42);
+
+        qb.whereCondition().addColumnCondition( Workplace.contact_tel, SqlCondition::Greater, Workplace.contact_fax );
+        QTest::newRow( "two and where conds" ) << qb << "SELECT * FROM tblWorkplace WHERE (tblWorkplace.itemorder = :0 AND tblWorkplace.contact_tel > tblWorkplace.contact_fax)" << (QVector<QVariant>() << 42);
+
+        qb.whereCondition().setLogicOperator( SqlCondition::Or );
+        QTest::newRow( "two or where conds" ) << qb << "SELECT * FROM tblWorkplace WHERE (tblWorkplace.itemorder = :0 OR tblWorkplace.contact_tel > tblWorkplace.contact_fax)" << (QVector<QVariant>() << 42);
+
+        SqlCondition cond( SqlCondition::And );
+        cond.addValueCondition( Workplace.short_desc, SqlCondition::Is, SqlNull );
+        cond.addValueCondition( Workplace.description, SqlCondition::LessOrEqual, QString::fromLatin1("foo") );
+        qb.whereCondition().addCondition( cond );
+        QTest::newRow( "nested conds" ) << qb << "SELECT * FROM tblWorkplace WHERE (tblWorkplace.itemorder = :0 OR tblWorkplace.contact_tel > tblWorkplace.contact_fax OR (tblWorkplace.short_desc IS NULL AND tblWorkplace.description <= :1))" << (QVector<QVariant>() << 42 << QString::fromLatin1( "foo" ));
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( QL1S( "table1" ) );
+        qb.addJoin( SqlSelectQueryBuilder::InnerJoin, QL1S( "table2" ), QL1S( "col1" ), QL1S( "col2_2" ) );
+        QTest::newRow( "1 inner join" ) << qb << "SELECT * FROM table1 INNER JOIN table2 ON col1 = col2_2" << QVector<QVariant>();
+
+        qb.addJoin( SqlSelectQueryBuilder::InnerJoin, QL1S( "table3" ), QL1S( "col3" ), QL1S( "col4_3" ) );
+        QTest::newRow( "2 inner joins" ) << qb << "SELECT * FROM table1 INNER JOIN table2 ON col1 = col2_2 INNER JOIN table3 ON col3 = col4_3" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.setTable( QL1S( "table1" ) );
+        qb.addColumn( QL1S( "col1" ));
+        qb.addGroupColumn( QL1S( "table1.col1" ) );
+        QTest::newRow( "1 group by" ) << qb << "SELECT col1 FROM table1 GROUP BY table1.col1" << QVector<QVariant>();
+
+        qb.addColumn( QL1S( "col2" ));
+        qb.addGroupColumn( QL1S( "table1.col2" ) );
+        QTest::newRow( "2 group by" ) << qb << "SELECT col1, col2 FROM table1 GROUP BY table1.col1, table1.col2" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( QL1S( "table1" ) );
+        qb.whereCondition().addPlaceholderCondition( QL1S( "col1" ), SqlCondition::Equals, QL1S( ":p" ) );
+        QTest::newRow( "placeholder" ) << qb << "SELECT * FROM table1 WHERE col1 = :p" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( Report );
+        qb.whereCondition().addValueCondition( Report.txt, SqlCondition::Like, QL1S( "%foo" ) );
+        QTest::newRow( "LIKE condition" ) << qb << "SELECT * FROM tblReport WHERE tblReport.txt LIKE :0" << (QVector<QVariant>() << QL1S( "%foo" ));
+
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( Workplace );
+        qb.lockExclusive( Workplace );
+        QTest::newRow( "LIKE condition" ) << qb << "SELECT * FROM tblWorkplace FOR UPDATE OF tblWorkplace" << QVector<QVariant>();
+        
+        qb = SqlSelectQueryBuilder();
+        qb.addAllColumns();
+        qb.setTable( Workplace );
+        qb.tryLockExclusive( Workplace );
+        QTest::newRow( "LIKE condition" ) << qb << "SELECT * FROM tblWorkplace FOR UPDATE OF tblWorkplace NOWAIT" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.setDistinct(true);
+        qb.addColumn(QL1S("col1"));
+        qb.setTable(QL1S( "table1" ));
+        QTest::newRow( "DISTINCT" ) << qb << "SELECT DISTINCT col1 FROM table1" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.setDistinctOn(QL1S("col2"));
+        qb.addColumn(QL1S("col1"));
+        qb.setTable(QL1S( "table1" ));
+        QTest::newRow( "DISTINCT ON" ) << qb << "SELECT DISTINCT ON(col2) col1 FROM table1" << QVector<QVariant>();
+
+
+        qb = SqlSelectQueryBuilder();
+        qb.setTable( QL1S("table1") );
+        qb.addColumn( QL1S("col1") );
+
+        SqlSelectQueryBuilder qb2;
+        qb2.setTable( QL1S("table2") );
+        qb2.addColumn( QL1S("col2_2") );
+
+        SqlSelectQueryBuilder qbCombined;
+        qbCombined.combineQueries(qb, qb2);
+        QTest::newRow( "UNION " ) << qbCombined << "SELECT col1 FROM table1 UNION SELECT col2_2 FROM table2" << QVector<QVariant>();
+
+        SqlSelectQueryBuilder qbCombinedAll;
+        qbCombinedAll.combineQueries(qb, qb2, SqlSelectQueryBuilder::UnionAll);
+        QTest::newRow( "UNION ALL" ) << qbCombinedAll << "SELECT col1 FROM table1 UNION ALL SELECT col2_2 FROM table2" << QVector<QVariant>();
+
+        qb = SqlSelectQueryBuilder();
+        qb.setTable(Report);
+        qb.addAllColumns();
+        qb.whereCondition().addValueCondition(Report.ts, SqlCondition::LessOrEqual, SqlNow);
+        qb.whereCondition().addValueCondition(Report.txt, SqlCondition::Is, SqlNull);
+        QTest::newRow( "server side time" ) << qb << "SELECT * FROM tblReport WHERE (tblReport.ts <= now() AND tblReport.txt IS NULL)" << QVector<QVariant>();
+    }
+
+    void testQueryBuilder()
+    {
+        QFETCH( SqlSelectQueryBuilder, qb );
+        QFETCH( QString, sql );
+        QFETCH( QVector<QVariant>, bindVals );
+
+        qb.query(); // trigger query assembly
+        QCOMPARE( qb.m_queryString, sql );
+        // variant comparission for custom types (here, mostly QUuid) doesn't work, so we have to do this manually...
+        QCOMPARE( qb.m_bindValues.size(), bindVals.size() );
+        QVERIFY( std::equal( qb.m_bindValues.begin(), qb.m_bindValues.end(), bindVals.begin(), deepVariantCompare ) );
+    }
+};
+
+QTEST_MAIN( SelectQueryBuilderTest )
+
+#include "selectquerybuildertest.moc"
diff --git a/tests/selecttest.cpp b/tests/selecttest.cpp
new file mode 100644
index 0000000..3c14699
--- /dev/null
+++ b/tests/selecttest.cpp
@@ -0,0 +1,156 @@
+#define QUERYBUILDER_UNITTEST
+#include "testschema.h"
+#include "testbase.h"
+#include "Sql.h"
+#include "SqlSelect.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+using namespace Sql;
+
+Q_DECLARE_METATYPE( SqlSelectQueryBuilder )
+Q_DECLARE_METATYPE( QVector<QVariant> )
+
+class SelectTest : public TestBase
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase() {
+      openDbTest();
+      createEmptyDb();
+    }
+    
+    void testSelect_data()
+    {
+        QTest::addColumn<SqlSelectQueryBuilder>( "qb" );
+        QTest::addColumn<QString>( "sql" );
+        QTest::addColumn<QVector<QVariant> >( "bindVals" );
+
+        QTest::newRow( "single col, no cond" ) << select( Person.id ).from( Person ).queryBuilder() << "SELECT tblPerson.id FROM tblPerson" << QVector<QVariant>();
+
+        QTest::newRow( "single condition" )
+            << select( Person.id ).from( Person ).where( Person.HireRights == true ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE tblPerson.HireRights = :0"
+            << (QVector<QVariant>() << true);
+
+#ifdef _BullseyeCoverage
+#pragma BullseyeCoverage off
+#endif
+        QTest::newRow( "double condition" )
+            << select( Person.id ).from( Person ).where( Person.HireRights == true || Person.PersonForename == Person.PersonSurname ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE (tblPerson.HireRights = :0 OR tblPerson.PersonForename = tblPerson.PersonSurname)"
+            << (QVector<QVariant>() << true);
+
+        QTest::newRow( "multi col, multi cond" )
+            << select(
+                Person.id,
+                Person.PersonForename,
+                Person.PersonSurname
+            ).from( Person )
+            .where( Person.PersonSurname == Person.PersonForename && Person.PersonActive == true ).queryBuilder()
+            << "SELECT tblPerson.id, tblPerson.PersonForename, tblPerson.PersonSurname "
+               "FROM tblPerson WHERE (tblPerson.PersonSurname = tblPerson.PersonForename AND tblPerson.PersonActive = :0)"
+            << (QVector<QVariant>() << 1);
+#ifdef _BullseyeCoverage
+#pragma BullseyeCoverage on
+#endif
+
+         QTest::newRow( "single join" )
+            << select( Person.id, PersonGrades.description ).from( Person ).innerJoin( PersonGrades, Person.PersonGrade == PersonGrades.id ).queryBuilder()
+            << "SELECT tblPerson.id, lutPersonGrades.description FROM tblPerson INNER JOIN lutPersonGrades ON tblPerson.fk_lutPersonGrades_id = lutPersonGrades.id"
+            << QVector<QVariant>();
+
+        QTest::newRow( "double join" )
+            << select( Person.id ).from( Person ).innerJoin( PersonSubDirectoratesRelation, Person.id == PersonSubDirectoratesRelation.left )
+                .innerJoin( SubDirectorates, PersonSubDirectoratesRelation.right == SubDirectorates.id ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson INNER JOIN rltPersonSubDirectorates ON tblPerson.id = rltPersonSubDirectorates.fk_tblPerson_id "
+               "INNER JOIN lutSubDirectorates ON rltPersonSubDirectorates.fk_lutSubDirectorates_id = lutSubDirectorates.id"
+            << QVector<QVariant>();
+
+        QTest::newRow( "double join with condtion" )
+            << select( Person.id ).from( Person ).innerJoin( PersonSubDirectoratesRelation, Person.id == PersonSubDirectoratesRelation.left )
+                .innerJoin( SubDirectorates, PersonSubDirectoratesRelation.right == SubDirectorates.id )
+                .where( SubDirectorates.description == QString::fromLatin1( "foo" ) ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson INNER JOIN rltPersonSubDirectorates ON tblPerson.id = rltPersonSubDirectorates.fk_tblPerson_id "
+               "INNER JOIN lutSubDirectorates ON rltPersonSubDirectorates.fk_lutSubDirectorates_id = lutSubDirectorates.id "
+               "WHERE lutSubDirectorates.description = :0"
+            << (QVector<QVariant>() << QLatin1String( "foo" ));
+
+        QTest::newRow( "leftOuterJoin" )
+            << select( Person.id, PersonGrades.description ).from( Person ).leftOuterJoin( PersonGrades, Person.PersonGrade == PersonGrades.id ).queryBuilder()
+            << "SELECT tblPerson.id, lutPersonGrades.description FROM tblPerson LEFT OUTER JOIN lutPersonGrades ON tblPerson.fk_lutPersonGrades_id = lutPersonGrades.id"
+            << QVector<QVariant>();
+
+        QTest::newRow( "single order by, default" )
+            << select( Person.id ).from( Person ).orderBy( Person.PersonSurname ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson ORDER BY tblPerson.PersonSurname ASC"
+            << QVector<QVariant>();
+
+        QTest::newRow( "single order by, desc" )
+            << select( Person.id ).from( Person ).orderBy( Person.PersonSurname, Qt::DescendingOrder ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson ORDER BY tblPerson.PersonSurname DESC"
+            << QVector<QVariant>();
+
+        QTest::newRow( "double order by, default" )
+            << select( Person.id ).from( Person ).orderBy( Person.PersonSurname, Person.PersonForename ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson ORDER BY tblPerson.PersonSurname ASC, tblPerson.PersonForename ASC"
+            << QVector<QVariant>();
+
+        QTest::newRow( "double order by, mixed" )
+            << select( Person.id ).from( Person ).orderBy( Person.PersonSurname, Qt::AscendingOrder, Person.PersonForename, Qt::DescendingOrder ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson ORDER BY tblPerson.PersonSurname ASC, tblPerson.PersonForename DESC"
+            << QVector<QVariant>();
+
+        QTest::newRow( "placeholder condition" )
+            << select( Person.id ).from( Person ).where( Person.id == placeholder(":foo") ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE tblPerson.id = :foo"
+            << QVector<QVariant>();
+
+#ifdef _BullseyeCoverage
+#pragma BullseyeCoverage off
+#endif
+        QTest::newRow( "placeholder + value condition" )
+            << select( Person.id ).from( Person ).where( Person.id == placeholder(":foo") || Person.PersonSurname == QString::fromLatin1("bar") ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE (tblPerson.id = :foo OR tblPerson.PersonSurname = :0)"
+            << (QVector<QVariant>() << QLatin1String( "bar" ));
+#ifdef _BullseyeCoverage
+#pragma BullseyeCoverage on
+#endif
+
+         QTest::newRow( "IS NULL condition" )
+            << select( Person.id ).from( Person ).where( isNull( Person.PersonForename ) ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE tblPerson.PersonForename IS NULL"
+            << QVector<QVariant>();
+
+        QTest::newRow( "LIKE condition" )
+            << select( Person.id ).from( Person ).where( like( Person.PersonForename, QLatin1String( "foo%" ) ) ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson WHERE tblPerson.PersonForename LIKE :0"
+            << (QVector<QVariant>() << QLatin1String( "foo%" ));
+
+        QTest::newRow( "1 GROUP BY" )
+            << select( Person.id ).from( Person ).groupBy( Person.PersonSurname, Person.id ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson GROUP BY tblPerson.PersonSurname, tblPerson.id"
+            << QVector<QVariant>();
+
+        QTest::newRow( "2 GROUP BY" )
+            << select( Person.id ).from( Person ).groupBy( Person.PersonSurname, Person.PersonForename, Person.id ).queryBuilder()
+            << "SELECT tblPerson.id FROM tblPerson GROUP BY tblPerson.PersonSurname, tblPerson.PersonForename, tblPerson.id"
+            << QVector<QVariant>();
+    }
+
+   void testSelect()
+    {
+        QFETCH( SqlSelectQueryBuilder, qb );
+        QFETCH( QString, sql );
+        QFETCH( QVector<QVariant>, bindVals );
+
+        qb.query(); // trigger query assembly
+        QCOMPARE( qb.m_queryString, sql );
+        QCOMPARE( qb.m_bindValues, bindVals );
+    }
+};
+
+QTEST_MAIN( SelectTest )
+
+#include "selecttest.moc"
diff --git a/tests/sqlutilstest.cpp b/tests/sqlutilstest.cpp
new file mode 100644
index 0000000..cd62249
--- /dev/null
+++ b/tests/sqlutilstest.cpp
@@ -0,0 +1,65 @@
+#include "SqlUtils.h"
+#include "test_utils.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+#include <QStringList>
+
+class SqlUtilsTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void testStripComments_data()
+    {
+        QTest::addColumn<QString>("input");
+        QTest::addColumn<QString>("output");
+
+        QTest::newRow("empty") << QString() << QString();
+        QTest::newRow("comment1") << "-- hi there" << QString();
+        QTest::newRow("comment2") << "-- hi there\n" << QString();
+        QTest::newRow("comment3") << "-- hi there\n\n" << QString();
+        QTest::newRow("query1") << "SELECT * FROM tblVersion;" << "SELECT * FROM tblVersion;";
+        QTest::newRow("query2") << "SELECT * FROM tblVersion" << "SELECT * FROM tblVersion";
+        QTest::newRow("query3") << "SELECT * FROM tblVersion\n" << "SELECT * FROM tblVersion";
+        QTest::newRow("multi1") << "-- comment\nSELECT * FROM tblVersion" << "SELECT * FROM tblVersion";
+        QTest::newRow("multi2") << "-- comment\nSELECT * FROM tblVersion;" << "SELECT * FROM tblVersion;";
+        QTest::newRow("multi3") << "-- comment\nSELECT * FROM tblVersion\n" << "SELECT * FROM tblVersion";
+    }
+
+    void testStripComments()
+    {
+        QFETCH(QString, input);
+        QFETCH(QString, output);
+
+        SqlUtils::stripComments(input);
+        QCOMPARE(input, output);
+    }
+
+    void testSplitQueries_data()
+    {
+        QTest::addColumn<QString>("input");
+        QTest::addColumn<QStringList>("output");
+
+        QTest::newRow("empty") << QString() << QStringList();
+        QTest::newRow("comment1") << "-- hi there" << (QStringList() << QL1S("-- hi there"));
+        QTest::newRow("comment2") << "-- hi there\n" << (QStringList() << QL1S("-- hi there\n"));
+        QTest::newRow("comment3") << "-- hi there\n\n" << (QStringList() << QL1S("-- hi there\n\n"));
+        QTest::newRow("query1") << "SELECT * FROM tblVersion;" << (QStringList() << QL1S("SELECT * FROM tblVersion;"));
+        QTest::newRow("query2") << "SELECT * FROM tblVersion;\n" << (QStringList() << QL1S("SELECT * FROM tblVersion"));
+        QTest::newRow("query3") << "SELECT * FROM tblVersion\n" << (QStringList() << QL1S("SELECT * FROM tblVersion\n"));
+        QTest::newRow("multi1") << "SELECT a FROM b;\nSELECT c FROM d" << (QStringList() << QL1S("SELECT a FROM b") << QL1S("SELECT c FROM d"));
+    }
+
+    void testSplitQueries()
+    {
+        QFETCH(QString, input);
+        QFETCH(QStringList, output);
+
+        const QStringList result = SqlUtils::splitQueries(input);
+        QCOMPARE(result, output);
+    }
+};
+
+QTEST_MAIN( SqlUtilsTest )
+
+#include "sqlutilstest.moc"
diff --git a/tests/test_utils.h b/tests/test_utils.h
new file mode 100644
index 0000000..adf8233
--- /dev/null
+++ b/tests/test_utils.h
@@ -0,0 +1,25 @@
+#ifndef SQLTEST_UTILS_H
+#define SQLTEST_UTILS_H
+
+#include "SqlCondition.h"
+#include "SqlSchema.h" //for QUuid metatype
+
+#include <QMetaType>
+#include <QUuid>
+
+#define QL1S(x) QString::fromLatin1(x)
+
+/** Extended variant comparison that also handles QUuid and our SQL dummy types. */
+inline bool deepVariantCompare( const QVariant &v1, const QVariant &v2 )
+{
+    if ( v1.type() != v2.type() )
+        return false;
+    if ( v1.userType() == qMetaTypeId<QUuid>() )
+        return v1.value<QUuid>() == v2.value<QUuid>();
+    if ( v1.userType() == qMetaTypeId<SqlNowType>() )
+        return v2.userType() == qMetaTypeId<SqlNowType>();
+    else
+        return v1 == v2;
+}
+
+#endif
diff --git a/tests/testbase.cpp b/tests/testbase.cpp
new file mode 100644
index 0000000..13ef695
--- /dev/null
+++ b/tests/testbase.cpp
@@ -0,0 +1,205 @@
+#include "testbase.h"
+
+#include "testschema.h"
+#include "SqlExceptions.h"
+#include "SqlQueryCache.h"
+#include "SqlGlobal.h"
+#include "SqlCreateTable.h"
+#include "Sql.h"
+
+#include <QtTest/QTest>
+#include <QFileInfo>
+#include <QMetaObject>
+#include <QString>
+#include <QSqlDatabase>
+#include <QSqlError>
+#include <QSqlQuery>
+#include <QDir>
+
+QString TestBase::databaseName() const
+{
+    const QString dbName = QLatin1String( qgetenv("SQLATE_DATABASE_NAME").constData() );
+    if (dbName.isEmpty()) {
+        return QLatin1String("sqlate_test");
+    }
+
+    return dbName.toLower();
+}
+
+void TestBase::openDbTest()
+{
+    QString dbName = databaseName();
+    QSqlDatabase db = QSqlDatabase::addDatabase(QLatin1String( "QPSQL" ));
+    db.setDatabaseName( dbName );
+     // Allow override by env settings
+    // No reason to restrict as only setting where the app connects to
+    QString dbHost = QLatin1String( qgetenv("SQLATE_DATABASE_HOST").constData() );
+    if (dbHost.isEmpty()) {
+        dbHost = QLatin1String("127.0.0.1");
+    }
+
+    QString dbUser = QLatin1String( "sqlate.user" );
+    QString dbPassword = QLatin1String("sql123456" );
+    int dbPort = getDbPort();
+    qDebug() << "Using database: " << dbName << " on host " << dbHost << " port: " << dbPort;
+    db.setHostName( dbHost );
+    db.setPort( dbPort );
+    db.setUserName( dbUser );
+    db.setPassword( dbPassword );
+
+    if ( !db.open() ) {
+        //try to create the database
+        db.close();
+        QSqlDatabase db2 = QSqlDatabase::database(  );
+        db2.setDatabaseName( QLatin1String("template1") );
+        db2.setHostName(dbHost);
+        db2.setPort(dbPort);
+        db2.setUserName(dbUser);
+        db2.setPassword(dbPassword);
+        if ( !db2.open() ) {
+            qFatal("Failed to connect: %s", db2.lastError().text().toLatin1().constData());
+        }
+
+        QString s = QString( QLatin1String("CREATE DATABASE %1 ENCODING 'UTF8' LC_COLLATE='en_US.UTF-8' LC_CTYPE='en_US.UTF-8' TEMPLATE template0") ).arg( databaseName() );
+        QSqlQuery query( db2 );
+        if ( !query.exec(s) ) {
+            qFatal("Failed to create the %s database: %s", databaseName().toLatin1().constData(), query.lastError().text().toLatin1().constData());
+        }
+        db2.close();
+        //reconnect again
+        db.close();
+        db = QSqlDatabase::database( );
+        db.setDatabaseName(databaseName());
+        db.setHostName(dbHost);
+        db.setPort(dbPort);
+        db.setUserName(dbUser);
+        db.setPassword(dbPassword);
+
+        if ( !db.open() ) {
+            qFatal("Failed to connect: %s", db.lastError().text().toLatin1().constData());
+        }
+    }
+    qDebug() << db;
+    /* else {
+        qFatal("Failed to connect: %s", db.lastError().text().toLatin1().constData());
+    }*/
+}
+
+bool TestBase::executePreCreateScripts(const QString &path)
+{
+    const QString proceduresFilesPath = QString::fromLatin1("%1/procedures/pre-create").arg(path);
+
+    QFileInfoList preCreateFiles;
+    // Make list of sql files to process
+    if ( path.length() ) {
+        QDir preCreateFilesDir(proceduresFilesPath, QLatin1String( "*.tsp" ));
+        preCreateFilesDir.setSorting( QDir::Name );
+        preCreateFiles.append(preCreateFilesDir.entryInfoList(QDir::Files));
+    } else {
+        message( tr( "Cannot find static data and procedures in %1").arg(path));
+        return false;
+    }
+
+    QFileInfoList::const_iterator sqlfileslist_it;
+    for (sqlfileslist_it=preCreateFiles.constBegin(); sqlfileslist_it!=preCreateFiles.constEnd(); ++sqlfileslist_it) {
+        bool result = processSqlFile( *sqlfileslist_it );
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool TestBase::processSqlFile(const QFileInfo &currentFileInfo)
+{
+    message(tr( " Processing file: %1").arg(currentFileInfo.absoluteFilePath()));
+    QFile file( currentFileInfo.absoluteFilePath() );
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        message( tr( " could not open file: %1").arg(currentFileInfo.absoluteFilePath()));
+        return false;
+    }
+    else {
+        message( tr( "... OK"));
+    }
+
+    QTextStream in(&file);
+    QString sql = in.readAll();
+
+    SqlUtils::stripComments(sql);
+    if ( sql.isEmpty() )
+        return true;
+
+    SqlQuery query;
+    query.exec( sql );
+    return true;
+}
+
+
+void TestBase::createEmptyDb()
+{
+    try {
+        SqlQuery q;
+        q.exec(QLatin1String("SET client_min_messages TO WARNING;"));
+    } catch ( const SqlException &e ) {
+        qDebug() << tr("Log messages cannot be turned off: %1").arg( e.error().text() );
+    }
+
+    dropTables();
+
+    executePreCreateScripts(QLatin1String(":/sql"));
+    // create tables
+    try {
+        Sql::createMissingTables<Sql::SQLateTestSchema>();
+    } catch ( const SqlException &e ) {
+        message( tr("Error while creating the tables: %1").arg(e.error().text()) );
+        return;
+    }
+
+    try {
+        Sql::createRulesPermissionsAndTriggers<Sql::SQLateTestSchema>();
+    } catch ( const SqlException &e ) {
+        message( tr("Error while creating the table rules, triggers and setting the permissions: %1").arg(e.error().text()) );
+        return;
+    }
+}
+
+bool TestBase::dropTables()
+{
+    message(tr("Dropping all tables..."));
+
+    foreach ( const QString &table, QSqlDatabase::database().tables() ) {
+        try {
+            SqlQuery q;
+            q.exec(QString::fromLatin1( "DROP TABLE IF EXISTS %1 CASCADE" ).arg( table ));
+        } catch ( const SqlException &e ) {
+           message( tr("Dropping table %1 failed: %2").arg( table ).arg( e.error().text() ) );
+           return false;
+        }
+    }
+   message(tr("All tables dropped."));
+
+   return true;
+}
+
+
+void TestBase::message(const QString& str)
+{
+    SQLDEBUG << str;
+}
+
+void TestBase::cleanupTestCase()
+{
+    SqlQueryCache::clear();
+}
+
+int TestBase::getDbPort()
+{
+    int dbPort = QString::fromLatin1( qgetenv("SQL_DATABASE_HOST_PORT").constData() ).toInt();
+    if (dbPort <= 0 ) {
+        dbPort = SQLATE_DEFAULT_SERVER_PORT;
+    }
+    return dbPort;
+}
+
+
+#include "moc_testbase.cpp"
diff --git a/tests/testbase.h b/tests/testbase.h
new file mode 100644
index 0000000..b46fece
--- /dev/null
+++ b/tests/testbase.h
@@ -0,0 +1,31 @@
+#ifndef TESTBASE_H
+#define TESTBASE_H
+
+#include <QObject>
+
+class QFileInfo;
+/** Base class for unit tests, mostly for logging and resetting the postgres database
+ */
+class TestBase : public QObject
+{
+    Q_OBJECT    
+
+protected slots:
+    virtual void message(const QString& str);
+    void cleanupTestCase();
+
+protected:
+    void openDbTest();
+    void createEmptyDb();
+
+    int getDbPort();
+    QString databaseName() const;
+    bool dropTables();
+    bool executePreCreateScripts(const QString &path);
+    bool processSqlFile(const QFileInfo &currentFileInfo);
+
+
+};
+
+
+#endif
diff --git a/tests/testschema.cpp b/tests/testschema.cpp
new file mode 100644
index 0000000..7bc5e01
--- /dev/null
+++ b/tests/testschema.cpp
@@ -0,0 +1,8 @@
+#include "testschema.h"
+
+namespace Sql {
+
+DEFINE_SCHEMA( SCHEMA )
+
+
+}
\ No newline at end of file
diff --git a/tests/testschema.h b/tests/testschema.h
new file mode 100644
index 0000000..7ce2299
--- /dev/null
+++ b/tests/testschema.h
@@ -0,0 +1,123 @@
+#ifndef TESTSCHEMA_H
+#define TESTSCHEMA_H
+
+#include "SqlSchema_p.h"
+#include "sqlate_export.h"
+
+#include <QDateTime>
+
+namespace Sql {
+
+TABLE( Version, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "tblVersion" );
+    COLUMN( version, int, NotNull );
+    typedef boost::mpl::vector<versionType> columns;
+};
+
+LOOKUP_TABLE( Prefix, SQLATE_EXPORT ) {
+     SQL_NAME( "lutPrefix" );
+};
+
+LOOKUP_TABLE( PersonRoles, SQLATE_EXPORT ) {
+    SQL_NAME( "lutPersonRoles" );
+    COLUMN( reportType, int, Default );
+    typedef append<baseColumns, boost::mpl::vector<reportTypeType> >::type columns;
+};
+
+LOOKUP_TABLE( PersonSubRoles, SQLATE_EXPORT ) {
+    SQL_NAME( "lutPersonSubRoles" );
+    FOREIGN_KEY( PersonRole, PersonRoles, id, NotNull );
+    typedef append<baseColumns, boost::mpl::vector<PersonRoleType> >::type columns;
+};
+
+LOOKUP_TABLE( PersonGrades, SQLATE_EXPORT ) {
+    SQL_NAME( "lutPersonGrades" );
+    FOREIGN_KEY( PersonRole, PersonRoles, id, NotNull|OnDeleteRestrict );
+    typedef append<baseColumns, boost::mpl::vector<PersonRoleType> >::type columns;
+};
+TABLE( Person, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "tblPerson" );
+    COLUMN( id, QUuid, PrimaryKey );
+    FOREIGN_KEY( fk_lutPrefix_id, Prefix, id, NotNull|OnDeleteRestrict );
+    COLUMN( PersonForename, QString, Null, 128 );
+    COLUMN( PersonSurname, QString, Null, 128 );
+    COLUMN(PersonSuffix, QString, Null, 128);
+    FOREIGN_KEY( PersonGrade, PersonGrades, id, NotNull|OnDeleteRestrict );
+    COLUMN( HireRights, bool, Null );
+    COLUMN( PersonActive, bool, Null );
+    COLUMN( UserName, QString, Unique, 255 );
+    typedef boost::mpl::vector<idType, fk_lutPrefix_idType, PersonForenameType, PersonSurnameType, PersonSuffixType, PersonGradeType, PersonActiveType, HireRightsType, UserNameType> columns;
+};
+
+
+UNIQUE_RELATION( PersonSubRolesRelation, Person, id, PersonSubRoles, id, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "rltPersonSubRoles" );
+    COLUMN_ALIAS( left, fk_tblPerson_id );
+    COLUMN_ALIAS( right, fk_lutPersonSubRoles_id );
+};
+
+
+LOOKUP_TABLE( Directorates, SQLATE_EXPORT ) {
+    SQL_NAME( "lutDirectorates" );
+};
+
+LOOKUP_TABLE( SubDirectorates, SQLATE_EXPORT ) {
+    SQL_NAME( "lutSubDirectorates" );
+    FOREIGN_KEY( Directorate, Directorates, id, NotNull );
+    typedef append<baseColumns, boost::mpl::vector<DirectorateType> >::type columns;
+};
+
+UNIQUE_RELATION( PersonSubDirectoratesRelation, Person, id, SubDirectorates, id, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "rltPersonSubDirectorates" );
+    COLUMN_ALIAS( left, fk_tblPerson_id );
+    COLUMN_ALIAS( right, fk_lutSubDirectorates_id );
+};
+
+UNIQUE_RECURSIVE_RELATION( PersonBossRelation, Person, id, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "rltPersonBossRelation" );
+    COLUMN( expires, QDateTime, Null );
+    COLUMN_ALIAS( left, fk_tblPerson_id );
+    COLUMN_ALIAS( right, fk_tblPerson_id_link );
+    typedef append<baseColumns, boost::mpl::vector<expiresType> >::type columns;
+};
+
+TABLE( WorkTask, SQLATE_EXPORT ) {
+    NO_USER_DELETE
+    SQL_NAME( "tblWorkTask" );
+    COLUMN( ealStart, QDateTime, NotNull );
+    COLUMN( ealEnd, QDateTime, Null );
+    COLUMN( foreign_id, QUuid, NotNull );
+    typedef boost::mpl::vector<ealStartType, ealEndType, foreign_idType> columns;
+    typedef append<baseConstraints, boost::mpl::vector<UniqueConstraint<boost::mpl::vector<foreign_idType, ealEndType> > > >::type constraints;
+};
+TABLE( Workplace, SQLATE_EXPORT ) {
+    ONLY_USER_SELECT
+    SQL_NAME( "tblWorkplace" );
+    COLUMN( id, QUuid, PrimaryKey | Notify );
+    COLUMN( itemorder, int, NotNull );
+    COLUMN( short_desc, QString, Null, 32 );
+    COLUMN( description, QString, Null, 255 );
+    COLUMN( contact_tel, QString, Null, 128 );
+    COLUMN( contact_fax, QString, Null, 128 );
+    typedef boost::mpl::vector<idType,  itemorderType, short_descType, descriptionType, contact_telType, contact_faxType> columns;
+};
+
+TABLE( Report, SQLATE_EXPORT ) {
+    NO_USER_DELETE
+    SQL_NAME( "tblReport" );
+    COLUMN( id, QUuid, PrimaryKey );
+    COLUMN( ts, QDateTime, NotNull );
+    COLUMN( txt, QString, Null );
+    typedef boost::mpl::vector<idType, tsType, txtType> columns;
+};
+
+#define SCHEMA (Version)(Prefix)(PersonRoles)(PersonSubRoles)(PersonGrades)(Person)(PersonSubRolesRelation)(Directorates)(SubDirectorates)(PersonSubDirectoratesRelation)(PersonBossRelation)(WorkTask)(Workplace)(Report)
+DECLARE_SCHEMA( SQLateTestSchema, SCHEMA );
+}
+
+#endif
diff --git a/tests/updatequerybuildertest.cpp b/tests/updatequerybuildertest.cpp
new file mode 100644
index 0000000..aaa0ad1
--- /dev/null
+++ b/tests/updatequerybuildertest.cpp
@@ -0,0 +1,119 @@
+#define QUERYBUILDER_UNITTEST
+
+#include "testschema.h"
+#include "testbase.h"
+#include "Sql.h"
+#include "SqlUpdateQueryBuilder.h"
+#include "test_utils.h"
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+Q_DECLARE_METATYPE( SqlUpdateQueryBuilder )
+Q_DECLARE_METATYPE( QVector<QVariant> )
+
+using namespace Sql;
+
+class UpdateQueryBuilderTest : public TestBase
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase() {
+      openDbTest();
+      createEmptyDb();
+      QSqlQuery query;
+      QVERIFY(query.exec(QLatin1String("CREATE TABLE table1 (first VARCHAR(128), second INTEGER)")));
+    }
+  
+    void testQueryBuilder_data()
+    {
+        QTest::addColumn<SqlUpdateQueryBuilder>( "qb" );
+        QTest::addColumn<QString>( "sql" );
+        QTest::addColumn<QStringList >( "columns" );
+        QTest::addColumn<QVector<QVariant> >( "values" );
+
+        SqlUpdateQueryBuilder qb;
+        QStringList columns;
+        QVector<QVariant> values;
+
+        qb.setTable( QL1S("table1") );
+        qb.addColumnValue( QL1S("first"), QL1S("1") );
+        columns << QL1S("first");
+        values << QL1S("1");
+        QTest::newRow( "Single column" ) << qb << "UPDATE table1 SET first = :0" << columns << values;
+
+        qb = SqlUpdateQueryBuilder();
+        qb.setTable( QL1S("table1") );
+        qb.addColumnValue( QL1S("first"), QL1S("foo") );
+        qb.addColumnValue( QL1S("second"), 42 );
+        columns.clear();
+        values.clear();
+        columns << QL1S("first") << QL1S("second");        
+        values << QL1S("foo") << 42;
+        QTest::newRow( "2 columns, string and number" ) << qb << "UPDATE table1 SET first = :0, second = :1" << columns << values;
+
+        qb = SqlUpdateQueryBuilder();
+        qb.setTable( QL1S("table1") );
+        qb.setIncludesubTales(false);
+        qb.addColumnValue( QL1S("first"), QL1S("foo") );
+        qb.addColumnValue( QL1S("second"), 42 );
+        columns.clear();
+        values.clear();
+        columns << QL1S("first") << QL1S("second");        
+        values << QL1S("foo") << 42;
+        QTest::newRow( "2 columns, no subtable update" ) << qb << "UPDATE ONLY table1 SET first = :0, second = :1" << columns << values;
+
+        qb = SqlUpdateQueryBuilder();
+        qb.setTable( QL1S("table1") );
+        qb.setIncludesubTales(false);
+        qb.addColumnValue( QL1S("first"), QL1S("foo") );
+        qb.addColumnValue( QL1S("second"), 42 );
+        qb.whereCondition().addPlaceholderCondition( QL1S( "first" ), SqlCondition::Equals, QL1S( ":p" ) );
+        columns.clear();
+        values.clear();
+        columns << QL1S("first") << QL1S("second");        
+        values << QL1S("foo") << 42;
+        QTest::newRow( "Where clause, placeholder" ) << qb << "UPDATE ONLY table1 SET first = :0, second = :1 WHERE first = :p" << columns << values;
+
+        qb = SqlUpdateQueryBuilder();
+        qb.setTable( Workplace );
+        qb.setIncludesubTales(false);
+        qb.addColumnValue( Workplace.description, QL1S("foo") );
+        qb.addColumnValue( Workplace.itemorder, 42 );
+        qb.whereCondition().addValueCondition( Workplace.short_desc, SqlCondition::Equals, QL1S( "bar" ) );
+        columns.clear();
+        values.clear();
+        columns << QL1S("description") << QL1S("itemorder");
+        values << QL1S("foo") << 42 << QL1S( "bar" );
+        QTest::newRow( "Where clause, value" ) << qb << "UPDATE ONLY tblWorkplace SET description = :0, itemorder = :1 WHERE tblWorkplace.short_desc = :2" << columns << values;
+
+        qb = SqlUpdateQueryBuilder();
+        qb.setTable( Report );
+        qb.addColumnValue( Report.ts, SqlNow );
+        qb.addColumnValue( Report.txt, SqlNull );
+        columns.clear();
+        values.clear();
+        columns << QL1S("ts") << QL1S("txt");
+        values << QVariant();
+        QTest::newRow( "server-side now" ) << qb << "UPDATE tblReport SET ts = now(), txt = :0" << columns << values;
+    }
+
+    void testQueryBuilder()
+    {
+        QFETCH( SqlUpdateQueryBuilder, qb );
+        QFETCH( QString, sql );
+        QFETCH( QStringList, columns );
+        QFETCH( QVector<QVariant>, values );
+
+        qb.query(); // trigger query assembly
+        QCOMPARE( qb.m_queryString, sql );
+        QCOMPARE( qb.columnNames(), columns );
+        // variant comparission for custom types (here, mostly QUuid) doesn't work, so we have to do this manually...
+        QCOMPARE( qb.m_bindValues.size(), values.size() );
+        QVERIFY( std::equal( qb.m_bindValues.begin(), qb.m_bindValues.end(), values.begin(), deepVariantCompare ) );
+    }
+};
+
+QTEST_MAIN( UpdateQueryBuilderTest )
+
+#include "updatequerybuildertest.moc"