Warning, file /pim/akonadi-search/xapian/xapiansearchstore.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
  * This file is part of the KDE Akonadi Search Project
  * SPDX-FileCopyrightText: 2013-2014 Vishesh Handa <me@vhanda.in>
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  *
  */
 
 #include "xapiansearchstore.h"
 #include "query.h"
 #include "xapianqueryparser.h"
 
 #include "akonadi_search_xapian_debug.h"
 #include <QList>
 
 #include <algorithm>
 
 using namespace Akonadi::Search;
 
 XapianSearchStore::XapianSearchStore(QObject *parent)
     : SearchStore(parent)
     , m_mutex()
 {
 }
 
 XapianSearchStore::~XapianSearchStore()
 {
     delete m_db;
 }
 
 void XapianSearchStore::setDbPath(const QString &path)
 {
     m_dbPath = path;
 
     delete m_db;
     m_db = nullptr;
 
     try {
         m_db = new Xapian::Database(m_dbPath.toStdString());
     } catch (const Xapian::DatabaseOpeningError &) {
         qCWarning(AKONADI_SEARCH_XAPIAN_LOG) << "Xapian Database does not exist at " << m_dbPath;
     } catch (const Xapian::DatabaseCorruptError &) {
         qCWarning(AKONADI_SEARCH_XAPIAN_LOG) << "Xapian Database corrupted at " << m_dbPath;
     } catch (...) {
         qCWarning(AKONADI_SEARCH_XAPIAN_LOG) << "Random exception, but we do not want to crash";
     }
 }
 
 QString XapianSearchStore::dbPath()
 {
     return m_dbPath;
 }
 
 Xapian::Query XapianSearchStore::toXapianQuery(Xapian::Query::op op, const QList<Term> &terms)
 {
     Q_ASSERT_X(op == Xapian::Query::OP_AND || op == Xapian::Query::OP_OR, "XapianSearchStore::toXapianQuery", "The op must be AND / OR");
 
     QList<Xapian::Query> queries;
     queries.reserve(terms.size());
 
     for (const Term &term : terms) {
         const Xapian::Query q = toXapianQuery(term);
         queries << q;
     }
 
     return {op, queries.begin(), queries.end()};
 }
 
 static Xapian::Query negate(bool shouldNegate, const Xapian::Query &query)
 {
     if (shouldNegate) {
         return Xapian::Query(Xapian::Query::OP_AND_NOT, Xapian::Query::MatchAll, query);
     }
     return query;
 }
 
 Xapian::Query XapianSearchStore::toXapianQuery(const Term &term)
 {
     if (term.operation() == Term::And) {
         return negate(term.isNegated(), toXapianQuery(Xapian::Query::OP_AND, term.subTerms()));
     }
     if (term.operation() == Term::Or) {
         return negate(term.isNegated(), toXapianQuery(Xapian::Query::OP_OR, term.subTerms()));
     }
 
     return negate(term.isNegated(), constructQuery(term.property(), term.value(), term.comparator()));
 }
 
 Xapian::Query XapianSearchStore::andQuery(const Xapian::Query &a, const Xapian::Query &b)
 {
     if (a.empty() && !b.empty()) {
         return b;
     }
     if (!a.empty() && b.empty()) {
         return a;
     }
     if (a.empty() && b.empty()) {
         return {};
     } else {
         return Xapian::Query(Xapian::Query::OP_AND, a, b);
     }
 }
 
 Xapian::Query XapianSearchStore::constructSearchQuery(const QString &str)
 {
     XapianQueryParser parser;
     parser.setDatabase(m_db);
     return parser.parseQuery(str);
 }
 
 int XapianSearchStore::exec(const Query &query)
 {
     if (!m_db) {
         return 0;
     }
 
     while (true) {
         try {
             QMutexLocker lock(&m_mutex);
             try {
                 m_db->reopen();
             } catch (Xapian::DatabaseError &e) {
                 qCDebug(AKONADI_SEARCH_XAPIAN_LOG) << "Failed to reopen database" << dbPath() << ":" << QString::fromStdString(e.get_msg());
                 return 0;
             }
 
             Xapian::Query xapQ = toXapianQuery(query.term());
             // The term was not properly converted. Lets abort. The properties
             // must not exist
             if (!query.term().empty() && xapQ.empty()) {
                 qCDebug(AKONADI_SEARCH_XAPIAN_LOG) << query.term() << "could not be processed. Aborting";
                 return 0;
             }
             if (!query.searchString().isEmpty()) {
                 QString str = query.searchString();
 
                 Xapian::Query q = constructSearchQuery(str);
                 xapQ = andQuery(xapQ, q);
             }
             xapQ = andQuery(xapQ, convertTypes(query.types()));
             xapQ = andQuery(xapQ, constructFilterQuery(query.yearFilter(), query.monthFilter(), query.dayFilter()));
             xapQ = applyCustomOptions(xapQ, query.customOptions());
             xapQ = finalizeQuery(xapQ);
 
             if (xapQ.empty()) {
                 // Return all the results
                 xapQ = Xapian::Query(std::string());
             }
             Xapian::Enquire enquire(*m_db);
             enquire.set_query(xapQ);
 
             if (query.sortingOption() == Query::SortNone) {
                 enquire.set_weighting_scheme(Xapian::BoolWeight());
             }
 
             Result &res = m_queryMap[m_nextId++];
             res.mset = enquire.get_mset(query.offset(), query.limit());
             res.it = res.mset.begin();
 
             return m_nextId - 1;
         } catch (const Xapian::DatabaseModifiedError &) {
             continue;
         } catch (const Xapian::Error &) {
             return 0;
         }
     }
 
     return 0;
 }
 
 void XapianSearchStore::close(int queryId)
 {
     QMutexLocker lock(&m_mutex);
     m_queryMap.remove(queryId);
 }
 
 QByteArray XapianSearchStore::id(int queryId)
 {
     QMutexLocker lock(&m_mutex);
     Q_ASSERT_X(m_queryMap.contains(queryId), "FileSearchStore::id", "Passed a queryId which does not exist");
 
     const Result res = m_queryMap.value(queryId);
     if (!res.lastId) {
         return {};
     }
 
     return serialize(idPrefix(), res.lastId);
 }
 
 QUrl XapianSearchStore::url(int queryId)
 {
     QMutexLocker lock(&m_mutex);
     Result &res = m_queryMap[queryId];
 
     if (!res.lastId) {
         return {};
     }
 
     if (!res.lastUrl.isEmpty()) {
         return res.lastUrl;
     }
 
     res.lastUrl = constructUrl(res.lastId);
     return res.lastUrl;
 }
 
 bool XapianSearchStore::next(int queryId)
 {
     if (!m_db) {
         return false;
     }
 
     QMutexLocker lock(&m_mutex);
     Result &res = m_queryMap[queryId];
 
     bool atEnd = (res.it == res.mset.end());
     if (atEnd) {
         res.lastId = 0;
         res.lastUrl.clear();
     } else {
         res.lastId = *res.it;
         res.lastUrl.clear();
         ++res.it;
     }
 
     return !atEnd;
 }
 
 Xapian::Document XapianSearchStore::docForQuery(int queryId)
 {
     if (!m_db) {
         return {};
     }
 
     QMutexLocker lock(&m_mutex);
 
     try {
         const Result &res = m_queryMap.value(queryId);
         if (!res.lastId) {
             return {};
         }
 
         return m_db->get_document(res.lastId);
     } catch (const Xapian::DocNotFoundError &) {
         return {};
     } catch (const Xapian::DatabaseModifiedError &) {
         m_db->reopen();
         return docForQuery(queryId);
     } catch (const Xapian::Error &) {
         return {};
     }
 }
 
 Xapian::Database *XapianSearchStore::xapianDb()
 {
     return m_db;
 }
 
 Xapian::Query XapianSearchStore::constructFilterQuery(int year, int month, int day)
 {
     Q_UNUSED(year)
     Q_UNUSED(month)
     Q_UNUSED(day)
     return {};
 }
 
 Xapian::Query XapianSearchStore::finalizeQuery(const Xapian::Query &query)
 {
     return query;
 }
 
 Xapian::Query XapianSearchStore::applyCustomOptions(const Xapian::Query &q, const QVariantMap &options)
 {
     Q_UNUSED(options)
     return q;
 }
 
 #include "moc_xapiansearchstore.cpp"