Merge pull request #14 from HamedMasafi/master

Merge back from zerocopy[master] to dev

src/database.cpp

@@ -190,6 +190,7 @@ bool DatabasePrivate::getCurrectScheema()
 
     // TODO: change logs must not be in model
     int changeLogTypeId = qRegisterMetaType<ChangeLogTable*>();
+
     currentModel.append(
         new TableModel(changeLogTypeId, __CHANGE_LOG_TABLE_NAME));
     tables.insert(ChangeLogTable::staticMetaObject.className(),

src/databasemodel.cpp

@@ -57,6 +57,10 @@ DatabaseModel::DatabaseModel(const QJsonObject &json) :
     }
 }
 
+DatabaseModel::~DatabaseModel()
+{
+}
+
 TableModel *DatabaseModel::tableByName(QString tableName) const
 {
     for(int i = 0; i < size(); i++){
@@ -223,4 +227,16 @@ DatabaseModel *DatabaseModel::modelByName(const QString &name)
     return Q_NULLPTR;
 }
 
+void DatabaseModel::deleteAllModels()
+{
+    QMapIterator<QString, DatabaseModel*> i(_models);
+     while (i.hasNext()) {
+         i.next();
+//         cout << i.key() << ": " << i.value() << endl;
+         delete i.value();
+     }
+//    qDeleteAll(_models.values());
+    _models.clear();
+}
+
 NUT_END_NAMESPACE

src/databasemodel.h

@@ -43,7 +43,7 @@ public:
     DatabaseModel(const QString &name = QString::null);
     DatabaseModel(const DatabaseModel &other);
     DatabaseModel(const QJsonObject &json);
-//    DatabaseModel(DatabaseModel &model);
+    ~DatabaseModel();
 
     TableModel *tableByName(QString tableName) const;
     TableModel *tableByClassName(QString className) const;
@@ -70,6 +70,7 @@ public:
     void fixRelations();
 
     static DatabaseModel *modelByName(const QString &name);
+    static void deleteAllModels();
 };
 
 NUT_END_NAMESPACE

src/defines.h

@@ -33,7 +33,8 @@
 #endif
 
 #define NUT_INFO(type, name, value)                                            \
