indexeditems.cpp

/*
 * This file is part of the KDE Akonadi Search Project
 * SPDX-FileCopyrightText: 2016-2023 Laurent Montel <[email protected]>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 *
 */
 
#include <xapian.h>
 
#include "akonadi_search_pim_debug.h"
#include "indexeditems.h"
 
#include <Akonadi/ServerManager>
#include <QDir>
#include <QHash>
#include <QStandardPaths>
 
using namespace Akonadi::Search::PIM;
 
class Akonadi::Search::PIM::IndexedItemsPrivate
{
public:
    IndexedItemsPrivate() = default;
 
    [[nodiscard]] QString dbPath(const QString &dbName) const;
    [[nodiscard]] QString emailIndexingPath() const;
    [[nodiscard]] QString collectionIndexingPath() const;
    [[nodiscard]] QString calendarIndexingPath() const;
    [[nodiscard]] QString akonotesIndexingPath() const;
    [[nodiscard]] QString emailContactsIndexingPath() const;
    [[nodiscard]] QString contactIndexingPath() const;
 
    mutable QHash<QString, QString> m_cachePath;
    QString m_overridePrefixPath;
    [[nodiscard]] qlonglong indexedItems(const qlonglong id);
    [[nodiscard]] qlonglong indexedItemsInDatabase(const std::string &term, const QString &dbPath) const;
    void findIndexedInDatabase(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId, const QString &dbPath);
    void findIndexed(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId);
};
 
QString IndexedItemsPrivate::dbPath(const QString &dbName) const
{
    const QString cachedPath = m_cachePath.value(dbName);
    if (!cachedPath.isEmpty()) {
        return cachedPath;
    }
    if (!m_overridePrefixPath.isEmpty()) {
        const QString path = QStringLiteral("%1/%2/").arg(m_overridePrefixPath, dbName);
        m_cachePath.insert(dbName, path);
        return path;
    }
 
    // First look into the old location from Baloo times in ~/.local/share/baloo,
    // because we don't migrate the database files automatically.
    QString basePath;
    bool hasInstanceIdentifier = Akonadi::ServerManager::hasInstanceIdentifier();
    if (hasInstanceIdentifier) {
        basePath = QStringLiteral("baloo/instances/%1").arg(Akonadi::ServerManager::instanceIdentifier());
    } else {
        basePath = QStringLiteral("baloo");
    }
    QString dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/%1/%2/").arg(basePath, dbName);
    if (QDir(dbPath).exists()) {
        m_cachePath.insert(dbName, dbPath);
        return dbPath;
    }
 
    // If the database does not exist in old Baloo folders, than use the new
    // location in Akonadi's datadir in ~/.local/share/akonadi/search_db.
    if (hasInstanceIdentifier) {
        basePath = QStringLiteral("akonadi/instance/%1/search_db").arg(Akonadi::ServerManager::instanceIdentifier());
    } else {
        basePath = QStringLiteral("akonadi/search_db");
    }
    dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/%1/%2/").arg(basePath, dbName);
    QDir().mkpath(dbPath);
    m_cachePath.insert(dbName, dbPath);
    return dbPath;
}
 
QString IndexedItemsPrivate::emailIndexingPath() const
{
    return dbPath(QStringLiteral("email"));
}
 
QString IndexedItemsPrivate::contactIndexingPath() const
{
    return dbPath(QStringLiteral("contacts"));
}
 
QString IndexedItemsPrivate::emailContactsIndexingPath() const
{
    return dbPath(QStringLiteral("emailContacts"));
}
 
QString IndexedItemsPrivate::akonotesIndexingPath() const
{
    return dbPath(QStringLiteral("notes"));
}
 
QString IndexedItemsPrivate::calendarIndexingPath() const
{
    return dbPath(QStringLiteral("calendars"));
}
 
QString IndexedItemsPrivate::collectionIndexingPath() const
{
    return dbPath(QStringLiteral("collections"));
}
 
qlonglong IndexedItemsPrivate::indexedItemsInDatabase(const std::string &term, const QString &dbPath) const
{
    Xapian::Database db;
    try {
        db = Xapian::Database(QFile::encodeName(dbPath).toStdString());
    } catch (const Xapian::DatabaseError &e) {
        qCCritical(AKONADI_SEARCH_PIM_LOG) << "Failed to open database" << dbPath << ":" << QString::fromStdString(e.get_msg());
        return 0;
    }
    return db.get_termfreq(term);
}
 
