Remember aggregated ids

5 files changed, 48 insertions, 20 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 50158c7..218796f 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -252,11 +252,18 @@ public:
         return false;
     }
 
-    QByteArray reduceOnValue(const QVariant &reductionValue, QMap<QByteArray, QVariant> &aggregateValues)
+    struct ReductionResult {
+        QByteArray selection;
+        QVector<QByteArray> aggregateIds;
+        QMap<QByteArray, QVariant> aggregateValues;
+    };
+
+    ReductionResult reduceOnValue(const QVariant &reductionValue)
     {
+        QMap<QByteArray, QVariant> aggregateValues;
         QVariant selectionResultValue;
         QByteArray selectionResult;
-        auto results = indexLookup(mReductionProperty, reductionValue);
+        const auto results = indexLookup(mReductionProperty, reductionValue);
         for (auto &aggregator : mAggregators) {
             aggregator.reset();
         }
@@ -287,7 +294,7 @@ public:
         for (auto &aggregator : mAggregators) {
             aggregateValues.insert(aggregator.resultProperty, aggregator.result());
         }
-        return selectionResult;
+        return {selectionResult, results, aggregateValues};
     }
 
     bool next(const std::function<void(const ResultSet::Result &)> &callback) Q_DECL_OVERRIDE {
@@ -302,12 +309,11 @@ public:
                 if (!mReducedValues.contains(reductionValueBa)) {
                     //Only reduce every value once.
                     mReducedValues.insert(reductionValueBa);
-                    QMap<QByteArray, QVariant> aggregateValues;
-                    auto selectionResult = reduceOnValue(reductionValue, aggregateValues);
+                    auto reductionResult = reduceOnValue(reductionValue);
 
-                    mSelectedValues.insert(reductionValueBa, selectionResult);
-                    readEntity(selectionResult, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
-                        callback({entity, operation, aggregateValues});
+                    mSelectedValues.insert(reductionValueBa, reductionResult.selection);
+                    readEntity(reductionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                        callback({entity, operation, reductionResult.aggregateValues, reductionResult.aggregateIds});
                         foundValue = true;
                     });
                 } else {
@@ -317,15 +323,14 @@ public:
                     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);
+                        auto selectionResult = reduceOnValue(reductionValue);
 
                         //TODO if old and new are the same a modification would be enough
                         auto oldSelectionResult = mSelectedValues.take(reductionValueBa);
-                        if (oldSelectionResult == selectionResult) {
-                            mSelectedValues.insert(reductionValueBa, selectionResult);
-                            readEntity(selectionResult, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
-                                callback({entity, Sink::Operation_Modification, aggregateValues});
+                        if (oldSelectionResult == selectionResult.selection) {
+                            mSelectedValues.insert(reductionValueBa, selectionResult.selection);
+                            readEntity(selectionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
+                                callback({entity, Sink::Operation_Modification, selectionResult.aggregateValues, selectionResult.aggregateIds});
                             });
                         } else {
                             //remove old result
@@ -334,9 +339,9 @@ public:
                             });
 
                             //add new result
-                            mSelectedValues.insert(reductionValueBa, selectionResult);
-                            readEntity(selectionResult, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
-                                callback({entity, Sink::Operation_Creation, aggregateValues});
+                            mSelectedValues.insert(reductionValueBa, selectionResult.selection);
+                            readEntity(selectionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
+                                callback({entity, Sink::Operation_Creation, selectionResult.aggregateValues, selectionResult.aggregateIds});
                             });
                         }
                     }
