13 files changed, 119 insertions, 149 deletions

diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index 4295a44..e11ec9c 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -253,14 +253,14 @@ bool ModelResult<T, Ptr>::hasChildren(const QModelIndex &parent) const
     if (mQuery.parentProperty().isEmpty() && parent.isValid()) {
         return false;
     }
-    //Figure out whether we have children
-    const auto id = parent.internalId();
-    if (!mEntityChildrenFetched.contains(id)) {
-        //Since we don't retrieve that information as part of the entity,
-        //we have to query for the children to see if we have some
-        auto p = const_cast<ModelResult<T, Ptr>*>(this);
-        p->fetchMore(parent);
-    }
+    // //Figure out whether we have children
+    // const auto id = parent.internalId();
+    // if (!mEntityChildrenFetched.contains(id)) {
+    //     //Since we don't retrieve that information as part of the entity,
+    //     //we have to query for the children to see if we have some
+    //     auto p = const_cast<ModelResult<T, Ptr>*>(this);
+    //     p->fetchMore(parent);
+    // }
     return QAbstractItemModel::hasChildren(parent);
 }
 
@@ -278,7 +278,9 @@ template <class T, class Ptr>
 void ModelResult<T, Ptr>::fetchMore(const QModelIndex &parent)
 {
     SinkTraceCtx(mLogCtx) << "Fetching more: " << parent;
-    fetchEntities(parent);
+    if (!parent.isValid()) {
+        fetchEntities();
+    }
 }
 
 template <class T, class Ptr>
@@ -287,10 +289,10 @@ void ModelResult<T, Ptr>::add(const Ptr &value)
     const auto childId = qHash(*value);
     const auto id = parentId(value);
     // Ignore updates we get before the initial fetch is done
-    if (!mEntityChildrenFetched.contains(id)) {
-        SinkTraceCtx(mLogCtx) << "Too early" << id;
-        return;
-    }
+    // if (!mEntityChildrenFetched.contains(id)) {
+    //     SinkTraceCtx(mLogCtx) << "Too early" << id;
+    //     return;
+    // }
     if (mEntities.contains(childId)) {
         SinkWarningCtx(mLogCtx) << "Entity already in model: " << value->identifier();
         return;
@@ -335,27 +337,27 @@ void ModelResult<T, Ptr>::remove(const Ptr &value)
 }
 
 template <class T, class Ptr>
-void ModelResult<T, Ptr>::fetchEntities(const QModelIndex &parent)
+void ModelResult<T, Ptr>::fetchEntities()
 {
     Q_ASSERT(QThread::currentThread() == this->thread());
-    const auto id = getIdentifier(parent);
+    const auto id = getIdentifier({});
     //There is already a fetch in progress, don't fetch again.
     if (mEntityChildrenFetched.contains(id) && !mEntityChildrenFetchComplete.contains(id)) {
-        SinkTraceCtx(mLogCtx) << "A fetch is already in progress: " << parent;
+        SinkTraceCtx(mLogCtx) << "A fetch is already in progress.";
         return;
     }
     mEntityChildrenFetchComplete.remove(id);
     mEntityChildrenFetched.insert(id);
     SinkTraceCtx(mLogCtx) << "Loading child entities of parent " << id;
     if (loadEntities) {
-        loadEntities(parent.data(DomainObjectRole).template value<Ptr>());
+        loadEntities();
     } else {
         SinkWarningCtx(mLogCtx) << "No way to fetch entities";
     }
 }
 
 template <class T, class Ptr>
