diff --git a/src/engine/transaction.cpp b/src/engine/transaction.cpp
index 07e232eb..2b2f8280 100644
--- a/src/engine/transaction.cpp
+++ b/src/engine/transaction.cpp
@@ -1,595 +1,606 @@
 /*
  * This file is part of the KDE Baloo project.
  * Copyright (C) 2015  Vishesh Handa <vhanda@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
 
 #include "transaction.h"
 #include "postingdb.h"
 #include "documentdb.h"
 #include "documenturldb.h"
 #include "documentiddb.h"
 #include "positiondb.h"
 #include "documentdatadb.h"
 #include "mtimedb.h"
 
 #include "document.h"
 #include "enginequery.h"
 
 #include "andpostingiterator.h"
 #include "orpostingiterator.h"
 #include "phraseanditerator.h"
 
 #include "writetransaction.h"
 #include "idutils.h"
 #include "database.h"
 #include "databasesize.h"
 
 #include <QFile>
 #include <QFileInfo>
 
 using namespace Baloo;
 
 Transaction::Transaction(const Database& db, Transaction::TransactionType type)
     : m_dbis(db.m_dbis)
     , m_env(db.m_env)
     , m_writeTrans(nullptr)
 {
     uint flags = type == ReadOnly ? MDB_RDONLY : 0;
     int rc = mdb_txn_begin(db.m_env, nullptr, flags, &m_txn);
     Q_ASSERT_X(rc == 0, "Transaction", mdb_strerror(rc));
 
     if (type == ReadWrite) {
         m_writeTrans = new WriteTransaction(m_dbis, m_txn);
     }
 }
 
 Transaction::Transaction(Database* db, Transaction::TransactionType type)
     : Transaction(*db, type)
 {
 }
 
 Transaction::~Transaction()
 {
     if (m_writeTrans)
         qWarning() << "Closing an active WriteTransaction without calling abort/commit";
 
     if (m_txn) {
         abort();
     }
 }
 
 bool Transaction::hasDocument(quint64 id) const
 {
     Q_ASSERT(id > 0);
 
     IdFilenameDB idFilenameDb(m_dbis.idFilenameDbi, m_txn);
     return idFilenameDb.contains(id);
 }
 
 bool Transaction::inPhaseOne(quint64 id) const
 {
     Q_ASSERT(id > 0);
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     return contentIndexingDb.contains(id);
 }
 
 bool Transaction::hasFailed(quint64 id) const
 {
     Q_ASSERT(id > 0);
     DocumentIdDB failedIdDb(m_dbis.failedIdDbi, m_txn);
     return failedIdDb.contains(id);
 }
 
 QByteArray Transaction::documentUrl(quint64 id) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
 
     DocumentUrlDB docUrlDb(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
     return docUrlDb.get(id);
 }
 
 quint64 Transaction::documentId(const QByteArray& path) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(!path.isEmpty());
 
     DocumentUrlDB docUrlDb(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
     QList<QByteArray> li = path.split('/');
 
     quint64 parentId = 0;
     for (const QByteArray& fileName : li) {
         if (fileName.isEmpty()) {
             continue;
         }
 
         parentId = docUrlDb.getId(parentId, fileName);
         if (!parentId) {
             return 0;
         }
     }
 
     return parentId;
 }
 
 QVector<quint64> Transaction::childrenDocumentId(quint64 parentId) const
 {
     DocumentUrlDB docUrlDB(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
 
     return docUrlDB.getChildren(parentId);
 }
 
 DocumentTimeDB::TimeInfo Transaction::documentTimeInfo(quint64 id) const
 {
     Q_ASSERT(m_txn);
 
     DocumentTimeDB docTimeDb(m_dbis.docTimeDbi, m_txn);
     return docTimeDb.get(id);
 }
 
 QByteArray Transaction::documentData(quint64 id) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
 
     DocumentDataDB docDataDb(m_dbis.docDataDbi, m_txn);
     return docDataDb.get(id);
 }
 
 bool Transaction::hasChanges() const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(m_writeTrans);
     return m_writeTrans->hasChanges();
 }
 
 QVector<quint64> Transaction::fetchPhaseOneIds(int size) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(size > 0);
 
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     return contentIndexingDb.fetchItems(size);
 }
 
 QVector<QByteArray> Transaction::fetchTermsStartingWith(const QByteArray& term) const
 {
     Q_ASSERT(term.size() > 0);
 
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
     return postingDb.fetchTermsStartingWith(term);
 }
 
 uint Transaction::phaseOneSize() const
 {
     Q_ASSERT(m_txn);
 
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     return contentIndexingDb.size();
 }
 
 uint Transaction::size() const
 {
     Q_ASSERT(m_txn);
 
     DocumentDB docTermsDb(m_dbis.docTermsDbi, m_txn);
     return docTermsDb.size();
 }
 
 //
 // Write Operations
 //
 void Transaction::setPhaseOne(quint64 id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     contentIndexingDb.put(id);
 }
 
 void Transaction::removePhaseOne(quint64 id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     contentIndexingDb.del(id);
 }
 
 void Transaction::addFailed(quint64 id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     DocumentIdDB failedIdDb(m_dbis.failedIdDbi, m_txn);
     failedIdDb.put(id);
 }
 
 void Transaction::addDocument(const Document& doc)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(doc.id() > 0);
     Q_ASSERT(m_writeTrans);
 
     m_writeTrans->addDocument(doc);
 }
 
 void Transaction::removeDocument(quint64 id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     m_writeTrans->removeDocument(id);
 }
 
 void Transaction::removeRecursively(quint64 id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     m_writeTrans->removeRecursively(id);
 }
 
 void Transaction::replaceDocument(const Document& doc, DocumentOperations operations)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(doc.id() > 0);
     Q_ASSERT(m_writeTrans);
     Q_ASSERT_X(hasDocument(doc.id()), "Transaction::replaceDocument", "Document does not exist");
 
     m_writeTrans->replaceDocument(doc, operations);
 }
 
 void Transaction::commit()
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(m_writeTrans);
 
     m_writeTrans->commit();
     delete m_writeTrans;
     m_writeTrans = nullptr;
 
     int rc = mdb_txn_commit(m_txn);
     Q_ASSERT_X(rc == 0, "Transaction::commit", mdb_strerror(rc));
 
     m_txn = nullptr;
 }
 
 void Transaction::abort()
 {
     Q_ASSERT(m_txn);
 
     mdb_txn_abort(m_txn);
     m_txn = nullptr;
 
     delete m_writeTrans;
     m_writeTrans = nullptr;
 }
 
 //
 // Queries
 //
 
 PostingIterator* Transaction::postingIterator(const EngineQuery& query) const
 {
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
     PositionDB positionDb(m_dbis.positionDBi, m_txn);
 
     if (query.leaf()) {
         if (query.op() == EngineQuery::Equal) {
             return postingDb.iter(query.term());
         } else if (query.op() == EngineQuery::StartsWith) {
             return postingDb.prefixIter(query.term());
         } else {
             Q_ASSERT(0);
         }
     }
 
     if (query.subQueries().isEmpty()) {
         return nullptr;
     }
 
     QVector<PostingIterator*> vec;
     vec.reserve(query.subQueries().size());
 
     if (query.op() == EngineQuery::Phrase) {
         const auto subQueries = query.subQueries();
         for (const EngineQuery& q : subQueries) {
             Q_ASSERT_X(q.leaf(), "Transaction::toPostingIterator", "Phrase queries must contain leaf queries");
             vec << positionDb.iter(q.term());
         }
 
         return new PhraseAndIterator(vec);
     }
 
     const auto subQueries = query.subQueries();
     for (const EngineQuery& q : subQueries) {
-        vec << postingIterator(q);
+        auto iterator = postingIterator(q);
+        if (iterator) {
+            vec << iterator;
+        } else if (query.op() == EngineQuery::And) {
+            return nullptr;
+        }
+    }
+
+    if (vec.empty()) {
+        return nullptr;
+    } else if (vec.size() == 1) {
+        return vec.takeFirst();
     }
 
     if (query.op() == EngineQuery::And) {
         return new AndPostingIterator(vec);
     } else if (query.op() == EngineQuery::Or) {
         return new OrPostingIterator(vec);
     }
 
     Q_ASSERT(0);
     return nullptr;
 }
 
 PostingIterator* Transaction::postingCompIterator(const QByteArray& prefix, const QByteArray& value, PostingDB::Comparator com) const
 {
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
     return postingDb.compIter(prefix, value, com);
 }
 
 PostingIterator* Transaction::mTimeIter(quint32 mtime, MTimeDB::Comparator com) const
 {
     MTimeDB mTimeDb(m_dbis.mtimeDbi, m_txn);
     return mTimeDb.iter(mtime, com);
 }
 
 PostingIterator* Transaction::mTimeRangeIter(quint32 beginTime, quint32 endTime) const
 {
     MTimeDB mTimeDb(m_dbis.mtimeDbi, m_txn);
     return mTimeDb.iterRange(beginTime, endTime);
 }
 
 PostingIterator* Transaction::docUrlIter(quint64 id) const
 {
     DocumentUrlDB docUrlDb(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
     return docUrlDb.iter(id);
 }
 
 QVector<quint64> Transaction::exec(const EngineQuery& query, int limit) const
 {
     Q_ASSERT(m_txn);
 
     QVector<quint64> results;
     PostingIterator* it = postingIterator(query);
     if (!it) {
         return results;
     }
 
     while (it->next() && limit) {
         results << it->docId();
         limit--;
     }
 
     return results;
 }
 
 //
 // Introspection
 //
 
 QVector<QByteArray> Transaction::documentTerms(quint64 docId) const
 {
     Q_ASSERT(docId);
 
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     return documentTermsDB.get(docId);
 }
 
 QVector<QByteArray> Transaction::documentFileNameTerms(quint64 docId) const
 {
     Q_ASSERT(docId);
 
     DocumentDB documentFileNameTermsDB(m_dbis.docFilenameTermsDbi, m_txn);
     return documentFileNameTermsDB.get(docId);
 }
 
 QVector<QByteArray> Transaction::documentXattrTerms(quint64 docId) const
 {
     Q_ASSERT(docId);
 
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
     return documentXattrTermsDB.get(docId);
 }
 
 //
 // File Size
 //
 static size_t dbiSize(MDB_txn* txn, MDB_dbi dbi)
 {
     MDB_stat stat;
     mdb_stat(txn, dbi, &stat);
 
     return (stat.ms_branch_pages + stat.ms_leaf_pages + stat.ms_overflow_pages) * stat.ms_psize;
 }
 
 DatabaseSize Transaction::dbSize()
 {
     DatabaseSize dbSize;
     dbSize.postingDb = dbiSize(m_txn, m_dbis.postingDbi);
     dbSize.positionDb = dbiSize(m_txn, m_dbis.positionDBi);
     dbSize.docTerms = dbiSize(m_txn, m_dbis.docTermsDbi);
     dbSize.docFilenameTerms = dbiSize(m_txn, m_dbis.docFilenameTermsDbi);
     dbSize.docXattrTerms = dbiSize(m_txn, m_dbis.docXattrTermsDbi);
 
     dbSize.idTree = dbiSize(m_txn, m_dbis.idTreeDbi);
     dbSize.idFilename = dbiSize(m_txn, m_dbis.idFilenameDbi);
 
     dbSize.docTime = dbiSize(m_txn, m_dbis.docTimeDbi);
     dbSize.docData = dbiSize(m_txn, m_dbis.docDataDbi);
 
     dbSize.contentIndexingIds = dbiSize(m_txn, m_dbis.contentIndexingDbi);
     dbSize.failedIds = dbiSize(m_txn, m_dbis.failedIdDbi);
 
     dbSize.mtimeDb = dbiSize(m_txn, m_dbis.mtimeDbi);
 
     dbSize.expectedSize = dbSize.positionDb + dbSize.positionDb + dbSize.docTerms + dbSize.docFilenameTerms
                   + dbSize.docXattrTerms + dbSize.idTree + dbSize.idFilename + dbSize.docTime
                   + dbSize.docData + dbSize.contentIndexingIds + dbSize.failedIds + dbSize.mtimeDb;
 
     MDB_envinfo info;
     mdb_env_info(m_env, &info);
     dbSize.actualSize = info.me_last_pgno * 4096; // TODO: separate page size
 
     return dbSize;
 }
 
 //
 // Debugging
 //
 void Transaction::checkFsTree()
 {
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
     DocumentDB documentFileNameTermsDB(m_dbis.docFilenameTermsDbi, m_txn);
     DocumentUrlDB docUrlDb(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
 
     auto map = postingDb.toTestMap();
 
     QSet<quint64> allIds;
     Q_FOREACH (const auto& list, map) {
         for (quint64 id : list) {
             allIds << id;
         }
     }
 
     QTextStream out(stdout);
     out << "Total Document IDs: " << allIds.size() << endl;
 
     int count = 0;
     for (quint64 id: qAsConst(allIds)) {
         QByteArray url = docUrlDb.get(id);
         if (url.isEmpty()) {
             auto terms = documentTermsDB.get(id);
             auto fileNameTerms = documentFileNameTermsDB.get(id);
             auto xAttrTerms = documentXattrTermsDB.get(id);
 
             // Lets reverse enginer the terms
             QList<QByteArray> newTerms;
             QMapIterator<QByteArray, PostingList> it(map);
             while (it.hasNext()) {
                 it.next();
                 if (it.value().contains(id)) {
                     newTerms << it.key();
                 }
             }
 
             out << "Missing filePath for " << id << endl;
             out << "\tPostingDB Terms: ";
             for (const QByteArray& term : qAsConst(newTerms)) {
                 out << term << " ";
             }
             out << endl;
 
             out << "\tDocumentTermsDB: ";
             for (const QByteArray& term : terms) {
                 out << term << " ";
             }
             out << endl;
 
             out << "\tFileNameTermsDB: ";
             for (const QByteArray& term : terms) {
                 out << term << " ";
             }
             out << endl;
 
             out << "\tXAttrTermsDB: ";
             for (const QByteArray& term : terms) {
                 out << term << " ";
             }
             out << endl;
 
             count++;
         } else if (!QFileInfo::exists(url)) {
             out << "FilePath " << url << " for " << id << " does not exist"<< endl;
             count++;
         }
     }
 
     out << "Invalid Entries: " << count << " (" << count * 100.0 / allIds.size() << "%)" << endl;
 }
 
 void Transaction::checkTermsDbinPostingDb()
 {
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
     DocumentDB documentFileNameTermsDB(m_dbis.docFilenameTermsDbi, m_txn);
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
 
     // Iterate over each document, and fetch all terms
     // check if each term maps to its own id in the posting db
 
     auto map = postingDb.toTestMap();
 
     QSet<quint64> allIds;
     Q_FOREACH (const auto& list, map) {
         for (quint64 id : list) {
             allIds << id;
         }
     }
 
     QTextStream out(stdout);
     out << "PostingDB check .." << endl;
     for (quint64 id : qAsConst(allIds)) {
         QVector<QByteArray> terms = documentTermsDB.get(id);
         terms += documentXattrTermsDB.get(id);
         terms += documentFileNameTermsDB.get(id);
 
         for (const QByteArray& term : qAsConst(terms)) {
             PostingList plist = postingDb.get(term);
             if (!plist.contains(id)) {
                 out << id << " is missing term " << term << endl;
             }
         }
     }
 }
 
 void Transaction::checkPostingDbinTermsDb()
 {
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
     DocumentDB documentFileNameTermsDB(m_dbis.docFilenameTermsDbi, m_txn);
     PostingDB postingDb(m_dbis.postingDbi, m_txn);
 
     QMap<QByteArray, PostingList> map = postingDb.toTestMap();
     QMapIterator<QByteArray, PostingList> it(map);
 
     QTextStream out(stdout);
     out << "DocumentTermsDB check .." << endl;
     while (it.hasNext()) {
         it.next();
 
         const QByteArray& term = it.key();
         const PostingList& list = it.value();
         for (quint64 id : list) {
             if (documentTermsDB.get(id).contains(term)) {
                 continue;
             }
             if (documentFileNameTermsDB.get(id).contains(term)) {
                 continue;
             }
             if (documentXattrTermsDB.get(id).contains(term)) {
                 continue;
             }
             out << id << " is missing " << QString::fromUtf8(term) << " from document terms db" << endl;
         }
     }
 }
 
diff --git a/src/lib/searchstore.cpp b/src/lib/searchstore.cpp
index 82d514f7..f7580ca8 100644
--- a/src/lib/searchstore.cpp
+++ b/src/lib/searchstore.cpp
@@ -1,406 +1,414 @@
 /*
  * This file is part of the KDE Baloo Project
  * Copyright (C) 2013-2015  Vishesh Handa <vhanda@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "searchstore.h"
 #include "term.h"
 #include "global.h"
 
 #include "database.h"
 #include "transaction.h"
 #include "enginequery.h"
 #include "queryparser.h"
 #include "termgenerator.h"
 #include "andpostingiterator.h"
 #include "orpostingiterator.h"
 #include "idutils.h"
 
 #include <QStandardPaths>
 #include <QFile>
 #include <QFileInfo>
 
 #include <KFileMetaData/PropertyInfo>
 #include <KFileMetaData/TypeInfo>
 #include <KFileMetaData/Types>
 
 #include <algorithm>
 #include <tuple>
 
 using namespace Baloo;
 
 SearchStore::SearchStore()
     : m_db(nullptr)
 {
     m_db = globalDatabaseInstance();
     if (!m_db->open(Database::ReadOnlyDatabase)) {
         m_db = nullptr;
     }
 
     m_prefixes.insert(QByteArray("filename"), QByteArray("F"));
     m_prefixes.insert(QByteArray("mimetype"), QByteArray("M"));
     m_prefixes.insert(QByteArray("rating"), QByteArray("R"));
     m_prefixes.insert(QByteArray("tag"), QByteArray("TAG-"));
     m_prefixes.insert(QByteArray("tags"), QByteArray("TA"));
     m_prefixes.insert(QByteArray("usercomment"), QByteArray("C"));
 }
 
 SearchStore::~SearchStore()
 {
 }
 
 // Return the result with-in [offset, offset + limit)
 QStringList SearchStore::exec(const Term& term, uint offset, int limit, bool sortResults)
 {
     if (!m_db || !m_db->isOpen()) {
         return QStringList();
     }
 
     Transaction tr(m_db, Transaction::ReadOnly);
     QScopedPointer<PostingIterator> it(constructQuery(&tr, term));
     if (!it) {
         return QStringList();
     }
 
     if (sortResults) {
         QVector<std::pair<quint64, quint32>> resultIds;
         while (it->next()) {
             quint64 id = it->docId();
             quint32 mtime = tr.documentTimeInfo(id).mTime;
             resultIds << std::pair<quint64, quint32>{id, mtime};
 
             Q_ASSERT(id > 0);
         }
 
         // Not enough results within range, no need to sort.
         if (offset >= static_cast<uint>(resultIds.size())) {
             return QStringList();
         }
 
         auto compFunc = [](const std::pair<quint64, quint32>& lhs,
                            const std::pair<quint64, quint32>& rhs) {
             return lhs.second > rhs.second;
         };
 
         std::sort(resultIds.begin(), resultIds.end(), compFunc);
         if (limit < 0) {
             limit = resultIds.size();
         }
 
         QStringList results;
         const uint end = qMin(static_cast<uint>(resultIds.size()), offset + static_cast<uint>(limit));
         for (uint i = offset; i < end; i++) {
             const quint64 id = resultIds[i].first;
             const QString filePath = tr.documentUrl(id);
 
             results << filePath;
         }
 
         return results;
     }
     else {
         QStringList results;
         uint ulimit = limit < 0 ? UINT_MAX : limit;
 
         while (offset && it->next()) {
             offset--;
         }
 
         while (ulimit && it->next()) {
             quint64 id = it->docId();
             Q_ASSERT(id > 0);
 
             results << tr.documentUrl(it->docId());
             Q_ASSERT(!results.last().isEmpty());
 
             ulimit--;
         }
 
         return results;
     }
 }
 
 QByteArray SearchStore::fetchPrefix(const QByteArray& property) const
 {
     auto it = m_prefixes.constFind(property.toLower());
     if (it != m_prefixes.constEnd()) {
         return it.value();
     }
     else {
         KFileMetaData::PropertyInfo pi = KFileMetaData::PropertyInfo::fromName(property);
         if (pi.property() == KFileMetaData::Property::Empty) {
             qDebug() << "Property" << property << "not found";
             return QByteArray();
         }
         int propPrefix = static_cast<int>(pi.property());
         return 'X' + QByteArray::number(propPrefix) + '-';
     }
 
 }
 
 PostingIterator* SearchStore::constructQuery(Transaction* tr, const Term& term)
 {
     Q_ASSERT(tr);
 
     if (term.operation() == Term::And || term.operation() == Term::Or) {
         const QList<Term> subTerms = term.subTerms();
         QVector<PostingIterator*> vec;
         vec.reserve(subTerms.size());
 
         for (const Term& t : subTerms) {
-            vec << constructQuery(tr, t);
+            auto iterator = constructQuery(tr, t);
+            // constructQuery returns a nullptr to signal an empty list
+            if (iterator) {
+                vec << iterator;
+            } else if (term.operation() == Term::And) {
+                return nullptr;
+            }
         }
 
         if (vec.isEmpty()) {
             return nullptr;
+        } else if (vec.size() == 1) {
+            return vec.takeFirst();
         }
 
         if (term.operation() == Term::And) {
             return new AndPostingIterator(vec);
         } else {
             return new OrPostingIterator(vec);
         }
     }
 
     if (term.value().isNull()) {
         return nullptr;
     }
     Q_ASSERT(term.value().isValid());
     Q_ASSERT(term.comparator() != Term::Auto);
     Q_ASSERT(term.comparator() == Term::Contains ? term.value().type() == QVariant::String : true);
 
     const QVariant value = term.value();
     const QByteArray property = term.property().toLower().toUtf8();
 
     if (property == "type" || property == "kind") {
         EngineQuery q = constructTypeQuery(value.toString());
         return tr->postingIterator(q);
     }
     else if (property == "includefolder") {
         const QByteArray folder = QFile::encodeName(QFileInfo(value.toString()).canonicalFilePath());
 
         Q_ASSERT(!folder.isEmpty());
         Q_ASSERT(folder.startsWith('/'));
 
         quint64 id = filePathToId(folder);
         if (!id) {
             qDebug() << "Folder" << value.toString() << "does not exist";
             return nullptr;
         }
 
         return tr->docUrlIter(id);
     }
     else if (property == "modified" || property == "mtime") {
         if (value.type() == QVariant::ByteArray) {
             QByteArray ba = value.toByteArray();
             Q_ASSERT(ba.size() >= 4);
 
             int year = ba.mid(0, 4).toInt();
             int month = ba.mid(4, 2).toInt();
             int day = ba.mid(6, 2).toInt();
 
             Q_ASSERT(year);
 
             // uses 0 to represent whole month or whole year
             month = month >= 0 && month <= 12 ? month : 0;
             day = day >= 0 && day <= 31 ? day : 0;
 
             QDate startDate(year, month ? month : 1, day ? day : 1);
             QDate endDate(startDate);
 
             if (month == 0) {
                 endDate.setDate(endDate.year(), 12, 31);
             } else if (day == 0) {
                 endDate.setDate(endDate.year(), endDate.month(), endDate.daysInMonth());
             }
 
             return tr->mTimeRangeIter(QDateTime(startDate).toTime_t(), QDateTime(endDate, QTime(23, 59, 59)).toTime_t());
         }
         else if (value.type() == QVariant::Date || value.type() == QVariant::DateTime) {
             const QDateTime dt = value.toDateTime();
             return constructMTimeQuery(tr, dt, term.comparator());
         }
         else {
             Q_ASSERT_X(0, "SearchStore::constructQuery", "modified property must contain date/datetime values");
         }
     }
     else if (property == "rating") {
         bool okay = false;
         int rating = value.toInt(&okay);
         if (!okay) {
             qDebug() << "Rating comparisons must be with an integer";
             return nullptr;
         }
 
         PostingDB::Comparator pcom;
         if (term.comparator() == Term::Greater || term.comparator() == Term::GreaterEqual) {
             pcom = PostingDB::GreaterEqual;
             if (term.comparator() == Term::Greater && rating)
                 rating++;
         }
         else if (term.comparator() == Term::Less || term.comparator() == Term::LessEqual) {
             pcom = PostingDB::LessEqual;
             if (term.comparator() == Term::Less)
                 rating--;
         }
         else if (term.comparator() == Term::Equal) {
             EngineQuery q = constructEqualsQuery("R", value.toString());
             return tr->postingIterator(q);
         }
         else {
             Q_ASSERT(0);
             return nullptr;
         }
 
         const QByteArray prefix = "R";
         const QByteArray val = QByteArray::number(rating);
         return tr->postingCompIterator(prefix, val, pcom);
     } else if (property == "tag") {
         if (term.comparator() == Term::Equal) {
             const QByteArray prefix = "TAG-";
             EngineQuery q = EngineQuery(prefix + value.toByteArray());
             return tr->postingIterator(q);
         } else if (term.comparator() == Term::Contains) {
             const QByteArray prefix = "TA";
             EngineQuery q = constructEqualsQuery(prefix, value.toString());
             return tr->postingIterator(q);
         } else {
             Q_ASSERT(0);
             return nullptr;
         }
     }
 
     QByteArray prefix;
     if (!property.isEmpty()) {
         prefix = fetchPrefix(property);
         if (prefix.isEmpty()) {
             return nullptr;
         }
     }
 
     auto com = term.comparator();
     if (com == Term::Contains) {
         EngineQuery q = constructContainsQuery(prefix, value.toString());
         return tr->postingIterator(q);
     }
 
     if (com == Term::Equal) {
         EngineQuery q = constructEqualsQuery(prefix, value.toString());
         return tr->postingIterator(q);
     }
 
     QVariant val = term.value();
     if (val.type() == QVariant::Int) {
         int intVal = value.toInt();
 
         PostingDB::Comparator pcom;
         if (term.comparator() == Term::Greater || term.comparator() == Term::GreaterEqual) {
             pcom = PostingDB::GreaterEqual;
             if (term.comparator() == Term::Greater && intVal)
                 intVal++;
         }
         else if (term.comparator() == Term::Less || term.comparator() == Term::LessEqual) {
             pcom = PostingDB::LessEqual;
             if (term.comparator() == Term::Less)
                 intVal--;
         }
         else {
             Q_ASSERT(0);
             return nullptr;
         }
 
         return tr->postingCompIterator(prefix, QByteArray::number(intVal), pcom);
     }
 
     return nullptr;
 }
 
 EngineQuery SearchStore::constructContainsQuery(const QByteArray& prefix, const QString& value)
 {
     QueryParser parser;
     return parser.parseQuery(value, prefix);
 }
 
 EngineQuery SearchStore::constructEqualsQuery(const QByteArray& prefix, const QString& value)
 {
     // We use the TermGenerator to normalize the words in the value and to
     // split it into other words. If we split the words, we then add them as a
     // phrase query.
     QStringList terms = TermGenerator::termList(value);
 
     QVector<EngineQuery> queries;
     int position = 1;
     for (const QString& term : terms) {
         QByteArray arr = prefix + term.toUtf8();
         queries << EngineQuery(arr, position++);
     }
 
     if (queries.isEmpty()) {
         return EngineQuery();
     } else if (queries.size() == 1) {
         return queries.first();
     } else {
         return EngineQuery(queries, EngineQuery::Phrase);
     }
 }
 
 EngineQuery SearchStore::constructTypeQuery(const QString& value)
 {
     Q_ASSERT(!value.isEmpty());
 
     KFileMetaData::TypeInfo ti = KFileMetaData::TypeInfo::fromName(value);
     if (ti == KFileMetaData::Type::Empty) {
         qDebug() << "Type" << value << "does not exist";
         return EngineQuery();
     }
     int num = static_cast<int>(ti.type());
 
     return EngineQuery('T' + QByteArray::number(num));
 }
 
 PostingIterator* SearchStore::constructMTimeQuery(Transaction* tr, const QDateTime& dt, Term::Comparator com)
 {
     Q_ASSERT(dt.isValid());
     quint32 timet = dt.toTime_t();
 
     MTimeDB::Comparator mtimeCom;
     if (com == Term::Equal) {
         mtimeCom = MTimeDB::Equal;
         quint32 end = QDateTime(dt.date().addDays(1)).toTime_t() - 1;
 
         return tr->mTimeRangeIter(timet, end);
     }
     else if (com == Term::GreaterEqual) {
         mtimeCom = MTimeDB::GreaterEqual;
     } else if (com == Term::Greater) {
         timet++;
         mtimeCom = MTimeDB::GreaterEqual;
     } else if (com == Term::LessEqual) {
         mtimeCom = MTimeDB::LessEqual;
     } else if (com == Term::Less) {
         mtimeCom = MTimeDB::LessEqual;
         timet--;
     } else {
         Q_ASSERT_X(0, "SearchStore::constructQuery", "mtime query must contain a valid comparator");
         return nullptr;
     }
 
     return tr->mTimeIter(timet, mtimeCom);
 }