Optimized the incremental update case.

This brings the incremental closer to a regular query (about 1.5 times
as bad instead of 3.5 times).
For a comparison look at MailQueryBenchmark::testIncremental()

The optimization is built on the assumption that we i.e. get an update
with 100 revisions, and thus the optimization applies to the case where
we have multiple revisions within that batch that are part of the same
reduction. In such a case we can avoid redoing the reduction lookup over
and over.

2 files changed, 16 insertions, 2 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index f3d9415..f5152b7 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -208,6 +208,7 @@ public:
     };
 
     QSet<QByteArray> mReducedValues;
+    QSet<QByteArray> mIncrementallyReducedValues;
     QHash<QByteArray, QByteArray> mSelectedValues;
     QByteArray mReductionProperty;
     QByteArray mSelectionProperty;
@@ -225,6 +226,11 @@ public:
 
     virtual ~Reduce(){}
 
+    void updateComplete() Q_DECL_OVERRIDE
+    {
+        mIncrementallyReducedValues.clear();
+    }
+
     static QByteArray getByteArray(const QVariant &value) {
         if (value.type() == QVariant::DateTime) {
             return value.toDateTime().toString().toLatin1();
@@ -304,7 +310,8 @@ public:
                     //During initial query, do nothing. The lookup above will take care of it.
                     //During updates adjust the reduction according to the modification/addition or removal
                     //We have to redo the reduction for every element, because of the aggregation values.
-                    if (mIncremental) {
+                    if (mIncremental && !mIncrementallyReducedValues.contains(reductionValueBa)) {
+                        mIncrementallyReducedValues.insert(reductionValueBa);
                         //Redo the reduction to find new aggregated values
                         QMap<QByteArray, QVariant> aggregateValues;
                         auto selectionResult = reduceOnValue(reductionValue, aggregateValues);
@@ -621,6 +628,11 @@ ResultSet DataStoreQuery::update(qint64 baseRevision)
 void DataStoreQuery::updateComplete()
 {
     mSource->mIncrementalIds.clear();
+    auto source = mCollector;
+    while (source) {
+        source->updateComplete();
+        source = source->mSource;
+    }
 }
 
 ResultSet DataStoreQuery::execute()
diff --git a/common/datastorequery.h b/common/datastorequery.h
index de4ae26..cc501e6 100644
--- a/common/datastorequery.h
+++ b/common/datastorequery.h
@@ -107,11 +107,13 @@ public:
         return mDatastore->indexLookup(property, value);
     }
 
-    virtual void skip() { mSource->skip(); };
+    virtual void skip() { mSource->skip(); }
 
     //Returns true for as long as a result is available
     virtual bool next(const std::function<void(const ResultSet::Result &)> &callback) = 0;
 
+    virtual void updateComplete() { }
+
     FilterBase::Ptr mSource;
     DataStoreQuery *mDatastore;
     bool mIncremental = false;