-void ModelResult<T, Ptr>::setFetcher(const std::function<void(const Ptr &parent)> &fetcher)
+void ModelResult<T, Ptr>::setFetcher(const std::function<void()> &fetcher)
 {
     SinkTraceCtx(mLogCtx) << "Setting fetcher";
     loadEntities = fetcher;
@@ -364,7 +366,7 @@ void ModelResult<T, Ptr>::setFetcher(const std::function<void(const Ptr &parent)
 template <class T, class Ptr>
 void ModelResult<T, Ptr>::setEmitter(const typename Sink::ResultEmitter<Ptr>::Ptr &emitter)
 {
-    setFetcher([this](const Ptr &parent) { mEmitter->fetch(parent); });
+    setFetcher([this]() { mEmitter->fetch(); });
 
     QPointer<QObject> guard(this);
     emitter->onAdded([this, guard](const Ptr &value) {
@@ -389,18 +391,19 @@ void ModelResult<T, Ptr>::setEmitter(const typename Sink::ResultEmitter<Ptr>::Pt
             remove(value);
         });
     });
-    emitter->onInitialResultSetComplete([this, guard](const Ptr &parent, bool fetchedAll) {
+    emitter->onInitialResultSetComplete([this, guard](bool fetchedAll) {
         SinkTraceCtx(mLogCtx) << "Initial result set complete. Fetched all: " << fetchedAll;
         Q_ASSERT(guard);
         Q_ASSERT(QThread::currentThread() == this->thread());
 
-        const qint64 parentId = parent ? qHash(*parent) : 0;
-        const auto parentIndex = createIndexFromId(parentId);
-        mEntityChildrenFetchComplete.insert(parentId);
+        // const qint64 parentId = parent ? qHash(*parent) : 0;
+        // const auto parentIndex = createIndexFromId(parentId);
+        mEntityChildrenFetchComplete.insert(0);
         if (fetchedAll) {
-            mEntityAllChildrenFetched.insert(parentId);
+            mEntityAllChildrenFetched.insert(0);
         }
-        emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
+        // emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
+        emit dataChanged({}, {}, QVector<int>() << ChildrenFetchedRole);
     });
     mEmitter = emitter;
 }
@@ -423,9 +426,9 @@ void ModelResult<T, Ptr>::modify(const Ptr &value)
     }
     auto id = parentId(value);
     // Ignore updates we get before the initial fetch is done
-    if (!mEntityChildrenFetched.contains(id)) {
-        return;
-    }
+    // if (!mEntityChildrenFetched.contains(id)) {
+    //     return;
+    // }
     auto parent = createIndexFromId(id);
     SinkTraceCtx(mLogCtx) << "Modified entity:" << value->identifier() << ", id: " << childId;
     auto i = mTree[id].indexOf(childId);
diff --git a/common/modelresult.h b/common/modelresult.h
index cc263cf..a4def81 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -65,7 +65,7 @@ public:
     bool canFetchMore(const QModelIndex &parent) const;
     void fetchMore(const QModelIndex &parent);
 
-    void setFetcher(const std::function<void(const Ptr &parent)> &fetcher);
+    void setFetcher(const std::function<void()> &fetcher);
 
 private:
     void add(const Ptr &value);
@@ -75,7 +75,7 @@ private:
 
     qint64 parentId(const Ptr &value);
     QModelIndex createIndexFromId(const qint64 &id) const;
-    void fetchEntities(const QModelIndex &parent);
+    void fetchEntities();
 
     Sink::Log::Context  mLogCtx;
     // TODO we should be able to directly use T as index, with an appropriate hash function, and thus have a QMap<T, T> and QList<T>
@@ -88,7 +88,7 @@ private:
     QMap<qint64 /* entity id */, int /* Status */> mEntityStatus;
     QList<QByteArray> mPropertyColumns;
     Sink::Query mQuery;
-    std::function<void(const Ptr &)> loadEntities;
+    std::function<void()> loadEntities;
     typename Sink::ResultEmitter<Ptr>::Ptr mEmitter;
     async::ThreadBoundary threadBoundary;
     QScopedPointer<Sink::Notifier> mNotifier;
diff --git a/common/notifier.cpp b/common/notifier.cpp
index 9aa6c90..131fd7a 100644
--- a/common/notifier.cpp
+++ b/common/notifier.cpp
@@ -82,16 +82,10 @@ Notifier::Notifier(const Sink::Query &resourceQuery) : d(new Sink::Notifier::Pri
         resourceAccess->open();
         d->listenForNotifications(resourceAccess);
     });
-    emitter->onModified([](const ApplicationDomain::SinkResource::Ptr &) {
-    });
-    emitter->onRemoved([](const ApplicationDomain::SinkResource::Ptr &) {
-    });
-    emitter->onInitialResultSetComplete([](const ApplicationDomain::SinkResource::Ptr &, bool) {
-    });
     emitter->onComplete([resourceCtx]() {
         SinkTraceCtx(resourceCtx) << "Resource query complete";
     });
-    emitter->fetch({});
+    emitter->fetch();
     if (resourceQuery.liveQuery()) {
         d->mResourceEmitter = emitter;
     }
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index f3a9af8..288ce27 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -51,7 +51,7 @@ public:
     virtual ~QueryWorker();
 
     ReplayResult executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, DataStoreQuery::State::Ptr state);