-    Q_CLASSINFO(__nut_NAME_PERFIX type #name #value, type "\n" #name "\n" #value)
+    Q_CLASSINFO(__nut_NAME_PERFIX type #name #value,                           \
+                type "\n" #name "\n" #value)
 
 // Database
 #define NUT_DB_VERSION(version)  \
@@ -48,7 +49,8 @@
 public:                                                                        \
     static const type _##name;                                                 \
     type* name() const{ return m_##name; }                                     \
-    NUT_WRAP_NAMESPACE(TableSet<type>) *name##Table() const { return m_##name##Table; }
+    NUT_WRAP_NAMESPACE(TableSet<type>) *name##Table() const                    \
+            { return m_##name##Table; }
 
 //Table
 #define NUT_DECLARE_FIELD(type, name, read, write)                             \
@@ -57,7 +59,9 @@ public:                                                                     \
     type m_##name;                                                             \
 public:                                                                        \
     static NUT_WRAP_NAMESPACE(FieldPhrase<type>) name ## Field(){              \
-        static NUT_WRAP_NAMESPACE(FieldPhrase<type>) f = NUT_WRAP_NAMESPACE(FieldPhrase<type>)(staticMetaObject.className(), #name);                          \
+        static NUT_WRAP_NAMESPACE(FieldPhrase<type>) f =                       \
+                NUT_WRAP_NAMESPACE(FieldPhrase<type>)                          \
+                        (staticMetaObject.className(), #name);                 \
         return f;                                                              \
     }                                                                          \
     type read() const{                                                         \

src/generators/sqlgeneratorbase.cpp

@@ -931,7 +931,9 @@ SqlGeneratorBase::operatorString(const PhraseData::Condition &cond) const
 
 void SqlGeneratorBase::appendSkipTake(QString &sql, int skip, int take)
 {
-
+    Q_UNUSED(sql);
+    Q_UNUSED(skip);
+    Q_UNUSED(take);
 }
 
 QString SqlGeneratorBase::createConditionalPhrase(const PhraseData *d) const

src/generators/sqlgeneratorbase_p.h

@@ -34,7 +34,7 @@ struct FieldModel;
 class DatabaseModel;
 class TableModel;
 class Database;
-class RelationModel;
+struct RelationModel;
 class SqlGeneratorBase : public QObject
 {
 //    Q_OBJECT

src/phrase.cpp

@@ -24,47 +24,71 @@
 
 NUT_BEGIN_NAMESPACE
 
-#define LOG(s) qDebug() << __func__ << s;
+#define LOG(s) qDebug() << __func__ << s
 
 PhraseData::PhraseData() :
     className(""), fieldName(""),
     type(Field), operatorCond(NotAssign),
-    left(0), right(0), operand(QVariant::Invalid), isNot(false)
+    left(0), right(0), operand(QVariant::Invalid), isNot(false), parents(1)
 { }
 
 PhraseData::PhraseData(const char *className, const char *fieldName) :
     className(className), fieldName(fieldName),
     type(Field), operatorCond(NotAssign),
-    left(0), right(0), operand(QVariant::Invalid), isNot(false)
+    left(0), right(0), operand(QVariant::Invalid), isNot(false), parents(1)
 { }
 
 PhraseData::PhraseData(PhraseData *l, PhraseData::Condition o)
     : className(0), fieldName(0),
-      type(WithoutOperand), operatorCond(o), left(new PhraseData(l)), right(0), isNot(false)
+      type(WithoutOperand), operatorCond(o), left(l), right(0),
-{ }
+      isNot(false), parents(1)
+{
+    l->parents++;
+}
 
 PhraseData::PhraseData(PhraseData *l, PhraseData::Condition o,
-                       const PhraseData *r)
+                       PhraseData *r)
     : className(0), fieldName(0),
-      type(WithOther), operatorCond(o), left(new PhraseData(l)), right(new PhraseData(r)), isNot(false)
+      type(WithOther), operatorCond(o),
-{ }
+      left(l), right(r),
+      isNot(false), parents(1)
+{
+    l->parents++;
+    r->parents++;
+}
 
 PhraseData::PhraseData(PhraseData *l, PhraseData::Condition o, QVariant r)
     : className(0), fieldName(0),
-      type(WithVariant), operatorCond(o), left(new PhraseData(l)), right(0), operand(r), isNot(false)
+      type(WithVariant), operatorCond(o), left(l),
+      right(0), operand(r), isNot(false), parents(1)
 { }
 
-PhraseData::PhraseData(const PhraseData &other) :
+PhraseData *PhraseData::operator =(PhraseData *other)
-    left(other.left), right(other.right), operand(other.operand),
+{
-    operatorCond(other.operatorCond), className(other.className),
+    LOG("");
-    fieldName(other.fieldName), type(other.type), isNot(other.isNot)
+    other->parents++;
-{ }
+    return other;
+}
 
-PhraseData::PhraseData(const PhraseData *other) :
+PhraseData &PhraseData::operator =(PhraseData &other)
-    left(other->left), right(other->right), operand(other->operand),
+{
-    operatorCond(other->operatorCond), className(other->className),
+    other.parents++;
-    fieldName(other->fieldName), type(other->type), isNot(other->isNot)
+    return other;
-{ }
+}
+
+//PhraseData::PhraseData(const PhraseData &other) :
+//    left(other.left), right(other.right), operand(other.operand),
+//    operatorCond(other.operatorCond), className(other.className),
+//    fieldName(other.fieldName), type(other.type), isNot(other.isNot),
+//    parents(other.parents + 1)
+//{ }
+
+//PhraseData::PhraseData(const PhraseData *other) :
+//    left(other->left), right(other->right), operand(other->operand),
+//    operatorCond(other->operatorCond), className(other->className),
+//    fieldName(other->fieldName), type(other->type), isNot(other->isNot),
+//    parents(other->parents + 1)
+//{ }
 
 QString PhraseData::toString() const
 {
@@ -81,10 +105,34 @@ PhraseData::~PhraseData()
 //        if (left)
 //            delete left;
 //    }
+
+//    if (right && !--right->parents)
+//        delete right;
+
+//    if (left && !--left->parents)
+//        delete left;
+
     LOG("");
 }
 
-AbstractFieldPhrase::AbstractFieldPhrase(const char *className, const char *fieldName)
+void PhraseData::cleanUp()
+{
+//    cleanUp(this);
+}
+
+void PhraseData::cleanUp(PhraseData *d)
+{
+    if (d->left)
+        cleanUp(d->left);
+    if (d->right)
+        cleanUp(d->right);
+}
+
+AbstractFieldPhrase::AbstractFieldPhrase(PhraseData *d) : data(d)
+{ }
+
+AbstractFieldPhrase::AbstractFieldPhrase(const char *className,
+                                         const char *fieldName)
     :data(new PhraseData(className, fieldName))
 {
     qDebug() <<"AbstractFieldPhrase created"<<className<<fieldName;
@@ -92,21 +140,30 @@ AbstractFieldPhrase::AbstractFieldPhrase(const char *className, const char *fiel
 
 AbstractFieldPhrase::AbstractFieldPhrase(const AbstractFieldPhrase &other)
 {
-    qDebug() <<"4444444444444444";
+    data = other.data;
-    data = new PhraseData(other.data);
+    data->parents++;
+    qDebug() <<"Copy ctor"<<other.data->toString()<<other.data->parents;
+}
+
+AbstractFieldPhrase::AbstractFieldPhrase(AbstractFieldPhrase &&other)
+{
+    data = other.data;
+    data->parents++;
+    other.data = 0;
 }
 
 AbstractFieldPhrase::~AbstractFieldPhrase()
 {
     if (data) {
-        LOG(data->toString());
+        LOG(data->toString()) << data->parents;
     } else {
         LOG("");
     }
 
     if (data) {
+        --data->parents;
+        if (data->parents <= 0)
             delete data;
-        data = 0;
     }
 }
 
@@ -121,9 +178,11 @@ ConditionalPhrase AbstractFieldPhrase::isNull()
 }
 
 
-ConditionalPhrase AbstractFieldPhrase::operator ==(const ConditionalPhrase &other)
+ConditionalPhrase AbstractFieldPhrase::operator ==(const ConditionalPhrase
+                                                   &other)
 {
-    return ConditionalPhrase(this, PhraseData::Equal, const_cast<ConditionalPhrase&>(other));
+    return ConditionalPhrase(this, PhraseData::Equal,
+                             const_cast<ConditionalPhrase&>(other));
 }
 
 #define AbstractFieldPhraseOperatorVariant(class, op, cond) \
@@ -150,9 +209,8 @@ AbstractFieldPhraseOperatorField(>=, PhraseData::GreaterEqual)
 
 AbstractFieldPhrase AbstractFieldPhrase::operator !()
 {
-    //TODO: classname and s
+
     AbstractFieldPhrase f(data->className, data->fieldName);
-    f.data = new PhraseData(data);
     f.data->isNot = !data->isNot;
     return f;
 }
@@ -174,56 +232,88 @@ PhraseList::PhraseList() : isValid(false)
 
 PhraseList::PhraseList(const PhraseList &other) : isValid(true)
 {
+    LOG("");
     data = qMove(other.data);
+    const_cast<PhraseList&>(other).data.clear();
+}
+
+PhraseList::PhraseList(PhraseList &&other)
+{
+    LOG("");
+    data = other.data;
 }
 
 PhraseList::PhraseList(const AbstractFieldPhrase &other) : isValid(true)
 {
-    data.append(new PhraseData(other.data));
+    data.append(other.data);
+    incAllDataParents();
 }
 
-PhraseList::PhraseList(const AbstractFieldPhrase *left, const AbstractFieldPhrase &right)
+PhraseList::PhraseList(const AbstractFieldPhrase *left,
+                       const AbstractFieldPhrase &right)
     : isValid(true)
 {
-    data.append(new PhraseData(left->data));
+    data.append(left->data);
-    data.append(new PhraseData(right.data));
+    data.append(right.data);
+    incAllDataParents();
 }
 
 PhraseList::PhraseList(PhraseList *left, PhraseList *right) : isValid(true)
 {
-    data = qMove(left->data + right->data);
+//    data = qMove(left->data + right->data);
+    data.append(left->data);
+    data.append(right->data);
+//    left->data.clear();
+//    right->data.clear();
 }
 
 PhraseList::PhraseList(PhraseList *left, const AbstractFieldPhrase *right)
     : isValid(true)
 {
-    data = left->data;
+    data.append(left->data);
-    data.append(new PhraseData(right->data));
+    data.append(right->data);
+    incAllDataParents();
 }
 
 PhraseList::~PhraseList()
 {
-//    data.clear();
+    LOG("");
+}
+
+PhraseList &PhraseList::operator =(const PhraseList &other)
+{
+    data.append(const_cast<PhraseList&>(other).data);
+    return *this;
 }
 
 PhraseList PhraseList::operator |(const AbstractFieldPhrase &other) {
     return PhraseList(this, &other);
 }
 
+void PhraseList::incAllDataParents()
+{
+//    foreach (PhraseData *d, data)
+//        d->parents++;
+}
+
 PhraseList PhraseList::operator |(PhraseList &other) {
     return PhraseList(this, &other);
 }
 
 AssignmentPhrase::AssignmentPhrase(PhraseData *d) : data(d)
-{ }
+{
+    d->parents++;
+}
 
 AssignmentPhrase::AssignmentPhrase(AbstractFieldPhrase *l, const QVariant r)
 {
+
     data = new PhraseData(l->data, PhraseData::Equal, r);
 //    l->data = 0;
 }
 
-AssignmentPhrase::AssignmentPhrase(AbstractFieldPhrase *l, const AssignmentPhrase *r)
+AssignmentPhrase::AssignmentPhrase(AbstractFieldPhrase *l,
+                                   const AssignmentPhrase *r)
 {
     data = new PhraseData(l->data, PhraseData::Equal, r->data);
     //    l->data = 0;
@@ -243,6 +333,7 @@ AssignmentPhrase::AssignmentPhrase(AssignmentPhrase *ph, const QVariant &v)
 AssignmentPhrase::~AssignmentPhrase()
 {
     if (data)
+        if (!--data->parents)
             delete data;
 }
 
@@ -265,44 +356,62 @@ AssignmentPhraseList::AssignmentPhraseList()
 AssignmentPhraseList::AssignmentPhraseList(const AssignmentPhrase &l)
 {
     data.append(l.data);
+    incAllDataParents();
 }
 
-AssignmentPhraseList::AssignmentPhraseList(AssignmentPhraseList *l, const AssignmentPhrase *r)
+AssignmentPhraseList::AssignmentPhraseList(AssignmentPhraseList *l,
+                                           const AssignmentPhrase *r)
 {
     data.append(l->data);
     data.append(r->data);
+    incAllDataParents();
 }
 
-AssignmentPhraseList::AssignmentPhraseList(AssignmentPhrase *l, const AssignmentPhrase *r)
+AssignmentPhraseList::AssignmentPhraseList(AssignmentPhrase *l,
+                                           const AssignmentPhrase *r)
 {
     data.append(l->data);
     data.append(r->data);
+    incAllDataParents();
 }
 
-AssignmentPhraseList::AssignmentPhraseList(const AssignmentPhrase &r, const AssignmentPhrase &l)
+AssignmentPhraseList::AssignmentPhraseList(const AssignmentPhrase &r,
+                                           const AssignmentPhrase &l)
 {
     data.append(l.data);
     data.append(r.data);
+    incAllDataParents();
 }
 
-AssignmentPhraseList AssignmentPhraseList::operator &(const AssignmentPhrase &ph)
+AssignmentPhraseList AssignmentPhraseList::operator &(const AssignmentPhrase
+                                                      &ph)
 {
     return AssignmentPhraseList(this, &ph);
 }
 
 AssignmentPhraseList::~AssignmentPhraseList()
 {
+    foreach (PhraseData *d, data)
+        if (!--d->parents)
+            delete d;
 //    qDeleteAll(data);
     //    data.clear();
 }
 
+void AssignmentPhraseList::incAllDataParents()
+{
+    foreach (PhraseData *d, data)
+        d->parents++;
+}
+
 ConditionalPhrase::ConditionalPhrase() : data(0)
 { }
 
 ConditionalPhrase::ConditionalPhrase(const ConditionalPhrase &other)
 {
     qDebug() << "************* ctor called:";
-    this->data = new PhraseData(other.data);
+    data = other.data;
+    data->parents++;
 //    const_cast<ConditionalPhrase&>(other).data = 0;
 }
 
@@ -316,7 +425,8 @@ ConditionalPhrase::ConditionalPhrase(const ConditionalPhrase &&other)
 
 ConditionalPhrase::ConditionalPhrase(const PhraseData *data)
 {
-    this->data = new PhraseData(data);
+    this->data = const_cast<PhraseData*>(data);
+    this->data->parents++;
 }
 
 ConditionalPhrase::ConditionalPhrase(AbstractFieldPhrase *l,
@@ -375,13 +485,17 @@ ConditionalPhrase::ConditionalPhrase(ConditionalPhrase *l,
 ConditionalPhrase::~ConditionalPhrase()
 {
     LOG("");
-    if (data)
+    if (data) {
+        data->cleanUp();
+        if (!--data->parents)
             delete data;
     }
+}
 
 ConditionalPhrase &ConditionalPhrase::operator =(const ConditionalPhrase &other)
 {
-    this->data = new PhraseData(other.data);
+    data = other.data;
+    data->parents++;
     return *this;
 }
 
@@ -408,33 +522,40 @@ ConditionalPhrase ConditionalPhrase::operator ==(const QVariant &other)
 //}
 
 #define DECLARE_CONDITIONALPHRASE_OPERATORS(op, cond) \
-ConditionalPhrase operator op(const ConditionalPhrase &l, const ConditionalPhrase &r) \
+ConditionalPhrase operator op(const ConditionalPhrase &l, \
-{ \
+                              const ConditionalPhrase &r) \
-    ConditionalPhrase p; \
-    p.data = new PhraseData; \
-    p.data->operatorCond = cond; \
-    p.data->left = new PhraseData(l.data); \
-    p.data->right = new PhraseData(r.data); \
-    return p; \
-} \
-ConditionalPhrase operator op(const ConditionalPhrase &l, ConditionalPhrase &&r) \
-{ \
-    ConditionalPhrase p; \
-    p.data = new PhraseData; \
-    p.data->operatorCond = cond; \
-    p.data->left = new PhraseData(l.data); \
-    p.data->right = r.data; \
-    r.data = 0; \
-    return p; \
-} \
-ConditionalPhrase operator op(ConditionalPhrase &&l, const ConditionalPhrase &r) \
 { \
     ConditionalPhrase p; \
     p.data = new PhraseData; \
     p.data->operatorCond = cond; \
     p.data->left = l.data; \
-    l.data = 0; \
+    p.data->right = r.data; \
-    p.data->right = new PhraseData(r.data); \
+    l.data->parents++;  \
+    r.data->parents++;  \
+    return p; \
+} \
+ConditionalPhrase operator op(const ConditionalPhrase &l, \
+                              ConditionalPhrase &&r) \
+{ \
+    ConditionalPhrase p; \
+    p.data = new PhraseData; \
+    p.data->operatorCond = cond; \
+    p.data->left = l.data; \
+    p.data->right = r.data; \
+    l.data->parents++;  \
+    r.data->parents++;  \
+    return p; \
+} \
+ConditionalPhrase operator op(ConditionalPhrase &&l, \
+                              const ConditionalPhrase &r) \
+{ \
+    ConditionalPhrase p; \
+    p.data = new PhraseData; \
+    p.data->operatorCond = cond; \
+    p.data->left = l.data; \
+    p.data->right = r.data; \
+    l.data->parents++;  \
+    r.data->parents++;  \
     return p; \
 } \
 ConditionalPhrase operator op(ConditionalPhrase &&l, ConditionalPhrase &&r) \
@@ -444,7 +565,8 @@ ConditionalPhrase operator op(ConditionalPhrase &&l, ConditionalPhrase &&r) \
     p.data->operatorCond = cond; \
     p.data->left = l.data; \
     p.data->right = r.data; \
-    l.data = r.data = 0; \
+    l.data->parents++;  \
+    r.data->parents++;  \
     return p; \
 }
 
@@ -459,6 +581,42 @@ ConditionalPhrase ConditionalPhrase::operator !()
     return f;
 }
 
+PhraseDataList::PhraseDataList() : QList<PhraseData*>()
+{
+
+}
+
+PhraseDataList::PhraseDataList(const PhraseDataList &other) : QList<PhraseData*>()
+{
+    PhraseDataList &o = const_cast<PhraseDataList&>(other);
+    PhraseDataList::iterator i;
+    for (i = o.begin(); i != o.end(); ++i)
+        append(*i);
+}
+
+void PhraseDataList::append(PhraseData *d)
+{
+    d->parents++;
+    QList<PhraseData*>::append(d);
+}
+
+void PhraseDataList::append(QList<PhraseData *> &dl)
+{
+    foreach (PhraseData *d, dl)
+        d->parents++;
+    QList<PhraseData*>::append(dl);
+}
+
+PhraseDataList::~PhraseDataList()
+{
+    QList<PhraseData*>::iterator i;
+    for (i = begin(); i != end(); ++i) {
+        (*i)->cleanUp();
+        if (!--(*i)->parents)
+            delete *i;
+    }
+}
+
 //AssignmentPhraseList operator &(const AssignmentPhrase &l, const AssignmentPhrase &r)
 //{
 //    return AssignmentPhraseList(l, r);

src/phrase.h

@@ -92,24 +92,42 @@ public:
 
     Type type;
 
-    const PhraseData *left;
+    PhraseData *left;
-    const PhraseData *right;
+    PhraseData *right;
 
     QVariant operand;
     Condition operatorCond;
     bool isNot;
+    quint16 parents;
 
     PhraseData();
     PhraseData(const char *className, const char *fieldName);
     PhraseData(PhraseData *l, Condition o);
-    PhraseData(PhraseData *l, Condition o, const PhraseData *r);
+    PhraseData(PhraseData *l, Condition o, PhraseData *r);
     PhraseData(PhraseData *l, Condition o, QVariant r);
-    explicit PhraseData(const PhraseData &other);
+//    explicit PhraseData(const PhraseData &other);
-    explicit PhraseData(const PhraseData *other);
+//    explicit PhraseData(const PhraseData *other);
+
+    PhraseData *operator =(PhraseData *other);
+    PhraseData &operator =(PhraseData &other);
 
     QString toString() const;
 
     ~PhraseData();
+
+    void cleanUp();
+private:
+    void cleanUp(PhraseData *d);
+};
+
+class PhraseDataList : public QList<PhraseData*>
+{
+public:
+    PhraseDataList();
+    PhraseDataList(const PhraseDataList &other);
+    void append(PhraseData *d);
+    void append(QList<PhraseData*> &dl);
+    virtual ~PhraseDataList();
 };
 
 class AssignmentPhraseList
@@ -125,6 +143,9 @@ public:
     AssignmentPhraseList operator &(const AssignmentPhrase &ph);
 
     ~AssignmentPhraseList();
+
+private:
+    void incAllDataParents();
 };
 
 class AssignmentPhrase
@@ -151,25 +172,30 @@ public:
 class PhraseList{
 public:
     bool isValid;
-    QList<const PhraseData*> data;
+    PhraseDataList data;
     explicit PhraseList();
     PhraseList(const PhraseList &other);
+    PhraseList(PhraseList &&other);
     PhraseList(const AbstractFieldPhrase &other);
     PhraseList(const AbstractFieldPhrase *left, const AbstractFieldPhrase &right);
     PhraseList(PhraseList *left, PhraseList *right);
     PhraseList(PhraseList *left, const AbstractFieldPhrase *right);
     virtual ~PhraseList();
 
+    PhraseList &operator =(const PhraseList &other);
     PhraseList operator |(PhraseList &other);
     PhraseList operator |(const AbstractFieldPhrase &other);
+
+private:
+    void incAllDataParents();
 };
 
 class ConditionalPhrase
 {
 public:
     PhraseData *data;
-    QSharedPointer<PhraseData> leftDataPointer;
+//    QSharedPointer<PhraseData> leftDataPointer;
-    QSharedPointer<PhraseData> rightDataPointer;
+//    QSharedPointer<PhraseData> rightDataPointer;
     ConditionalPhrase();
     ConditionalPhrase(const ConditionalPhrase &other);
 #ifdef Q_COMPILER_RVALUE_REFS
@@ -212,8 +238,10 @@ class AbstractFieldPhrase
 {
 public:
     PhraseData *data;
+    explicit AbstractFieldPhrase(PhraseData *d);
     AbstractFieldPhrase(const char *className, const char *fieldName);
     AbstractFieldPhrase(const AbstractFieldPhrase &other);
+    AbstractFieldPhrase(AbstractFieldPhrase &&other);
 
     virtual ~AbstractFieldPhrase();
 
@@ -348,7 +376,7 @@ public:
     FieldPhrase<bool> operator !()
     {
         FieldPhrase<bool> f(data->className, data->fieldName);
-        f.data = new PhraseData(data);
+//        f.data = new PhraseData(data);
         f.data->isNot = !data->isNot;
         return f;
     }

src/query.h

@@ -73,9 +73,6 @@ public:
     Query<T> *where(const ConditionalPhrase &ph);
     Query<T> *setWhere(const ConditionalPhrase &ph);
 
-    Query<T> *include(TableSetBase *t);
-    Query<T> *include(Table *t);
-
     //data selecting
     T *first();
     QList<T*> toList(int count = -1);
@@ -139,7 +136,7 @@ Q_OUTOFLINE_TEMPLATE QList<T *> Query<T>::toList(int count)
     d->sql = d->database->sqlGenertor()->selectCommand(
                 d->tableName, d->fieldPhrase, d->wherePhrase, d->orderPhrase,
                 d->relations, d->skip, d->take);
-qDebug() <<d->sql;
+
     QSqlQuery q = d->database->exec(d->sql);
     if (q.lastError().isValid()) {
         qDebug() << q.lastError().text();
@@ -307,7 +304,7 @@ Q_OUTOFLINE_TEMPLATE QList<F> Query<T>::select(const FieldPhrase<F> f)
                 d->wherePhrase,
                 d->relations,
                 d->skip, d->take);
-qDebug() << d->sql;
+
     QSqlQuery q = d->database->exec(d->sql);
 
     while (q.next()) {
@@ -496,20 +493,6 @@ Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::orderBy(const PhraseList &ph)
     return this;
 }
 
-template <class T>
-Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::include(TableSetBase *t)
-{
-    Q_D(Query);
-    return this;
-}
-
-template <class T>
-Q_OUTOFLINE_TEMPLATE Query<T> *Query<T>::include(Table *t)
-{
-    Q_D(Query);
-    return this;
-}
-
 template <class T>
 Q_OUTOFLINE_TEMPLATE int Query<T>::update(const AssignmentPhraseList &ph)
 {
@@ -520,7 +503,7 @@ Q_OUTOFLINE_TEMPLATE int Query<T>::update(const AssignmentPhraseList &ph)
                 ph,
                 d->wherePhrase);
     QSqlQuery q = d->database->exec(d->sql);
-qDebug() << d->sql;
+
     if (m_autoDelete)
         deleteLater();
     return q.numRowsAffected();

src/query_p.h

@@ -31,7 +31,7 @@ NUT_BEGIN_NAMESPACE
 class Database;
 class TableSetBase;
 class QueryBase;
-class RelationModel;
+struct RelationModel;
 class QueryPrivate{
     QueryBase *q_ptr;
     Q_DECLARE_PUBLIC(QueryBase)

src/tablemodel.cpp

@@ -324,6 +324,12 @@ TableModel::TableModel(QJsonObject json, QString tableName)
     _allModels.insert(this);
 }
 
+TableModel::~TableModel()
+{
+    qDeleteAll(_fields);
+    qDeleteAll(_foreignKeys);
+}
+
 QJsonObject TableModel::toJson() const
 {
     QJsonObject obj;

src/tablemodel.h

@@ -94,6 +94,7 @@ class TableModel
 public:
     explicit TableModel(int typeId, QString tableName = QString::null);
     explicit TableModel(QJsonObject json, QString tableName);
+    virtual ~TableModel();
 
     QJsonObject toJson() const;
 

test/basic/maintest.cpp

@@ -209,7 +209,7 @@ void MainTest::testDate()
 
     db.postTable()->append(newPost);
 
-    db.saveChanges();
+    db.saveChanges(true);
 
     auto q = db.postTable()->query()
             ->setWhere(Post::idField() == newPost->id())
@@ -269,4 +269,13 @@ void MainTest::emptyDatabase()
     QTEST_ASSERT(commentsCount == 6);
 }
 
+void MainTest::cleanupTestCase()
+{
+    post->deleteLater();
+    user->deleteLater();
+
+    qDeleteAll(TableModel::allModels());
+    DatabaseModel::deleteAllModels();
+}
+
 QTEST_MAIN(MainTest)

test/basic/maintest.h

@@ -39,6 +39,8 @@ private slots:
     void selectWithInvalidRelation();
     void modifyPost();
     void emptyDatabase();
+
+    void cleanupTestCase();
 };
 
 #endif // MAINTEST_H