where phrase

README.md

@@ -7,7 +7,7 @@
 
  - Easy to use
  - Automatically create and update database
- - IDE auto complete support
+ - IDE auto complete support, No hard-code nedded
  - Table join detect 
 
 ## Sample Codes
@@ -26,7 +26,7 @@ auto post = q->first();
 
 ### Adding to database:
 ```cpp
-Post*newPost = new Post;
+Post *newPost = new Post;
 newPost->setTitle("post title");
 
 db.posts()->append(newPost);

src/database.cpp

@@ -333,11 +333,11 @@ bool Database::open()
     Q_D(Database);
 
     if(d->driver == "QPSQL" || d->driver == "QPSQL7")
-        d->sqlGenertor = new PostgreSqlGenerator;
+        d->sqlGenertor = new PostgreSqlGenerator(this);
     else if (d->driver == "QMYSQL" || d->driver == "QMYSQL3")
-        d->sqlGenertor = new MySqlGenerator;
+        d->sqlGenertor = new MySqlGenerator(this);
     else if (d->driver == "QSQLITE" || d->driver == "QSQLITE3")
-        d->sqlGenertor = new SqliteGenerator;
+        d->sqlGenertor = new SqliteGenerator(this);
     else if(d->driver == "QODBC" || d->driver == "QODBC3"){
         QString driverName = QString::null;
         QStringList parts = d->databaseName.toLower().split(';');
@@ -346,7 +346,7 @@ bool Database::open()
                 driverName = p.split('=').at(1);
 
         if(driverName == "{sql server}")
-            d->sqlGenertor = new SqlServerGenerator;
+            d->sqlGenertor = new SqlServerGenerator(this);
     }
 
     if(!d->sqlGenertor){

src/defines.h

@@ -79,10 +79,10 @@ public:                                                                     \
     private:                                                                \
         TableSet<type> *m_##n;                                              \
     public:                                                                 \
-        /*static type ## Field() const{                                       \
-            static type t;                                                  \
-            return t;                                                       \
-        }*/                                                                   \
+        static type *n##Table(){                                             \
+            static type *f = new type();                                    \
+            return f;                                                      \
+        }                                                                   \
         TableSet<type> *n(){                                                \
             return m_##n;                                                   \
         }

src/mysqlgenerator.cpp

@@ -23,7 +23,7 @@
 
 QT_BEGIN_NAMESPACE
 
-MySqlGenerator::MySqlGenerator(QObject *parent) : SqlGeneratorBase(parent)
+MySqlGenerator::MySqlGenerator(Database *parent) : SqlGeneratorBase(parent)
 {
 
 }

src/mysqlgenerator.h

@@ -29,7 +29,7 @@ QT_BEGIN_NAMESPACE
 class MySqlGenerator : public SqlGeneratorBase
 {
 public:
-    MySqlGenerator(QObject *parent = 0);
+    MySqlGenerator(Database *parent = 0);
 
     QString fieldType(FieldModel *field);
 

src/postgresqlgenerator.cpp

@@ -24,7 +24,7 @@
 
 QT_BEGIN_NAMESPACE
 
-PostgreSqlGenerator::PostgreSqlGenerator(QObject *parent) : SqlGeneratorBase (parent)
+PostgreSqlGenerator::PostgreSqlGenerator(Database *parent) : SqlGeneratorBase (parent)
 {
 
 }

src/postgresqlgenerator.h

@@ -29,7 +29,7 @@ QT_BEGIN_NAMESPACE
 class PostgreSqlGenerator : public SqlGeneratorBase
 {
 public:
-    PostgreSqlGenerator(QObject *parent = 0);
+    PostgreSqlGenerator(Database *parent);
 
     QString fieldType(FieldModel *field);
 

src/query.h

@@ -44,7 +44,7 @@ class NUT_EXPORT Query : public QueryBase
     Database *_database;
     TableSetBase *_tableSet;
     QString _joinClassName;
-    QList<FieldPhrase> _wheres;
+    QList<WherePhrase> _wheres;
 public:
     Query(Database *database, TableSetBase *tableSet);
 
@@ -59,7 +59,7 @@ public:
     int remove();
 
     Query<T> *join(const QString &tableName);
-    Query<T> *setWhere(FieldPhrase where);
+    Query<T> *setWhere(WherePhrase where);
 //    Query<T> *setWhere(const QString &where);
     Query<T> *orderBy(QString fieldName, QString type);
 
@@ -92,7 +92,7 @@ Q_OUTOFLINE_TEMPLATE QList<T *> Query<T>::toList(int count)
     QList<T*> result;
     _select = "*";
     qDebug()<<queryText();
-    QSqlQuery q = _database->exec(queryText());
+    QSqlQuery q = _database->exec(_database->sqlGenertor()->selectCommand(_wheres, _orders, _tableName, _joinClassName));
 
     QString pk =_database->model().model(_tableName)->primaryKey();
     QVariant lastPkValue = QVariant();
@@ -176,7 +176,8 @@ Q_OUTOFLINE_TEMPLATE int Query<T>::count()
 template<class T>
 Q_OUTOFLINE_TEMPLATE int Query<T>::remove()
 {
-    QString sql = _database->sqlGenertor()->deleteRecords(_tableName, queryText());
+    QString sql = _database->sqlGenertor()->deleteCommand(_wheres, _tableName);
+//            _database->sqlGenertor()->deleteRecords(_tableName, queryText());
 //    sql = compileCommand(sql);
     QSqlQuery q = _database->exec(sql);
     return q.numRowsAffected();
@@ -190,7 +191,7 @@ Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::join(const QString &tableName)
 }
 
 template<class T>
-Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::setWhere(FieldPhrase where)
+Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::setWhere(WherePhrase where)
 {
     _wheres.append(where);
     return this;
@@ -240,7 +241,7 @@ Q_OUTOFLINE_TEMPLATE QString Query<T>::queryText()
 {
     QStringList orderby;
     QString q = "";//compileCommand(_where);
-    foreach (FieldPhrase p, _wheres) {
+    foreach (WherePhrase p, _wheres) {
         if(q != "")
             q.append(" AND ");
         q.append(p.command(_database->sqlGenertor()));
@@ -284,6 +285,9 @@ Q_OUTOFLINE_TEMPLATE QString Query<T>::queryText()
 
     for(int i = 0; i < _database->model().count(); i++)
         command = command.replace(_database->model().at(i)->className() + "." , _database->model().at(i)->name() + ".");
+
+    qDebug() << command
+             << _database->sqlGenertor()->selectCommand(_wheres, _orders, _tableName, _joinClassName);
     return command;
 }
 

src/sqlgeneratorbase.cpp

@@ -23,6 +23,7 @@
 #include <QTime>
 #include <QVariant>
 
+#include "database.h"
 #include "databasemodel.h"
 #include "sqlgeneratorbase_p.h"
 #include "table.h"
@@ -30,9 +31,10 @@
 
 QT_BEGIN_NAMESPACE
 
-SqlGeneratorBase::SqlGeneratorBase(QObject *parent) : QObject(parent)
+SqlGeneratorBase::SqlGeneratorBase(Database *parent) : QObject((QObject*)parent)
 {
-
+    if(parent)
+        _database = parent;
 }
 
 SqlGeneratorBase::~SqlGeneratorBase()
@@ -249,5 +251,78 @@ QString SqlGeneratorBase::escapeFieldValue(QVariant &field) const
     }
 }
 
+QString SqlGeneratorBase::createWhere(QList<WherePhrase> &wheres)
+{
+    QString whereText = "";
+    foreach (WherePhrase p, wheres) {
+        if(whereText != "")
+            whereText.append(" AND ");
+        whereText.append(p.command(this));
+    }
+    if(whereText != "")
+        whereText.prepend(" WHERE ");
+
+    return whereText;
+}
+
+QString SqlGeneratorBase::selectCommand(QList<WherePhrase> &wheres, QHash<QString, QString> &orders, QString tableName, QString joinClassName)
+{
+    QString orderText = "";
+    QStringList orderby;
+
+    QString whereText = createWhere(wheres);
+
+    QString tableNameText = tableName;
+    if(!joinClassName.isNull()){
+        QString joinTableName = _database->tableName(joinClassName);
+        RelationModel *rel = _database->model().relationByTableNames(tableName, joinTableName);
+        if(rel){
+            QString pk = _database->model().model(tableName)->primaryKey();
+            tableNameText  = QString("%1 INNER JOIN %2 ON (%1.%3 = %2.%4)")
+                    .arg(tableName)
+                    .arg(joinTableName)
+                    .arg(pk)
+                    .arg(rel->localColumn);
+            orderby.append(tableName + "." + pk);
+        }else{
+            qWarning(QString("Relation between table %1 and class %2 (%3) not exists!")
+                     .arg(tableName)
+                     .arg(joinClassName)
+                     .arg(joinTableName.isNull() ? "NULL" : joinTableName)
+                     .toLatin1().data());
+            joinClassName = QString::null;
+        }
+    }
+
+    if(orders.count())
+        foreach (QString o, orders.keys())
+//            orderby.append(o + (orders.value(o) ? " ASC" : " DESC"));
+            orderby.append(o + " " + orders.value(o));
+
+    if(orderby.count())
+        orderText = " ORDER BY " + orderby.join(", ");
+
+    QString command = "SELECT * FROM "
+            + tableNameText
+            + whereText
+            + orderText;
+
+    for(int i = 0; i < _database->model().count(); i++)
+        command = command.replace(_database->model().at(i)->className() + "." , _database->model().at(i)->name() + ".");
+    return command;
+
+}
+
+QString SqlGeneratorBase::deleteCommand(QList<WherePhrase> &wheres, QString tableName)
+{
+    QString command = "DELETE FROM "
+            + tableName
+            + createWhere(wheres);
+
+    for(int i = 0; i < _database->model().count(); i++)
+        command = command.replace(_database->model().at(i)->className() + "." , _database->model().at(i)->name() + ".");
+    return command;
+}
+
 
 QT_END_NAMESPACE

src/sqlgeneratorbase_p.h

@@ -31,10 +31,22 @@ class Table;
 struct FieldModel;
 class DatabaseModel;
 class TableModel;
+class WherePhrase;
+class Database;
 class SqlGeneratorBase : public QObject
 {
+//    Q_OBJECT
+
+    Database *_database;
 public:
-    SqlGeneratorBase(QObject *parent = 0);
+    enum CommandType{
+        Select,
+        Insert,
+        Update,
+        Delete
+    };
+
+    SqlGeneratorBase(Database *parent);
     virtual ~SqlGeneratorBase();
 
     virtual QString masterDatabaseName(QString databaseName);
@@ -55,6 +67,14 @@ public:
     virtual QString deleteRecords(QString tableName, QString where);
 
     virtual QString escapeFieldValue(QVariant &field) const;
+
+    virtual QString selectCommand(QList<WherePhrase> &wheres, QHash<QString, QString>  &orders,
+                                  QString tableName, QString joinClassName);
+
+    virtual QString deleteCommand(QList<WherePhrase> &wheres, QString tableName);
+
+private:
+    QString createWhere(QList<WherePhrase> &wheres);
 };
 
 QT_END_NAMESPACE

src/sqlitegenerator.cpp

@@ -22,7 +22,7 @@
 #include "table.h"
 #include "tablemodel.h"
 
-SqliteGenerator::SqliteGenerator(QObject *parent) : SqlGeneratorBase(parent)
+SqliteGenerator::SqliteGenerator(Database *parent) : SqlGeneratorBase(parent)
 {
 
 }
@@ -52,9 +52,9 @@ QString SqliteGenerator::fieldType(FieldModel *field)
         dbType = "real";
         break;
     case QVariant::Int:
-        if(field->isPrimaryKey)
-            dbType = "INTEGER PRIMARY KEY";
-        else
+//        if(field->isPrimaryKey)
+//            dbType = "INTEGER PRIMARY KEY";
+//        else
             dbType = "integer";
         break;
     case QVariant::String:

src/sqlitegenerator.h

@@ -27,7 +27,7 @@
 class SqliteGenerator : public SqlGeneratorBase
 {
 public:
-    SqliteGenerator(QObject *parent = 0);
+    SqliteGenerator(Database *parent = 0);
 
     QString fieldType(FieldModel *field);
 };

src/sqlservergenerator.cpp

@@ -26,7 +26,7 @@
 
 QT_BEGIN_NAMESPACE
 
-SqlServerGenerator::SqlServerGenerator(QObject *parent) : SqlGeneratorBase(parent)
+SqlServerGenerator::SqlServerGenerator(Database *parent) : SqlGeneratorBase(parent)
 {
 
 }

src/sqlservergenerator.h

@@ -29,7 +29,7 @@ QT_BEGIN_NAMESPACE
 class SqlServerGenerator : public SqlGeneratorBase
 {
 public:
-    SqlServerGenerator(QObject *parent = 0);
+    SqlServerGenerator(Database *parent = 0);
     
     QString masterDatabaseName(QString databaseName);
 

src/wherephrase.cpp

@@ -172,47 +172,47 @@ QString PhraseData::command(SqlGeneratorBase *generator) const
 }
 
 
-FieldPhrase::FieldPhrase(const char *className, const char *s) : willDeleteData(false)
+WherePhrase::WherePhrase(const char *className, const char *s) : willDeleteData(false)
 {
     data = new PhraseData(className, s);
     text = QString(className) + "." + s;
 }
 
-FieldPhrase::FieldPhrase(PhraseData *l) : willDeleteData(false)
+WherePhrase::WherePhrase(PhraseData *l) : willDeleteData(false)
 {
     data = l;
 }
 
-FieldPhrase::FieldPhrase(PhraseData *l, PhraseData::Condition o) : willDeleteData(false)
+WherePhrase::WherePhrase(PhraseData *l, PhraseData::Condition o) : willDeleteData(false)
 {
     data = new PhraseData(l, o);
 }
 
 
-FieldPhrase::FieldPhrase(PhraseData *l, PhraseData::Condition o, PhraseData *r) : willDeleteData(false)
+WherePhrase::WherePhrase(PhraseData *l, PhraseData::Condition o, PhraseData *r) : willDeleteData(false)
 {
     data = new PhraseData(l, o, r);
 }
 
-FieldPhrase::FieldPhrase(PhraseData *l, PhraseData::Condition o, QVariant r) : willDeleteData(false)
+WherePhrase::WherePhrase(PhraseData *l, PhraseData::Condition o, QVariant r) : willDeleteData(false)
 {
     data = new PhraseData(l, o, r);
 }
 
-FieldPhrase::~FieldPhrase()
+WherePhrase::~WherePhrase()
 {
 //    if(willDeleteData)
 //        delete data;
 }
 
 
-QString FieldPhrase::command(SqlGeneratorBase *generator)
+QString WherePhrase::command(SqlGeneratorBase *generator)
 {
     willDeleteData = true;
     return data->command(generator);
 }
 
-void FieldPhrase::deleteData(PhraseData *d)
+void WherePhrase::deleteData(PhraseData *d)
 {
     deleteData(d);
     if(d->type == PhraseData::WithOther){
@@ -223,125 +223,132 @@ void FieldPhrase::deleteData(PhraseData *d)
         delete d->left;
 }
 
-FieldPhrase FieldPhrase::operator ==(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Equal, other.data);
+WherePhrase WherePhrase::operator ==(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Equal, other.data);
 }
 
-FieldPhrase FieldPhrase::operator !=(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::NotEqual, other.data);
+WherePhrase WherePhrase::operator !=(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::NotEqual, other.data);
 }
 
-FieldPhrase FieldPhrase::operator <(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Less, other.data);
+WherePhrase WherePhrase::operator <(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Less, other.data);
 }
 
-FieldPhrase FieldPhrase::operator >(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Greater, other.data);
+WherePhrase WherePhrase::operator >(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Greater, other.data);
 }
 
-FieldPhrase FieldPhrase::operator <=(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::LessEqual, other.data);
+WherePhrase WherePhrase::operator <=(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::LessEqual, other.data);
 }
 
-FieldPhrase FieldPhrase::operator >=(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::GreaterEqual, other.data);
+WherePhrase WherePhrase::operator >=(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::GreaterEqual, other.data);
 }
 
-FieldPhrase FieldPhrase::operator =(const FieldPhrase &other)
+WherePhrase WherePhrase::operator =(const WherePhrase &other)
 {
-    return FieldPhrase(this->data, PhraseData::Set, other.data);
+    return WherePhrase(this->data, PhraseData::Set, other.data);
 }
 
-FieldPhrase FieldPhrase::operator +(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Add, other.data);
+WherePhrase WherePhrase::operator +(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Add, other.data);
 }
 
-FieldPhrase FieldPhrase::operator -(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Minus, other.data);
+WherePhrase WherePhrase::operator -(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Minus, other.data);
 }
 
-FieldPhrase FieldPhrase::operator *(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Multiple, other.data);
+WherePhrase WherePhrase::operator *(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Multiple, other.data);
 }
 
-FieldPhrase FieldPhrase::operator /(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Divide, other.data);
+WherePhrase WherePhrase::operator /(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Divide, other.data);
 }
 
-FieldPhrase FieldPhrase::operator &&(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::And, other.data);
+WherePhrase WherePhrase::operator &&(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::And, other.data);
 }
 
-FieldPhrase FieldPhrase::operator ||(const FieldPhrase &other){
-    return FieldPhrase(this->data, PhraseData::Or, other.data);
+WherePhrase WherePhrase::operator ||(const WherePhrase &other){
+    return WherePhrase(this->data, PhraseData::Or, other.data);
 }
 
-FieldPhrase FieldPhrase::operator &(const FieldPhrase &other)
+WherePhrase WherePhrase::operator &(const WherePhrase &other)
 {
-    return FieldPhrase(this->data, PhraseData::Append, other.data);
+    return WherePhrase(this->data, PhraseData::Append, other.data);
 }
 
-FieldPhrase FieldPhrase::operator ,(const FieldPhrase &other)
-{
-    return FieldPhrase(this->data, PhraseData::Append, other.data);
-}
-
-FieldPhrase FieldPhrase::operator !(){
+WherePhrase FieldPhrase::operator !(){
     if(data->operatorCond < 20)
         data->operatorCond = (PhraseData::Condition)((data->operatorCond + 10) % 20);
     else
         qFatal("Operator ! can not aplied to non condition statements");
 
-    return FieldPhrase(data);
+    return WherePhrase(data);
 }
 
-FieldPhrase FieldPhrase::operator ==(const QVariant &other){
-    return FieldPhrase(this->data, PhraseData::Equal, other);
+WherePhrase WherePhrase::operator ==(const QVariant &other){
+    return WherePhrase(this->data, PhraseData::Equal, other);
 }
 
-FieldPhrase FieldPhrase::operator !=(const QVariant &other){
-    return FieldPhrase(this->data, PhraseData::NotEqual, other);
+WherePhrase WherePhrase::operator !=(const QVariant &other){
+    return WherePhrase(this->data, PhraseData::NotEqual, other);
 }
 
-FieldPhrase FieldPhrase::operator <(const QVariant &other){
-    return FieldPhrase(this->data, PhraseData::Less, other);
+WherePhrase WherePhrase::operator <(const QVariant &other){
+    return WherePhrase(this->data, PhraseData::Less, other);
 }
 
-FieldPhrase FieldPhrase::operator >(const QVariant &other){
+WherePhrase WherePhrase::operator >(const QVariant &other){
     qDebug() << "var";
-    return FieldPhrase(this->data, PhraseData::Greater, other);
+    return WherePhrase(this->data, PhraseData::Greater, other);
 }
 
-FieldPhrase FieldPhrase::operator <=(const QVariant &other){
-    return FieldPhrase(this->data, PhraseData::LessEqual, other);
+WherePhrase WherePhrase::operator <=(const QVariant &other){
+    return WherePhrase(this->data, PhraseData::LessEqual, other);
 }
 
-FieldPhrase FieldPhrase::operator >=(const QVariant &other){
-    return FieldPhrase(this->data, PhraseData::GreaterEqual, other);
+WherePhrase WherePhrase::operator >=(const QVariant &other){
+    return WherePhrase(this->data, PhraseData::GreaterEqual, other);
 }
 
-FieldPhrase FieldPhrase::operator =(const QVariant &other)
+WherePhrase FieldPhrase::operator =(const QVariant &other)
 {
-    return FieldPhrase(this->data, PhraseData::Set, other);
+    return WherePhrase(this->data, PhraseData::Set, other);
 }
 
-FieldPhrase FieldPhrase::isNull(){
-    return FieldPhrase(this->data, PhraseData::Null);
-}
-
-FieldPhrase FieldPhrase::in(QVariantList list)
+FieldPhrase::FieldPhrase(const char *className, const char *s) : WherePhrase(className, s)
 {
-    return FieldPhrase(this->data, PhraseData::In, list);
+    data = new PhraseData(className, s);
+    text = QString(className) + "." + s;
 }
 
-FieldPhrase FieldPhrase::in(QStringList list)
+WherePhrase FieldPhrase::operator &(const QVariant &other)
 {
-    return FieldPhrase(this->data, PhraseData::In, list);
+    Q_UNUSED(other);
+    qFatal("The operator & can not applied for two fields");
 }
 
-FieldPhrase FieldPhrase::like(QString pattern)
+WherePhrase FieldPhrase::isNull(){
+    return WherePhrase(this->data, PhraseData::Null);
+}
+
+WherePhrase FieldPhrase::in(QVariantList list)
 {
-    return FieldPhrase(this->data, PhraseData::Like, pattern);
+    return WherePhrase(this->data, PhraseData::In, list);
+}
+
+WherePhrase FieldPhrase::in(QStringList list)
+{
+    return WherePhrase(this->data, PhraseData::In, list);
+}
+
+WherePhrase FieldPhrase::like(QString pattern)
+{
+    return WherePhrase(this->data, PhraseData::Like, pattern);
 }
 
 QT_END_NAMESPACE

src/wherephrase.h

@@ -28,7 +28,6 @@
 #include <QDateTime>
 #include <QTime>
 
-
 QT_BEGIN_NAMESPACE
 
 class SqlGeneratorBase;
@@ -88,62 +87,71 @@ struct PhraseData{
     QString command(SqlGeneratorBase *generator) const;
 };
 
-class FieldPhrase{
+class WherePhrase{
+protected:
     PhraseData *data;
     bool willDeleteData;
+
 public:
 
     QString text;
 
-    FieldPhrase(const char *className, const char* s);
+    WherePhrase(const char *className, const char* s);
 
-    FieldPhrase(PhraseData *l);
-    FieldPhrase(PhraseData *l, PhraseData::Condition o);
-    FieldPhrase(PhraseData *l, PhraseData::Condition o, PhraseData *r);
-    FieldPhrase(PhraseData *l, PhraseData::Condition o, QVariant r);
+    WherePhrase(PhraseData *l);
+    WherePhrase(PhraseData *l, PhraseData::Condition o);
+    WherePhrase(PhraseData *l, PhraseData::Condition o, PhraseData *r);
+    WherePhrase(PhraseData *l, PhraseData::Condition o, QVariant r);
 
-    ~FieldPhrase();
+    ~WherePhrase();
 
     QString command(SqlGeneratorBase *generator);
 
     void deleteData(PhraseData *d);
 
-    FieldPhrase operator ==(const FieldPhrase &other);
-    FieldPhrase operator !=(const FieldPhrase &other);
-    FieldPhrase operator <(const FieldPhrase &other);
-    FieldPhrase operator >(const FieldPhrase &other);
-    FieldPhrase operator <=(const FieldPhrase &other);
-    FieldPhrase operator >=(const FieldPhrase &other);
+    WherePhrase operator ==(const WherePhrase &other);
+    WherePhrase operator !=(const WherePhrase &other);
+    WherePhrase operator <(const WherePhrase &other);
+    WherePhrase operator >(const WherePhrase &other);
+    WherePhrase operator <=(const WherePhrase &other);
+    WherePhrase operator >=(const WherePhrase &other);
 
-    FieldPhrase operator =(const FieldPhrase &other);
+    WherePhrase operator =(const WherePhrase &other);
 
-    FieldPhrase operator +(const FieldPhrase &other);
-    FieldPhrase operator -(const FieldPhrase &other);
-    FieldPhrase operator *(const FieldPhrase &other);
-    FieldPhrase operator /(const FieldPhrase &other);
+    WherePhrase operator +(const WherePhrase &other);
+    WherePhrase operator -(const WherePhrase &other);
+    WherePhrase operator *(const WherePhrase &other);
+    WherePhrase operator /(const WherePhrase &other);
 
-    FieldPhrase operator &&(const FieldPhrase &other);
-    FieldPhrase operator ||(const FieldPhrase &other);
+    WherePhrase operator &&(const WherePhrase &other);
+    WherePhrase operator ||(const WherePhrase &other);
 
-    FieldPhrase operator &(const FieldPhrase &other);
+    WherePhrase operator &(const WherePhrase &other);
 
-    FieldPhrase operator ,(const FieldPhrase &other);
 
-    FieldPhrase operator !();
+    WherePhrase operator ==(const QVariant &other);
+    WherePhrase operator !=(const QVariant &other);
+    WherePhrase operator <(const QVariant &other);
+    WherePhrase operator >(const QVariant &other);
+    WherePhrase operator <=(const QVariant &other);
+    WherePhrase operator >=(const QVariant &other);
 
-    FieldPhrase operator ==(const QVariant &other);
-    FieldPhrase operator !=(const QVariant &other);
-    FieldPhrase operator <(const QVariant &other);
-    FieldPhrase operator >(const QVariant &other);
-    FieldPhrase operator <=(const QVariant &other);
-    FieldPhrase operator >=(const QVariant &other);
 
-    FieldPhrase operator =(const QVariant &other);
+};
 
-    FieldPhrase isNull();
-    FieldPhrase in(QVariantList list);
-    FieldPhrase in(QStringList list);
-    FieldPhrase like(QString pattern);
+class FieldPhrase: public WherePhrase{
+public:
+    FieldPhrase(const char *className, const char* s);
+
+    WherePhrase operator &(const QVariant &other);
+
+    WherePhrase operator =(const QVariant &other);
+    WherePhrase operator !();
+
+    WherePhrase isNull();
+    WherePhrase in(QVariantList list);
+    WherePhrase in(QStringList list);
+    WherePhrase like(QString pattern);
 };
 
 QT_END_NAMESPACE

test/basic/maintest.cpp

@@ -18,7 +18,6 @@ MainTest::MainTest(QObject *parent) : QObject(parent)
 
 void MainTest::initTestCase()
 {
-//    qDebug() << "Table type id:" << qRegisterMetaType<Table*>();
     qDebug() << "User type id:" << qRegisterMetaType<Post*>();
     qDebug() << "Comment type id:" << qRegisterMetaType<Comment*>();
     qDebug() << "DB type id:" << qRegisterMetaType<WeblogDatabase*>();
@@ -30,21 +29,6 @@ void MainTest::initTestCase()
 //    db.setUserName("sa");
 //    db.setPassword("qwe123!@#");
 
-    QStringList list;
-    list << "one" << "two" << "three";
-    FieldPhrase q = (Post::idField() = 1)
-            & (Post::saveDateField() = QDateTime::currentDateTime())
-            & (Post::saveDateField() < QDateTime::currentDateTime()
-//            (/*(Post::saveDateField() > Post::idField())
-//                     && */
-//                     !Post::saveDateField().isNull()
-//                     &&
-//                      !Post::idField().in(list)
-//                     || (Post::idField() == 4)
-//                     && Post::saveDateField() >= QDateTime::currentDateTime()
-                     /*|| Post::saveDateField().isNull()*/);
-    qDebug() << "Command="<< q.command(0);
-    QTEST_ASSERT(1==2);
     // postgres
     db.setDriver("QPSQL");
     db.setHostName("127.0.0.1");
@@ -98,9 +82,12 @@ void MainTest::createPost()
 
 void MainTest::selectPosts()
 {
-    q = FROM(db.posts())
-        JOIN(Comment)
-        WHERE(Post::idField() == postId);
+//    auto q = FROM(db.posts())
+//        JOIN(Comment)
+//        WHERE(Post::idField() == postId);
+    auto q = db.posts()->createQuery();
+    q->join("Comment");
+    q->setWhere(Post::idField() == postId);
 
     auto posts = q->toList();
 
@@ -181,4 +168,5 @@ void MainTest::deletePost()
     QTEST_ASSERT(count == 0);
 }
 
+
 QTEST_MAIN(MainTest)

test/basic/maintest.h

@@ -12,7 +12,6 @@ class MainTest : public QObject
     WeblogDatabase db;
     int postId;
     Post *post;
-    Query<Post> *q;
 public:
     explicit MainTest(QObject *parent = 0);
 

test/basic/tst_basic.pro

@@ -0,0 +1,21 @@
+QT       += qml quick testlib sql
+QT       -= gui
+
+TARGET = tst_nut
+TEMPLATE = app
+
+CONFIG   += warn_on qmltestcase c++11
+INCLUDEPATH += $$PWD/../../src $$PWD/../common
+include(../../nut.pri)
+IMPORTPATH += $$OUT_PWD/../src/imports
+SOURCES += \
+    maintest.cpp \
+    ../common/comment.cpp \
+    ../common/post.cpp \
+    ../common/weblogdatabase.cpp
+
+HEADERS += \
+    maintest.h \
+    ../common/comment.h \
+    ../common/post.h \
+    ../common/weblogdatabase.h

test/benckmark/maintest.cpp

@@ -0,0 +1,68 @@
+#include <QtTest>
+#include <QJsonDocument>
+#include <QSqlError>
+
+#include "maintest.h"
+#include "query.h"
+#include "tableset.h"
+#include "tablemodel.h"
+#include "databasemodel.h"
+
+#include "post.h"
+#include "comment.h"
+
+MainTest::MainTest(QObject *parent) : QObject(parent)
+{
+
+}
+
+void MainTest::initTestCase()
+{
+    qDebug() << "User type id:" << qRegisterMetaType<Post*>();
+    qDebug() << "Comment type id:" << qRegisterMetaType<Comment*>();
+    qDebug() << "DB type id:" << qRegisterMetaType<WeblogDatabase*>();
+
+    //sql server
+//    db.setDriver("QODBC");
+//    db.setHostName("127.0.0.1");
+//    db.setDatabaseName("DRIVER={SQL Server};Server=.;Database=Nut;Uid=sa;Port=1433;Pwd=qwe123!@#;WSID=.");
+//    db.setUserName("sa");
+//    db.setPassword("qwe123!@#");
+
+    // postgres
+    db.setDriver("QPSQL");
+    db.setHostName("127.0.0.1");
+    db.setDatabaseName("nutdb3");
+    db.setUserName("postgres");
+    db.setPassword("856856");
+
+// mysql
+//    db.setDriver("QMYSQL");
+//    db.setHostName("127.0.0.1");
+//    db.setDatabaseName("nutdb");
+//    db.setUserName("root");
+//    db.setPassword("onlyonlyi");
+
+    bool ok = db.open();
+
+    QTEST_ASSERT(ok);
+}
+
+void MainTest::insert1kPost()
+{
+    QTime t;
+    t.start();
+
+    for (int i = 0; i < 1000; ++i) {
+        Post *newPost = new Post;
+        newPost->setTitle("post title");
+        newPost->setSaveDate(QDateTime::currentDateTime());
+
+        db.posts()->append(newPost);
+    }
+    db.saveChanges();
+
+    qDebug("1k post inserted in %d ms", t.elapsed());
+}
+
+QTEST_MAIN(MainTest)

test/benckmark/maintest.h

@@ -0,0 +1,27 @@
+#ifndef MAINTEST_H
+#define MAINTEST_H
+
+#include <QtCore/QObject>
+#include <QtCore/qglobal.h>
+
+#include "weblogdatabase.h"
+class Post;
+class MainTest : public QObject
+{
+    Q_OBJECT
+    WeblogDatabase db;
+    int postId;
+    Post *post;
+    Query<Post> *q;
+public:
+    explicit MainTest(QObject *parent = 0);
+
+signals:
+
+private slots:
+    void initTestCase();
+
+    void insert1kPost();
+};
+
+#endif // MAINTEST_H

test/benckmark/tst_benchmark.pro

@@ -0,0 +1,21 @@
+QT       += qml quick testlib sql
+
+QT       -= gui
+
+TARGET = tst_nut
+CONFIG   += warn_on qmltestcase c++11
+INCLUDEPATH += $$PWD/../../src $$PWD/../common
+include(../../nut.pri)
+TEMPLATE = app
+IMPORTPATH += $$OUT_PWD/../src/imports
+SOURCES += \
+    maintest.cpp \
+    ../common/comment.cpp \
+    ../common/post.cpp \
+    ../common/weblogdatabase.cpp
+
+HEADERS += \
+    maintest.h \
+    ../common/comment.h \
+    ../common/post.h \
+    ../common/weblogdatabase.h

test/tst_nut.pro

@@ -1,21 +0,0 @@
-QT       += qml quick testlib sql
-
-QT       -= gui
-
-TARGET = tst_nut
-CONFIG   += warn_on qmltestcase c++11
-INCLUDEPATH += $$PWD/../src
-include(../nut.pri)
-TEMPLATE = app
-IMPORTPATH += $$OUT_PWD/../src/imports
-SOURCES += \
-    maintest.cpp \
-    comment.cpp \
-    post.cpp \
-    weblogdatabase.cpp
-
-HEADERS += \
-    maintest.h \
-    comment.h \
-    post.h \
-    weblogdatabase.h