-    ReplayResult executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state);
+    ReplayResult executeInitialQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state);
 
 private:
     void resultProviderCallback(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const ResultSet::Result &result);
@@ -70,34 +70,33 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
         SinkWarningCtx(mLogCtx) << "A limited query without sorting is typically a bad idea, because there is no telling what you're going to get.";
     }
     auto guardPtr = QPointer<QObject>(&guard);
-    auto fetcher = [=](const typename DomainType::Ptr &parent) {
-        const QByteArray parentId = parent ? parent->identifier() : QByteArray();
+    auto fetcher = [=]() {
         SinkTraceCtx(mLogCtx) << "Running fetcher. Batchsize: " << mBatchSize;
         auto resultProvider = mResultProvider;
         auto resultTransformation = mResultTransformation;
         auto batchSize = mBatchSize;
         auto resourceContext = mResourceContext;
         auto logCtx = mLogCtx;
-        auto state = mQueryState.value(parentId);
+        auto state = mQueryState;
         const bool runAsync = !query.synchronousQuery();
         //The lambda will be executed in a separate thread, so copy all arguments
         async::run<ReplayResult>([=]() {
             QueryWorker<DomainType> worker(query, resourceContext, bufferType, resultTransformation, logCtx);
-            return worker.executeInitialQuery(query, parent, *resultProvider, batchSize, state);
+            return worker.executeInitialQuery(query, *resultProvider, batchSize, state);
         }, runAsync)
-            .then([this, parentId, query, parent, resultProvider, guardPtr](const ReplayResult &result) {
+            .then([this, query, resultProvider, guardPtr](const ReplayResult &result) {
                 if (!guardPtr) {
                     //Not an error, the query can vanish at any time.
                     return;
                 }
                 mInitialQueryComplete = true;
-                mQueryState[parentId] = result.queryState;
+                mQueryState = result.queryState;
                 // Only send the revision replayed information if we're connected to the resource, there's no need to start the resource otherwise.
                 if (query.liveQuery()) {
                     mResourceAccess->sendRevisionReplayedCommand(result.newRevision);
                 }
                 resultProvider->setRevision(result.newRevision);
-                resultProvider->initialResultSetComplete(parent, result.replayedAll);
+                resultProvider->initialResultSetComplete(result.replayedAll);
             })
             .exec();
     };
@@ -110,14 +109,13 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
         Q_ASSERT(!query.synchronousQuery());
         // Incremental updates are always loaded directly, leaving it up to the result to discard the changes if they are not interesting
         setQuery([=]() -> KAsync::Job<void> {
-            const QByteArray parentId;
             auto resultProvider = mResultProvider;
             auto resourceContext = mResourceContext;
             auto logCtx = mLogCtx;
-            auto state = mQueryState.value(parentId);
+            auto state = mQueryState;
             if (!mInitialQueryComplete) {
                 SinkWarningCtx(mLogCtx) << "Can't start the incremental query before the initial query is complete";
-                fetcher({});
+                fetcher();
                 return KAsync::null();
             }
             if (mQueryInProgress) {
@@ -240,7 +238,7 @@ ReplayResult QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query
 
 template <class DomainType>
 ReplayResult QueryWorker<DomainType>::executeInitialQuery(
-    const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state)
+    const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state)
 {
     QTime time;
     time.start();
diff --git a/common/queryrunner.h b/common/queryrunner.h
index 11a302f..a567b3c 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -96,7 +96,7 @@ private:
     QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
     QSharedPointer<Sink::ResultProvider<typename DomainType::Ptr>> mResultProvider;
     ResultTransformation mResultTransformation;
-    QHash<QByteArray, DataStoreQuery::State::Ptr> mQueryState;
+    DataStoreQuery::State::Ptr mQueryState;
     int mBatchSize;
     QObject guard;
     Sink::Log::Context mLogCtx;
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index 0687bbc..3dba3e5 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -110,7 +110,7 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
     };
 
     QObject *guard = new QObject;
-    mResultProvider->setFetcher([this, query, guard, &configNotifier, matchesTypeAndIds](const QSharedPointer<DomainType> &) {
+    mResultProvider->setFetcher([this, query, guard, &configNotifier, matchesTypeAndIds]() {
         const auto entries = mConfigStore.getEntries();
         for (const auto &res : entries.keys()) {
             const auto type = entries.value(res);
@@ -127,7 +127,7 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
             mResultProvider->add(entity);
         }
         // TODO initialResultSetComplete should be implicit
-        mResultProvider->initialResultSetComplete(typename DomainType::Ptr(), true);
+        mResultProvider->initialResultSetComplete(true);
         mResultProvider->complete();
     });
     if (query.liveQuery()) {
@@ -390,11 +390,7 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
                 auto resourceAccess = Sink::ResourceAccessFactory::instance().getAccess(resource->identifier(), ResourceConfig::getResourceType(resource->identifier()));
                 monitorResource(accountIdentifier, *resource, resourceAccess);
             });
-            emitter->onModified([](const ApplicationDomain::SinkResource::Ptr &) {});
-            emitter->onRemoved([](const ApplicationDomain::SinkResource::Ptr &) {});
-            emitter->onInitialResultSetComplete([](const ApplicationDomain::SinkResource::Ptr &, bool) {});
-            emitter->onComplete([]() {});
-            emitter->fetch({});
+            emitter->fetch();
             runner->mResourceEmitter[accountIdentifier] = emitter;
         }
 
diff --git a/common/resultprovider.h b/common/resultprovider.h
index d6feaf9..890e109 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -48,10 +48,10 @@ public:
     virtual void add(const T &value) = 0;
     virtual void modify(const T &value) = 0;
     virtual void remove(const T &value) = 0;
-    virtual void initialResultSetComplete(const T &parent, bool) = 0;
+    virtual void initialResultSetComplete(bool) = 0;
     virtual void complete() = 0;
     virtual void clear() = 0;
-    virtual void setFetcher(const std::function<void(const T &parent)> &fetcher) = 0;
+    virtual void setFetcher(const std::function<void()> &fetcher) = 0;
 
     void setRevision(qint64 revision)
     {
@@ -102,10 +102,10 @@ public:
         }
     }
 
-    void initialResultSetComplete(const T &parent, bool replayedAll)
+    void initialResultSetComplete(bool replayedAll)
     {
         if (auto strongRef = mResultEmitter.toStrongRef()) {
-            strongRef->initialResultSetComplete(parent, replayedAll);
+            strongRef->initialResultSetComplete(replayedAll);
         }
     }
 
@@ -134,9 +134,9 @@ public:
                 delete emitter;
             });
             mResultEmitter = sharedPtr;
-            sharedPtr->setFetcher([this](const T &parent) {
+            sharedPtr->setFetcher([this]() {
                 Q_ASSERT(mFetcher);
-                mFetcher(parent);
+                mFetcher();
             });
             return sharedPtr;
         }
@@ -155,7 +155,7 @@ public:
         return mResultEmitter.toStrongRef().isNull();
     }
 
-    void setFetcher(const std::function<void(const T &parent)> &fetcher)
+    void setFetcher(const std::function<void()> &fetcher)
     {
         mFetcher = fetcher;
     }
@@ -173,7 +173,7 @@ private:
 
     QWeakPointer<ResultEmitter<T>> mResultEmitter;
     std::function<void()> mOnDoneCallback;
-    std::function<void(const T &parent)> mFetcher;
+    std::function<void()> mFetcher;
 };
 
 /*
@@ -222,7 +222,7 @@ public:
         removeHandler = handler;
     }
 
-    void onInitialResultSetComplete(const std::function<void(const DomainType &, bool)> &handler)
+    void onInitialResultSetComplete(const std::function<void(bool)> &handler)
     {
         initialResultSetCompleteHandler = handler;
     }
@@ -246,7 +246,9 @@ public:
     {
         QMutexLocker locker{&mMutex};
         if (guardOk()) {
-            addHandler(value);
+            if (addHandler) {
+                addHandler(value);
+            }
         }
     }
 
@@ -254,7 +256,9 @@ public:
     {
         QMutexLocker locker{&mMutex};
         if (guardOk()) {
-            modifyHandler(value);
+            if (modifyHandler) {
+                modifyHandler(value);
+            }
         }
     }
 
@@ -262,16 +266,20 @@ public:
     {
         QMutexLocker locker{&mMutex};
         if (guardOk()) {
-            removeHandler(value);
+            if (removeHandler) {
+                removeHandler(value);
+            }
         }
     }
 
-    void initialResultSetComplete(const DomainType &parent, bool replayedAll)
+    void initialResultSetComplete(bool replayedAll)
     {
         //This callback is only ever called from the main thread, so we don't do any locking
         if (initialResultSetCompleteHandler && guardOk()) {
-            //This can directly lead to our destruction and thus waitForMethodExecutionEnd
-            initialResultSetCompleteHandler(parent, replayedAll);
+            if (initialResultSetCompleteHandler) {
+                //This can directly lead to our destruction and thus waitForMethodExecutionEnd
+                initialResultSetCompleteHandler(replayedAll);
+            }
         }
     }
 
@@ -279,7 +287,9 @@ public:
     {
         QMutexLocker locker{&mMutex};
         if (completeHandler && guardOk()) {
-            completeHandler();
+            if (completeHandler) {
+                completeHandler();
+            }
         }
     }
 
@@ -287,19 +297,21 @@ public:
     {
         QMutexLocker locker{&mMutex};
         if (clearHandler && guardOk()) {
-            clearHandler();
+            if (clearHandler) {
+                clearHandler();
+            }
         }
     }
 
-    void setFetcher(const std::function<void(const DomainType &parent)> &fetcher)
+    void setFetcher(const std::function<void()> &fetcher)
     {
         mFetcher = fetcher;
     }
 
-    virtual void fetch(const DomainType &parent)
+    virtual void fetch()
     {
         if (mFetcher) {
-            mFetcher(parent);
+            mFetcher();
         }
     }
 
@@ -309,11 +321,11 @@ private:
     std::function<void(const DomainType &)> addHandler;
     std::function<void(const DomainType &)> modifyHandler;
     std::function<void(const DomainType &)> removeHandler;
-    std::function<void(const DomainType &, bool)> initialResultSetCompleteHandler;
+    std::function<void(bool)> initialResultSetCompleteHandler;
     std::function<void(void)> completeHandler;
     std::function<void(void)> clearHandler;
 
-    std::function<void(const DomainType &parent)> mFetcher;
+    std::function<void()> mFetcher;
     /*
      * This mutex is here to protect the emitter from getting destroyed while the producer-thread (ResultProvider) is calling into it,
      * and vice-verca, to protect the producer thread from calling into a destroyed emitter.
@@ -350,53 +362,50 @@ public:
         emitter->onModified([this](const DomainType &value) { this->modify(value); });
         emitter->onRemoved([this](const DomainType &value) { this->remove(value); });
         auto ptr = emitter.data();
-        emitter->onInitialResultSetComplete([this, ptr](const DomainType &parent, bool replayedAll) {
-            auto hashValue = qHash(parent);
+        emitter->onInitialResultSetComplete([this, ptr](bool replayedAll) {
             if (replayedAll) {
-                mAllResultsReplayed.remove(hashValue, ptr);
+                mAllResultsReplayed.remove(ptr);
             }
-            mInitialResultSetInProgress.remove(hashValue, ptr);
-            callInitialResultCompleteIfDone(parent);
+            mInitialResultSetInProgress.remove(ptr);
+            callInitialResultCompleteIfDone();
         });
         emitter->onComplete([this]() { this->complete(); });
         emitter->onClear([this]() { this->clear(); });
         mEmitter << emitter;
     }
 
-    void callInitialResultCompleteIfDone(const DomainType &parent)
+    void callInitialResultCompleteIfDone()
     {
-        auto hashValue = qHash(parent);
         // Normally a parent is only in a single resource, except the toplevel (invalid) parent
-        if (!mInitialResultSetInProgress.contains(hashValue) && mAllResultsFetched && !mResultEmitted) {
-            bool allResourcesReplayedAll = mAllResultsReplayed.isEmpty();
+        if (mInitialResultSetInProgress.isEmpty() && mAllResultsFetched && !mResultEmitted) {
             mResultEmitted = true;
-            this->initialResultSetComplete(parent, allResourcesReplayedAll);
+            this->initialResultSetComplete(mAllResultsReplayed.isEmpty());
         }
     }
 
-    void fetch(const DomainType &parent) Q_DECL_OVERRIDE
+    void fetch() Q_DECL_OVERRIDE
     {
         if (mEmitter.isEmpty()) {
-            this->initialResultSetComplete(parent, true);
+            this->initialResultSetComplete(true);
         } else {
             mResultEmitted = false;
             mAllResultsFetched = false;
+            mInitialResultSetInProgress.clear();
             mAllResultsReplayed.clear();
-            const auto hashValue = qHash(parent);
             for (const auto &emitter : mEmitter) {
-                mInitialResultSetInProgress.insert(hashValue, emitter.data());
-                mAllResultsReplayed.insert(hashValue, emitter.data());
-                emitter->fetch(parent);
+                mInitialResultSetInProgress.insert(emitter.data());
+                mAllResultsReplayed.insert(emitter.data());
+                emitter->fetch();
             }
             mAllResultsFetched = true;
-            callInitialResultCompleteIfDone(parent);
+            callInitialResultCompleteIfDone();
         }
     }
 
 private:
     QList<typename ResultEmitter<DomainType>::Ptr> mEmitter;
-    QMultiMap<qint64, ResultEmitter<DomainType> *> mInitialResultSetInProgress;
-    QMultiMap<qint64, ResultEmitter<DomainType> *> mAllResultsReplayed;
+    QSet<ResultEmitter<DomainType>*> mInitialResultSetInProgress;
+    QSet<ResultEmitter<DomainType>*> mAllResultsReplayed;
     bool mAllResultsFetched;
     bool mResultEmitted;
 };
diff --git a/common/store.cpp b/common/store.cpp
index 1701a43..b16fa4e 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -136,12 +136,6 @@ QPair<typename AggregatingResultEmitter<typename DomainType::Ptr>::Ptr,  typenam
             Q_ASSERT(!resourceType.isEmpty());
             queryResource<DomainType>(resourceType, resource->identifier(), query, aggregatingEmitter, ctx).exec();
         });
-        emitter->onModified([](const ApplicationDomain::SinkResource::Ptr &) {
-        });
-        emitter->onRemoved([](const ApplicationDomain::SinkResource::Ptr &) {
-        });
-        emitter->onInitialResultSetComplete([](const ApplicationDomain::SinkResource::Ptr &, bool) {
-        });
         emitter->onComplete([query, aggregatingEmitter, resourceCtx]() {
             SinkTraceCtx(resourceCtx) << "Resource query complete";
         });
@@ -178,7 +172,7 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(const Query &query)
     //Keep the emitter alive
     if (auto resourceEmitter = result.second) {
         model->setProperty("resourceEmitter", QVariant::fromValue(resourceEmitter)); //TODO only neceesary for live queries
-        resourceEmitter->fetch(ApplicationDomain::SinkResource::Ptr());
+        resourceEmitter->fetch();
     }
 
 
@@ -443,10 +437,10 @@ QList<DomainType> Store::read(const Sink::Query &query_)
     });
 
     if (auto resourceEmitter = result.second) {
-        resourceEmitter->fetch(ApplicationDomain::SinkResource::Ptr());
+        resourceEmitter->fetch();
     }
 
-    aggregatingEmitter->fetch(typename DomainType::Ptr());
+    aggregatingEmitter->fetch();
     return list;
 }
 
diff --git a/common/test.cpp b/common/test.cpp
index 237d3bb..52d79ca 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -150,22 +150,13 @@ public:
         // We have to do it this way, otherwise we're not setting the fetcher right
         auto emitter = resultProvider->emitter();
 
-        resultProvider->setFetcher([query, resultProvider, this](const typename T::Ptr &parent) {
-            if (parent) {
-                SinkTrace() << "Running the fetcher " << parent->identifier();
-            } else {
-                SinkTrace() << "Running the fetcher.";
-            }
+        resultProvider->setFetcher([query, resultProvider, this]() {
+            SinkTrace() << "Running the fetcher.";
             SinkTrace() << "-------------------------.";
             for (const auto &res : mTestAccount->entities<T>()) {
-                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();
-                    resultProvider->add(res.template staticCast<T>());
-                }
+                resultProvider->add(res.template staticCast<T>());
             }
-            resultProvider->initialResultSetComplete(parent, true);
+            resultProvider->initialResultSetComplete(true);
         });
         auto job = KAsync::start([query, resultProvider]() {});
         return qMakePair(job, emitter);
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 7e348c2..94818e1 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -13,7 +13,6 @@
 
 template <typename T>
 struct Result {
-    QSharedPointer<T> parent;
     bool fetchedAll;
 };
 
@@ -73,37 +72,28 @@ public:
         // We have to do it this way, otherwise we're not setting the fetcher right
         auto emitter = resultProvider->emitter();
 
-        resultProvider->setFetcher([query, resultProvider, this, ctx](const typename T::Ptr &parent) {
+        resultProvider->setFetcher([query, resultProvider, this, ctx]() {
             async::run<Result<T>>([=] {
-                if (parent) {
-                    SinkTraceCtx(ctx) << "Running the fetcher " << parent->identifier();
-                } else {
-                    SinkTraceCtx(ctx) << "Running the fetcher.";
-                }
+                SinkTraceCtx(ctx) << "Running the fetcher.";
                 SinkTraceCtx(ctx) << "-------------------------.";
                 int count = 0;
                 for (int i = offset; i < results.size(); i++) {
                     const auto res = results.at(i);
                     count++;
-                    // SinkTraceCtx(ctx) << "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()) {
-                        // SinkTraceCtx(ctx) << "Found a hit" << res->identifier();
-                        resultProvider->add(res);
-                    }
+                    resultProvider->add(res);
                     if (query.limit()) {
                         if (count >= query.limit()) {
                             SinkTraceCtx(ctx) << "Aborting early after " << count << "results.";
                             offset = i + 1;
                             bool fetchedAll = (i + 1 >= results.size());
-                            return Result<T>{parent, fetchedAll};
+                            return Result<T>{fetchedAll};
                         }
                     }
                 }
-                return Result<T>{parent, true};
+                return Result<T>{true};
             }, runAsync)
             .then([=] (const Result<T> &r) {
-                resultProvider->initialResultSetComplete(r.parent, r.fetchedAll);
+                resultProvider->initialResultSetComplete(r.fetchedAll);
             })
             .exec();
         });
diff --git a/tests/databasepopulationandfacadequerybenchmark.cpp b/tests/databasepopulationandfacadequerybenchmark.cpp
index 4f81d1d..7f478cf 100644
--- a/tests/databasepopulationandfacadequerybenchmark.cpp
+++ b/tests/databasepopulationandfacadequerybenchmark.cpp
@@ -113,8 +113,8 @@ class DatabasePopulationAndFacadeQueryBenchmark : public QObject
         QList<Sink::ApplicationDomain::Event::Ptr> list;
         emitter->onAdded([&list](const Sink::ApplicationDomain::Event::Ptr &event) { list << event; });
         bool done = false;
-        emitter->onInitialResultSetComplete([&done](const Sink::ApplicationDomain::Event::Ptr &event, bool) { done = true; });
-        emitter->fetch(Sink::ApplicationDomain::Event::Ptr());
+        emitter->onInitialResultSetComplete([&done](bool) { done = true; });
+        emitter->fetch();
         QUICK_TRY_VERIFY(done);
         QCOMPARE(list.size(), count);
 
diff --git a/tests/mailquerybenchmark.cpp b/tests/mailquerybenchmark.cpp
index 1d295b5..3eccfc3 100644
--- a/tests/mailquerybenchmark.cpp
+++ b/tests/mailquerybenchmark.cpp
@@ -96,8 +96,8 @@ class MailQueryBenchmark : public QObject
         int i = 0;
         emitter->onAdded([&](const Mail::Ptr &) { i++; });
         bool done = false;
-        emitter->onInitialResultSetComplete([&done](const Mail::Ptr &mail, bool) { done = true; });
-        emitter->fetch(Mail::Ptr());
+        emitter->onInitialResultSetComplete([&done](bool) { done = true; });
+        emitter->fetch();
         QUICK_TRY_VERIFY(done);
         return i;
     }
@@ -273,8 +273,8 @@ private slots:
         emitter->onRemoved([&](const Mail::Ptr &mail) { removed << mail; /*qWarning() << "Removed";*/ });
         emitter->onModified([&](const Mail::Ptr &mail) { modified << mail; /*qWarning() << "Modified";*/ });
         bool done = false;
