Differential D18664 Diff 52229 src/engine/transaction.cpp

Changeset View

Standalone View

View Options

src/engine/transaction.cpp

Show All 33 Lines
34#include "orpostingiterator.h" 34​#include "orpostingiterator.h"
35#include "phraseanditerator.h" 35​#include "phraseanditerator.h"
36 36​
37#include "writetransaction.h" 37​#include "writetransaction.h"
38#include "idutils.h" 38​#include "idutils.h"
39#include "database.h" 39​#include "database.h"
40#include "databasesize.h" 40​#include "databasesize.h"
41 41​
42​#include "enginedebug.h"
43​
42#include <QFile> 44​#include <QFile>
43#include <QFileInfo> 45​#include <QFileInfo>
44 46​
45using namespace Baloo; 47​using namespace Baloo;
46 48​
47Transaction::Transaction(const Database& db, Transaction::TransactionType type) 49​Transaction::Transaction(const Database& db, Transaction::TransactionType type)
48 : m_dbis(db.m_dbis) 50​ : m_dbis(db.m_dbis)
49 , m_env(db.m_env) 51​ , m_env(db.m_env)
50 , m_writeTrans(nullptr) 52​ , m_writeTrans(nullptr)
51{ 53​{
52 uint flags = type == ReadOnly ? MDB_RDONLY : 0; 54​ uint flags = type == ReadOnly ? MDB_RDONLY : 0;
53 int rc = mdb_txn_begin(db.m_env, nullptr, flags, &m_txn); 55​ int rc = mdb_txn_begin(db.m_env, nullptr, flags, &m_txn);
54 Q_ASSERT_X(rc == 0, "Transaction", mdb_strerror(rc)); 56​ if (rc) {
57​ qCDebug(ENGINE) << "Transaction" << mdb_strerror(rc);
58​ return;
59​ }
55 60​
56 if (type == ReadWrite) { 61​ if (type == ReadWrite) {
57 m_writeTrans = new WriteTransaction(m_dbis, m_txn); 62​ m_writeTrans = new WriteTransaction(m_dbis, m_txn);
58 } 63​ }
59} 64​}
60 65​
61Transaction::Transaction(Database* db, Transaction::TransactionType type) 66​Transaction::Transaction(Database* db, Transaction::TransactionType type)
62 : Transaction(*db, type) 67​ : Transaction(*db, type)
63{ 68​{
64} 69​}
65 70​
66Transaction::~Transaction() 71​Transaction::~Transaction()
67{ 72​{
68 if (m_writeTrans) 73​ if (m_writeTrans) {
69 qWarning() << "Closing an active WriteTransaction without calling abort/commit"; 74​ qWarning(ENGINE) << "Closing an active WriteTransaction without calling abort/commit";
75​ }
70 76​
71 if (m_txn) { 77​ if (m_txn) {
72 abort(); 78​ abortTransaction();
73 } 79​ }
74} 80​}
75 81​
76bool Transaction::hasDocument(quint64 id) const 82​bool Transaction::hasDocument(quint64 id) const
77{ 83​{
78 Q_ASSERT(id > 0); 84​ Q_ASSERT(id > 0);
79 85​
80 IdFilenameDB idFilenameDb(m_dbis.idFilenameDbi, m_txn); 86​ IdFilenameDB idFilenameDb(m_dbis.idFilenameDbi, m_txn);
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Line(s)152{
149 155​
150 DocumentDataDB docDataDb(m_dbis.docDataDbi, m_txn); 156​ DocumentDataDB docDataDb(m_dbis.docDataDbi, m_txn);
151 return docDataDb.get(id); 157​ return docDataDb.get(id);
152} 158​}
153 159​
154bool Transaction::hasChanges() const 160​bool Transaction::hasChanges() const
155{ 161​{
156 Q_ASSERT(m_txn); 162​ Q_ASSERT(m_txn);
157 Q_ASSERT(m_writeTrans); 163​ if (!m_writeTrans) {
164​ qCWarning(ENGINE) << "m_writeTrans is null";
165​ return false;
166​ }
167​
158 return m_writeTrans->hasChanges(); 168​ return m_writeTrans->hasChanges();
159} 169​}
160 170​
161QVector<quint64> Transaction::fetchPhaseOneIds(int size) const 171​QVector<quint64> Transaction::fetchPhaseOneIds(int size) const
162{ 172​{
163 Q_ASSERT(m_txn); 173​ Q_ASSERT(m_txn);
164 Q_ASSERT(size > 0); 174​ Q_ASSERT(size > 0);
165 175​
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Line(s)228{
223 DocumentIdDB failedIdDb(m_dbis.failedIdDbi, m_txn); 233​ DocumentIdDB failedIdDb(m_dbis.failedIdDbi, m_txn);
224 failedIdDb.put(id); 234​ failedIdDb.put(id);
225} 235​}
226 236​
227void Transaction::addDocument(const Document& doc) 237​void Transaction::addDocument(const Document& doc)
228{ 238​{
229 Q_ASSERT(m_txn); 239​ Q_ASSERT(m_txn);
230 Q_ASSERT(doc.id() > 0); 240​ Q_ASSERT(doc.id() > 0);
231 Q_ASSERT(m_writeTrans); 241​ if (!m_writeTrans) {
242​ qCWarning(ENGINE) << "m_writeTrans is null";
243​ return;
244​ }
232 245​
233 m_writeTrans->addDocument(doc); 246​ m_writeTrans->addDocument(doc);
234} 247​}
235 248​
236void Transaction::removeDocument(quint64 id) 249​void Transaction::removeDocument(quint64 id)
237{ 250​{
238 Q_ASSERT(m_txn); 251​ Q_ASSERT(m_txn);
239 Q_ASSERT(id > 0); 252​ Q_ASSERT(id > 0);
240 Q_ASSERT(m_writeTrans); 253​ if (!m_writeTrans) {
254​ qCWarning(ENGINE) << "m_writeTrans is null";
255​ return;
256​ }
241 257​
242 m_writeTrans->removeDocument(id); 258​ m_writeTrans->removeDocument(id);
243} 259​}
244 260​
245void Transaction::removeRecursively(quint64 id) 261​void Transaction::removeRecursively(quint64 id)
246{ 262​{
247 Q_ASSERT(m_txn); 263​ Q_ASSERT(m_txn);
248 Q_ASSERT(id > 0); 264​ Q_ASSERT(id > 0);
249 Q_ASSERT(m_writeTrans); 265​ if (!m_writeTrans) {
266​ qCWarning(ENGINE) << "m_writeTrans is null";
267​ return;
268​ }
250 269​
251 m_writeTrans->removeRecursively(id); 270​ m_writeTrans->removeRecursively(id);
252} 271​}
253 272​
254void Transaction::replaceDocument(const Document& doc, DocumentOperations operations) 273​void Transaction::replaceDocument(const Document& doc, DocumentOperations operations)
255{ 274​{
256 Q_ASSERT(m_txn); 275​ Q_ASSERT(m_txn);
257 Q_ASSERT(doc.id() > 0); 276​ Q_ASSERT(doc.id() > 0);
258 Q_ASSERT(m_writeTrans); 277​ Q_ASSERT(m_writeTrans);
259 Q_ASSERT_X(hasDocument(doc.id()), "Transaction::replaceDocument", "Document does not exist"); 278​ if (!hasDocument(doc.id())) {
279​ qCDebug(ENGINE) << "Transaction::replaceDocument" << "Document does not exist";
280​ }
281​
282​ if (!m_writeTrans) {
283​ qCWarning(ENGINE) << "m_writeTrans is null";
brunsUnsubmitted
Done

warning

bruns: warning
284​ return;
285​ }
260 286​
261 m_writeTrans->replaceDocument(doc, operations); 287​ m_writeTrans->replaceDocument(doc, operations);
262} 288​}
263 289​
264void Transaction::commit() 290​void Transaction::commit()
265{ 291​{
266 Q_ASSERT(m_txn); 292​ Q_ASSERT(m_txn);
267 Q_ASSERT(m_writeTrans); 293​ if (!m_writeTrans) {
294​ qCWarning(ENGINE) << "m_writeTrans is null";
295​ return;
296​ }
268 297​
269 m_writeTrans->commit(); 298​ m_writeTrans->commit();
270 delete m_writeTrans; 299​ delete m_writeTrans;
271 m_writeTrans = nullptr; 300​ m_writeTrans = nullptr;
272 301​
273 int rc = mdb_txn_commit(m_txn); 302​ int rc = mdb_txn_commit(m_txn);
274 Q_ASSERT_X(rc == 0, "Transaction::commit", mdb_strerror(rc)); 303​ if (rc) {
304​ qCWarning(ENGINE) << "Transaction::commit" << mdb_strerror(rc);
brunsUnsubmitted
Done

This should also be a warning IMHO

bruns: This should also be a warning IMHO
305​ }
275 306​
276 m_txn = nullptr; 307​ m_txn = nullptr;
277} 308​}
278 309​
279void Transaction::abort() 310​void Transaction::abortTransaction()
280{ 311​{
281 Q_ASSERT(m_txn); 312​ Q_ASSERT(m_txn);
282 313​
283 mdb_txn_abort(m_txn); 314​ mdb_txn_abort(m_txn);
284 m_txn = nullptr; 315​ m_txn = nullptr;
285 316​
286 delete m_writeTrans; 317​ delete m_writeTrans;
287 m_writeTrans = nullptr; 318​ m_writeTrans = nullptr;
Show All 23 Lines326{
311 } 342​ }
312 343​
313 QVector<PostingIterator*> vec; 344​ QVector<PostingIterator*> vec;
314 vec.reserve(query.subQueries().size()); 345​ vec.reserve(query.subQueries().size());
315 346​
316 if (query.op() == EngineQuery::Phrase) { 347​ if (query.op() == EngineQuery::Phrase) {
317 const auto subQueries = query.subQueries(); 348​ const auto subQueries = query.subQueries();
318 for (const EngineQuery& q : subQueries) { 349​ for (const EngineQuery& q : subQueries) {
319 Q_ASSERT_X(q.leaf(), "Transaction::toPostingIterator", "Phrase queries must contain leaf queries"); 350​ if (!q.leaf()) {
351​ qCDebug(ENGINE) << "Transaction::toPostingIterator" << "Phrase queries must contain leaf queries";
352​ continue;
353​ }
320 vec << positionDb.iter(q.term()); 354​ vec << positionDb.iter(q.term());
321 } 355​ }
322 356​
323 return new PhraseAndIterator(vec); 357​ return new PhraseAndIterator(vec);
324 } 358​ }
325 359​
326 const auto subQueries = query.subQueries(); 360​ const auto subQueries = query.subQueries();
327 for (const EngineQuery& q : subQueries) { 361​ for (const EngineQuery& q : subQueries) {
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines