commit e0e1ead821f79cb33d9f212191809e4914172aa8
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Sun May 10 14:59:06 2015 +0200

    formatting

diff --git a/src/cache.cpp b/src/cache.cpp
index 1bcb33c..c12170a 100644
--- a/src/cache.cpp
+++ b/src/cache.cpp
@@ -36,7 +36,8 @@ bool Cache::contains(const QString &key) {
 
 void Cache::insert(const QSharedPointer<Entity> &entity) {
     if (entity.data() && entity.data()->getId() > -1) {
-        this->cache.insert(this->generateKey(entity.data()->getId(), QString(entity.data()->getClassname())),
+        this->cache.insert(this->generateKey(entity.data()->getId(),
+                                             QString(entity.data()->getClassname())),
                            entity.toWeakRef());
     }
 }
diff --git a/src/database.cpp b/src/database.cpp
index d621a78..a02ca2b 100644
--- a/src/database.cpp
+++ b/src/database.cpp
@@ -24,14 +24,17 @@ Database::Database(QSqlDatabase database) {
 
 }
 
-Database::Database(QString databaseType, QString connectionName, QString databasename) {
+Database::Database(QString databaseType, QString connectionName,
+                   QString databasename) {
     this->database = QSqlDatabase::addDatabase(databaseType, connectionName);
     this->connectionName = connectionName;
     this->database.setDatabaseName(databasename);
     this->init();
 }
 
-Database::Database(QString databaseType, QString connectionName, QString hostname, QString databasename,
+Database::Database(QString databaseType, QString connectionName,
+                   QString hostname,
+                   QString databasename,
                    QString username, QString password, qint64 port) {
     this->database = QSqlDatabase::addDatabase(databaseType, connectionName);
     this->connectionName = connectionName;
@@ -45,7 +48,8 @@ Database::Database(QString databaseType, QString connectionName, QString hostnam
 
 void Database::init() {
     this->database.open();
-    this->supportTransactions = this->database.driver()->hasFeature(QSqlDriver::Transactions);
+    this->supportTransactions = this->database.driver()->hasFeature(
+                                    QSqlDriver::Transactions);
 }
 
 Database::~Database() {
@@ -135,7 +139,8 @@ DatabaseType Database::getDatabaseType(QString s) {
     }
 }
 
-QSharedPointer<Schema> Database::getSchema(int db, QSharedPointer<Database> database) {
+QSharedPointer<Schema> Database::getSchema(int db,
+        QSharedPointer<Database> database) {
     switch (db) {
     case SQLITE:
         return QSharedPointer<Schema>(new SqliteSchema(database));;
diff --git a/src/database.h b/src/database.h
index fd89d6c..44d78b9 100644
--- a/src/database.h
+++ b/src/database.h
@@ -41,7 +41,8 @@ class Database {
     ~Database();
     Database(QString databaseType, QString databasename);
     Database(QString databaseType, QString connectionName, QString databasename);
-    Database(QString databaseType, QString connectionName = "", QString hostname = "", QString databasename = "" ,
+    Database(QString databaseType, QString connectionName = "", QString hostname = "",
+             QString databasename = "" ,
              QString username = "", QString password = "", qint64 port = 0);
     QSqlDatabase getDatabase();
     QString getConnectionName();
diff --git a/src/databasemigration.cpp b/src/databasemigration.cpp
index f01d71f..1d35e7c 100644
--- a/src/databasemigration.cpp
+++ b/src/databasemigration.cpp
@@ -20,7 +20,8 @@ DatabaseMigration::DatabaseMigration() : Entity() {
 
 }
 
-DatabaseMigration::DatabaseMigration(QString version, QDateTime applyTime) : Entity() {
+DatabaseMigration::DatabaseMigration(QString version,
+                                     QDateTime applyTime) : Entity() {
     this->version = version;
     this->applyTime = applyTime;
 }
diff --git a/src/entityinstancefactory.cpp b/src/entityinstancefactory.cpp
index 7df4284..3468bb0 100644
--- a/src/entityinstancefactory.cpp
+++ b/src/entityinstancefactory.cpp
@@ -37,13 +37,15 @@ Entity *EntityInstanceFactory::createInstance(int metaTypeId) {
     return e;
 }
 
-Entity *EntityInstanceFactory::createInstance(const char *className, const QHash<QString, QVariant> &attributes) {
+Entity *EntityInstanceFactory::createInstance(const char *className,
+        const QHash<QString, QVariant> &attributes) {
     Entity *e = EntityInstanceFactory::createInstance(className);
     EntityInstanceFactory::setAttributes(e, attributes);
     return e;
 }
 
-Entity *EntityInstanceFactory::setAttributes(Entity *e, const QHash<QString, QVariant> &attributes,
+Entity *EntityInstanceFactory::setAttributes(Entity *e,
+        const QHash<QString, QVariant> &attributes,
         QHash<QString, QMetaProperty> metaprops) {
     if (e) {
         auto iterator = attributes.constBegin();
@@ -60,7 +62,8 @@ Entity *EntityInstanceFactory::setAttributes(Entity *e, const QHash<QString, QVa
     return e;
 }
 
-Entity *EntityInstanceFactory::setAttributes(Entity *e, const QHash<QString, QVariant> &attributes) {
+Entity *EntityInstanceFactory::setAttributes(Entity *e,
+        const QHash<QString, QVariant> &attributes) {
     auto metaprops = e->getMetaProperties();
     return EntityInstanceFactory::setAttributes(e, attributes, metaprops);
 }
diff --git a/src/entityinstancefactory.h b/src/entityinstancefactory.h
index dea64f0..faeefe3 100644
--- a/src/entityinstancefactory.h
+++ b/src/entityinstancefactory.h
@@ -26,7 +26,8 @@ class EntityInstanceFactory {
     static Entity *createInstance(const char *className);
     static Entity *createInstance(const QString &className);
     static Entity *createInstance(int metaTypeId);
-    static Entity *createInstance(const char *className, const QHash<QString, QVariant> &attributes);
+    static Entity *createInstance(const char *className,
+                                  const QHash<QString, QVariant> &attributes);
     static Entity *setAttributes(Entity *e, const QHash<QString, QVariant> &attributes,
                                  QHash<QString, QMetaProperty> metaprops);
     static Entity *setAttributes(Entity *e, const QHash<QString, QVariant> &attributes);
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index e663aef..7200fab 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -44,7 +44,8 @@ bool EntityManager::startup(QString version, QStringList toInitialize) {
         for (int var = 0; var < toInitialize.size(); ++var) {
             if (ok) {
                 QString c = toInitialize.at(var);
-                ok = this->createTable(QSharedPointer<Entity>(EntityInstanceFactory::createInstance(c)));
+                ok = this->createTable(QSharedPointer<Entity>
+                                       (EntityInstanceFactory::createInstance(c)));
             } else {
                 break;
             }
@@ -59,9 +60,17 @@ bool EntityManager::startup(QString version, QStringList toInitialize) {
     return ok;
 }
 
-EntityManager::EntityManager(const QString &databaseType, QString databasename , QString hostname, QString username,
+bool EntityManager::executeQuery(const QString &query) {
+    return this->db.data()->transaction(query);
+}
+
+EntityManager::EntityManager(const QString &databaseType, QString databasename ,
+                             QString hostname,
+                             QString username,
                              QString password, QString port) {
-    auto db = new Database(databaseType, this->createConnection(), hostname, databasename, username, password,
+    auto db = new Database(databaseType, this->createConnection(), hostname,
+                           databasename, username,
+                           password,
                            port.toInt());
     this->db = QSharedPointer<Database>(db);
     this->init();
@@ -128,19 +137,25 @@ QSharedPointer<Entity> EntityManager::findById(const qint64 &id, Entity *&e) {
     return r;
 }
 
-QSharedPointer<Entity> EntityManager::findById(const qint64 &id, const QString &classname) {
+QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
+        const QString &classname) {
     Entity *e = EntityInstanceFactory::createInstance(classname);
     return this->findById(id, e);
 
 }
 
-QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant> &map, const char *classname) {
-    auto ptr = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(classname, map));
+QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant>
+        &map,
+        const char *classname) {
+    auto ptr = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
+                                          classname, map));
     this->cache.insert(ptr);
     return ptr;
 }
 
-QList<QSharedPointer<Entity> > EntityManager::convert(QList<QHash<QString, QVariant> > maps, const char *classname) {
+QList<QSharedPointer<Entity> > EntityManager::convert(
+    QList<QHash<QString, QVariant> > maps,
+    const char *classname) {
     auto list = QList<QSharedPointer<Entity> >();
     for (int var = 0; var < maps.size(); ++var) {
         auto ptr = this->convert(maps.at(var), classname);
@@ -150,24 +165,33 @@ QList<QSharedPointer<Entity> > EntityManager::convert(QList<QHash<QString, QVari
     return list;
 }
 
-void EntityManager::manyToOne(const QSharedPointer<Entity> &entity, const QVariant &id, const QMetaProperty &property) {
+void EntityManager::manyToOne(const QSharedPointer<Entity> &entity,
+                              const QVariant &id,
+                              const QMetaProperty &property) {
     qint64 convertedId = -1;
     bool ok = false;
     if ((convertedId == id.toLongLong(&ok)) && ok && convertedId > -1) {
-        QString className = EntityInstanceFactory::extractEntityType(property.typeName());
+        QString className = EntityInstanceFactory::extractEntityType(
+                                property.typeName());
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>();
-        if (!(this->cache.contains(convertedId, className) && (ptr = this->cache.get(convertedId, className)) && ptr.data())) {
+        if (!(this->cache.contains(convertedId, className)
+                && (ptr = this->cache.get(convertedId, className)) && ptr.data())) {
             ptr = this->findById(convertedId, className);
         }
         this->setProperty(entity, ptr, property);
     }
 }
 
-void EntityManager::oneToMany(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property) {
+void EntityManager::oneToMany(const QSharedPointer<Entity> &entity,
+                              const Relation &r,
+                              const QMetaProperty &property) {
     if (entity.data() && entity.data()->getId() > -1) {
-        Entity *e = EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(property.typeName()));
-        QSqlQuery q = this->schema.data()->getQueryBuilder().data()->oneToMany(e->getTablename(),
-                      r.getMappedBy() + "_id", entity.data()->getId());
+        Entity *e = EntityInstanceFactory::createInstance(
+                        EntityInstanceFactory::extractEntityType(
+                            property.typeName()));
+        QSqlQuery q = this->schema.data()->getQueryBuilder().data()->oneToMany(
+                          e->getTablename(),
+                          r.getMappedBy() + "_id", entity.data()->getId());
         auto listMap = this->convertQueryResult(q);
         auto entities = this->convert(listMap, e->getClassname());
         delete e;
@@ -176,16 +200,21 @@ void EntityManager::oneToMany(const QSharedPointer<Entity> &entity, const Relati
 }
 
 
-void EntityManager::oneToOne(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property,
+void EntityManager::oneToOne(const QSharedPointer<Entity> &entity,
+                             const Relation &r,
+                             const QMetaProperty &property,
                              const QVariant &id) {
     qint64 convertedId = -1;
     bool ok = false;
     if (r.getMappedBy().isEmpty()) {
         this->manyToOne(entity, id, property);
     } else {
-        Entity *e = EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(property.typeName()));
-        QSqlQuery q = this->schema.data()->getQueryBuilder().data()->oneToMany(e->getTablename(),
-                      r.getMappedBy() + "_id", entity.data()->getId(), 1);
+        Entity *e = EntityInstanceFactory::createInstance(
+                        EntityInstanceFactory::extractEntityType(
+                            property.typeName()));
+        QSqlQuery q = this->schema.data()->getQueryBuilder().data()->oneToMany(
+                          e->getTablename(),
+                          r.getMappedBy() + "_id", entity.data()->getId(), 1);
         auto listMap = this->convertQueryResult(q);
         auto entities = this->convert(listMap, e->getClassname());
         if (!entities.isEmpty()) {
@@ -197,14 +226,16 @@ void EntityManager::oneToOne(const QSharedPointer<Entity> &entity, const Relatio
 }
 
 
-void EntityManager::setListProperty(const QSharedPointer<Entity> &entity, QList<QSharedPointer<Entity> > &list,
+void EntityManager::setListProperty(const QSharedPointer<Entity> &entity,
+                                    QList<QSharedPointer<Entity> > &list,
                                     const QMetaProperty &property) const {
     QVariant var;
     var.setValue<QList<QSharedPointer<Entity>>>(list);
     property.write(entity.data(), var);
 }
 
-void EntityManager::setProperty(const QSharedPointer<Entity> &entiy, QSharedPointer<Entity> value,
+void EntityManager::setProperty(const QSharedPointer<Entity> &entiy,
+                                QSharedPointer<Entity> value,
                                 const QMetaProperty &property) const {
     if (value.data() && value.data()->getId() > -1) {
         property.write(entiy.data(), QVariant(value));
@@ -212,9 +243,13 @@ void EntityManager::setProperty(const QSharedPointer<Entity> &entiy, QSharedPoin
 }
 
 
-void EntityManager::manyToMany(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property) {
-    Entity *secEntity = EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(QString(
-                            property.typeName())));
+void EntityManager::manyToMany(const QSharedPointer<Entity> &entity,
+                               const Relation &r,
+                               const QMetaProperty &property) {
+    Entity *secEntity = EntityInstanceFactory::createInstance(
+                            EntityInstanceFactory::extractEntityType(
+                                QString(
+                                    property.typeName())));
     auto builder = this->schema.data()->getQueryBuilder();
     if (secEntity) {
         QSharedPointer<Entity> secEntityPtr = QSharedPointer<Entity>(secEntity);
@@ -241,8 +276,10 @@ void EntityManager::manyToMany(const QSharedPointer<Entity> &entity, const Relat
     }
 }
 
-QList<QSharedPointer<Entity> > EntityManager::findEntityByAttributes(const QSharedPointer<Entity> &entity,
-        bool ignoreID) {
+QList<QSharedPointer<Entity> > EntityManager::findEntityByAttributes(
+    const QSharedPointer<Entity>
+    &entity,
+    bool ignoreID) {
     auto maps = this->findAllByAttributes(entity, ignoreID);
     return this->convert(maps, entity.data()->getClassname());
 }
@@ -302,15 +339,20 @@ QHash<QString, QVariant> EntityManager::findByPk(qint64 id, QString tblname) {
 }
 
 
-QList<QHash<QString, QVariant> > EntityManager::findAllByAttributes(const QSharedPointer<Entity> &entity,
-        bool ignoreID) {
-    QSqlQuery q = this->schema.data()->getQueryBuilder().data()->findByAttributes(entity, ignoreID);
+QList<QHash<QString, QVariant> > EntityManager::findAllByAttributes(
+    const QSharedPointer<Entity>
+    &entity,
+    bool ignoreID) {
+    QSqlQuery q = this->schema.data()->getQueryBuilder().data()->findByAttributes(
+                      entity, ignoreID);
     return this->convertQueryResult(q);
 }
 
-QList<QHash <QString, QVariant> > EntityManager::findAllByAttributes(const QHash<QString, QVariant> &m,
-        const QString &tblname,
-        bool ignoreID) {
+QList<QHash <QString, QVariant> > EntityManager::findAllByAttributes(
+    const QHash<QString, QVariant>
+    &m,
+    const QString &tblname,
+    bool ignoreID) {
     QSqlQuery q = this->schema.data()->getQueryBuilder().data()->findByAttributes(m,
                   tblname, ignoreID);
     return this->convertQueryResult(q);
@@ -333,7 +375,8 @@ bool EntityManager::merge(QSharedPointer<Entity> &entity, bool withRelations) {
 }
 
 
-QList<QHash<QString, QVariant> > EntityManager::convertQueryResult(QSqlQuery &q) {
+QList<QHash<QString, QVariant> > EntityManager::convertQueryResult(
+    QSqlQuery &q) {
     QList<QHash <QString, QVariant> > listmap = QList<QHash <QString, QVariant> >();
     this->db->select(q);
     QSqlRecord rec = q.record();
@@ -357,7 +400,8 @@ QList<QHash <QString, QVariant> > EntityManager::findAll(QString tblname) {
     return this->convertQueryResult(q);
 }
 
-void EntityManager::resolveRelations(const QSharedPointer<Entity> &entity, const QHash<QString, QVariant> &map) {
+void EntityManager::resolveRelations(const QSharedPointer<Entity> &entity,
+                                     const QHash<QString, QVariant> &map) {
     auto props = entity.data()->getRelationProperties();
     auto iterator = props.constBegin();
     while (iterator != props.constEnd()) {
@@ -417,9 +461,11 @@ bool EntityManager::createTable(const QSharedPointer<Entity> &entity) {
     return this->schema.data()->getQueryBuilder().data()->createTable(entity);
 }
 
-qint8 EntityManager::count(const QSharedPointer<Entity> &entity, bool ignoreID) {
+qint8 EntityManager::count(const QSharedPointer<Entity> &entity,
+                           bool ignoreID) {
     qint8 rc = -1;
-    QSqlQuery q = this->schema.data()->getQueryBuilder().data()->count(entity, ignoreID);
+    QSqlQuery q = this->schema.data()->getQueryBuilder().data()->count(entity,
+                  ignoreID);
     this->db->select(q);
     if (q.next()) {
         rc = q.value(0).toInt();
diff --git a/src/entitymanager.h b/src/entitymanager.h
index bf0f5ac..889ae1c 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -51,26 +51,42 @@ class EntityManager {
   protected:
     void init();
     QList<QHash<QString, QVariant> > findAll(QString tblname);
-    void resolveRelations(const QSharedPointer<Entity> &entity, const QHash<QString, QVariant> &map);
+    void resolveRelations(const QSharedPointer<Entity> &entity,
+                          const QHash<QString, QVariant> &map);
     QHash<QString, QVariant> findByPk(qint64 id, QString tblname);
-    QSharedPointer<Entity> convert(const QHash<QString, QVariant> &map, const char *classname);
-    QList<QSharedPointer<Entity>> convert(QList<QHash<QString, QVariant> > maps, const char *classname);
-    void manyToOne(const QSharedPointer<Entity> &entity, const QVariant &id, const QMetaProperty &property);
-    void oneToMany(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property);
-    void manyToMany(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property);
-    void oneToOne(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property,
+    QSharedPointer<Entity> convert(const QHash<QString, QVariant> &map,
+                                   const char *classname);
+    QList<QSharedPointer<Entity>> convert(QList<QHash<QString, QVariant> > maps,
+                                          const char *classname);
+    void manyToOne(const QSharedPointer<Entity> &entity, const QVariant &id,
+                   const QMetaProperty &property);
+    void oneToMany(const QSharedPointer<Entity> &entity, const Relation &r,
+                   const QMetaProperty &property);
+    void manyToMany(const QSharedPointer<Entity> &entity, const Relation &r,
+                    const QMetaProperty &property);
+    void oneToOne(const QSharedPointer<Entity> &entity, const Relation &r,
+                  const QMetaProperty &property,
                   const QVariant &id = "");
-    QList<QHash<QString, QVariant> > findAllByAttributes(const QSharedPointer<Entity> &entity, bool ignoreID = false);
-    QList<QHash<QString, QVariant> > findAllByAttributes(const QHash<QString, QVariant> &m, const QString &tblname,
+    QList<QHash<QString, QVariant> > findAllByAttributes(const
+            QSharedPointer<Entity> &entity,
+            bool ignoreID = false);
+    QList<QHash<QString, QVariant> > findAllByAttributes(const
+            QHash<QString, QVariant> &m,
+            const QString &tblname,
             bool ignoreID = false);
     QSharedPointer<Entity> findById(const qint64 &id, Entity *&e);
-    void setListProperty(const QSharedPointer<Entity> &entity, QList<QSharedPointer<Entity>> &list,
+    void setListProperty(const QSharedPointer<Entity> &entity,
+                         QList<QSharedPointer<Entity>> &list,
                          const QMetaProperty &property) const;
-    void setProperty(const QSharedPointer<Entity> &entiy, QSharedPointer<Entity> value, const QMetaProperty &property) const;
+    void setProperty(const QSharedPointer<Entity> &entiy,
+                     QSharedPointer<Entity> value,
+                     const QMetaProperty &property) const;
 
   public:
     EntityManager(QSqlDatabase database);
-    EntityManager(const QString &databaseType, QString databasename = "" , QString hostname = "", QString username = "",
+    EntityManager(const QString &databaseType, QString databasename = "" ,
+                  QString hostname = "",
+                  QString username = "",
                   QString password = "", QString port = "");
     ~EntityManager();
     static QStringList getConnectionNames();
@@ -81,9 +97,12 @@ class EntityManager {
      * @return
      */
     bool startup(QString version, QStringList toInitialize);
+    bool executeQuery(const QString &query);
     static void removeConnectionName(const QString &name);
     QSharedPointer<Entity> findById(const qint64 &id, const QString &classname);
-    QList<QSharedPointer<Entity>> findEntityByAttributes(const QSharedPointer<Entity> &entity, bool ignoreID = false);
+    QList<QSharedPointer<Entity>> findEntityByAttributes(const
+                               QSharedPointer<Entity> &entity,
+                               bool ignoreID = false);
     bool create(QList<QSharedPointer<Entity>> entities);
     bool create(QSharedPointer<Entity> &entity);
     bool save(QSharedPointer<Entity> &entity);
@@ -102,7 +121,8 @@ class EntityManager {
     /**
      *@TODO use conditions
      */
-    template<class T> qint8 count(QHash<QString, QString> condition = QHash<QString, QString>()) {
+    template<class T> qint8 count(QHash<QString, QString> condition =
+                                      QHash<QString, QString>()) {
         Entity *e = EntityInstanceFactory::createInstance<T>();
         qint8 rc = 0;
         if (e) {
@@ -128,7 +148,9 @@ class EntityManager {
         return this->findById(id, e);
     }
 
-    template<class T> QSharedPointer<Entity> findEntityByAttributes(const QHash<QString, QString> &attributes) {
+    template<class T> QSharedPointer<Entity> findEntityByAttributes(
+        const QHash<QString, QString>
+        &attributes) {
         auto list = this->findAllEntitiesByAttributes<T>(attributes, 1, 0);
         if (list.isEmpty()) {
             return QSharedPointer<Entity>();
@@ -136,13 +158,15 @@ class EntityManager {
         return list.at(0);
     }
 
-    template<class T> QList<QSharedPointer<Entity>> findAllEntitiesByAttributes(const QHash<QString, QString> &attributes =
+    template<class T> QList<QSharedPointer<Entity>> findAllEntitiesByAttributes(
+                const QHash<QString, QString> &attributes =
     QHash<QString, QString>(), quint32 limit = 0, quint32 offset = 0) {
         auto list = this->findAllEntitiesByAttributes<T>(attributes);
         return list;
     }
 
-    template<class T> QList<QSharedPointer<Entity>> findEntitiesBySql(const QString &sql) {
+    template<class T> QList<QSharedPointer<Entity>> findEntitiesBySql(
+    const QString &sql) {
         Entity *e = EntityInstanceFactory::createInstance<T>();
         if (e) {
             QSqlQuery q = this->schema.data()->getQueryBuilder().data()->getQuery();
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index fb941e6..b0e935a 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -23,7 +23,8 @@
 
 using namespace CuteEntityManager;
 
-QueryBuilder::QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database) {
+QueryBuilder::QueryBuilder(QSharedPointer<Schema> schema,
+                           QSharedPointer<Database> database) {
     this->schema = schema;
     this->database = database;
 }
@@ -33,14 +34,17 @@ QueryBuilder::~QueryBuilder() {
 }
 
 bool QueryBuilder::createTable(const QSharedPointer<Entity> &entity) const {
-    return this->createTable(entity.data()->getTablename(), this->generateTableDefinition(entity));
+    return this->createTable(entity.data()->getTablename(),
+                             this->generateTableDefinition(entity));
 }
 
-bool QueryBuilder::createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
+bool QueryBuilder::createTable(const QString &tableName,
+                               const QHash<QString, QString> &tableDefinition) const {
     bool rc = false;
     this->schema.data()->containsTable(tableName) ? rc = true : rc = false;
     if (!rc) {
-        QSqlQuery q = this->database.data()->getQuery(this->createTableQuery(tableName, tableDefinition));
+        QSqlQuery q = this->database.data()->getQuery(this->createTableQuery(tableName,
+                      tableDefinition));
         if (this->database.data()->transaction(q)) {
             this->schema.data()->getTableSchema(tableName);
             rc = true;
@@ -49,7 +53,8 @@ bool QueryBuilder::createTable(const QString &tableName, const QHash<QString, QS
     return rc;
 }
 
-QString QueryBuilder::createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const {
+QString QueryBuilder::createTableQuery(const QString &tableName,
+                                       const QHash<QString, QString> &tableDefinition) const {
     bool first = true;
     QString s = "CREATE TABLE ";
     s.append(this->schema.data()->quoteTableName(tableName).append(" (\n"));
@@ -60,7 +65,9 @@ QString QueryBuilder::createTableQuery(const QString &tableName, const QHash<QSt
         } else {
             s.append(", ");
         }
-        s.append(this->schema.data()->quoteColumnName(i.key())).append(" " + this->getColumnType(i.value()));
+        s.append(this->schema.data()->quoteColumnName(i.key())).append(" " +
+                this->getColumnType(
+                    i.value()));
         ++i;
     }
     s.append("\n);");
@@ -68,7 +75,9 @@ QString QueryBuilder::createTableQuery(const QString &tableName, const QHash<QSt
 }
 
 QString QueryBuilder::renameTable(QString tableName, QString newName) const {
-    return "RENAME TABLE " + this->schema.data()->quoteTableName(tableName) + " TO " + this->schema.data()->quoteTableName(
+    return "RENAME TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " TO " +
+           this->schema.data()->quoteTableName(
                newName);
 }
 
@@ -80,42 +89,61 @@ QString QueryBuilder::truncateTable(QString tableName) const {
     return "TRUNCATE TABLE " + this->schema.data()->quoteTableName(tableName);
 }
 
-QString QueryBuilder::addColumn(QString tableName, QString columnName, QString columnType) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " ADD " + this->schema.data()->quoteColumnName(
+QString QueryBuilder::addColumn(QString tableName, QString columnName,
+                                QString columnType) const {
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " ADD " +
+           this->schema.data()->quoteColumnName(
                columnName) + " " + this->getColumnType(columnType);
 }
 
 QString QueryBuilder::dropColumn(QString tableName, QString columName) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " DROP COLUMN " +
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " DROP COLUMN " +
            this->schema.data()->quoteColumnName(columName);
 }
 
-QString QueryBuilder::renameColumn(QString tableName, QString oldName, QString newName) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " RENAME COLUMN " +
-           this->schema.data()->quoteColumnName(oldName) + " TO " + this->schema.data()->quoteColumnName(newName);
+QString QueryBuilder::renameColumn(QString tableName, QString oldName,
+                                   QString newName) const {
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " RENAME COLUMN " +
+           this->schema.data()->quoteColumnName(oldName) + " TO " +
+           this->schema.data()->quoteColumnName(
+               newName);
 }
 
-QString QueryBuilder::alterColumn(QString tableName, QString columnName, QString newType) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " CHANGE " +
+QString QueryBuilder::alterColumn(QString tableName, QString columnName,
+                                  QString newType) const {
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " CHANGE " +
            this->schema.data()->quoteColumnName(columnName) + " " +
            this->schema.data()->quoteColumnName(columnName) + this->getColumnType(newType);
 }
 
-QString QueryBuilder::addPrimaryKey(QString name, QString tableName, QStringList columns) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " ADD CONSTRAINT " +
-           this->schema.data()->quoteColumnName(name) + "PRIMARY KEY (" + this->buildColumns(columns) + " )";
+QString QueryBuilder::addPrimaryKey(QString name, QString tableName,
+                                    QStringList columns) const {
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " ADD CONSTRAINT " +
+           this->schema.data()->quoteColumnName(name) + "PRIMARY KEY (" +
+           this->buildColumns(columns) + " )";
 }
 
 QString QueryBuilder::dropPrimaryKey(QString name, QString tableName) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " DROP CONSTRAINT " +
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " DROP CONSTRAINT " +
            this->schema.data()->quoteColumnName(name);
 }
 
-QString QueryBuilder::addForeignKey(QString name, QString tableName, QStringList columns, QString refTableName,
-                                    QStringList refColumns, QString deleteConstraint, QString updateConstraint) const {
-    QString r = "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + "ADD CONSTRAINT " +
+QString QueryBuilder::addForeignKey(QString name, QString tableName,
+                                    QStringList columns,
+                                    QString refTableName,
+                                    QStringList refColumns, QString deleteConstraint,
+                                    QString updateConstraint) const {
+    QString r = "ALTER TABLE " + this->schema.data()->quoteTableName(
+                    tableName) + "ADD CONSTRAINT " +
                 this->schema.data()->quoteColumnName(name)
-                + " FOREIGN KEY (" +  this->buildColumns(columns) + ")" + " REFERENCES " + this->schema.data()->quoteTableName(
+                + " FOREIGN KEY (" +  this->buildColumns(columns) + ")" + " REFERENCES " +
+                this->schema.data()->quoteTableName(
                     refTableName) +
                 " (" + this->buildColumns(refColumns) + ")";
     if (!deleteConstraint.isEmpty()) {
@@ -128,12 +156,16 @@ QString QueryBuilder::addForeignKey(QString name, QString tableName, QStringList
 }
 
 QString QueryBuilder::dropForeignKey(QString name, QString tableName) const {
-    return "ALTER TABLE " + this->schema.data()->quoteTableName(tableName) + " DROP CONSTRAINT " +
+    return "ALTER TABLE " + this->schema.data()->quoteTableName(
+               tableName) + " DROP CONSTRAINT " +
            this->schema.data()->quoteColumnName(name);
 }
 
-QString QueryBuilder::createIndex(QString name, QString tableName, QStringList columns, bool unique) const {
-    QString s = (unique ? "CREATE UNIQUE INDEX " : "CREATE INDEX ") + this->schema.data()->quoteTableName(
+QString QueryBuilder::createIndex(QString name, QString tableName,
+                                  QStringList columns,
+                                  bool unique) const {
+    QString s = (unique ? "CREATE UNIQUE INDEX " : "CREATE INDEX ") +
+                this->schema.data()->quoteTableName(
                     name) + " ON " + this->schema.data()->quoteTableName(tableName) + " (";
     s.append(this->buildColumns(columns));
     s.append(");");
@@ -141,7 +173,8 @@ QString QueryBuilder::createIndex(QString name, QString tableName, QStringList c
 }
 
 QString QueryBuilder::dropIndex(QString name, QString tableName) const {
-    return "DROP INDEX " + this->schema.data()->quoteTableName(name) + " ON " + this->schema.data()->quoteTableName(
+    return "DROP INDEX " + this->schema.data()->quoteTableName(name) + " ON " +
+           this->schema.data()->quoteTableName(
                tableName);
 }
 
@@ -153,7 +186,8 @@ void QueryBuilder::setDatabase(const QSharedPointer<Database> &value) {
     database = value;
 }
 
-QString QueryBuilder::buildCreateQuery(QHash<QString, QVariant>::const_iterator i,
+QString QueryBuilder::buildCreateQuery(QHash<QString, QVariant>::const_iterator
+                                       i,
                                        QHash<QString, QVariant>::const_iterator end,
                                        QString &p1, QString &p2) const {
     bool first = true;
@@ -173,7 +207,9 @@ QString QueryBuilder::buildCreateQuery(QHash<QString, QVariant>::const_iterator
     return p1 + p2;
 }
 
-QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPointer<Entity> &entity) const {
+QHash<QString, QString> QueryBuilder::generateTableDefinition(
+    const QSharedPointer<Entity> &entity)
+const {
     auto map = QHash<QString, QString>();
     auto o = entity.data()->metaObject();
     QHash<QString, Relation> relations = entity.data()->getRelations();
@@ -182,17 +218,22 @@ QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPoint
         if (m.name() != QString("objectName") && m.isReadable()
                 && !entity.data()->getTransientAttributes().contains(m.name())) {
             if (m.isEnumType()) {
-                map.insert(m.name(), this->schema.data()->getTypeMap().data()->value(this->schema.data()->TYPE_INTEGER));
+                map.insert(m.name(), this->schema.data()->getTypeMap().data()->value(
+                               this->schema.data()->TYPE_INTEGER));
             } else if (relations.contains(m.name())) {
                 Relation r = relations.value(m.name());
-                if (r.getType() == RelationType::MANY_TO_ONE || (r.getType() == RelationType::ONE_TO_ONE
-                        && r.getMappedBy().isEmpty())) {
+                if (r.getType() == RelationType::MANY_TO_ONE
+                        || (r.getType() == RelationType::ONE_TO_ONE
+                            && r.getMappedBy().isEmpty())) {
                     map.insert(QString(m.name()) + "_id", this->schema.data()->TYPE_BIGINT);
                 }
             } else if (entity.data()->getBLOBColumns().contains(m.name())) {
-                map.insert(m.name(), this->schema.data()->getTypeMap().data()->value(this->schema.data()->TYPE_BINARY));
+                map.insert(m.name(), this->schema.data()->getTypeMap().data()->value(
+                               this->schema.data()->TYPE_BINARY));
             } else {
-                map.insert(m.name(), this->transformAbstractTypeToRealDbType(this->transformTypeToAbstractDbType(m.typeName())));
+                map.insert(m.name(), this->transformAbstractTypeToRealDbType(
+                               this->transformTypeToAbstractDbType(
+                                   m.typeName())));
             }
         }
     }
@@ -205,13 +246,16 @@ QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPoint
     return map;
 }
 
-QString QueryBuilder::generateManyToManyTableName(const QSharedPointer<Entity> &firstEntity,
+QString QueryBuilder::generateManyToManyTableName(const QSharedPointer<Entity>
+        &firstEntity,
         const QSharedPointer<Entity> &secondEntity) const {
-    return QString(firstEntity.data()->metaObject()->className()).toLower() + "_" + QString(
+    return QString(firstEntity.data()->metaObject()->className()).toLower() + "_" +
+           QString(
                secondEntity.data()->metaObject()->className()).toLower();
 }
 
-QHash<QString, QHash<QString, QString>> QueryBuilder::generateRelationTables(const QSharedPointer<Entity> &entity)
+QHash<QString, QHash<QString, QString>> QueryBuilder::generateRelationTables(
+        const QSharedPointer<Entity> &entity)
 const {
     auto relations = QHash<QString, QHash<QString, QString>>();
     QHash<QString, Relation> m = entity.data()->getRelations();
@@ -221,7 +265,8 @@ const {
         if (r.getType() == MANY_TO_MANY && r.getMappedBy().isEmpty()) {
             QHash<QString, QString> h = QHash<QString, QString>();
             h.insert("id", this->schema.data()->TYPE_BIGPK);
-            h.insert(this->generateManyToManyColumnName(entity), this->schema.data()->TYPE_BIGINT);
+            h.insert(this->generateManyToManyColumnName(entity),
+                     this->schema.data()->TYPE_BIGINT);
             auto m = props.value(r.getPropertyName());
             Entity *e = EntityInstanceFactory::createInstance(m.type());
             QSharedPointer<Entity> ptr = QSharedPointer<Entity>(e);
@@ -251,7 +296,8 @@ QString QueryBuilder::transformTypeToAbstractDbType(QString typeName) const {
     return this->schema.data()->TYPE_TEXT;
 }
 
-QString QueryBuilder::transformAbstractTypeToRealDbType(QString typeName) const {
+QString QueryBuilder::transformAbstractTypeToRealDbType(
+    QString typeName) const {
     return this->schema.data()->getTypeMap().data()->value(typeName);
 }
 
@@ -265,9 +311,11 @@ QString QueryBuilder::getColumnType(const QString &type) const {
     }
     //cant believe that this could work in Qt
     //https://github.com/yiisoft/yii2/blob/master/framework/db/QueryBuilder.php
-    QRegularExpression reg = QRegularExpression(QRegularExpression::escape("/^(\\w+)\((.+?)\\)(.*)$/"));
+    QRegularExpression reg = QRegularExpression(
+                                 QRegularExpression::escape("/^(\\w+)\((.+?)\\)(.*)$/"));
     reg.optimize();
-    QRegularExpressionMatchIterator i = reg.globalMatch(type, 0, QRegularExpression::PartialPreferFirstMatch);
+    QRegularExpressionMatchIterator i = reg.globalMatch(type, 0,
+                                        QRegularExpression::PartialPreferFirstMatch);
     short s = 0;
     bool ok = false;
     QString before = "";
@@ -277,7 +325,8 @@ QString QueryBuilder::getColumnType(const QString &type) const {
             ok = true;
         }
         if (ok) {
-            return before.replace(QRegularExpression::escape("/\\(.+\\)/"), "(" + i.next().captured() + ")");
+            return before.replace(QRegularExpression::escape("/\\(.+\\)/"),
+                                  "(" + i.next().captured() + ")");
         }
         s++;
     }
@@ -296,7 +345,8 @@ QString QueryBuilder::getColumnType(const QString &type) const {
  * @return
  */
 QSqlQuery QueryBuilder::find(const qint64 &id, const QString &tableName) const {
-    QSqlQuery q = this->database.data()->getQuery("SELECT * FROM " + this->schema.data()->quoteTableName(
+    QSqlQuery q = this->database.data()->getQuery("SELECT * FROM " +
+                  this->schema.data()->quoteTableName(
                       tableName) + " WHERE id= :id LIMIT 1;");
     q.bindValue(":id", id);
     return q;
@@ -309,35 +359,48 @@ QSqlQuery QueryBuilder::find(const qint64 &id, const QString &tableName) const {
  * @param ignoreID
  * @return
  */
-QSqlQuery QueryBuilder::findByAttributes(const QHash<QString, QVariant> &m, const QString &tableName,
+QSqlQuery QueryBuilder::findByAttributes(const QHash<QString, QVariant> &m,
+        const QString &tableName,
         const bool &ignoreID, const qint64 limit, const qint64 offset) const {
-    QSqlQuery q = this->database.data()->getQuery("SELECT * FROM " + this->schema.data()->quoteTableName(
+    QSqlQuery q = this->database.data()->getQuery("SELECT * FROM " +
+                  this->schema.data()->quoteTableName(
                       tableName) + this->where(m, "AND", ignoreID) + this->limit(limit, offset));
     this->bindValues(m, q, ignoreID);
     return q;
 }
 
-QSqlQuery QueryBuilder::findByAttributes(const QSharedPointer<Entity> &e, bool ignoreID, const qint64 limit,
+QSqlQuery QueryBuilder::findByAttributes(const QSharedPointer<Entity> &e,
+        bool ignoreID,
+        const qint64 limit,
         const qint64 offset) {
-    QHash<QString, QVariant> values = this->getEntityAttributes(e.data()->getMetaProperties(), e);
-    return this->findByAttributes(values, e.data()->getTablename(), ignoreID, limit, offset);
+    QHash<QString, QVariant> values = this->getEntityAttributes(
+                                          e.data()->getMetaProperties(), e);
+    return this->findByAttributes(values, e.data()->getTablename(), ignoreID, limit,
+                                  offset);
 }
 
 QSqlQuery QueryBuilder::findAll(const QString &tableName) const {
-    return this->database->getQuery("SELECT * FROM " + this->schema.data()->quoteTableName(
+    return this->database->getQuery("SELECT * FROM " +
+                                    this->schema.data()->quoteTableName(
                                         tableName) + ";");
 }
 
 QSqlQuery QueryBuilder::remove(const QSharedPointer<Entity> &entity) const {
-    QSqlQuery q = this->database->getQuery("DELETE FROM " + this->schema.data()->quoteTableName(
-            entity.data()->getTablename()) + " WHERE " + this->schema.data()->quoteColumnName("id") + "=:id;");
+    QSqlQuery q = this->database->getQuery("DELETE FROM " +
+                                           this->schema.data()->quoteTableName(
+                                                   entity.data()->getTablename()) + " WHERE " +
+                                           this->schema.data()->quoteColumnName("id") + "=:id;");
     q.bindValue(":id", entity.data()->getId());
     return q;
 }
 
 QSqlQuery QueryBuilder::findId(const QSharedPointer<Entity> &entity) const {
-    QHash<QString, QVariant> values = this->getEntityAttributes(entity.data()->getMetaProperties(), entity);
-    QSqlQuery q = this->database.data()->getQuery("SELECT " + this->schema.data()->quoteColumnName("id") + " FROM " +
+    QHash<QString, QVariant> values = this->getEntityAttributes(
+                                          entity.data()->getMetaProperties(),
+                                          entity);
+    QSqlQuery q = this->database.data()->getQuery("SELECT " +
+                  this->schema.data()->quoteColumnName("id")
+                  + " FROM " +
                   this->schema.data()->quoteTableName(
                       entity.data()->getTablename()) + this->where(values,
                               "AND", true) + " LIMIT 1");
@@ -345,9 +408,13 @@ QSqlQuery QueryBuilder::findId(const QSharedPointer<Entity> &entity) const {
     return q;
 }
 
-QSqlQuery QueryBuilder::count(const QSharedPointer<Entity> &entity, bool ignoreID) const {
-    QHash<QString, QVariant> values = this->getEntityAttributes(entity.data()->getMetaProperties(), entity);
-    QSqlQuery q = this->database.data()->getQuery("SELECT COUNT(*) FROM " + this->schema.data()->quoteTableName(
+QSqlQuery QueryBuilder::count(const QSharedPointer<Entity> &entity,
+                              bool ignoreID) const {
+    QHash<QString, QVariant> values = this->getEntityAttributes(
+                                          entity.data()->getMetaProperties(),
+                                          entity);
+    QSqlQuery q = this->database.data()->getQuery("SELECT COUNT(*) FROM " +
+                  this->schema.data()->quoteTableName(
                       entity.data()->getTablename()) + this->where(
                       values, "AND", ignoreID));
     this->bindValues(values, q, ignoreID);
@@ -355,14 +422,16 @@ QSqlQuery QueryBuilder::count(const QSharedPointer<Entity> &entity, bool ignoreI
 }
 
 QSqlQuery QueryBuilder::count(const QString &tableName) const {
-    QSqlQuery q = this->database.data()->getQuery("SELECT COUNT(*) FROM " + this->schema.data()->quoteTableName(
+    QSqlQuery q = this->database.data()->getQuery("SELECT COUNT(*) FROM " +
+                  this->schema.data()->quoteTableName(
                       tableName) + ";");
     return q;
 }
 
 QSqlQuery QueryBuilder::merge(const QSharedPointer<Entity> &entity) const {
     QHash<QString, QVariant> values = this->saveAttributes(entity);
-    QSqlQuery q = this->database.data()->getQuery("UPDATE " + this->schema.data()->quoteTableName(
+    QSqlQuery q = this->database.data()->getQuery("UPDATE " +
+                  this->schema.data()->quoteTableName(
                       entity->getTablename()) + " SET " + this->attributes(
                       values) + " WHERE " + this->schema.data()->quoteColumnName("id") + "=:id;");
     this->bindValues(values, q);
@@ -373,7 +442,8 @@ QSqlQuery QueryBuilder::create(const QSharedPointer<Entity> &entity) const {
     QHash<QString, QVariant> values = this->saveAttributes(entity);
     values.remove("id");
     QSqlQuery q = this->database.data()->getQuery();
-    QString p1 = "INSERT INTO " + this->schema.data()->quoteTableName(entity->getTablename()) + "(";
+    QString p1 = "INSERT INTO " + this->schema.data()->quoteTableName(
+                     entity->getTablename()) + "(";
     QString p2 = "VALUES(";
     if (!values.isEmpty()) {
         q.prepare(this->buildCreateQuery(values.constBegin(), values.constEnd(),
@@ -383,28 +453,39 @@ QSqlQuery QueryBuilder::create(const QSharedPointer<Entity> &entity) const {
     return q;
 }
 
-QSqlQuery QueryBuilder::oneToMany(const QString &tableName, const QString &attribute, const qint64 &id,
+QSqlQuery QueryBuilder::oneToMany(const QString &tableName,
+                                  const QString &attribute,
+                                  const qint64 &id,
                                   const qint64 &limit) {
     QHash<QString, QVariant> values = QHash<QString, QVariant>();
     values.insert(attribute, id);
     return this->findByAttributes(values, tableName, false, limit);
 }
 
-QSqlQuery QueryBuilder::manyToMany(const QString &tableName, const QString &attribute, const qint64 &id,
+QSqlQuery QueryBuilder::manyToMany(const QString &tableName,
+                                   const QString &attribute,
+                                   const qint64 &id,
                                    const QString &foreignKey, const QString &foreignTable) {
     QSqlQuery q = this->database.data()->getQuery();
-    QString sql = "SELECT " + this->schema.data()->quoteTableName(foreignTable) + ".* FROM " +
-                  this->schema.data()->quoteTableName(tableName) + " " + this->leftJoin(foreignTable, tableName,
-                          foreignKey) + " WHERE " + this->schema.data()->quoteColumnName(attribute) + "=:id;";
+    QString sql = "SELECT " + this->schema.data()->quoteTableName(
+                      foreignTable) + ".* FROM " +
+                  this->schema.data()->quoteTableName(tableName) + " " + this->leftJoin(
+                      foreignTable, tableName,
+                      foreignKey) + " WHERE " + this->schema.data()->quoteColumnName(
+                      attribute) + "=:id;";
     q.prepare(sql);
     q.bindValue(":id", id);
     return q;
 }
 
 
-QString QueryBuilder::leftJoin(const QString &foreignTable, const QString &tableName, const QString &foreignKey) {
-    return "LEFT JOIN " + this->schema.data()->quoteTableName(foreignTable) + " ON " +
-           this->schema.data()->quoteColumnName(foreignTable + ".id") + "=" + this->schema.data()->quoteColumnName(
+QString QueryBuilder::leftJoin(const QString &foreignTable,
+                               const QString &tableName,
+                               const QString &foreignKey) {
+    return "LEFT JOIN " + this->schema.data()->quoteTableName(
+               foreignTable) + " ON " +
+           this->schema.data()->quoteColumnName(foreignTable + ".id") + "=" +
+           this->schema.data()->quoteColumnName(
                tableName + "." + foreignKey);
 }
 
@@ -419,7 +500,8 @@ QString QueryBuilder::limit(const qint64 &limit, const qint64 &offset) const {
     return s;
 }
 
-QString QueryBuilder::generateManyToManyColumnName(const QSharedPointer<Entity> &entity) const {
+QString QueryBuilder::generateManyToManyColumnName(const QSharedPointer<Entity>
+        &entity) const {
     return QString(entity.data()->metaObject()->className()) + QString("_id");
 }
 
@@ -427,7 +509,8 @@ QSqlQuery QueryBuilder::getQuery() const {
     return this->database.data()->getQuery();
 }
 
-QHash<QString, QVariant> QueryBuilder::saveAttributes(const QSharedPointer<Entity> &entity) const {
+QHash<QString, QVariant> QueryBuilder::saveAttributes(const
+        QSharedPointer<Entity> &entity) const {
     auto props = entity.data()->getMetaProperties();
     auto values = this->getEntityAttributes(props, entity);
     auto relValues = this->getManyToOneAttributes(props, entity);
@@ -439,8 +522,10 @@ QHash<QString, QVariant> QueryBuilder::saveAttributes(const QSharedPointer<Entit
     return values;
 }
 
-QHash<QString, QVariant> QueryBuilder::getEntityAttributes(const QHash<QString, QMetaProperty> &props,
-        const QSharedPointer<Entity> &entity) const {
+QHash<QString, QVariant> QueryBuilder::getEntityAttributes(
+    const QHash<QString, QMetaProperty>
+    &props,
+    const QSharedPointer<Entity> &entity) const {
     Entity *e = entity.data();
     auto map = QHash<QString, QVariant>();
     auto transientAttrs = e->getTransientAttributes();
@@ -455,8 +540,10 @@ QHash<QString, QVariant> QueryBuilder::getEntityAttributes(const QHash<QString,
     return map;
 }
 
-QHash<QString, QVariant> QueryBuilder::getManyToOneAttributes(const QHash<QString, QMetaProperty> &props,
-        const QSharedPointer<Entity> &entity) const {
+QHash<QString, QVariant> QueryBuilder::getManyToOneAttributes(
+    const QHash<QString, QMetaProperty>
+    &props,
+    const QSharedPointer<Entity> &entity) const {
     Entity *e = entity.data();
     auto map = QHash<QString, QVariant>();
     auto relations = e->getRelations();
@@ -468,7 +555,8 @@ QHash<QString, QVariant> QueryBuilder::getManyToOneAttributes(const QHash<QStrin
             if (v.canConvert<Entity *>()) {
                 this->insertRelationId(qvariant_cast<Entity *>(v), map, i.key());
             } else if (v.canConvert<QSharedPointer<Entity>>()) {
-                this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(), map, i.key());
+                this->insertRelationId(qvariant_cast<QSharedPointer<Entity>>(v).data(), map,
+                                       i.key());
             } else if (v.canConvert<QPointer<Entity>>()) {
                 this->insertRelationId(qvariant_cast<QPointer<Entity>>(v).data(), map, i.key());
             }
@@ -478,7 +566,9 @@ QHash<QString, QVariant> QueryBuilder::getManyToOneAttributes(const QHash<QStrin
     return map;
 }
 
-void QueryBuilder::insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) const {
+void QueryBuilder::insertRelationId(const Entity *e,
+                                    QHash<QString, QVariant> &map,
+                                    QString relName) const {
     if (e && e->getId() > -1) {
         map.insert(relName + "_id", e->getId());
     }
@@ -498,7 +588,8 @@ QString QueryBuilder::buildColumns(const QStringList &columns) const {
     return r;
 }
 
-void QueryBuilder::bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q, bool ignoreID) const {
+void QueryBuilder::bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q,
+                              bool ignoreID) const {
     QHash<QString, QVariant>::const_iterator i = h.constBegin();
     while (i != h.constEnd()) {
         if (!ignoreID || (ignoreID && !(i.key() == "id"))) {
@@ -508,18 +599,26 @@ void QueryBuilder::bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q, b
     }
 }
 
-QString QueryBuilder::where(const QSharedPointer<Entity> &entity, QString conjunction, bool ignoreID) const {
-    return this->where(this->getEntityAttributes(entity.data()->getMetaProperties(), entity), conjunction, ignoreID);
+QString QueryBuilder::where(const QSharedPointer<Entity> &entity,
+                            QString conjunction,
+                            bool ignoreID) const {
+    return this->where(this->getEntityAttributes(entity.data()->getMetaProperties(),
+                       entity),
+                       conjunction, ignoreID);
 }
 
-QString QueryBuilder::where(const QHash<QString, QVariant> &m, const QString &conjunction, bool ignoreID) const {
+QString QueryBuilder::where(const QHash<QString, QVariant> &m,
+                            const QString &conjunction,
+                            bool ignoreID) const {
     if (m.size() == 0 || (ignoreID && m.contains("id") && m.size() == 1)) {
         return "";
     }
     return " WHERE " + this->attributes(m, conjunction, ignoreID);
 }
 
-QString QueryBuilder::attributes(const QHash<QString, QVariant> &m, const QString &conjunction, bool ignoreID) const {
+QString QueryBuilder::attributes(const QHash<QString, QVariant> &m,
+                                 const QString &conjunction,
+                                 bool ignoreID) const {
     QString rc = "";
     if (!m.isEmpty()) {
         QHash<QString, QVariant>::const_iterator i = m.constBegin();
diff --git a/src/querybuilder.h b/src/querybuilder.h
index c09077b..f1882d8 100644
--- a/src/querybuilder.h
+++ b/src/querybuilder.h
@@ -29,23 +29,35 @@ class QueryBuilder {
     QueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
     virtual ~QueryBuilder();
     virtual bool createTable(const QSharedPointer<Entity> &entity) const;
-    virtual bool createTable(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
-    virtual QString createTableQuery(const QString &tableName, const QHash<QString, QString> &tableDefinition) const;
+    virtual bool createTable(const QString &tableName,
+                             const QHash<QString, QString> &tableDefinition) const;
+    virtual QString createTableQuery(const QString &tableName,
+                                     const QHash<QString, QString> &tableDefinition) const;
     virtual QString renameTable(QString tableName, QString newName) const;
     virtual QString dropTable(QString tableName) const;
     virtual QString truncateTable(QString tableName) const;
-    virtual QString addColumn(QString tableName, QString columnName, QString columnType) const;
+    virtual QString addColumn(QString tableName, QString columnName,
+                              QString columnType) const;
     virtual QString dropColumn(QString tableName, QString columName)const;
-    virtual QString renameColumn(QString tableName, QString oldName, QString newName) const;
-    virtual QString alterColumn(QString tableName, QString columnName, QString newType)const;
-    virtual QString addPrimaryKey(QString name, QString tableName, QStringList columns)const;
+    virtual QString renameColumn(QString tableName, QString oldName,
+                                 QString newName) const;
+    virtual QString alterColumn(QString tableName, QString columnName,
+                                QString newType)const;
+    virtual QString addPrimaryKey(QString name, QString tableName,
+                                  QStringList columns)const;
     virtual QString dropPrimaryKey(QString name, QString tableName) const;
-    virtual QString addForeignKey(QString name, QString tableName, QStringList columns, QString refTableName,
-                                  QStringList refColumns, QString deleteConstraint, QString updateConstraint) const;
+    virtual QString addForeignKey(QString name, QString tableName,
+                                  QStringList columns,
+                                  QString refTableName,
+                                  QStringList refColumns, QString deleteConstraint,
+                                  QString updateConstraint) const;
     virtual QString dropForeignKey(QString name, QString tableName) const;
-    virtual QString createIndex(QString name, QString tableName, QStringList columns, bool unique)const;
+    virtual QString createIndex(QString name, QString tableName,
+                                QStringList columns,
+                                bool unique)const;
     virtual QString dropIndex(QString name, QString tableName)const;
-    QHash<QString, QVariant> getEntityAttributes(const QHash<QString, QMetaProperty> &props,
+    QHash<QString, QVariant> getEntityAttributes(const QHash<QString, QMetaProperty>
+            &props,
             const QSharedPointer<Entity> &entity) const;
 
     QSharedPointer<Schema> getSchema() const;
@@ -53,8 +65,12 @@ class QueryBuilder {
 
     QSharedPointer<Database> getDatabase() const;
     void setDatabase(const QSharedPointer<Database> &value);
-    QHash<QString, QHash<QString, QString>> generateRelationTables(const QSharedPointer<Entity> &entity) const;
-    QHash<QString, QString> generateTableDefinition(const QSharedPointer<Entity> &entity) const;
+    QHash<QString, QHash<QString, QString>> generateRelationTables(
+            const QSharedPointer<Entity> &entity)
+                                         const;
+    QHash<QString, QString> generateTableDefinition(const QSharedPointer<Entity>
+            &entity)
+    const;
     QString generateManyToManyTableName(const QSharedPointer<Entity> &firstEntity,
                                         const QSharedPointer<Entity> &secondEntity) const;
 
@@ -62,9 +78,13 @@ class QueryBuilder {
     QString transformAbstractTypeToRealDbType(QString typeName) const;
     QString getColumnType(const QString &type) const;
     QSqlQuery find(const qint64 &id, const QString &tableName) const;
-    QSqlQuery findByAttributes(const QHash<QString, QVariant> &m, const QString &tableName,
-                               const bool &ignoreID = true, const qint64 limit = 0, const qint64 offset = 0) const;
-    QSqlQuery findByAttributes(const QSharedPointer<Entity> &e, bool ignoreID = true,const qint64 limit = 0, const qint64 offset = 0);
+    QSqlQuery findByAttributes(const QHash<QString, QVariant> &m,
+                               const QString &tableName,
+                               const bool &ignoreID = true, const qint64 limit = 0,
+                               const qint64 offset = 0) const;
+    QSqlQuery findByAttributes(const QSharedPointer<Entity> &e,
+                               bool ignoreID = true,
+                               const qint64 limit = 0, const qint64 offset = 0);
     QSqlQuery findAll(const QString &tableName) const;
     QSqlQuery remove(const QSharedPointer<Entity> &entity) const;
     QSqlQuery findId(const QSharedPointer<Entity> &entity) const;
@@ -72,29 +92,49 @@ class QueryBuilder {
     QSqlQuery count(const QString &tableName) const;
     QSqlQuery merge(const QSharedPointer<Entity> &entity) const;
     QSqlQuery create(const QSharedPointer<Entity> &entity) const;
-    QSqlQuery oneToMany(const QString &tableName, const QString &attribute, const qint64 &id, const qint64 &limit = 0);
-    QSqlQuery manyToMany(const QString &tableName, const QString &attribute, const qint64 &id, const QString &foreignKey,
+    QSqlQuery oneToMany(const QString &tableName, const QString &attribute,
+                        const qint64 &id,
+                        const qint64 &limit = 0);
+    QSqlQuery manyToMany(const QString &tableName, const QString &attribute,
+                         const qint64 &id,
+                         const QString &foreignKey,
                          const QString &foreignTable);
     virtual QString limit(const qint64 &limit, const qint64 &offset) const;
-    QString generateManyToManyColumnName(const QSharedPointer<Entity> &entity) const;
+    QString generateManyToManyColumnName(const QSharedPointer<Entity> &entity)
+    const;
     QSqlQuery getQuery() const;
 
   protected:
-    void insertRelationId(const Entity *e, QHash<QString, QVariant> &map, QString relName) const;
+    void insertRelationId(const Entity *e, QHash<QString, QVariant> &map,
+                          QString relName) const;
     QString buildColumns(const QStringList &columns) const;
-    QHash<QString, QVariant> getManyToOneAttributes(const QHash<QString, QMetaProperty> &props,
+    QHash<QString, QVariant> getManyToOneAttributes(const
+            QHash<QString, QMetaProperty>
+            &props,
             const QSharedPointer<Entity> &entity) const;
-    QHash<QString, QMetaProperty> getMetaProperties(const QSharedPointer<Entity> &entity) const;
-    QHash<QString, QVariant> getPropertyValues(const QHash<QString, QMetaProperty> &metaProps,
+    QHash<QString, QMetaProperty> getMetaProperties(const QSharedPointer<Entity>
+            &entity)
+    const;
+    QHash<QString, QVariant> getPropertyValues(const QHash<QString, QMetaProperty>
+            &metaProps,
             const QSharedPointer<Entity> &entity) const;
-    QString buildCreateQuery(QHash<QString, QVariant>::const_iterator i, QHash<QString, QVariant>::const_iterator end,
+    QString buildCreateQuery(QHash<QString, QVariant>::const_iterator i,
+                             QHash<QString, QVariant>::const_iterator end,
                              QString &p1, QString &p2) const;
-    void bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q, bool ignoreID = false) const;
-    QString where(const QSharedPointer<Entity> &entity, QString conjunction = ",", bool ignoreID = false) const;
-    QString where(const QHash<QString, QVariant> &m, const QString &conjunction = ",", bool ignoreID = false) const;
-    QString attributes(const QHash<QString, QVariant> &m, const QString &conjunction = ",", bool ignoreID = false) const;
-    QHash<QString, QVariant> saveAttributes(const QSharedPointer<Entity> &entity) const;
-    QString leftJoin(const QString &foreignTable, const QString &tableName, const QString &foreignKey);
+    void bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q,
+                    bool ignoreID = false) const;
+    QString where(const QSharedPointer<Entity> &entity, QString conjunction = ",",
+                  bool ignoreID = false) const;
+    QString where(const QHash<QString, QVariant> &m,
+                  const QString &conjunction = ",",
+                  bool ignoreID = false) const;
+    QString attributes(const QHash<QString, QVariant> &m,
+                       const QString &conjunction = ",",
+                       bool ignoreID = false) const;
+    QHash<QString, QVariant> saveAttributes(const QSharedPointer<Entity> &entity)
+    const;
+    QString leftJoin(const QString &foreignTable, const QString &tableName,
+                     const QString &foreignKey);
 
     QSharedPointer<Schema> schema;
     QSharedPointer<Database> database;
diff --git a/src/relation.cpp b/src/relation.cpp
index 35507ec..a52a413 100644
--- a/src/relation.cpp
+++ b/src/relation.cpp
@@ -27,7 +27,8 @@ Relation::Relation(QString propertyName, RelationType type, bool optional) {
     this->cascadeType = ALL;
 }
 
-Relation::Relation(QString propertyName, RelationType type, QString mappedBy, QString tableName,
+Relation::Relation(QString propertyName, RelationType type, QString mappedBy,
+                   QString tableName,
                    CascadeType cascadeType) {
     this->propertyName = propertyName;
     this->type = type;
diff --git a/src/relation.h b/src/relation.h
index b7b1ccf..6c456d8 100644
--- a/src/relation.h
+++ b/src/relation.h
@@ -43,7 +43,8 @@ class Relation {
      * @param type
      * @param mappedBy Q_PROPERTY in foreign Entity
      */
-    Relation(QString propertyName, RelationType type, QString mappedBy, QString tableName = "",
+    Relation(QString propertyName, RelationType type, QString mappedBy,
+             QString tableName = "",
              CascadeType cascadeType = ALL);
     ~Relation();
     RelationType getType() const;
diff --git a/src/schema.cpp b/src/schema.cpp
index bb3c8f3..1a58c0c 100644
--- a/src/schema.cpp
+++ b/src/schema.cpp
@@ -22,14 +22,15 @@ using namespace CuteEntityManager;
 
 Schema::Schema(QSharedPointer<Database> database) {
     this->database = database;
-    this->abstractTypeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
+    this->abstractTypeMap = QSharedPointer<QHash<QString, QString>>
+                            (new QHash<QString, QString>());
     this->queryBuilder = QSharedPointer<QueryBuilder>();
-    this->typeMap = QSharedPointer<QHash<QString, QString>>(new QHash<QString, QString>());
+    this->typeMap = QSharedPointer<QHash<QString, QString>>(new
+                    QHash<QString, QString>());
     this->initAbstractDatabaseTypes();
 }
 
 Schema::~Schema() {
-
 }
 
 void Schema::initAbstractDatabaseTypes() {
@@ -99,7 +100,8 @@ QString Schema::quoteSimpleColumnName(QString name) {
     return name.indexOf("`") || name == "*" ? name : "`" + name + "`";
 }
 
-QHash<QString, QSharedPointer<TableSchema> > Schema::getTableSchemas(QString schema, bool refresh) {
+QHash<QString, QSharedPointer<TableSchema> > Schema::getTableSchemas(
+    QString schema, bool refresh) {
     QStringList names = this->getTableNames();
     for (int i = 0; i < names.size(); ++i) {
         QString name;
@@ -166,7 +168,8 @@ QSharedPointer<QHash<QString, QString> > Schema::getAbstractTypeMap() const {
     return abstractTypeMap;
 }
 
-void Schema::setAbstractTypeMap(const QSharedPointer<QHash<QString, QString> > &value) {
+void Schema::setAbstractTypeMap(const QSharedPointer<QHash<QString, QString> >
+                                &value) {
     abstractTypeMap = value;
 }
 
@@ -175,7 +178,8 @@ QHash<QString, QSharedPointer<TableSchema> > Schema::getTables() const {
     return this->tables;
 }
 
-void Schema::setTables(const QHash<QString, QSharedPointer<TableSchema> > &value) {
+void Schema::setTables(const QHash<QString, QSharedPointer<TableSchema> >
+                       &value) {
     tables = value;
 }
 
diff --git a/src/schema.h b/src/schema.h
index ec21658..28a49b9 100644
--- a/src/schema.h
+++ b/src/schema.h
@@ -52,8 +52,11 @@ class Schema {
     virtual QString quoteTableName(QString name);
     virtual QString quoteColumnName(QString name);
     virtual QString quoteSimpleColumnName(QString name);
-    virtual QHash<QString, QSharedPointer<TableSchema>> getTableSchemas(QString schema = "", bool refresh = false);
-    virtual QSharedPointer<TableSchema> getTableSchema(QString name, bool refresh = false);
+    virtual QHash<QString, QSharedPointer<TableSchema>> getTableSchemas(
+                QString schema = "",
+                bool refresh = false);
+    virtual QSharedPointer<TableSchema> getTableSchema(QString name,
+            bool refresh = false);
     virtual QStringList getTableNames(QString schema = "");
     virtual QVariant getLastInsertID();
     virtual void refresh();
@@ -73,7 +76,9 @@ class Schema {
 
   protected:
     virtual QStringList findTableNames(QString schema = "") = 0;
-    virtual QHash<QString, QStringList> findUniqueIndexes(const QSharedPointer<TableSchema> &table) = 0;
+    virtual QHash<QString, QStringList> findUniqueIndexes(const
+            QSharedPointer<TableSchema>
+            &table) = 0;
     virtual void findConstraints(const QSharedPointer<TableSchema> &ts) = 0;
     virtual bool findColumns(const QSharedPointer<TableSchema> &ts) = 0;
     virtual QSharedPointer<TableSchema> loadTableSchema(QString name)  = 0;
diff --git a/src/schema/sqlitequerybuilder.cpp b/src/schema/sqlitequerybuilder.cpp
index 1b4ed79..0e32d75 100644
--- a/src/schema/sqlitequerybuilder.cpp
+++ b/src/schema/sqlitequerybuilder.cpp
@@ -16,8 +16,11 @@
 #include "sqlitequerybuilder.h"
 #include "../schema.h"
 
-CuteEntityManager::SqliteQueryBuilder::SqliteQueryBuilder(QSharedPointer<CuteEntityManager::Schema> schema,
-        QSharedPointer<CuteEntityManager::Database> database) : QueryBuilder(schema, database) {
+CuteEntityManager::SqliteQueryBuilder::SqliteQueryBuilder(
+    QSharedPointer<CuteEntityManager::Schema>
+    schema,
+    QSharedPointer<CuteEntityManager::Database> database) : QueryBuilder(schema,
+                database) {
 
 }
 
@@ -25,55 +28,60 @@ CuteEntityManager::SqliteQueryBuilder::~SqliteQueryBuilder() {
 
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::truncateTable(QString tableName) const {
+QString CuteEntityManager::SqliteQueryBuilder::truncateTable(
+    QString tableName) const {
     return "DELETE FROM " + this->schema.data()->quoteTableName(tableName);
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::dropIndex(QString name, QString tableName) const {
+QString CuteEntityManager::SqliteQueryBuilder::dropIndex(QString name,
+        QString tableName) const {
     return "DROP INDEX " + this->schema.data()->quoteTableName(name);
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::dropColumn(QString tableName, QString columName) const {
+QString CuteEntityManager::SqliteQueryBuilder::dropColumn(QString tableName,
+        QString columName) const {
     //not supported
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::renameColumn(QString tableName, QString oldName, QString newName) const {
+QString CuteEntityManager::SqliteQueryBuilder::renameColumn(QString tableName,
+        QString oldName,
+        QString newName) const {
     //not supported
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::addForeignKey(QString name, QString tableName, QStringList columns,
-        QString refTableName, QStringList refColumns, QString deleteConstraint, QString updateConstraint) const {
+QString CuteEntityManager::SqliteQueryBuilder::addForeignKey(QString name,
+        QString tableName,
+        QStringList columns,
+        QString refTableName, QStringList refColumns, QString deleteConstraint,
+        QString updateConstraint) const {
     //not supported
-    Q_UNUSED(refTableName)
-    Q_UNUSED(refColumns)
-    Q_UNUSED(name)
-    Q_UNUSED(tableName)
-    Q_UNUSED(deleteConstraint)
-    Q_UNUSED(columns)
-    Q_UNUSED(updateConstraint)
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::dropForeignKey(QString name, QString tableName) const {
+QString CuteEntityManager::SqliteQueryBuilder::dropForeignKey(QString name,
+        QString tableName) const {
     //not supported
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::alterColumn(QString tableName, QString columnName,
+QString CuteEntityManager::SqliteQueryBuilder::alterColumn(QString tableName,
+        QString columnName,
         QString newType) const {
     //not supported
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::addPrimaryKey(QString name, QString tableName,
+QString CuteEntityManager::SqliteQueryBuilder::addPrimaryKey(QString name,
+        QString tableName,
         QStringList columns) const {
     //not supported
     return "";
 }
 
-QString CuteEntityManager::SqliteQueryBuilder::dropPrimaryKey(QString name, QString tableName) const {
+QString CuteEntityManager::SqliteQueryBuilder::dropPrimaryKey(QString name,
+        QString tableName) const {
     //not supported
     return "";
 }
diff --git a/src/schema/sqlitequerybuilder.h b/src/schema/sqlitequerybuilder.h
index 601743a..3bee36d 100644
--- a/src/schema/sqlitequerybuilder.h
+++ b/src/schema/sqlitequerybuilder.h
@@ -17,21 +17,26 @@
 #define SQLITEQUERYBUILDER_H
 #include "../querybuilder.h"
 namespace CuteEntityManager {
-class SqliteQueryBuilder : public QueryBuilder
-{
-public:
-    SqliteQueryBuilder(QSharedPointer<Schema> schema, QSharedPointer<Database> database);
+class SqliteQueryBuilder : public QueryBuilder {
+  public:
+    SqliteQueryBuilder(QSharedPointer<Schema> schema,
+                       QSharedPointer<Database> database);
     ~SqliteQueryBuilder();
 
     virtual QString truncateTable(QString tableName) const;
     virtual QString dropIndex(QString name, QString tableName) const;
     virtual QString dropColumn(QString tableName, QString columName)const;
-    virtual QString renameColumn(QString tableName, QString oldName, QString newName) const;
-    virtual QString addForeignKey(QString name, QString tableName, QStringList columns, QString refTableName,
-                                  QStringList refColumns, QString deleteConstraint, QString updateConstraint) const;
+    virtual QString renameColumn(QString tableName, QString oldName,
+                                 QString newName) const;
+    virtual QString addForeignKey(QString name, QString tableName, QStringList columns,
+                                  QString refTableName,
+                                  QStringList refColumns, QString deleteConstraint,
+                                  QString updateConstraint) const;
     virtual QString dropForeignKey(QString name, QString tableName) const;
-    virtual QString alterColumn(QString tableName, QString columnName, QString newType) const;
-    virtual QString addPrimaryKey(QString name, QString tableName, QStringList columns) const;
+    virtual QString alterColumn(QString tableName, QString columnName,
+                                QString newType) const;
+    virtual QString addPrimaryKey(QString name, QString tableName,
+                                  QStringList columns) const;
     virtual QString dropPrimaryKey(QString name, QString tableName) const;
 
 };
diff --git a/src/schema/sqliteschema.cpp b/src/schema/sqliteschema.cpp
index b68c288..f815866 100644
--- a/src/schema/sqliteschema.cpp
+++ b/src/schema/sqliteschema.cpp
@@ -20,8 +20,11 @@
 #include "sqlitequerybuilder.h"
 using namespace CuteEntityManager;
 
-SqliteSchema::SqliteSchema(QSharedPointer<Database> database) : Schema(database) {
-    this->queryBuilder = QSharedPointer<QueryBuilder>(new SqliteQueryBuilder(QSharedPointer<Schema>(this), database));
+SqliteSchema::SqliteSchema(QSharedPointer<Database> database) : Schema(
+        database) {
+    this->queryBuilder = QSharedPointer<QueryBuilder>(new SqliteQueryBuilder(
+                             QSharedPointer<Schema>
+                             (this), database));
 }
 
 SqliteSchema::~SqliteSchema() {
@@ -30,8 +33,10 @@ SqliteSchema::~SqliteSchema() {
 
 QSharedPointer<QHash<QString, QString>> SqliteSchema::getTypeMap() {
     if (this->typeMap.data()->empty()) {
-        this->typeMap.data()->insert(TYPE_PK, "integer PRIMARY KEY AUTOINCREMENT NOT NULL");
-        this->typeMap.data()->insert(TYPE_BIGPK, "integer PRIMARY KEY AUTOINCREMENT NOT NULL");
+        this->typeMap.data()->insert(TYPE_PK,
+                                     "integer PRIMARY KEY AUTOINCREMENT NOT NULL");
+        this->typeMap.data()->insert(TYPE_BIGPK,
+                                     "integer PRIMARY KEY AUTOINCREMENT NOT NULL");
         this->typeMap.data()->insert(TYPE_BOOLEAN, "boolean");
         this->typeMap.data()->insert(TYPE_SMALLINT, "smallint");
         this->typeMap.data()->insert(TYPE_INTEGER, "integer");
@@ -55,7 +60,8 @@ QSharedPointer<QHash<QString, QString>> SqliteSchema::getTypeMap() {
 
 QStringList SqliteSchema::findTableNames(QString schema) {
     auto l = QStringList();
-    QString sql = "SELECT DISTINCT tbl_name FROM sqlite_master WHERE tbl_name<>'sqlite_sequence' ORDER BY tbl_name";
+    QString sql =
+        "SELECT DISTINCT tbl_name FROM sqlite_master WHERE tbl_name<>'sqlite_sequence' ORDER BY tbl_name";
     auto q = this->database.data()->getQuery();
     q.prepare(sql);
     this->database.data()->select(q);
@@ -65,11 +71,14 @@ QStringList SqliteSchema::findTableNames(QString schema) {
     return l;
 }
 
-QHash<QString, QStringList> SqliteSchema::findUniqueIndexes(const QSharedPointer<TableSchema> &table) {
+QHash<QString, QStringList> SqliteSchema::findUniqueIndexes(
+    const QSharedPointer<TableSchema>
+    &table) {
     QHash<QString, QStringList> uniqueIndexes = QHash<QString, QStringList>();
     QSqlQuery q = this->database.data()->getQuery();
     q.setForwardOnly(true);
-    q.exec("PRAGMA index_list(" + this->quoteSimpleTableName(table->getName()) + ')');
+    q.exec("PRAGMA index_list(" + this->quoteSimpleTableName(
+               table->getName()) + ')');
     while (q.next()) {
         QString indexName = q.value("name").toString();
         QSqlQuery q2 = this->database.data()->getQuery();
@@ -89,13 +98,16 @@ QHash<QString, QStringList> SqliteSchema::findUniqueIndexes(const QSharedPointer
 void SqliteSchema::findConstraints(const QSharedPointer<TableSchema> &ts) {
     QSqlQuery q = this->database.data()->getQuery();
     q.setForwardOnly(true);
-    q.exec("PRAGMA foreign_key_list(" + this->quoteSimpleTableName(ts.data()->getName()) + ')');
+    q.exec("PRAGMA foreign_key_list(" + this->quoteSimpleTableName(
+               ts.data()->getName()) + ')');
     auto foreignKeys = ts.data()->getRelations();
     while (q.next()) {
         bool ok;
         int id = q.value("id").toInt(&ok);
         if (ok) {
-            auto rel = new QSqlRelation(q.value("table").toString(), q.value("from").toString(), q.value("to").toString());
+            auto rel = new QSqlRelation(q.value("table").toString(),
+                                        q.value("from").toString(),
+                                        q.value("to").toString());
             auto ptr = QSharedPointer<QSqlRelation>(rel);
             foreignKeys.insert(QString::number(id), ptr);
         }
@@ -106,8 +118,10 @@ void SqliteSchema::findConstraints(const QSharedPointer<TableSchema> &ts) {
 bool SqliteSchema::findColumns(const QSharedPointer<TableSchema> &ts) {
     QSqlQuery q = this->database.data()->getQuery();
     q.setForwardOnly(true);
-    q.exec("SELECT * FROM " + this->quoteSimpleTableName(ts.data()->getName()) + " LIMIT 0");
-    QHash<QString, QSharedPointer<QSqlField>> columns = QHash<QString, QSharedPointer<QSqlField>>();
+    q.exec("SELECT * FROM " + this->quoteSimpleTableName(ts.data()->getName()) +
+           " LIMIT 0");
+    QHash<QString, QSharedPointer<QSqlField>> columns =
+            QHash<QString, QSharedPointer<QSqlField>>();
     auto rec = q.record();
     int count = rec.count();
     if (count == 0) {
diff --git a/src/schema/sqliteschema.h b/src/schema/sqliteschema.h
index a511c59..ee089c9 100644
--- a/src/schema/sqliteschema.h
+++ b/src/schema/sqliteschema.h
@@ -26,7 +26,8 @@ class SqliteSchema : public Schema {
   protected:
 
     virtual QStringList findTableNames(QString schema = "");
-    virtual QHash<QString, QStringList> findUniqueIndexes(const QSharedPointer<TableSchema> &table);
+    virtual QHash<QString, QStringList> findUniqueIndexes(const QSharedPointer<TableSchema>
+            &table);
     virtual void findConstraints(const QSharedPointer<TableSchema> &ts);
     virtual bool findColumns(const QSharedPointer<TableSchema> &ts);
     virtual QSharedPointer<TableSchema> loadTableSchema(QString name);
diff --git a/src/tableschema.cpp b/src/tableschema.cpp
index ed777b3..42d7828 100644
--- a/src/tableschema.cpp
+++ b/src/tableschema.cpp
@@ -83,13 +83,16 @@ QHash<QString, QSharedPointer<QSqlField> > TableSchema::getColumns() const {
     return columns;
 }
 
-void TableSchema::setColumns(const QHash<QString, QSharedPointer<QSqlField> > &value) {
+void TableSchema::setColumns(const QHash<QString, QSharedPointer<QSqlField> >
+                             &value) {
     columns = value;
 }
-QHash<QString, QSharedPointer<QSqlRelation> > TableSchema::getRelations() const {
+QHash<QString, QSharedPointer<QSqlRelation> > TableSchema::getRelations()
+const {
     return relations;
 }
 
-void TableSchema::setRelations(const QHash<QString, QSharedPointer<QSqlRelation> > &value) {
+void TableSchema::setRelations(
+    const QHash<QString, QSharedPointer<QSqlRelation> > &value) {
     relations = value;
 }
diff --git a/src/tableschema.h b/src/tableschema.h
index 85f25f5..9ecac26 100644
--- a/src/tableschema.h
+++ b/src/tableschema.h
@@ -52,7 +52,7 @@ class TableSchema {
     QHash<QString, QSharedPointer<QSqlRelation> > getRelations() const;
     void setRelations(const QHash<QString, QSharedPointer<QSqlRelation> > &value);
 
-private:
+  private:
     QString schemaName;
     QString name;
     QString fullName;