commit 2ee5022f3791de30be735d4977becb404e5f9329
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Mon Aug 3 22:57:06 2015 +0200

    query stuff

diff --git a/EntityManager.pro b/EntityManager.pro
index 13aba2f..d34fa4d 100644
--- a/EntityManager.pro
+++ b/EntityManager.pro
@@ -26,7 +26,9 @@ src/entity.h \
     src/entityhelper.h \
     src/logger.h \
     src/query.h \
-    src/join.h
+    src/join.h \
+    src/queryinterpreter.h \
+    src/condition.h
 
 SOURCES += \
 src/entity.cpp \
@@ -46,7 +48,9 @@ src/entity.cpp \
     src/entityhelper.cpp \
     src/logger.cpp \
     src/query.cpp \
-    src/join.cpp
+    src/join.cpp \
+    src/queryinterpreter.cpp \
+    src/condition.cpp
 
 unix {
     target.path = /usr/lib
diff --git a/src/condition.cpp b/src/condition.cpp
new file mode 100644
index 0000000..98d2048
--- /dev/null
+++ b/src/condition.cpp
@@ -0,0 +1,36 @@
+#include "condition.h"
+using namespace CuteEntityManager;
+Condition::Condition() {
+
+}
+
+Condition::Condition(QString condition) {
+    if (!condition.isEmpty()) {
+        this->conditions.append(condition);
+    }
+}
+
+void Condition::appendCondition(const QString &value) {
+    this->conditions.append(value);
+}
+
+QStringList Condition::getConditions() const {
+    return conditions;
+}
+
+void Condition::setConditions(const QStringList &value) {
+    conditions = value;
+}
+
+QList<Condition> Condition::getSubConditions() const {
+    return subConditions;
+}
+
+void Condition::setSubConditions(const QList<Condition> &value) {
+    subConditions = value;
+}
+
+void CuteEntityManager::Condition::addSubCondition(const
+        CuteEntityManager::Condition &value) {
+    this->subConditions.append(value);
+}
diff --git a/src/condition.h b/src/condition.h
new file mode 100644
index 0000000..39faf7e
--- /dev/null
+++ b/src/condition.h
@@ -0,0 +1,24 @@
+#ifndef CONDITION_H
+#define CONDITION_H
+
+#include <QStringList>
+namespace CuteEntityManager {
+class Condition {
+  public:
+    Condition();
+    Condition(QString condition);
+    void appendCondition(const QString &value);
+    QStringList getConditions() const;
+    void setConditions(const QStringList &value);
+
+    void addSubCondition(const Condition &value);
+    QList<Condition> getSubConditions() const;
+    void setSubConditions(const QList<Condition> &value);
+
+  private:
+    QStringList conditions;
+    QList<Condition> subConditions;
+};
+}
+
+#endif // CONDITION_H
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index 4eb9537..5a5fc80 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -18,6 +18,7 @@
 #include "entitymanager.h"
 #include "enums/databasetype.h"
 #include "databasemigration.h"
+#include "queryinterpreter.h"
 using namespace CuteEntityManager;
 
 QStringList EntityManager::connectionNames = QStringList();
@@ -49,6 +50,8 @@ void EntityManager::init() {
                                           this->db->getDatabase().driverName()), this->db);
     this->schema = QSharedPointer<Schema>(schema);
     this->schema->setTables(this->schema->getTableSchemas());
