zc

src/phrase.cpp

@@ -29,42 +29,60 @@ NUT_BEGIN_NAMESPACE
 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(3)
 { }
 
 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(const PhraseData &other) :
-    left(other->left), right(other->right), operand(other->operand),
+//    left(other.left), right(other.right), operand(other.operand),
-    operatorCond(other->operatorCond), className(other->className),
+//    operatorCond(other.operatorCond), className(other.className),
-    fieldName(other->fieldName), type(other->type), isNot(other->isNot)
+//    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,13 +99,34 @@ PhraseData::~PhraseData()
 //        if (left)
 //            delete left;
 //    }
+
+//    if (right && !--right->parents)
+//        delete right;
+
+//    if (left && !--left->parents)
+//        delete left;
+
     LOG("");
 }
 
+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)
+AbstractFieldPhrase::AbstractFieldPhrase(const char *className,
+                                         const char *fieldName)
     :data(new PhraseData(className, fieldName))
 {
     qDebug() <<"AbstractFieldPhrase created"<<className<<fieldName;
@@ -95,8 +134,9 @@ AbstractFieldPhrase::AbstractFieldPhrase(const char *className, const char *fiel
 
 AbstractFieldPhrase::AbstractFieldPhrase(const AbstractFieldPhrase &other)
 {
-    qDebug() <<"Copy ctor"<<other.data->toString();
+    qDebug() <<"Copy ctor"<<other.data->toString()<<other.data->parents;
-    data = new PhraseData(other.data);
+    data = other.data;
+    data->parents++;
 }
 
 AbstractFieldPhrase::AbstractFieldPhrase(AbstractFieldPhrase &&other)
@@ -109,13 +149,15 @@ AbstractFieldPhrase::~AbstractFieldPhrase()
 {
     if (data) {
         LOG(data->toString());
+        qDebug() << data->parents;
     } else {
         LOG("");
     }
 
     if (data) {
-        delete data;
+        --data->parents;
-        data = 0;
+        if (data->parents <= 0)
+            delete data;
     }
 }
 
@@ -130,9 +172,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) \
@@ -159,7 +203,7 @@ AbstractFieldPhraseOperatorField(>=, PhraseData::GreaterEqual)
 
 AbstractFieldPhrase AbstractFieldPhrase::operator !()
 {
-    AbstractFieldPhrase f(new PhraseData(data));
+    AbstractFieldPhrase f(data->className, data->fieldName);
     f.data->isNot = !data->isNot;
     return f;
 }
@@ -187,54 +231,67 @@ PhraseList::PhraseList(const PhraseList &other) : isValid(true)
 
 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);
-    left->data.clear();
+    data.append(left->data);
-    right->data.clear();
+    data.append(right->data);
+//    left->data.clear();
+//    right->data.clear();
 }
 
 PhraseList::PhraseList(PhraseList *left, const AbstractFieldPhrase *right)
     : isValid(true)
 {
     data = left->data;
-    data.append(new PhraseData(right->data));
+    data.append(right->data);
+    incAllDataParents();
 }
 
 PhraseList::~PhraseList()
-{
+{ }
-    qDeleteAll(data);
-//    data.clear();
-}
 
 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;
@@ -254,7 +311,8 @@ AssignmentPhrase::AssignmentPhrase(AssignmentPhrase *ph, const QVariant &v)
 AssignmentPhrase::~AssignmentPhrase()
 {
     if (data)
-        delete data;
+        if (!--data->parents)
+            delete data;
 }
 
 //AssignmentPhrase::AssignmentPhrase(AssignmentPhrase *l, const AssignmentPhrase *r)
@@ -276,35 +334,52 @@ 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();
+    //    data.clear();
+}
+
+void AssignmentPhraseList::incAllDataParents()
+{
+    foreach (PhraseData *d, data)
+        d->parents++;
 }
 
 ConditionalPhrase::ConditionalPhrase() : data(0)
@@ -313,7 +388,8 @@ 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;
 }
 
@@ -327,7 +403,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,
@@ -386,13 +463,17 @@ ConditionalPhrase::ConditionalPhrase(ConditionalPhrase *l,
 ConditionalPhrase::~ConditionalPhrase()
 {
     LOG("");
-    if (data)
+    if (data) {
-        delete 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;
 }
 
@@ -419,33 +500,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) \
@@ -455,7 +543,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; \
 }
 
@@ -470,6 +559,34 @@ ConditionalPhrase ConditionalPhrase::operator !()
     return f;
 }
 
+PhraseDataList::PhraseDataList() : QList<PhraseData*>()
+{
+
+}
+
+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,40 @@ 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);
 
     QString toString() const;
 
     ~PhraseData();
+
+    void cleanUp();
+private:
+    void cleanUp(PhraseData *d);
+};
+
+class PhraseDataList : public QList<PhraseData*>
+{
+public:
+    PhraseDataList();
+    void append(PhraseData *d);
+    void append(QList<PhraseData*> &dl);
+    virtual ~PhraseDataList();
 };
 
 class AssignmentPhraseList
@@ -125,6 +141,9 @@ public:
     AssignmentPhraseList operator &(const AssignmentPhrase &ph);
 
     ~AssignmentPhraseList();
+
+private:
+    void incAllDataParents();
 };
 
 class AssignmentPhrase
@@ -151,7 +170,7 @@ public:
 class PhraseList{
 public:
     bool isValid;
-    QList<const PhraseData*> data;
+    PhraseDataList data;
     explicit PhraseList();
     PhraseList(const PhraseList &other);
     PhraseList(const AbstractFieldPhrase &other);
@@ -162,6 +181,9 @@ public:
 
     PhraseList operator |(PhraseList &other);
     PhraseList operator |(const AbstractFieldPhrase &other);
+
+private:
+    void incAllDataParents();
 };
 
 class ConditionalPhrase
@@ -350,7 +372,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

@@ -139,7 +139,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 +307,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()) {
@@ -520,7 +520,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();