6 files changed, 76 insertions, 48 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index dac171c..0cc30e5 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -407,23 +407,25 @@ QByteArrayList DataStoreQuery::executeSubquery(const Query &subquery)
 
 void DataStoreQuery::setupQuery()
 {
-    for (const auto &k : mQuery.propertyFilter.keys()) {
+    auto baseFilters = mQuery.getBaseFilters();
+    for (const auto &k : baseFilters.keys()) {
         if (k == ApplicationDomain::Entity::Resource::name) {
             continue;
         }
-        const auto comparator = mQuery.propertyFilter.value(k);
+        const auto comparator = baseFilters.value(k);
         if (comparator.value.canConvert<Query>()) {
             SinkTrace() << "Executing subquery for property: " << k;
             const auto result = executeSubquery(comparator.value.value<Query>());
-            mQuery.propertyFilter.insert(k, Query::Comparator(QVariant::fromValue(result), Query::Comparator::In));
+            baseFilters.insert(k, Query::Comparator(QVariant::fromValue(result), Query::Comparator::In));
         }
     }
+    mQuery.setBaseFilters(baseFilters);
 
     FilterBase::Ptr baseSet;
     QSet<QByteArray> remainingFilters = mQuery.getBaseFilters().keys().toSet();
     QByteArray appliedSorting;
-    if (!mQuery.ids.isEmpty()) {
-        mSource = Source::Ptr::create(mQuery.ids.toVector(), this);
+    if (!mQuery.ids().isEmpty()) {
+        mSource = Source::Ptr::create(mQuery.ids().toVector(), this);
         baseSet = mSource;
     } else {
         QSet<QByteArray> appliedFilters;
@@ -457,7 +459,7 @@ void DataStoreQuery::setupQuery()
     /* } */
 
     //Setup the rest of the filter stages on top of the base set
-    for (const auto &stage : mQuery.filterStages) {
+    for (const auto &stage : mQuery.filterStages.mid(1)) {
         if (auto filter = stage.dynamicCast<Query::Filter>()) {
             auto f = Filter::Ptr::create(baseSet, this);
             f->propertyFilter = filter->propertyFilter;
diff --git a/common/query.h b/common/query.h
index 403c5b5..82b04f7 100644
--- a/common/query.h
+++ b/common/query.h
@@ -82,14 +82,14 @@ public:
     {
         Q_ASSERT(!identifier.isEmpty());
         Query query;
-        query.ids << identifier;
+        query.filter(identifier);
         return query;
     }
 
     static Query IdentityFilter(const QByteArrayList &identifier)
     {
         Query query;
-        query.ids = identifier;
+        query.filter(identifier);
         return query;
     }
 
@@ -123,39 +123,17 @@ public:
 
     Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false)
     {
-        ids << value.identifier();
-        resources << value.resourceInstanceIdentifier();
+        filter(value.identifier());
+        filter(ApplicationDomain::SinkResource(value.resourceInstanceIdentifier()));
     }
 
-    Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
-    {
-    }
-
-    Query &operator+=(const Query &rhs)
-    {
-        resources += rhs.resources;
-        accounts += rhs.accounts;
-        ids += rhs.ids;
-        for (auto it = rhs.propertyFilter.constBegin(); it != rhs.propertyFilter.constEnd(); it++) {
-            propertyFilter.insert(it.key(), it.value());
-        }
-        requestedProperties += rhs.requestedProperties;
-        parentProperty = rhs.parentProperty;
-        sortProperty = rhs.sortProperty;
-        limit = rhs.limit;
-        return *this;
-    }
 
-    friend Query operator+(Query lhs, const Query &rhs)
+    Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
     {
-        lhs += rhs;
-        return lhs;
     }
 
     QByteArrayList resources;
     QByteArrayList accounts;
-    QByteArrayList ids;
-    QHash<QByteArray, Comparator> propertyFilter;
     QByteArrayList requestedProperties;
     QByteArray parentProperty;
     QByteArray sortProperty;
@@ -176,6 +154,7 @@ public:
     */
     class Filter : public FilterStage {
     public:
+        QByteArrayList ids;
         QHash<QByteArray, Comparator> propertyFilter;
     };
 
@@ -197,25 +176,71 @@ public:
         return filter(T::name, comparator);
     }
 
+    Query &filter(const QByteArray &id)
+    {
+        if (filterStages.isEmpty()) {
+            filterStages << QSharedPointer<Filter>::create();
+        }
+        filterStages.first().staticCast<Filter>()->ids << id;
+        return *this;
+    }
+
+    Query &filter(const QByteArrayList &ids)
+    {
+        if (filterStages.isEmpty()) {
+            filterStages << QSharedPointer<Filter>::create();
+        }
+        filterStages.first().staticCast<Filter>()->ids << ids;
+        return *this;
+    }
+
     Query &filter(const QByteArray &property, const Comparator &comparator)
     {
-        propertyFilter.insert(property, comparator);
+        if (filterStages.isEmpty()) {
+            filterStages << QSharedPointer<Filter>::create();
+        }
+        filterStages.first().staticCast<Filter>()->propertyFilter.insert(property, comparator);
         return *this;
     }
 
     Comparator getFilter(const QByteArray &property) const
     {
-        return propertyFilter.value(property);
+        if (filterStages.isEmpty()) {
+            return Comparator();
+        }
+        return filterStages.first().staticCast<Filter>()->propertyFilter.value(property);
     }
 
     bool hasFilter(const QByteArray &property) const
     {
-        return propertyFilter.contains(property);
+        if (filterStages.isEmpty()) {
+            return false;
+        }
+        return filterStages.first().staticCast<Filter>()->propertyFilter.contains(property);
+    }
+
+    void setBaseFilters(const QHash<QByteArray, Comparator> &filter)
+    {
+        if (filterStages.isEmpty()) {
+            filterStages << QSharedPointer<Filter>::create();
+        }
+        filterStages.first().staticCast<Filter>()->propertyFilter = filter;
     }
 
     QHash<QByteArray, Comparator> getBaseFilters() const
     {
-        return propertyFilter;
+        if (filterStages.isEmpty()) {
+            return QHash<QByteArray, Comparator>();
+        }
+        return filterStages.first().staticCast<Filter>()->propertyFilter;
+    }
+
+    QByteArrayList ids() const
+    {
+        if (filterStages.isEmpty()) {
+            return QByteArrayList();
+        }
+        return filterStages.first().staticCast<Filter>()->ids;
     }
 
     template <typename T>
@@ -334,7 +359,7 @@ public:
         if (!mail.resourceInstanceIdentifier().isEmpty()) {
             query.filter(ApplicationDomain::SinkResource(mail.resourceInstanceIdentifier()));
         }
-        query.ids << mail.identifier();
+        query.filter(mail.identifier());
         query.sort<ApplicationDomain::Mail::Date>();
         query.bloom<ApplicationDomain::Mail::ThreadId>();
         return query;
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index 6747938..09323a0 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -72,7 +72,7 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
                 SinkTrace() << "Skipping due to type.";
                 continue;
             }
-            if (!query.ids.isEmpty() && !query.ids.contains(res)) {
+            if (!query.ids().isEmpty() && !query.ids().contains(res)) {
                 continue;
             }
             const auto configurationValues = mConfigStore.get(res);
diff --git a/common/store.cpp b/common/store.cpp
index efe1179..c015ef6 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -71,9 +71,10 @@ static QMap<QByteArray, QByteArray> getResources(const Sink::Query &query, const
         }
         //Subquery for the resource
         if (resourceComparator.value.canConvert<Query>()) {
-            auto subquery = resourceComparator.value.value<Query>();
-            for (const auto &filterProperty : subquery.propertyFilter.keys()) {
-                const auto filter = subquery.propertyFilter.value(filterProperty);
+            const auto subquery = resourceComparator.value.value<Query>();
+            const auto baseFilters = subquery.getBaseFilters();
+            for (const auto &filterProperty : baseFilters.keys()) {
+                const auto filter = baseFilters.value(filterProperty);
                 if (!filter.matches(configuration.value(filterProperty))) {
                     return true;
                 }
@@ -140,9 +141,9 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
 {
     SinkTrace() << "Query: " << ApplicationDomain::getTypeName<DomainType>();
     SinkTrace() << "  Requested: " << query.requestedProperties;
-    SinkTrace() << "  Filter: " << query.propertyFilter;
+    SinkTrace() << "  Filter: " << query.getBaseFilters();
     SinkTrace() << "  Parent: " << query.parentProperty;
-    SinkTrace() << "  Ids: " << query.ids;
+    SinkTrace() << "  Ids: " << query.ids();
     SinkTrace() << "  IsLive: " << query.liveQuery;
     SinkTrace() << "  Sorting: " << query.sortProperty;
     auto model = QSharedPointer<ModelResult<DomainType, typename DomainType::Ptr>>::create(query, query.requestedProperties);
diff --git a/sinksh/syntax_modules/sink_show.cpp b/sinksh/syntax_modules/sink_show.cpp
index 100b921..5197e77 100644
--- a/sinksh/syntax_modules/sink_show.cpp
+++ b/sinksh/syntax_modules/sink_show.cpp
@@ -58,9 +58,9 @@ bool show(const QStringList &args, State &state)
 
     Sink::Query query;
     if (queryForResourceOrAgent) {
-        query.ids << resource.toLatin1();
+        query.filter(resource.toLatin1());
     } else {
-        query.resources << resource.toLatin1();
+        query.filter(Sink::ApplicationDomain::SinkResource(resource.toLatin1()));
     }
     query.liveQuery = false;
 
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index 6348316..db17026 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -164,8 +164,8 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
-        query.ids << id;
+        query.filter(SinkResource("sink.dummy.instance1"));
+        query.filter(id);
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);