+    this->queryInterpreter = QSharedPointer<QueryInterpreter>(new QueryInterpreter(
+                                 this->schema->getQueryBuilder()));
 }
 
 EntityManager::~EntityManager() {
diff --git a/src/entitymanager.h b/src/entitymanager.h
index eede28d..3084fb8 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -36,6 +36,7 @@ namespace CuteEntityManager {
 
 
 class Logger;
+class QueryInterpreter;
 class EntityManager : public QObject {
     Q_OBJECT
   signals:
@@ -232,6 +233,7 @@ class EntityManager : public QObject {
     QString createConnection();
     QList<QHash<QString, QVariant> > convertQueryResult(QSqlQuery &q);
     bool checkTable(const QSharedPointer<Entity> &entity);
+    QSharedPointer<QueryInterpreter> queryInterpreter;
 
 };
 }
diff --git a/src/query.cpp b/src/query.cpp
index 5439755..28abd44 100644
--- a/src/query.cpp
+++ b/src/query.cpp
@@ -1,4 +1,5 @@
 #include "query.h"
+#include "condition.h"
 using namespace CuteEntityManager;
 Query::Query() {
     this->select << "*";
@@ -9,8 +10,19 @@ QStringList Query::getSelect() const {
 }
 
 void Query::appendCondition(const QString &condition) {
+    this->conditions.append(Condition(condition));
+}
+
+void Query::appendCondition(const Condition &condition) {
     this->conditions.append(condition);
 }
+QLinkedList<Condition> Query::getConditions() const {
+    return conditions;
+}
+
+void Query::setConditions(const QLinkedList<Condition> &value) {
+    conditions = value;
+}
 
 void Query::setSelect(const QStringList &value) {
     select = value;
@@ -85,11 +97,3 @@ uint Query::getOffset() const {
 void Query::setOffset(const uint &value) {
     offset = value;
 }
-
-QLinkedList<QString> Query::getConditions() const {
-    return conditions;
-}
-
-void Query::setConditions(const QLinkedList<QString> &value) {
-    conditions = value;
-}
diff --git a/src/query.h b/src/query.h
index f245f8a..b187387 100644
--- a/src/query.h
+++ b/src/query.h
@@ -7,9 +7,9 @@
 #include "join.h"
 
 namespace CuteEntityManager {
-class Query
-{
-public:
+class Condition;
+class Query {
+  public:
     Query();
     QStringList getSelect() const;
     void setSelect(const QStringList &value);
@@ -42,22 +42,23 @@ public:
     uint getOffset() const;
     void setOffset(const uint &value);
 
-    QLinkedList<QString> getConditions() const;
     void appendCondition(const QString &condition);
-    void setConditions(const QLinkedList<QString> &value);
+    void appendCondition(const Condition &condition);
+    QLinkedList<Condition> getConditions() const;
+    void setConditions(const QLinkedList<Condition> &value);
 
-private:
+  private:
     QStringList select;
     QString selectOption = QStringLiteral("");
     bool distinct = false;
     QStringList from;
     QStringList groupBy;
     QStringList orderBy;
-    QLinkedList<QString> conditions;
+    QLinkedList<Condition> conditions;
     QList<Join> joins;
     QHash<QString, QVariant> params;
-     uint limit = 0;
-     uint offset = 0;
+    uint limit = 0;
+    uint offset = 0;
 };
 
 enum class JokerPosition {
diff --git a/src/querybuilder.cpp b/src/querybuilder.cpp
index c4de56d..7d79977 100644
--- a/src/querybuilder.cpp
+++ b/src/querybuilder.cpp
@@ -867,7 +867,8 @@ QString QueryBuilder::inFunction(Query &q, QString column,
 
 QString QueryBuilder::between(QString colName, QString valName1,
                               QString valName2, bool notOp) {
-    return "(" + this->schema->quoteColumnName(colName) + " " + this->between() +
+    return "(" + this->schema->quoteColumnName(colName) + (notOp ? (" " +
+            this->notKeyword() + " ") : " ") + this->between() +
            " " + this->placeHolder(valName1) + " " + this->andKeyword() + " " +
            this->placeHolder(valName2) + ")";
 }
@@ -1223,11 +1224,6 @@ void QueryBuilder::like(Query &query, QHash<QString, QVariant> conditions,
     }
 }
 
-QSqlQuery QueryBuilder::generateQuery(const Query &query) const {
-
-}
-
-
 void QueryBuilder::where(Query &query, QString column, QVariant value) {
     QString placeholder = column + "_where";
     query.appendCondition(this->schema->quoteColumnName(column) + "=" +
diff --git a/src/querybuilder.h b/src/querybuilder.h
index 2694b28..f452ca9 100644
--- a/src/querybuilder.h
+++ b/src/querybuilder.h
@@ -112,7 +112,8 @@ class QueryBuilder {
      */
     void where(Query &query, QHash<QString, QVariant> conditions,
                QString conjunction = "AND");
-    void where(Query &query, QString condition,QHash<QString, QVariant> values= QHash<QString, QVariant>());
+    void where(Query &query, QString condition,
+               QHash<QString, QVariant> values = QHash<QString, QVariant>());
     //void where(Query &query,QHash<QString, QList<QVariant>> conditions, QString concat="AND");
     void between(Query &query, QString column, QVariant firstValue,
                  QVariant secondValue);
@@ -146,14 +147,16 @@ class QueryBuilder {
      * @param column
      * @param value
      */
-    void like(Query &q, QString column, QVariant value, JokerPosition jp = JokerPosition::BOTH, QChar wildcard ='%');
+    void like(Query &q, QString column, QVariant value,
+              JokerPosition jp = JokerPosition::BOTH, QChar wildcard = '%');
     /**
      * @brief like
      * @param condition
      * @param concat
      */
-    void like(Query &query, QHash<QString, QVariant> conditions, QString conjunction = "AND",
-              JokerPosition jp= JokerPosition::BOTH, QChar wildcard ='%');
+    void like(Query &query, QHash<QString, QVariant> conditions,
+              QString conjunction = "AND",
+              JokerPosition jp = JokerPosition::BOTH, QChar wildcard = '%');
 
   protected:
     class ClassAttributes {
@@ -175,8 +178,6 @@ class QueryBuilder {
         QString pk;
         QHash<QString, QVariant> attributes;
     };
-    QSqlQuery generateQuery(const Query &query) const;
-
     QSqlQuery find(const qint64 &id, const QString &tableName) const;
     QSqlQuery find(const qint64 &id, const QSharedPointer<Entity> &entity,
                    qint64 offset = 0, QString pk = "id") const;
@@ -265,7 +266,8 @@ class QueryBuilder {
     QString leftJoin(const QString &foreignTable, const QString &tableName,
                      const QString &foreignKey = "id", const QString &primaryKey = "id") const;
     QString superClassColumnName(const QMetaObject *&superMeta) const;
-    QString addWildcard(QVariant var, JokerPosition jp, QChar jokerChar = '%') const;
+    QString addWildcard(QVariant var, JokerPosition jp,
+                        QChar jokerChar = '%') const;
 
     QString joinSuperClasses(const QSharedPointer<Entity> &entity) const;
     virtual QString selectBase(const QStringList &tables,
diff --git a/src/queryinterpreter.cpp b/src/queryinterpreter.cpp
new file mode 100644
index 0000000..ae6e185
--- /dev/null
+++ b/src/queryinterpreter.cpp
@@ -0,0 +1,11 @@
+#include "queryinterpreter.h"
+using namespace CuteEntityManager;
+
+
+QueryInterpreter::QueryInterpreter(QSharedPointer<QueryBuilder> builder) {
+    this->builder = builder;
+}
+
+QSqlQuery QueryInterpreter::interpretQuery(Query &q) {
+
+}
diff --git a/src/queryinterpreter.h b/src/queryinterpreter.h
new file mode 100644
index 0000000..e2e5ed2
--- /dev/null
+++ b/src/queryinterpreter.h
@@ -0,0 +1,18 @@
+#ifndef QUERYINTERPRETER_H
+#define QUERYINTERPRETER_H
+
+#include <QSqlQuery>
+#include <QSharedPointer>
+namespace CuteEntityManager {
+class Query;
+class QueryBuilder;
+class QueryInterpreter {
+  public:
+    QueryInterpreter(QSharedPointer<QueryBuilder> builder);
+    QSqlQuery interpretQuery(Query &q);
+  private:
+    QSharedPointer<QueryBuilder> builder;
+};
+}
+
+#endif // QUERYINTERPRETER_H