Use the Query::filter api.

3 files changed, 64 insertions, 77 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 0fc9234..3c4ae00 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -146,6 +146,7 @@ public:
     typedef QSharedPointer<Reduce> Ptr;
 
     QHash<QByteArray, QVariant> mAggregateValues;
+    QSet<QByteArray> mReducedValues;
     QByteArray mReductionProperty;
     QByteArray mSelectionProperty;
     Query::Reduce::Selector::Comparator mSelectionComparator;
@@ -184,7 +185,9 @@ public:
         bool foundValue = false;
         while(!foundValue && mSource->next([this, callback, &foundValue](Sink::Operation operation, const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
                 auto reductionValue = getProperty(entityBuffer.entity(), mReductionProperty);
-                if (!mAggregateValues.contains(getByteArray(reductionValue))) {
+                if (!mReducedValues.contains(getByteArray(reductionValue))) {
+                    //Only reduce every value once.
+                    mReducedValues.insert(getByteArray(reductionValue));
                     QVariant selectionResultValue;
                     QByteArray selectionResult;
                     auto results = indexLookup(mReductionProperty, reductionValue);
@@ -373,17 +376,16 @@ QVector<QByteArray> DataStoreQuery::indexLookup(const QByteArray &property, cons
 void DataStoreQuery::setupQuery()
 {
     FilterBase::Ptr baseSet;
-    QSet<QByteArray> remainingFilters;
+    QSet<QByteArray> remainingFilters = mQuery.getBaseFilters().keys().toSet();
     QByteArray appliedSorting;
     if (!mQuery.ids.isEmpty()) {
         mSource = Source::Ptr::create(mQuery.ids.toVector(), this);
         baseSet = mSource;
-        remainingFilters = mQuery.propertyFilter.keys().toSet();
     } else {
         QSet<QByteArray> appliedFilters;
 
         auto resultSet = mTypeIndex.query(mQuery, appliedFilters, appliedSorting, mTransaction);
-        remainingFilters = mQuery.propertyFilter.keys().toSet() - appliedFilters;
+        remainingFilters = remainingFilters - appliedFilters;
 
         // We do a full scan if there were no indexes available to create the initial set.
         if (appliedFilters.isEmpty()) {
@@ -394,12 +396,12 @@ void DataStoreQuery::setupQuery()
         }
         baseSet = mSource;
     }
-    if (!mQuery.propertyFilter.isEmpty()) {
+    if (!mQuery.getBaseFilters().isEmpty()) {
         auto filter = Filter::Ptr::create(baseSet, this);
-        filter->propertyFilter = mQuery.propertyFilter;
-        /* for (const auto &f : remainingFilters) { */
-        /*     filter->propertyFilter.insert(f, mQuery.propertyFilter.value(f)); */
-        /* } */
+        //For incremental queries the remaining filters are not sufficient
+        for (const auto &f : mQuery.getBaseFilters().keys()) {
+            filter->propertyFilter.insert(f, mQuery.getFilter(f));
+        }
         baseSet = filter;
     }
     /* if (appliedSorting.isEmpty() && !mQuery.sortProperty.isEmpty()) { */
@@ -407,15 +409,16 @@ void DataStoreQuery::setupQuery()
     /*     baseSet = Sort::Ptr::create(baseSet, mQuery.sortProperty); */
     /* } */
 
+    //Setup the rest of the filter stages on top of the base set
     for (const auto &stage : mQuery.filterStages) {
         if (auto filter = stage.dynamicCast<Query::Filter>()) {
-
+            auto f = Filter::Ptr::create(baseSet, this);
+            f->propertyFilter = filter->propertyFilter;
+            baseSet = f;
         } else if (auto filter = stage.dynamicCast<Query::Reduce>()) {
-            auto reduce = Reduce::Ptr::create(filter->property, filter->selector.property, filter->selector.comparator, baseSet, this);
-            baseSet = reduce;
+            baseSet = Reduce::Ptr::create(filter->property, filter->selector.property, filter->selector.comparator, baseSet, this);
         } else if (auto filter = stage.dynamicCast<Query::Bloom>()) {
-            auto reduce = Bloom::Ptr::create(filter->property, baseSet, this);
-            baseSet = reduce;
+            baseSet = Bloom::Ptr::create(filter->property, baseSet, this);
         }
     }
 
diff --git a/common/query.h b/common/query.h
index 0c6260b..3362ac7 100644
--- a/common/query.h
+++ b/common/query.h
@@ -58,26 +58,6 @@ public:
         Comparators comparator;
     };
 
-
-    static Query PropertyFilter(const QByteArray &key, const QVariant &value)
-    {
-        Query query;
-        query.propertyFilter.insert(key, Comparator(value));
-        return query;
-    }
-
-    static Query PropertyContainsFilter(const QByteArray &key, const QVariant &value)
-    {
-        Query query;
-        query.propertyFilter.insert(key, Comparator(value, Comparator::Contains));
-        return query;
-    }
-
-    static Query PropertyFilter(const QByteArray &key, const ApplicationDomain::Entity &entity)
-    {
-        return PropertyFilter(key, QVariant::fromValue(entity.identifier()));
-    }
-
     static Query ResourceFilter(const QByteArray &identifier)
     {
         Query query;
@@ -97,33 +77,6 @@ public:
         return ResourceFilter(entity.identifier());
     }
 
-    static Query AccountFilter(const QByteArray &identifier)
-    {
-        Query query;
-        query.accounts.append(identifier);
-        return query;
-    }
-
-    static Query CapabilityFilter(const QByteArray &capability)
-    {
-        Query query;
-        query.propertyFilter.insert("capabilities", Comparator(capability, Comparator::Contains));
-        return query;
-    }
-
-    static Query AccountFilter(const QByteArrayList &identifier)
-    {
-        Q_ASSERT(!identifier.isEmpty());
-        Query query;
-        query.accounts = identifier;
-        return query;
-    }
-
-    static Query AccountFilter(const ApplicationDomain::SinkAccount &entity)
-    {
-        return AccountFilter(entity.identifier());
-    }
-
     static Query IdentityFilter(const QByteArray &identifier)
     {
         Q_ASSERT(!identifier.isEmpty());
@@ -146,24 +99,17 @@ public:
         return query;
     }
 
-    static Query RequestedProperties(const QByteArrayList &properties)
-    {
-        Query query;
-        query.requestedProperties = properties;
-        return query;
-    }
-
-    static Query RequestTree(const QByteArray &parentProperty)
+    template <typename T>
+    Query &request()
     {
-        Query query;
-        query.parentProperty = parentProperty;
-        return query;
+        requestedProperties << T::name;
+        return *this;
     }
 
     template <typename T>
-    Query &request()
+    Query &requestTree()
     {
-        requestedProperties << T::name;
+        parentProperty = T::name;
         return *this;
     }
 
@@ -227,9 +173,8 @@ public:
     * Filters
     */
     class Filter : public FilterStage {
-        QByteArrayList ids;
+    public:
         QHash<QByteArray, Comparator> propertyFilter;
-        QByteArray sortProperty;
     };
 
     template <typename T>
@@ -239,6 +184,12 @@ public:
     }
 
     template <typename T>
+    Query &containsFilter(const QVariant &value)
+    {
+        return filter(T::name, Comparator(value, Comparator::Contains));
+    }
+
+    template <typename T>
     Query &filter(const Comparator &comparator)
     {
         return filter(T::name, comparator);
@@ -362,6 +313,39 @@ public:
         filterStages << bloom;
     }
 
+    //Query fixtures
+
+    /**
+     * Returns the complete thread, containing all mails from all folders.
+     */
+    static Query completeThread(const ApplicationDomain::Mail &mail)
+    {
+        Sink::Query query;
+        if (!mail.resourceInstanceIdentifier().isEmpty()) {
+            query.filter(ApplicationDomain::SinkResource(mail.resourceInstanceIdentifier()));
+        }
+        query.ids << mail.identifier();
+        query.sort<ApplicationDomain::Mail::Date>();
+        query.bloom<ApplicationDomain::Mail::ThreadId>();
+        return query;
+    }
+
+    /**
+     * Returns thread leaders only, sorted by date.
+     */
+    static Query threadLeaders(const ApplicationDomain::Folder &folder)
+    {
+        Sink::Query query;
+        if (!folder.resourceInstanceIdentifier().isEmpty()) {
+            query.filter(ApplicationDomain::SinkResource(folder.resourceInstanceIdentifier()));
+        }
+        query.filter<ApplicationDomain::Mail::Folder>(folder);
+        query.sort<ApplicationDomain::Mail::Date>();
+        query.reduce<ApplicationDomain::Mail::ThreadId>(Query::Reduce::Selector::max<ApplicationDomain::Mail::Date>());
+        return query;
+    }
+
+
 };
 
 }
diff --git a/common/test.cpp b/common/test.cpp
index 1a8e11d..97c42ef 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -147,7 +147,7 @@ public:
             }
             SinkTrace() << "-------------------------.";
             for (const auto &res : mTestAccount->entities<T>()) {
-                qDebug() << "Parent filter " << query.propertyFilter.value("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
+                qDebug() << "Parent filter " << query.getFilter("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
                 auto parentProperty = res->getProperty("parent").toByteArray();
                 if ((!parent && parentProperty.isEmpty()) || (parent && parentProperty == parent->identifier()) || query.parentProperty.isEmpty()) {
                     qDebug() << "Found a match" << res->identifier();