summaryrefslogtreecommitdiffstats
path: root/common/queryrunner.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'common/queryrunner.cpp')
-rw-r--r--common/queryrunner.cpp132
1 files changed, 66 insertions, 66 deletions
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 89610e3..25d69b1 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -26,7 +26,7 @@
26#include "domainadaptor.h" 26#include "domainadaptor.h"
27#include "asyncutils.h" 27#include "asyncutils.h"
28 28
29using namespace Akonadi2; 29using namespace Sink;
30 30
31/* 31/*
32 * This class wraps the actual query implementation. 32 * This class wraps the actual query implementation.
@@ -38,34 +38,34 @@ template<typename DomainType>
38class QueryWorker : public QObject 38class QueryWorker : public QObject
39{ 39{
40public: 40public:
41 QueryWorker(const Akonadi2::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType); 41 QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType);
42 virtual ~QueryWorker(); 42 virtual ~QueryWorker();
43 43
44 qint64 executeIncrementalQuery(const Akonadi2::Query &query, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider); 44 qint64 executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
45 qint64 executeInitialQuery(const Akonadi2::Query &query, const typename DomainType::Ptr &parent, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider); 45 qint64 executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
46 46
47private: 47private:
48 static void replaySet(ResultSet &resultSet, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties); 48 static void replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties);
49 49
50 void readEntity(const Akonadi2::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> &resultCallback); 50 void readEntity(const Sink::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)> &resultCallback);
51 51
52 ResultSet loadInitialResultSet(const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters); 52 ResultSet loadInitialResultSet(const Sink::Query &query, Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters);
53 ResultSet loadIncrementalResultSet(qint64 baseRevision, const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters); 53 ResultSet loadIncrementalResultSet(qint64 baseRevision, const Sink::Query &query, Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters);
54 54
55 ResultSet filterSet(const ResultSet &resultSet, const std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const Akonadi2::Storage::NamedDatabase &db, bool initialQuery); 55 ResultSet filterSet(const ResultSet &resultSet, const std::function<bool(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const Sink::Storage::NamedDatabase &db, bool initialQuery);
56 std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> getFilter(const QSet<QByteArray> remainingFilters, const Akonadi2::Query &query); 56 std::function<bool(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> getFilter(const QSet<QByteArray> remainingFilters, const Sink::Query &query);
57 qint64 load(const Akonadi2::Query &query, const std::function<ResultSet(Akonadi2::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery); 57 qint64 load(const Sink::Query &query, const std::function<ResultSet(Sink::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery);
58 58
59private: 59private:
60 DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory; 60 DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
61 QByteArray mResourceInstanceIdentifier; 61 QByteArray mResourceInstanceIdentifier;
62 QByteArray mBufferType; 62 QByteArray mBufferType;
63 Akonadi2::Query mQuery; 63 Sink::Query mQuery;
64}; 64};
65 65
66 66
67template<class DomainType> 67template<class DomainType>
68QueryRunner<DomainType>::QueryRunner(const Akonadi2::Query &query, const Akonadi2::ResourceAccessInterface::Ptr &resourceAccess, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType) 68QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::ResourceAccessInterface::Ptr &resourceAccess, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType)
69 : QueryRunnerBase(), 69 : QueryRunnerBase(),
70 mResourceAccess(resourceAccess), 70 mResourceAccess(resourceAccess),
71 mResultProvider(new ResultProvider<typename DomainType::Ptr>) 71 mResultProvider(new ResultProvider<typename DomainType::Ptr>)
@@ -107,7 +107,7 @@ QueryRunner<DomainType>::QueryRunner(const Akonadi2::Query &query, const Akonadi
107 //Ensure the connection is open, if it wasn't already opened 107 //Ensure the connection is open, if it wasn't already opened
108 //TODO If we are not connected already, we have to check for the latest revision once connected, otherwise we could miss some updates 108 //TODO If we are not connected already, we have to check for the latest revision once connected, otherwise we could miss some updates
109 mResourceAccess->open(); 109 mResourceAccess->open();
110 QObject::connect(mResourceAccess.data(), &Akonadi2::ResourceAccess::revisionChanged, this, &QueryRunner::revisionChanged); 110 QObject::connect(mResourceAccess.data(), &Sink::ResourceAccess::revisionChanged, this, &QueryRunner::revisionChanged);
111 } 111 }
112} 112}
113 113
@@ -118,26 +118,26 @@ QueryRunner<DomainType>::~QueryRunner()
118} 118}
119 119
120template<class DomainType> 120template<class DomainType>
121typename Akonadi2::ResultEmitter<typename DomainType::Ptr>::Ptr QueryRunner<DomainType>::emitter() 121typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr QueryRunner<DomainType>::emitter()
122{ 122{
123 return mResultProvider->emitter(); 123 return mResultProvider->emitter();
124} 124}
125 125
126 126
127 127
128static inline ResultSet fullScan(const Akonadi2::Storage::Transaction &transaction, const QByteArray &bufferType) 128static inline ResultSet fullScan(const Sink::Storage::Transaction &transaction, const QByteArray &bufferType)
129{ 129{
130 //TODO use a result set with an iterator, to read values on demand 130 //TODO use a result set with an iterator, to read values on demand
131 QVector<QByteArray> keys; 131 QVector<QByteArray> keys;
132 transaction.openDatabase(bufferType + ".main").scan(QByteArray(), [&](const QByteArray &key, const QByteArray &value) -> bool { 132 transaction.openDatabase(bufferType + ".main").scan(QByteArray(), [&](const QByteArray &key, const QByteArray &value) -> bool {
133 //Skip internals 133 //Skip internals
134 if (Akonadi2::Storage::isInternalKey(key)) { 134 if (Sink::Storage::isInternalKey(key)) {
135 return true; 135 return true;
136 } 136 }
137 keys << Akonadi2::Storage::uidFromKey(key); 137 keys << Sink::Storage::uidFromKey(key);
138 return true; 138 return true;
139 }, 139 },
140 [](const Akonadi2::Storage::Error &error) { 140 [](const Sink::Storage::Error &error) {
141 qWarning() << "Error during query: " << error.message; 141 qWarning() << "Error during query: " << error.message;
142 }); 142 });
143 143
@@ -147,7 +147,7 @@ static inline ResultSet fullScan(const Akonadi2::Storage::Transaction &transacti
147 147
148 148
149template<class DomainType> 149template<class DomainType>
150QueryWorker<DomainType>::QueryWorker(const Akonadi2::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType) 150QueryWorker<DomainType>::QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType)
151 : QObject(), 151 : QObject(),
152 mDomainTypeAdaptorFactory(factory), 152 mDomainTypeAdaptorFactory(factory),
153 mResourceInstanceIdentifier(instanceIdentifier), 153 mResourceInstanceIdentifier(instanceIdentifier),
@@ -164,23 +164,23 @@ QueryWorker<DomainType>::~QueryWorker()
164} 164}
165 165
166template<class DomainType> 166template<class DomainType>
167void QueryWorker<DomainType>::replaySet(ResultSet &resultSet, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties) 167void QueryWorker<DomainType>::replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties)
168{ 168{
169 int counter = 0; 169 int counter = 0;
170 while (resultSet.next([&resultProvider, &counter, &properties](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value, Akonadi2::Operation operation) -> bool { 170 while (resultSet.next([&resultProvider, &counter, &properties](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &value, Sink::Operation operation) -> bool {
171 counter++; 171 counter++;
172 switch (operation) { 172 switch (operation) {
173 case Akonadi2::Operation_Creation: 173 case Sink::Operation_Creation:
174 // Trace() << "Got creation"; 174 // Trace() << "Got creation";
175 resultProvider.add(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>()); 175 resultProvider.add(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
176 break; 176 break;
177 case Akonadi2::Operation_Modification: 177 case Sink::Operation_Modification:
178 // Trace() << "Got modification"; 178 // Trace() << "Got modification";
179 resultProvider.modify(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>()); 179 resultProvider.modify(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
180 break; 180 break;
181 case Akonadi2::Operation_Removal: 181 case Sink::Operation_Removal:
182 // Trace() << "Got removal"; 182 // Trace() << "Got removal";
183 resultProvider.remove(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>()); 183 resultProvider.remove(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
184 break; 184 break;
185 } 185 }
186 return true; 186 return true;
@@ -189,35 +189,35 @@ void QueryWorker<DomainType>::replaySet(ResultSet &resultSet, Akonadi2::ResultPr
189} 189}
190 190
191template<class DomainType> 191template<class DomainType>
192void QueryWorker<DomainType>::readEntity(const Akonadi2::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> &resultCallback) 192void QueryWorker<DomainType>::readEntity(const Sink::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)> &resultCallback)
193{ 193{
194 //This only works for a 1:1 mapping of resource to domain types. 194 //This only works for a 1:1 mapping of resource to domain types.
195 //Not i.e. for tags that are stored as flags in each entity of an imap store. 195 //Not i.e. for tags that are stored as flags in each entity of an imap store.
196 //additional properties that don't have a 1:1 mapping (such as separately stored tags), 196 //additional properties that don't have a 1:1 mapping (such as separately stored tags),
197 //could be added to the adaptor. 197 //could be added to the adaptor.
198 db.findLatest(key, [=](const QByteArray &key, const QByteArray &value) -> bool { 198 db.findLatest(key, [=](const QByteArray &key, const QByteArray &value) -> bool {
199 Akonadi2::EntityBuffer buffer(value.data(), value.size()); 199 Sink::EntityBuffer buffer(value.data(), value.size());
200 const Akonadi2::Entity &entity = buffer.entity(); 200 const Sink::Entity &entity = buffer.entity();
201 const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata()); 201 const auto metadataBuffer = Sink::EntityBuffer::readBuffer<Sink::Metadata>(entity.metadata());
202 Q_ASSERT(metadataBuffer); 202 Q_ASSERT(metadataBuffer);
203 const qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1; 203 const qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
204 const auto operation = metadataBuffer ? metadataBuffer->operation() : Akonadi2::Operation_Creation; 204 const auto operation = metadataBuffer ? metadataBuffer->operation() : Sink::Operation_Creation;
205 resultCallback(DomainType::Ptr::create(mResourceInstanceIdentifier, Akonadi2::Storage::uidFromKey(key), revision, mDomainTypeAdaptorFactory->createAdaptor(entity)), operation); 205 resultCallback(DomainType::Ptr::create(mResourceInstanceIdentifier, Sink::Storage::uidFromKey(key), revision, mDomainTypeAdaptorFactory->createAdaptor(entity)), operation);
206 return false; 206 return false;
207 }, 207 },
208 [](const Akonadi2::Storage::Error &error) { 208 [](const Sink::Storage::Error &error) {
209 qWarning() << "Error during query: " << error.message; 209 qWarning() << "Error during query: " << error.message;
210 }); 210 });
211} 211}
212 212
213template<class DomainType> 213template<class DomainType>
214ResultSet QueryWorker<DomainType>::loadInitialResultSet(const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) 214ResultSet QueryWorker<DomainType>::loadInitialResultSet(const Sink::Query &query, Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters)
215{ 215{
216 if (!query.ids.isEmpty()) { 216 if (!query.ids.isEmpty()) {
217 return ResultSet(query.ids.toVector()); 217 return ResultSet(query.ids.toVector());
218 } 218 }
219 QSet<QByteArray> appliedFilters; 219 QSet<QByteArray> appliedFilters;
220 auto resultSet = Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(query, mResourceInstanceIdentifier, appliedFilters, transaction); 220 auto resultSet = Sink::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(query, mResourceInstanceIdentifier, appliedFilters, transaction);
221 remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters; 221 remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
222 222
223 //We do a full scan if there were no indexes available to create the initial set. 223 //We do a full scan if there were no indexes available to create the initial set.
@@ -229,24 +229,24 @@ ResultSet QueryWorker<DomainType>::loadInitialResultSet(const Akonadi2::Query &q
229} 229}
230 230
231template<class DomainType> 231template<class DomainType>
232ResultSet QueryWorker<DomainType>::loadIncrementalResultSet(qint64 baseRevision, const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) 232ResultSet QueryWorker<DomainType>::loadIncrementalResultSet(qint64 baseRevision, const Sink::Query &query, Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters)
233{ 233{
234 const auto bufferType = mBufferType; 234 const auto bufferType = mBufferType;
235 auto revisionCounter = QSharedPointer<qint64>::create(baseRevision); 235 auto revisionCounter = QSharedPointer<qint64>::create(baseRevision);
236 remainingFilters = query.propertyFilter.keys().toSet(); 236 remainingFilters = query.propertyFilter.keys().toSet();
237 return ResultSet([bufferType, revisionCounter, &transaction]() -> QByteArray { 237 return ResultSet([bufferType, revisionCounter, &transaction]() -> QByteArray {
238 const qint64 topRevision = Akonadi2::Storage::maxRevision(transaction); 238 const qint64 topRevision = Sink::Storage::maxRevision(transaction);
239 //Spit out the revision keys one by one. 239 //Spit out the revision keys one by one.
240 while (*revisionCounter <= topRevision) { 240 while (*revisionCounter <= topRevision) {
241 const auto uid = Akonadi2::Storage::getUidFromRevision(transaction, *revisionCounter); 241 const auto uid = Sink::Storage::getUidFromRevision(transaction, *revisionCounter);
242 const auto type = Akonadi2::Storage::getTypeFromRevision(transaction, *revisionCounter); 242 const auto type = Sink::Storage::getTypeFromRevision(transaction, *revisionCounter);
243 // Trace() << "Revision" << *revisionCounter << type << uid; 243 // Trace() << "Revision" << *revisionCounter << type << uid;
244 if (type != bufferType) { 244 if (type != bufferType) {
245 //Skip revision 245 //Skip revision
246 *revisionCounter += 1; 246 *revisionCounter += 1;
247 continue; 247 continue;
248 } 248 }
249 const auto key = Akonadi2::Storage::assembleKey(uid, *revisionCounter); 249 const auto key = Sink::Storage::assembleKey(uid, *revisionCounter);
250 *revisionCounter += 1; 250 *revisionCounter += 1;
251 return key; 251 return key;
252 } 252 }
@@ -257,21 +257,21 @@ ResultSet QueryWorker<DomainType>::loadIncrementalResultSet(qint64 baseRevision,
257} 257}
258 258
259template<class DomainType> 259template<class DomainType>
260ResultSet QueryWorker<DomainType>::filterSet(const ResultSet &resultSet, const std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const Akonadi2::Storage::NamedDatabase &db, bool initialQuery) 260ResultSet QueryWorker<DomainType>::filterSet(const ResultSet &resultSet, const std::function<bool(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const Sink::Storage::NamedDatabase &db, bool initialQuery)
261{ 261{
262 auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet); 262 auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet);
263 263
264 //Read through the source values and return whatever matches the filter 264 //Read through the source values and return whatever matches the filter
265 std::function<bool(std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)>)> generator = [this, resultSetPtr, &db, filter, initialQuery](std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> callback) -> bool { 265 std::function<bool(std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)>)> generator = [this, resultSetPtr, &db, filter, initialQuery](std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)> callback) -> bool {
266 if (resultSetPtr->next()) { 266 if (resultSetPtr->next()) {
267 //readEntity is only necessary if we actually want to filter or know the operation type (but not a big deal if we do it always I guess) 267 //readEntity is only necessary if we actually want to filter or know the operation type (but not a big deal if we do it always I guess)
268 readEntity(db, resultSetPtr->id(), [this, filter, callback, initialQuery](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject, Akonadi2::Operation operation) { 268 readEntity(db, resultSetPtr->id(), [this, filter, callback, initialQuery](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject, Sink::Operation operation) {
269 //Always remove removals, they probably don't match due to non-available properties 269 //Always remove removals, they probably don't match due to non-available properties
270 if (filter(domainObject) || operation == Akonadi2::Operation_Removal) { 270 if (filter(domainObject) || operation == Sink::Operation_Removal) {
271 if (initialQuery) { 271 if (initialQuery) {
272 //We're not interested in removals during the initial query 272 //We're not interested in removals during the initial query
273 if (operation != Akonadi2::Operation_Removal) { 273 if (operation != Sink::Operation_Removal) {
274 callback(domainObject, Akonadi2::Operation_Creation); 274 callback(domainObject, Sink::Operation_Creation);
275 } 275 }
276 } else { 276 } else {
277 callback(domainObject, operation); 277 callback(domainObject, operation);
@@ -287,9 +287,9 @@ ResultSet QueryWorker<DomainType>::filterSet(const ResultSet &resultSet, const s
287} 287}
288 288
289template<class DomainType> 289template<class DomainType>
290std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> QueryWorker<DomainType>::getFilter(const QSet<QByteArray> remainingFilters, const Akonadi2::Query &query) 290std::function<bool(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> QueryWorker<DomainType>::getFilter(const QSet<QByteArray> remainingFilters, const Sink::Query &query)
291{ 291{
292 return [remainingFilters, query](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool { 292 return [remainingFilters, query](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool {
293 if (!query.ids.isEmpty()) { 293 if (!query.ids.isEmpty()) {
294 if (!query.ids.contains(domainObject->identifier())) { 294 if (!query.ids.contains(domainObject->identifier())) {
295 return false; 295 return false;
@@ -312,32 +312,32 @@ std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr
312} 312}
313 313
314template<class DomainType> 314template<class DomainType>
315qint64 QueryWorker<DomainType>::load(const Akonadi2::Query &query, const std::function<ResultSet(Akonadi2::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery) 315qint64 QueryWorker<DomainType>::load(const Sink::Query &query, const std::function<ResultSet(Sink::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery)
316{ 316{
317 Akonadi2::Storage storage(Akonadi2::storageLocation(), mResourceInstanceIdentifier); 317 Sink::Storage storage(Sink::storageLocation(), mResourceInstanceIdentifier);
318 storage.setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) { 318 storage.setDefaultErrorHandler([](const Sink::Storage::Error &error) {
319 Warning() << "Error during query: " << error.store << error.message; 319 Warning() << "Error during query: " << error.store << error.message;
320 }); 320 });
321 auto transaction = storage.createTransaction(Akonadi2::Storage::ReadOnly); 321 auto transaction = storage.createTransaction(Sink::Storage::ReadOnly);
322 auto db = transaction.openDatabase(mBufferType + ".main"); 322 auto db = transaction.openDatabase(mBufferType + ".main");
323 323
324 QSet<QByteArray> remainingFilters; 324 QSet<QByteArray> remainingFilters;
325 auto resultSet = baseSetRetriever(transaction, remainingFilters); 325 auto resultSet = baseSetRetriever(transaction, remainingFilters);
326 auto filteredSet = filterSet(resultSet, getFilter(remainingFilters, query), db, initialQuery); 326 auto filteredSet = filterSet(resultSet, getFilter(remainingFilters, query), db, initialQuery);
327 replaySet(filteredSet, resultProvider, query.requestedProperties); 327 replaySet(filteredSet, resultProvider, query.requestedProperties);
328 resultProvider.setRevision(Akonadi2::Storage::maxRevision(transaction)); 328 resultProvider.setRevision(Sink::Storage::maxRevision(transaction));
329 return Akonadi2::Storage::maxRevision(transaction); 329 return Sink::Storage::maxRevision(transaction);
330} 330}
331 331
332template<class DomainType> 332template<class DomainType>
333qint64 QueryWorker<DomainType>::executeIncrementalQuery(const Akonadi2::Query &query, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider) 333qint64 QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider)
334{ 334{
335 QTime time; 335 QTime time;
336 time.start(); 336 time.start();
337 337
338 const qint64 baseRevision = resultProvider.revision() + 1; 338 const qint64 baseRevision = resultProvider.revision() + 1;
339 Trace() << "Running incremental query " << baseRevision; 339 Trace() << "Running incremental query " << baseRevision;
340 auto revision = load(query, [&](Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet { 340 auto revision = load(query, [&](Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet {
341 return loadIncrementalResultSet(baseRevision, query, transaction, remainingFilters); 341 return loadIncrementalResultSet(baseRevision, query, transaction, remainingFilters);
342 }, resultProvider, false); 342 }, resultProvider, false);
343 Trace() << "Incremental query took: " << time.elapsed() << " ms"; 343 Trace() << "Incremental query took: " << time.elapsed() << " ms";
@@ -345,7 +345,7 @@ qint64 QueryWorker<DomainType>::executeIncrementalQuery(const Akonadi2::Query &q
345} 345}
346 346
347template<class DomainType> 347template<class DomainType>
348qint64 QueryWorker<DomainType>::executeInitialQuery(const Akonadi2::Query &query, const typename DomainType::Ptr &parent, Akonadi2::ResultProviderInterface<typename DomainType::Ptr> &resultProvider) 348qint64 QueryWorker<DomainType>::executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider)
349{ 349{
350 QTime time; 350 QTime time;
351 time.start(); 351 time.start();
@@ -360,7 +360,7 @@ qint64 QueryWorker<DomainType>::executeInitialQuery(const Akonadi2::Query &query
360 modifiedQuery.propertyFilter.insert(query.parentProperty, QVariant()); 360 modifiedQuery.propertyFilter.insert(query.parentProperty, QVariant());
361 } 361 }
362 } 362 }
363 auto revision = load(modifiedQuery, [&](Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet { 363 auto revision = load(modifiedQuery, [&](Sink::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet {
364 return loadInitialResultSet(modifiedQuery, transaction, remainingFilters); 364 return loadInitialResultSet(modifiedQuery, transaction, remainingFilters);
365 }, resultProvider, true); 365 }, resultProvider, true);
366 Trace() << "Initial query took: " << time.elapsed() << " ms"; 366 Trace() << "Initial query took: " << time.elapsed() << " ms";
@@ -368,9 +368,9 @@ qint64 QueryWorker<DomainType>::executeInitialQuery(const Akonadi2::Query &query
368 return revision; 368 return revision;
369} 369}
370 370
371template class QueryRunner<Akonadi2::ApplicationDomain::Folder>; 371template class QueryRunner<Sink::ApplicationDomain::Folder>;
372template class QueryRunner<Akonadi2::ApplicationDomain::Mail>; 372template class QueryRunner<Sink::ApplicationDomain::Mail>;
373template class QueryRunner<Akonadi2::ApplicationDomain::Event>; 373template class QueryRunner<Sink::ApplicationDomain::Event>;
374template class QueryWorker<Akonadi2::ApplicationDomain::Folder>; 374template class QueryWorker<Sink::ApplicationDomain::Folder>;
375template class QueryWorker<Akonadi2::ApplicationDomain::Mail>; 375template class QueryWorker<Sink::ApplicationDomain::Mail>;
376template class QueryWorker<Akonadi2::ApplicationDomain::Event>; 376template class QueryWorker<Sink::ApplicationDomain::Event>;
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-28 21:37:12 +0000