From 625190d311adfcf3f0436cfece82249a92489348 Mon Sep 17 00:00:00 2001 From: Christian Mollekopf Date: Thu, 28 Dec 2017 12:05:34 +0100 Subject: No parent query --- common/modelresult.cpp | 59 +++++++------- common/modelresult.h | 6 +- common/notifier.cpp | 8 +- common/queryrunner.cpp | 22 +++--- common/queryrunner.h | 2 +- common/resourcefacade.cpp | 10 +-- common/resultprovider.h | 91 ++++++++++++---------- common/store.cpp | 12 +-- common/test.cpp | 17 +--- tests/clientapitest.cpp | 22 ++---- .../databasepopulationandfacadequerybenchmark.cpp | 4 +- tests/mailquerybenchmark.cpp | 8 +- tests/querytest.cpp | 7 +- 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::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*>(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*>(this); + // p->fetchMore(parent); + // } return QAbstractItemModel::hasChildren(parent); } @@ -278,7 +278,9 @@ template void ModelResult::fetchMore(const QModelIndex &parent) { SinkTraceCtx(mLogCtx) << "Fetching more: " << parent; - fetchEntities(parent); + if (!parent.isValid()) { + fetchEntities(); + } } template @@ -287,10 +289,10 @@ void ModelResult::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::remove(const Ptr &value) } template -void ModelResult::fetchEntities(const QModelIndex &parent) +void ModelResult::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()); + loadEntities(); } else { SinkWarningCtx(mLogCtx) << "No way to fetch entities"; } } template -void ModelResult::setFetcher(const std::function &fetcher) +void ModelResult::setFetcher(const std::function &fetcher) { SinkTraceCtx(mLogCtx) << "Setting fetcher"; loadEntities = fetcher; @@ -364,7 +366,7 @@ void ModelResult::setFetcher(const std::function void ModelResult::setEmitter(const typename Sink::ResultEmitter::Ptr &emitter) { - setFetcher([this](const Ptr &parent) { mEmitter->fetch(parent); }); + setFetcher([this]() { mEmitter->fetch(); }); QPointer guard(this); emitter->onAdded([this, guard](const Ptr &value) { @@ -389,18 +391,19 @@ void ModelResult::setEmitter(const typename Sink::ResultEmitter::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() << ChildrenFetchedRole); + // emit dataChanged(parentIndex, parentIndex, QVector() << ChildrenFetchedRole); + emit dataChanged({}, {}, QVector() << ChildrenFetchedRole); }); mEmitter = emitter; } @@ -423,9 +426,9 @@ void ModelResult::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 &fetcher); + void setFetcher(const std::function &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 and QList @@ -88,7 +88,7 @@ private: QMap mEntityStatus; QList mPropertyColumns; Sink::Query mQuery; - std::function loadEntities; + std::function loadEntities; typename Sink::ResultEmitter::Ptr mEmitter; async::ThreadBoundary threadBoundary; QScopedPointer 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 &resultProvider, DataStoreQuery::State::Ptr state); - ReplayResult executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface &resultProvider, int batchsize, DataStoreQuery::State::Ptr state); + ReplayResult executeInitialQuery(const Sink::Query &query, Sink::ResultProviderInterface &resultProvider, int batchsize, DataStoreQuery::State::Ptr state); private: void resultProviderCallback(const Sink::Query &query, Sink::ResultProviderInterface &resultProvider, const ResultSet::Result &result); @@ -70,34 +70,33 @@ QueryRunner::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(&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([=]() { QueryWorker 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::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 { - 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::executeIncrementalQuery(const Sink::Query template ReplayResult QueryWorker::executeInitialQuery( - const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface &resultProvider, int batchsize, DataStoreQuery::State::Ptr state) + const Sink::Query &query, Sink::ResultProviderInterface &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 mResourceAccess; QSharedPointer> mResultProvider; ResultTransformation mResultTransformation; - QHash 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::LocalStorageQueryRunner(const Query &query, }; QObject *guard = new QObject; - mResultProvider->setFetcher([this, query, guard, &configNotifier, matchesTypeAndIds](const QSharedPointer &) { + 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::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, typename Sink::ResultEmitteridentifier(), 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 &fetcher) = 0; + virtual void setFetcher(const std::function &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 &fetcher) + void setFetcher(const std::function &fetcher) { mFetcher = fetcher; } @@ -173,7 +173,7 @@ private: QWeakPointer> mResultEmitter; std::function mOnDoneCallback; - std::function mFetcher; + std::function mFetcher; }; /* @@ -222,7 +222,7 @@ public: removeHandler = handler; } - void onInitialResultSetComplete(const std::function &handler) + void onInitialResultSetComplete(const std::function &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 &fetcher) + void setFetcher(const std::function &fetcher) { mFetcher = fetcher; } - virtual void fetch(const DomainType &parent) + virtual void fetch() { if (mFetcher) { - mFetcher(parent); + mFetcher(); } } @@ -309,11 +321,11 @@ private: std::function addHandler; std::function modifyHandler; std::function removeHandler; - std::function initialResultSetCompleteHandler; + std::function initialResultSetCompleteHandler; std::function completeHandler; std::function clearHandler; - std::function mFetcher; + std::function 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::Ptr> mEmitter; - QMultiMap *> mInitialResultSetInProgress; - QMultiMap *> mAllResultsReplayed; + QSet*> mInitialResultSetInProgress; + QSet*> 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::Ptr, typenam Q_ASSERT(!resourceType.isEmpty()); queryResource(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 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 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()) { - 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()); - } + resultProvider->add(res.template staticCast()); } - 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 struct Result { - QSharedPointer 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>([=] { - 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{parent, fetchedAll}; + return Result{fetchedAll}; } } } - return Result{parent, true}; + return Result{true}; }, runAsync) .then([=] (const Result &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 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(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(query); QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool()); QCOMPARE(model->rowCount(), 1); - model->fetchMore(model->index(0, 0)); auto subfolder = ApplicationDomainType::createEntity("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(subfolder)); -- cgit v1.2.3