@@ -648,7 +653,7 @@ ResultSet DataStoreQuery::execute()
         if (mCollector->next([this, callback](const ResultSet::Result &result) {
                 if (result.operation != Sink::Operation_Removal) {
                     SinkTraceCtx(mLogCtx) << "Got initial result: " << result.entity.identifier() << result.operation;
-                    callback(ResultSet::Result{result.entity, Sink::Operation_Creation, result.aggregateValues});
+                    callback(ResultSet::Result{result.entity, Sink::Operation_Creation, result.aggregateValues, result.aggregateIds});
                 }
             }))
         {
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 8bb74e3..c315e33 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -184,6 +184,7 @@ ApplicationDomainType& ApplicationDomainType::operator=(const ApplicationDomainT
     mResourceInstanceIdentifier = other.mResourceInstanceIdentifier;
     mIdentifier = other.mIdentifier;
     mRevision = other.mRevision;
+    mAggreatedIds = other.mAggreatedIds;
     return *this;
 }
 
@@ -262,6 +263,21 @@ QByteArray ApplicationDomainType::identifier() const
     return mIdentifier;
 }
 
+bool ApplicationDomainType::isAggregate() const
+{
+    return !mAggreatedIds.isEmpty();
+}
+
+QVector<QByteArray> ApplicationDomainType::aggregatedIds() const
+{
+    return mAggreatedIds;
+}
+
+QVector<QByteArray> &ApplicationDomainType::aggregatedIds()
+{
+    return mAggreatedIds;
+}
+
 SinkResource::SinkResource(const QByteArray &identifier)
     : ApplicationDomainType("", identifier, 0, QSharedPointer<BufferAdaptor>(new MemoryBufferAdaptor()))
 {
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index b4db54e..dcd401c 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -268,6 +268,10 @@ public:
     void setResource(const QByteArray &identifier);
     QByteArray identifier() const;
 
+    bool isAggregate() const;
+    QVector<QByteArray> aggregatedIds() const;
+    QVector<QByteArray> &aggregatedIds();
+
 private:
     friend QDebug operator<<(QDebug, const ApplicationDomainType &);
     QSharedPointer<BufferAdaptor> mAdaptor;
@@ -278,6 +282,8 @@ private:
     QByteArray mResourceInstanceIdentifier;
     QByteArray mIdentifier;
     qint64 mRevision;
+
+    QVector<QByteArray> mAggreatedIds;
 };
 
 /*
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 0ed4cb5..2062828 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -45,7 +45,6 @@ struct ReplayResult {
 template <typename DomainType>
 class QueryWorker : public QObject
 {
-    typedef std::function<bool(const typename DomainType::Ptr &domainObject, Sink::Operation operation, const QMap<QByteArray, QVariant> &aggregateValues)> ResultCallback;
 public:
     QueryWorker(const Sink::Query &query, const ResourceContext &context, const QByteArray &bufferType, const QueryRunnerBase::ResultTransformation &transformation, const Sink::Log::Context &logCtx);
     virtual ~QueryWorker();
@@ -210,6 +209,7 @@ void QueryWorker<DomainType>::resultProviderCallback(const Sink::Query &query, S
     for (auto it = result.aggregateValues.constBegin(); it != result.aggregateValues.constEnd(); it++) {
         valueCopy->setProperty(it.key(), it.value());
     }
+    valueCopy->aggregatedIds() = result.aggregateIds;
     if (mResultTransformation) {
         mResultTransformation(*valueCopy);
     }
diff --git a/common/resultset.h b/common/resultset.h
index 707bc7e..5587c54 100644
--- a/common/resultset.h
+++ b/common/resultset.h
@@ -35,10 +35,11 @@ class ResultSet
 {
 public:
     struct Result {
-        Result(const Sink::ApplicationDomain::ApplicationDomainType &e, Sink::Operation op, const QMap<QByteArray, QVariant> &v = QMap<QByteArray, QVariant>{}) : entity(e), operation(op), aggregateValues(v) {}
+        Result(const Sink::ApplicationDomain::ApplicationDomainType &e, Sink::Operation op, const QMap<QByteArray, QVariant> &v = {}, const QVector<QByteArray> &a = {}) : entity(e), operation(op), aggregateValues(v), aggregateIds(a) {}
         Sink::ApplicationDomain::ApplicationDomainType entity;
         Sink::Operation operation;
         QMap<QByteArray, QVariant> aggregateValues;
+        QVector<QByteArray> aggregateIds;
     };
     typedef std::function<void(const Result &)> Callback;
     typedef std::function<bool(Callback)> ValueGenerator;