-        emitter->onInitialResultSetComplete([&done](const Mail::Ptr &mail, bool) { done = true; });
-        emitter->fetch(Mail::Ptr());
+        emitter->onInitialResultSetComplete([&done](bool) { done = true; });
+        emitter->fetch();
         QUICK_TRY_VERIFY(done);
         QCOMPARE(added.size(), expectedSize);
 
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index 6279fa9..5af8a99 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -245,8 +245,6 @@ private slots:
         auto model = Sink::Store::loadModel<Folder>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
-        model->fetchMore(model->index(0, 0));
-        QTRY_VERIFY(model->data(model->index(0, 0), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(model->index(0, 0)), 1);
     }
 
@@ -266,7 +264,6 @@ private slots:
         auto model = Sink::Store::loadModel<Folder>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
-        model->fetchMore(model->index(0, 0));
 
         auto subfolder = ApplicationDomainType::createEntity<Folder>("sink.dummy.instance1");
         subfolder.setParent(folder.identifier());
@@ -274,9 +271,7 @@ private slots:
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue("sink.dummy.instance1"));
 
         //Ensure the folder appears
-        model->fetchMore(model->index(0, 0));
-        QTRY_VERIFY(model->data(model->index(0, 0), Sink::Store::ChildrenFetchedRole).toBool());
-        QCOMPARE(model->rowCount(model->index(0, 0)), 1);
+        QTRY_COMPARE(model->rowCount(model->index(0, 0)), 1);
 
         //...and dissapears again after removal
         VERIFYEXEC(Sink::Store::remove<Folder>(subfolder));