commit c9f217782e289331ba37da5aa32043f4a00e31f7
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Fri Aug 7 17:39:03 2015 +0200

    fixes

diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index 969b64e..d140549 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -650,7 +650,7 @@ bool EntityManager::create(QSharedPointer<Entity> &entity,
 }
 
 bool EntityManager::merge(QSharedPointer<Entity> &entity, bool withRelations) {
-    if (entity->getId() > -1 && this->count(entity) == 1) {
+    if (entity->getId() > -1) {
         if (withRelations) {
             this->savePrePersistedRelations(entity);
         }
@@ -754,7 +754,7 @@ void EntityManager::resolveRelations(const QSharedPointer<Entity> &entity,
 
 bool EntityManager::save(QSharedPointer<Entity> &entity,
                          const bool persistRelations) {
-    if (entity->getProperty(entity->getPrimaryKey()) > -1) {
+    if (entity->getProperty(entity->getPrimaryKey()).toLongLong() > -1) {
         return this->merge(entity, persistRelations);
     } else {
         return this->create(entity, persistRelations);
@@ -825,20 +825,22 @@ void EntityManager::setConnectionNames(QStringList list) {
 
 QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant>
         &map,
-        const char *classname, const bool refresh) {
+        const char *classname, const bool refresh, const bool resolveRelations) {
     auto ptr = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
                                           classname, map));
     this->cache.insert(ptr);
-    this->resolveRelations(ptr, map, refresh);
+    if (resolveRelations) {
+        this->resolveRelations(ptr, map, refresh);
+    }
     return ptr;
 }
 
 QList<QSharedPointer<Entity> > EntityManager::convert(
     QList<QHash<QString, QVariant> > maps,
-    const char *classname, const bool refresh) {
+    const char *classname, const bool refresh, const bool resolveRelations) {
     auto list = QList<QSharedPointer<Entity> >();
     for (int var = 0; var < maps.size(); ++var) {
-        auto ptr = this->convert(maps.at(var), classname, refresh);
+        auto ptr = this->convert(maps.at(var), classname, refresh, resolveRelations);
         list.append(ptr);
         this->cache.insert(ptr);
     }
diff --git a/src/entitymanager.h b/src/entitymanager.h
index f644614..48b5850 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -87,27 +87,34 @@ class EntityManager : public QObject {
     static QStringList getConnectionNames();
     QSharedPointer<QueryBuilder> getQueryBuilder() const;
 
-    template<class T> QList<QSharedPointer<T>> find(Query &q) {
+    template<class T> QList<QSharedPointer<T>> find(Query &q,
+    const bool joinBaseClasses = false, const bool resolveRelations = true) {
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>
                                      (EntityInstanceFactory::createInstance<T *>());
         if (ptr) {
             if (q.getFrom().isEmpty()) {
                 q.setFrom(QStringList(ptr->getTablename()));
             }
+            if (joinBaseClasses) {
+                q.appendJoins(this->schema->getQueryBuilder()->joinBaseClasses(ptr));
+            }
             QSqlQuery query = this->queryInterpreter->build(q);
             auto maps = this->convertQueryResult(query);
-            auto converted = this->convert(maps, EntityHelper::getClassname(ptr.data()));
+            auto converted = this->convert(maps, EntityHelper::getClassname(ptr.data()),
+                                           resolveRelations);
             return this->convertList<T>(converted);
         }
         return QList<QSharedPointer<T>>();
     }
 
-    template<class T> QList<QSharedPointer<T>> findAll() {
+    template<class T> QList<QSharedPointer<T>> findAll(const bool resolveRelations =
+    true) {
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>
                                      (EntityInstanceFactory::createInstance<T *>());
         if (ptr) {
             auto maps = this->findAll(ptr);
-            auto converted = this->convert(maps, EntityHelper::getClassname(ptr.data()));
+            auto converted = this->convert(maps, EntityHelper::getClassname(ptr.data()),
+                                           resolveRelations);
             return this->convertList<T>(converted);
         }
         return QList<QSharedPointer<T>>();
@@ -119,10 +126,13 @@ class EntityManager : public QObject {
         return this->findById(id, ptr).objectCast<T>();
     }
 
-    template<class T> QSharedPointer<T> findEntityByAttributes(
+    template<class T>
+    QSharedPointer<T> findEntityByAttributes(
         const QHash<QString, QVariant>
-        &attributes) {
-        auto list = this->findAllEntitiesByAttributes<T>(attributes, 1, 0);
+        &attributes, const bool joinBaseClasses = false,
+        const bool resolveRelations = true) {
+        auto list = this->findAllEntitiesByAttributes<T>(attributes, 1, 0,
+                    joinBaseClasses, resolveRelations);
         if (list.isEmpty()) {
             return QSharedPointer<T>();
         }
@@ -132,17 +142,22 @@ class EntityManager : public QObject {
 
     template<class T> QList<QSharedPointer<T>> findAllEntitiesByAttributes(
             const QHash<QString, QVariant> &attributes =
-    QHash<QString, QString>(), quint64 limit = 0, quint64 offset = 0) {
+                QHash<QString, QString>(), quint64 limit = 0, quint64 offset = 0,
+    bool joinBaseClasses = false, const bool resolveRelations = true) {
         QSharedPointer<Entity> e = QSharedPointer<Entity>
-                              (EntityInstanceFactory::createInstance<T *>());
+                                   (EntityInstanceFactory::createInstance<T *>());
         if (e) {
             Query query = Query(QStringList(e->getTablename()));
+            if (joinBaseClasses) {
+                query.appendJoins(this->schema->getQueryBuilder()->joinBaseClasses(e));
+            }
             query.appendWhere(this->schema->getQueryBuilder()->where(attributes));
             query.setLimit(limit);
             query.setOffset(offset);
             QSqlQuery q = this->queryInterpreter->build(query);
             auto results = this->convertQueryResult(q);
-            auto list = this->convert(results, EntityHelper::getClassname(e.data()));
+            auto list = this->convert(results, EntityHelper::getClassname(e.data()),
+                                      resolveRelations);
             return this->convertList<T>(list);
         }
         return QList<QSharedPointer<T>>();
@@ -237,9 +252,11 @@ class EntityManager : public QObject {
     void setNullOneToManyRelation(QVariant &var, const Relation &r);
     void setNullEntityPropertyRelation(QVariant &var, const Relation &r);
     QSharedPointer<Entity> convert(const QHash<QString, QVariant> &map,
-                                   const char *classname, const bool refresh = false);
+                                   const char *classname, const bool refresh = false,
+                                   const bool resolveRelations = true);
     QList<QSharedPointer<Entity>> convert(QList<QHash<QString, QVariant> > maps,
-                                          const char *classname, const bool refresh = false);
+                                          const char *classname, const bool refresh = false,
+                                          const bool resolveRelations = true);
     void missingManyToManyTable(const QString &tblName,
                                 const QSharedPointer<Entity> &e, const Relation &r);
     bool isRelationPropertyValid(const QMetaProperty &prop, const Relation &r,
diff --git a/src/query.cpp b/src/query.cpp
index 7930deb..2ffab80 100644
--- a/src/query.cpp
+++ b/src/query.cpp
@@ -105,6 +105,10 @@ void Query::appendJoin(const Join &value) {
     }
 }
 
+void Query::appendJoins(const QList<Join> &value) {
+    this->joins.append(value);
+}
+
 QStringList Query::getGroupBy() const {
     return groupBy;
 }
diff --git a/src/query.h b/src/query.h
index f1b4292..3c47765 100644
--- a/src/query.h
+++ b/src/query.h
@@ -49,6 +49,7 @@ class Query {
     void setFrom(const QStringList &value);
 
     void appendJoin(const Join &value);
+    void appendJoins(const QList<Join> &value);
     QList<Join> getJoins() const;
     void setJoins(const QList<Join> &value);
 
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index a06a855..32fdb4a 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -702,12 +702,15 @@ QSqlQuery QueryBuilder::insert(const QString &tableName,
 
 QSqlQuery QueryBuilder::update(const QString &tableName,
                                QHash<QString, QVariant> &attributes, const QString &primaryKey) const {
+    QVariant pk = attributes.value(primaryKey);
+    attributes.remove(primaryKey);
     QSqlQuery q = this->database->getQuery("UPDATE " + this->schema->quoteTableName(
             tableName) + " SET " + this->attributes(attributes) + " " + this->whereKeyword()
                                            + " " +
                                            this->schema->quoteColumnName(primaryKey) + " = " + this->placeHolder(
                                                    primaryKey) + ";");
     this->bindValues(attributes, q);
+    this->bindValue(primaryKey, pk, q);
     return q;
 }
 
@@ -786,25 +789,6 @@ QString QueryBuilder::addWildcard(QVariant var, JokerPosition jp,
     return val;
 }
 
-QString QueryBuilder::joinSuperClasses(const QSharedPointer<Entity> &entity)
-const {
-    auto classes = EntityHelper::superClasses(entity.data(), true);
-    QString joined = "";
-    Entity *e = 0;
-    for (int var = 0; var < classes.size(); ++var) {
-        auto metaObject = classes.at(var);
-        e = EntityInstanceFactory::createInstance(metaObject->className());
-        if (e) {
-            joined.append(" ");
-            joined.append(this->leftJoin(e->getTablename(), entity->getTablename(),
-                                         e->getPrimaryKey(), entity->getPrimaryKey()));
-        }
-        delete e;
-        e = 0;
-    }
-    return joined;
-}
-
 QString QueryBuilder::countFunction(const QString &distinctColumn) const {
     return QString(this->countKeyword() + "(" + (distinctColumn.isEmpty() ? "*" :
                    (this->distinct() +
@@ -1022,9 +1006,9 @@ QList<QueryBuilder::ClassAttributes> QueryBuilder::inheritedAttributes(
 
 QString QueryBuilder::leftJoin(const QString &foreignTable,
                                const QString &tableName, const QString &foreignKey,
-                               const QString &primaryKey) const {
-    return "LEFT JOIN " + this->schema->quoteTableName(
-               foreignTable) + " ON " +
+                               const QString &primaryKey, bool onlyCondition) const {
+    return (!onlyCondition ? ("LEFT JOIN " + this->schema->quoteTableName(
+                                  foreignTable) + " ON ") : "") +
            this->schema->quoteColumnName(foreignTable + "." + primaryKey) + "=" +
            this->schema->quoteColumnName(
                tableName + "." + foreignKey);
@@ -1260,6 +1244,49 @@ Expression QueryBuilder::where(QString column, QVariant value) {
     return exp;
 }
 
+Join QueryBuilder::joinClasses(const QSharedPointer<Entity> &mainEntity,
+                               const QSharedPointer<Entity> &foreignEntity, const QString &joinType) const {
+    Join j = Join(foreignEntity->getTablename(),
+                  this->leftJoin(foreignEntity->getTablename(), mainEntity->getTablename(),
+                                 foreignEntity->getPrimaryKey(), mainEntity->getPrimaryKey(), true));
+    j.setType(joinType);
+    return j;
+}
+
+QList<Join> QueryBuilder::joinBaseClasses(const QSharedPointer<Entity>
+        &entity) {
+    auto classes = EntityHelper::superClasses(entity.data(), true);
+    QList<Join> joins = QList<Join>();
+    for (int var = 0; var < classes.size(); ++var) {
+        auto metaObject = classes.at(var);
+        QSharedPointer<Entity> e = QSharedPointer<Entity>
+                                   (EntityInstanceFactory::createInstance(metaObject->className()));
+        if (e) {
+            joins.append(this->joinClasses(entity, e));
+        }
+    }
+    return joins;
+}
+
+QString QueryBuilder::joinSuperClasses(const QSharedPointer<Entity> &entity)
+const {
+    auto classes = EntityHelper::superClasses(entity.data(), true);
+    QString joined = "";
+    Entity *e = nullptr;
+    for (int var = 0; var < classes.size(); ++var) {
+        auto metaObject = classes.at(var);
+        e = EntityInstanceFactory::createInstance(metaObject->className());
+        if (e) {
+            joined.append(" ");
+            joined.append(this->leftJoin(e->getTablename(), entity->getTablename(),
+                                         e->getPrimaryKey(), entity->getPrimaryKey()));
+        }
+        delete e;
+        e = nullptr;
+    }
+    return joined;
+}
+
 Expression QueryBuilder::where(QHash<QString, QVariant> conditions,
                                QString conjunction) {
     Expression exp = Expression(this->where(conditions, conjunction, false, "id",
diff --git a/src/querybuilder.h b/src/querybuilder.h
index 46ee948..0ea23b5 100644
--- a/src/querybuilder.h
+++ b/src/querybuilder.h
@@ -102,9 +102,11 @@ class QueryBuilder {
     QString getColumnType(const QString &type) const;
     virtual QString placeHolder(const QString &key) const;
     void bindValues(const QHash<QString, QVariant> &h, QSqlQuery &q,
-                    bool ignoreID = false, const QString &primaryKey = "id") const;
+                    bool ignoreID = false, const QString &primaryKey = QStringLiteral("id")) const;
     void bindValue(const QString &key, const QVariant &value, QSqlQuery &q) const;
     Expression where(QString column, QVariant value);
+    Join joinClasses(const QSharedPointer<Entity> &mainEntity, const QSharedPointer<Entity> &foreignEntity, const QString &joinType=QStringLiteral("LEFT JOIN"))const;
+    QList<Join> joinBaseClasses(const QSharedPointer<Entity> &entity);
     /**
      * @brief where
      * @param query
@@ -112,7 +114,7 @@ class QueryBuilder {
      * @param conjunction its AND or OR
      */
     Expression where(QHash<QString, QVariant> conditions,
-                     QString conjunction = "AND");
+                     QString conjunction = QStringLiteral("AND"));
     Expression where(QString condition,
                      QHash<QString, QVariant> values = QHash<QString, QVariant>());
     //void where(Query &query,QHash<QString, QList<QVariant>> conditions, QString concat="AND");
@@ -156,7 +158,7 @@ class QueryBuilder {
      * @param concat
      */
     Expression like(QHash<QString, QVariant> conditions,
-                    QString conjunction = "AND",
+                    QString conjunction = QStringLiteral("AND"),
                     JokerPosition jp = JokerPosition::BOTH, QChar wildcard = '%');
 
   protected:
@@ -270,7 +272,7 @@ class QueryBuilder {
         const QSharedPointer<Entity> &entity) const;
 
     QString leftJoin(const QString &foreignTable, const QString &tableName,
-                     const QString &foreignKey = "id", const QString &primaryKey = "id") const;
+                     const QString &foreignKey = "id", const QString &primaryKey = "id", bool onlyCondition=false) const;
     QString superClassColumnName(const QMetaObject *&superMeta) const;
     QString addWildcard(QVariant var, JokerPosition jp,
                         QChar jokerChar = '%') const;
diff --git a/src/queryinterpreter.cpp b/src/queryinterpreter.cpp
index d7c9920..a378eee 100644
--- a/src/queryinterpreter.cpp
+++ b/src/queryinterpreter.cpp
@@ -61,7 +61,8 @@ QSqlQuery QueryInterpreter::build(Query &q) {
 QString QueryInterpreter::buildSelect(Query &q,
                                       const QList<Expression> &columns,
                                       const bool &distinct, const QString &selectOption) const {
-    QString sqlSelect = distinct ? "SELECT DISTINCT" : "SELECT";
+    QString sqlSelect = distinct ? ("SELECT " + this->builder->distinct()) :
+                        "SELECT";
     if (!selectOption.isEmpty()) {
         sqlSelect += this->builder->getSeparator() + selectOption;
     }
diff --git a/src/schema.cpp b/src/schema.cpp
index 0adb13e..0bc6063 100644
--- a/src/schema.cpp
+++ b/src/schema.cpp
@@ -66,7 +66,7 @@ void Schema::initAbstractDatabaseTypes() {
 }
 
 QString Schema::quoteSimpleTableName(QString name) {
-    return name.indexOf("`") != -1 ? name : "`" + name + "`";
+    return name.indexOf("`") != -1 ? name : ("`" + name + "`");
 }
 
 QString Schema::quoteTableName(QString name) {
@@ -98,7 +98,7 @@ QString Schema::quoteColumnName(QString name) {
 }
 
 QString Schema::quoteSimpleColumnName(QString name) {
-    return name.indexOf("`") != -1 || name == "*" ? name : "`" + name + "`";
+    return name.indexOf("`") != -1 || name == "*" ? name : ("`" + name + "`");
 }
 
 QHash<QString, QSharedPointer<TableSchema> > Schema::getTableSchemas(