qlonglong IndexedItemsPrivate::indexedItems(const qlonglong id)
{
    const std::string term = QStringLiteral("C%1").arg(id).toStdString();
    return indexedItemsInDatabase(term, emailIndexingPath()) + indexedItemsInDatabase(term, contactIndexingPath())
        + indexedItemsInDatabase(term, akonotesIndexingPath()) + indexedItemsInDatabase(term, calendarIndexingPath());
}
 
void IndexedItemsPrivate::findIndexedInDatabase(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId, const QString &dbPath)
{
    Xapian::Database db;
    try {
        db = Xapian::Database(QFile::encodeName(dbPath).toStdString());
    } catch (const Xapian::DatabaseError &e) {
        qCCritical(AKONADI_SEARCH_PIM_LOG) << "Failed to open database" << dbPath << ":" << QString::fromStdString(e.get_msg());
        return;
    }
    const std::string term = QStringLiteral("C%1").arg(collectionId).toStdString();
    const Xapian::Query query(term);
    Xapian::Enquire enquire(db);
    enquire.set_query(query);
 
    auto getResults = [&enquire, &indexed]() {
        Xapian::MSet mset;
        mset = enquire.get_mset(0, UINT_MAX);
        Xapian::MSetIterator it = mset.begin();
        for (auto result : mset) {
            indexed << result;
        }
    };
 
    try {
        getResults();
    } catch (const Xapian::DatabaseModifiedError &e) {
        qCCritical(AKONADI_SEARCH_PIM_LOG) << "Failed to read database" << dbPath << ":" << QString::fromStdString(e.get_msg());
        qCCritical(AKONADI_SEARCH_PIM_LOG) << "Calling reopen() on database" << dbPath << "and trying again";
        if (db.reopen()) { // only try again once
            try {
                getResults();
            } catch (const Xapian::DatabaseModifiedError &e) {
                qCCritical(AKONADI_SEARCH_PIM_LOG) << "Failed to query database" << dbPath << "even after calling reopen()";
            }
        }
    } catch (const Xapian::DatabaseCorruptError &e) {
        qCCritical(AKONADI_SEARCH_PIM_LOG) << "Failed to query database" << dbPath << ":" << QString::fromStdString(e.get_msg());
    }
}
 
void IndexedItemsPrivate::findIndexed(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId)
{
    findIndexedInDatabase(indexed, collectionId, emailIndexingPath());
    findIndexedInDatabase(indexed, collectionId, contactIndexingPath());
    findIndexedInDatabase(indexed, collectionId, akonotesIndexingPath());
    findIndexedInDatabase(indexed, collectionId, calendarIndexingPath());
}
 
IndexedItems::IndexedItems(QObject *parent)
    : QObject(parent)
    , d(new Akonadi::Search::PIM::IndexedItemsPrivate())
{
}
 
IndexedItems::~IndexedItems() = default;
 
void IndexedItems::setOverrideDbPrefixPath(const QString &path)
{
    d->m_overridePrefixPath = path;
    d->m_cachePath.clear();
}
 
qlonglong IndexedItems::indexedItems(const qlonglong id)
{
    return d->indexedItems(id);
}
 
void IndexedItems::findIndexedInDatabase(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId, const QString &dbPath)
{
    d->findIndexedInDatabase(indexed, collectionId, dbPath);
}
 
void IndexedItems::findIndexed(QSet<Akonadi::Item::Id> &indexed, Akonadi::Collection::Id collectionId)
{
    d->findIndexed(indexed, collectionId);
}
 
QString IndexedItems::emailIndexingPath() const
{
    return d->emailIndexingPath();
}
 
QString IndexedItems::collectionIndexingPath() const
{
    return d->collectionIndexingPath();
}
 
QString IndexedItems::calendarIndexingPath() const
{
    return d->calendarIndexingPath();
}
 
QString IndexedItems::akonotesIndexingPath() const
{
    return d->akonotesIndexingPath();
}
 
QString IndexedItems::emailContactsIndexingPath() const
{
    return d->emailContactsIndexingPath();
}
 
QString IndexedItems::contactIndexingPath() const
{
    return d->contactIndexingPath();
}
 
#include "moc_indexeditems.cpp"