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

    onetoone

diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index 2b178a8..e663aef 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -156,14 +156,10 @@ void EntityManager::manyToOne(const QSharedPointer<Entity> &entity, const QVaria
     if ((convertedId == id.toLongLong(&ok)) && ok && convertedId > -1) {
         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()) {
-
-        } else {
+        if (!(this->cache.contains(convertedId, className) && (ptr = this->cache.get(convertedId, className)) && ptr.data())) {
             ptr = this->findById(convertedId, className);
         }
-        if (ptr.data() && ptr.data()->getId() > -1) {
-            property.write(entity.data(), QVariant(ptr));
-        }
+        this->setProperty(entity, ptr, property);
     }
 }
 
@@ -179,6 +175,28 @@ void EntityManager::oneToMany(const QSharedPointer<Entity> &entity, const Relati
     }
 }
 
+
+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);
+        auto listMap = this->convertQueryResult(q);
+        auto entities = this->convert(listMap, e->getClassname());
+        if (!entities.isEmpty()) {
+            QSharedPointer<Entity> ptr = entities.at(0);
+            this->setProperty(entity, ptr, property);
+        }
+        delete e;
+    }
+}
+
+
 void EntityManager::setListProperty(const QSharedPointer<Entity> &entity, QList<QSharedPointer<Entity> > &list,
                                     const QMetaProperty &property) const {
     QVariant var;
@@ -186,6 +204,13 @@ void EntityManager::setListProperty(const QSharedPointer<Entity> &entity, QList<
     property.write(entity.data(), var);
 }
 
+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));
+    }
+}
+
 
 void EntityManager::manyToMany(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property) {
     Entity *secEntity = EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(QString(
@@ -202,21 +227,20 @@ void EntityManager::manyToMany(const QSharedPointer<Entity> &entity, const Relat
         /**
          * maybe it would be better, to fetch first the ids, look up cache and then request missing entities
          */
-        QSqlQuery q = this->schema.data()->getQueryBuilder().data()->manyToMany(tblName,
-                      builder.data()->generateManyToManyColumnName(entity), entity.data()->getId(),
-                      builder.data()->generateManyToManyColumnName(secEntityPtr),
-                      secEntityPtr.data()->getTablename());
-        auto listMap = this->convertQueryResult(q);
-        auto entities = this->convert(listMap, entity.data()->getClassname());
-        this->setListProperty(entity, entities, property);
+        if (this->schema.data()->getTables().contains(tblName)) {
+            QSqlQuery q = this->schema.data()->getQueryBuilder().data()->manyToMany(tblName,
+                          builder.data()->generateManyToManyColumnName(entity), entity.data()->getId(),
+                          builder.data()->generateManyToManyColumnName(secEntityPtr),
+                          secEntityPtr.data()->getTablename());
+            auto listMap = this->convertQueryResult(q);
+            auto entities = this->convert(listMap, entity.data()->getClassname());
+            this->setListProperty(entity, entities, property);
+        } else {
+            qDebug() << "MANY_TO_MANY Table " << tblName << " not exists";
+        }
     }
 }
 
-void EntityManager::oneToOne(const QSharedPointer<Entity> &entity, const Relation &r, const QMetaProperty &property,
-                             const QVariant &id) {
-
-}
-
 QList<QSharedPointer<Entity> > EntityManager::findEntityByAttributes(const QSharedPointer<Entity> &entity,
         bool ignoreID) {
     auto maps = this->findAllByAttributes(entity, ignoreID);
@@ -274,18 +298,6 @@ QHash<QString, QVariant> EntityManager::findByPk(qint64 id, QString tblname) {
     if (!listMap.isEmpty()) {
         return listMap.at(0);
     }
-//    this->db->select(q);
-//    QSqlRecord rec = q.record();
-//    QHash<QString, QVariant> map = QHash<QString, QVariant>();
-//    if (q.next()) {
-//        for (int var = 0; var < rec.count(); ++var) {
-//            QVariant variant = rec.value(var);
-//            if (variant.isValid()) {
-//                map.insert(rec.fieldName(var), variant);
-//            }
-//        }
-//    }
-//    return map;
     return QHash<QString, QVariant>();
 }
 
diff --git a/src/entitymanager.h b/src/entitymanager.h
index eff3be4..bf0f5ac 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -66,6 +66,7 @@ class EntityManager {
     QSharedPointer<Entity> findById(const qint64 &id, Entity *&e);
     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;
 
   public:
     EntityManager(QSqlDatabase database);
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index 9de161f..fb941e6 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -185,7 +185,8 @@ QHash<QString, QString> QueryBuilder::generateTableDefinition(const QSharedPoint
                 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) {
+                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())) {
@@ -309,16 +310,17 @@ QSqlQuery QueryBuilder::find(const qint64 &id, const QString &tableName) const {
  * @return
  */
 QSqlQuery QueryBuilder::findByAttributes(const QHash<QString, QVariant> &m, const QString &tableName,
-        const bool &ignoreID) const {
+        const bool &ignoreID, const qint64 limit, const qint64 offset) const {
     QSqlQuery q = this->database.data()->getQuery("SELECT * FROM " + this->schema.data()->quoteTableName(
-                      tableName) + this->where(m, "AND", ignoreID));
+                      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) {
+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);
+    return this->findByAttributes(values, e.data()->getTablename(), ignoreID, limit, offset);
 }
 
 QSqlQuery QueryBuilder::findAll(const QString &tableName) const {
@@ -381,34 +383,40 @@ 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);
+    return this->findByAttributes(values, tableName, false, limit);
 }
 
 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,
+                  this->schema.data()->quoteTableName(tableName) + " " + this->leftJoin(foreignTable, tableName,
                           foreignKey) + " WHERE " + this->schema.data()->quoteColumnName(attribute) + "=:id;";
     q.prepare(sql);
     q.bindValue(":id", id);
-    //SELECT user.* FROM `parent_child` LEFT JOIN user ON user.id=parent_child.user_id WHERE child_id = 1
     return q;
 }
 
 
-QString QueryBuilder::leftJoin(const QString &joinableTable, const QString &tableName, const QString &foreignKey) {
-    return "LEFT JOIN " + this->schema.data()->quoteTableName(joinableTable) + " ON " +
-           this->schema.data()->quoteColumnName(joinableTable + ".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);
 }
 
-
-QString QueryBuilder::limit(const qint8 limit, const qint64 offset) const {
-    return " LIMIT " + QString(limit) + (offset > 0 ? QString("," + offset) : "");
+QString QueryBuilder::limit(const qint64 &limit, const qint64 &offset) const {
+    QString s = "";
+    if (limit > 0) {
+        s.append(" LIMIT ").append(QString::number(limit));
+    }
+    if (offset > 0) {
+        s.append(" OFFSET ").append(QString::number(offset));
+    }
+    return s;
 }
 
 QString QueryBuilder::generateManyToManyColumnName(const QSharedPointer<Entity> &entity) const {
diff --git a/src/querybuilder.h b/src/querybuilder.h
index b004f12..c09077b 100644
--- a/src/querybuilder.h
+++ b/src/querybuilder.h
@@ -63,8 +63,8 @@ class QueryBuilder {
     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;
-    QSqlQuery findByAttributes(const QSharedPointer<Entity> &e, bool ignoreID = true);
+                               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,10 +72,10 @@ 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);
+    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 qint8 limit, const qint64 offset) const;
+    virtual QString limit(const qint64 &limit, const qint64 &offset) const;
     QString generateManyToManyColumnName(const QSharedPointer<Entity> &entity) const;
     QSqlQuery getQuery() const;
 
@@ -94,7 +94,7 @@ class QueryBuilder {
     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 &joinableTable, const QString &tableName, const QString &foreignKey);
+    QString leftJoin(const QString &foreignTable, const QString &tableName, const QString &foreignKey);
 
     QSharedPointer<Schema> schema;
     QSharedPointer<Database> database;
