diff --git a/src/codecs/coding.h b/src/codecs/coding.h
--- a/src/codecs/coding.h
+++ b/src/codecs/coding.h
@@ -51,6 +51,8 @@
 #ifndef BALOO_STORAGE_LEVELDB_UTIL_CODING_H
 #define BALOO_STORAGE_LEVELDB_UTIL_CODING_H
 
+#include "idutils.h"
+
 #include <QByteArray>
 #include <QVector>
 
@@ -62,7 +64,7 @@
  * ones available here you can take a look in the git baloo history
  */
 
-inline void putFixed64(QByteArray* dst, quint64 value)
+inline void putFixed64(QByteArray* dst, DocId value)
 {
     dst->append(reinterpret_cast<const char*>(&value), sizeof(value));
 }
@@ -77,10 +79,10 @@
 char* getDifferentialVarInt32(char* input, char* limit, QVector<quint32>* values);
 extern const char* getVarint32Ptr(const char* p, const char* limit, quint32* v);
 
-inline quint64 decodeFixed64(const char* ptr)
+inline DocId decodeFixed64(const char* ptr)
 {
     // Load the raw bytes
-    quint64 result;
+    DocId result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
 }
diff --git a/src/codecs/positioncodec.cpp b/src/codecs/positioncodec.cpp
--- a/src/codecs/positioncodec.cpp
+++ b/src/codecs/positioncodec.cpp
@@ -52,7 +52,7 @@
         PositionInfo info;
 
         info.docId = decodeFixed64(data);
-        data += sizeof(quint64);
+        data += sizeof(DocId);
         data = getDifferentialVarInt32(data, end, &info.positions);
 
         vec << info;
diff --git a/src/codecs/postingcodec.h b/src/codecs/postingcodec.h
--- a/src/codecs/postingcodec.h
+++ b/src/codecs/postingcodec.h
@@ -21,6 +21,8 @@
 #ifndef BALOO_POSTINGCODEC_H
 #define BALOO_POSTINGCODEC_H
 
+#include "idutils.h"
+
 #include <QByteArray>
 #include <QVector>
 
@@ -31,8 +33,8 @@
 public:
     PostingCodec();
 
-    QByteArray encode(const QVector<quint64>& list);
-    QVector<quint64> decode(const QByteArray& arr);
+    QByteArray encode(const QVector<DocId>& list);
+    QVector<DocId> decode(const QByteArray& arr);
 };
 
 }
diff --git a/src/codecs/postingcodec.cpp b/src/codecs/postingcodec.cpp
--- a/src/codecs/postingcodec.cpp
+++ b/src/codecs/postingcodec.cpp
@@ -26,18 +26,18 @@
 {
 }
 
-QByteArray PostingCodec::encode(const QVector<quint64>& list)
+QByteArray PostingCodec::encode(const QVector<DocId>& list)
 {
-    uint size = list.size() * sizeof(quint64);
-    char* ptr = reinterpret_cast<char*>(const_cast<quint64*>(list.constData()));
+    uint size = list.size() * sizeof(DocId);
+    char* ptr = reinterpret_cast<char*>(const_cast<DocId*>(list.constData()));
 
     return QByteArray(ptr, size);
 }
 
-QVector<quint64> PostingCodec::decode(const QByteArray& arr)
+QVector<DocId> PostingCodec::decode(const QByteArray& arr)
 {
-    QVector<quint64> vec;
-    vec.resize(arr.size() / sizeof(quint64));
+    QVector<DocId> vec;
+    vec.resize(arr.size() / sizeof(DocId));
 
     memcpy(vec.data(), arr.data(), arr.size());
     return vec;
diff --git a/src/engine/andpostingiterator.h b/src/engine/andpostingiterator.h
--- a/src/engine/andpostingiterator.h
+++ b/src/engine/andpostingiterator.h
@@ -32,12 +32,12 @@
     explicit AndPostingIterator(const QVector<PostingIterator*>& iterators);
     ~AndPostingIterator();
 
-    quint64 next() Q_DECL_OVERRIDE;
-    quint64 docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
 
 private:
     QVector<PostingIterator*> m_iterators;
-    quint64 m_docId;
+    DocId m_docId;
 };
 
 }
diff --git a/src/engine/andpostingiterator.cpp b/src/engine/andpostingiterator.cpp
--- a/src/engine/andpostingiterator.cpp
+++ b/src/engine/andpostingiterator.cpp
@@ -37,12 +37,12 @@
     qDeleteAll(m_iterators);
 }
 
-quint64 AndPostingIterator::docId() const
+DocId AndPostingIterator::docId() const
 {
     return m_docId;
 }
 
-quint64 AndPostingIterator::next()
+DocId AndPostingIterator::next()
 {
     if (m_iterators.isEmpty()) {
         m_docId = 0;
diff --git a/src/engine/document.h b/src/engine/document.h
--- a/src/engine/document.h
+++ b/src/engine/document.h
@@ -22,6 +22,8 @@
 #define BALOO_DOCUMENT_H
 
 #include "engine_export.h"
+#include "idutils.h"
+
 #include <QByteArray>
 #include <QDebug>
 #include <QVector>
@@ -56,8 +58,8 @@
     void addFileNameTerm(const QByteArray& term, int wdfInc = 1);
     void addFileNamePositionTerm(const QByteArray& term, int position = 0, int wdfInc = 1);
 
-    quint64 id() const;
-    void setId(quint64 id);
+    DocId id() const;
+    void setId(DocId id);
 
     QByteArray url() const;
     void setUrl(const QByteArray& url);
@@ -75,7 +77,7 @@
     void setData(const QByteArray& data);
 
 private:
-    quint64 m_id;
+    DocId m_id;
 
     struct TermData {
         int wdf;
diff --git a/src/engine/document.cpp b/src/engine/document.cpp
--- a/src/engine/document.cpp
+++ b/src/engine/document.cpp
@@ -84,12 +84,12 @@
     m_fileNameTerms[term].wdf += wdfInc;
 }
 
-quint64 Document::id() const
+DocId Document::id() const
 {
     return m_id;
 }
 
-void Document::setId(quint64 id)
+void Document::setId(DocId id)
 {
     Q_ASSERT(id);
     m_id = id;
diff --git a/src/engine/documentdatadb.h b/src/engine/documentdatadb.h
--- a/src/engine/documentdatadb.h
+++ b/src/engine/documentdatadb.h
@@ -21,6 +21,7 @@
 #define BALOO_DOCUMENTDATADB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <lmdb.h>
 #include <QByteArray>
 #include <QMap>
@@ -36,13 +37,13 @@
     static MDB_dbi create(MDB_txn* txn);
     static MDB_dbi open(MDB_txn* txn);
 
-    void put(quint64 docId, const QByteArray& data);
-    QByteArray get(quint64 docId);
+    void put(DocId docId, const QByteArray& data);
+    QByteArray get(DocId docId);
 
-    void del(quint64 docId);
-    bool contains(quint64 docId);
+    void del(DocId docId);
+    bool contains(DocId docId);
 
-    QMap<quint64, QByteArray> toTestMap() const;
+    QMap<DocId, QByteArray> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/documentdatadb.cpp b/src/engine/documentdatadb.cpp
--- a/src/engine/documentdatadb.cpp
+++ b/src/engine/documentdatadb.cpp
@@ -54,13 +54,13 @@
     return dbi;
 }
 
-void DocumentDataDB::put(quint64 docId, const QByteArray& url)
+void DocumentDataDB::put(DocId docId, const QByteArray& url)
 {
     Q_ASSERT(docId > 0);
     Q_ASSERT(!url.isEmpty());
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -71,12 +71,12 @@
     Q_ASSERT_X(rc == 0, "DocumentDataDB::put", mdb_strerror(rc));
 }
 
-QByteArray DocumentDataDB::get(quint64 docId)
+QByteArray DocumentDataDB::get(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -89,12 +89,12 @@
     return QByteArray(static_cast<char*>(val.mv_data), val.mv_size);
 }
 
-void DocumentDataDB::del(quint64 docId)
+void DocumentDataDB::del(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
@@ -104,12 +104,12 @@
     Q_ASSERT_X(rc == 0, "DocumentUrlDB::del", mdb_strerror(rc));
 }
 
-bool DocumentDataDB::contains(quint64 docId)
+bool DocumentDataDB::contains(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -122,23 +122,23 @@
     return true;
 }
 
-QMap<quint64, QByteArray> DocumentDataDB::toTestMap() const
+QMap<DocId, QByteArray> DocumentDataDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint64, QByteArray> map;
+    QMap<DocId, QByteArray> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "DocumentDataDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
         const QByteArray ba(static_cast<char*>(val.mv_data), val.mv_size);
         map.insert(id, ba);
     }
diff --git a/src/engine/documentdb.h b/src/engine/documentdb.h
--- a/src/engine/documentdb.h
+++ b/src/engine/documentdb.h
@@ -22,6 +22,7 @@
 #define BALOO_DOCUMENTDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <lmdb.h>
 #include <QVector>
 #include <QMap>
@@ -37,14 +38,14 @@
     static MDB_dbi create(const char* name, MDB_txn* txn);
     static MDB_dbi open(const char* name, MDB_txn* txn);
 
-    void put(quint64 docId, const QVector< QByteArray >& list);
-    QVector<QByteArray> get(quint64 docId);
+    void put(DocId docId, const QVector< QByteArray >& list);
+    QVector<QByteArray> get(DocId docId);
 
-    bool contains(quint64 docId);
-    void del(quint64 docId);
+    bool contains(DocId docId);
+    void del(DocId docId);
     uint size();
 
-    QMap<quint64, QVector<QByteArray>> toTestMap() const;
+    QMap<DocId, QVector<QByteArray>> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/documentdb.cpp b/src/engine/documentdb.cpp
--- a/src/engine/documentdb.cpp
+++ b/src/engine/documentdb.cpp
@@ -58,13 +58,13 @@
     return dbi;
 }
 
-void DocumentDB::put(quint64 docId, const QVector<QByteArray>& list)
+void DocumentDB::put(DocId docId, const QVector<QByteArray>& list)
 {
     Q_ASSERT(docId > 0);
     Q_ASSERT(!list.isEmpty());
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     DocTermsCodec codec;
@@ -78,12 +78,12 @@
     Q_ASSERT_X(rc == 0, "DocumentDB::put", mdb_strerror(rc));
 }
 
-QVector<QByteArray> DocumentDB::get(quint64 docId)
+QVector<QByteArray> DocumentDB::get(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -99,12 +99,12 @@
     return codec.decode(arr);
 }
 
-void DocumentDB::del(quint64 docId)
+void DocumentDB::del(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
@@ -114,12 +114,12 @@
     Q_ASSERT_X(rc == 0, "DocumentDB::del", mdb_strerror(rc));
 }
 
-bool DocumentDB::contains(quint64 docId)
+bool DocumentDB::contains(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -141,23 +141,23 @@
     return stat.ms_entries;
 }
 
-QMap<quint64, QVector<QByteArray>> DocumentDB::toTestMap() const
+QMap<DocId, QVector<QByteArray>> DocumentDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint64, QVector<QByteArray>> map;
+    QMap<DocId, QVector<QByteArray>> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "PostingDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
         const QVector<QByteArray> vec = DocTermsCodec().decode(QByteArray(static_cast<char*>(val.mv_data), val.mv_size));
         map.insert(id, vec);
     }
diff --git a/src/engine/documentiddb.h b/src/engine/documentiddb.h
--- a/src/engine/documentiddb.h
+++ b/src/engine/documentiddb.h
@@ -22,6 +22,7 @@
 #define BALOO_INDEXINGLEVELDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <QByteArray>
 #include <QVector>
 #include <lmdb.h>
@@ -37,14 +38,14 @@
     static MDB_dbi create(const char* name, MDB_txn* txn);
     static MDB_dbi open(const char* name, MDB_txn* txn);
 
-    void put(quint64 docId);
-    bool contains(quint64 docId);
-    void del(quint64 docID);
+    void put(DocId docId);
+    bool contains(DocId docId);
+    void del(DocId docID);
 
-    QVector<quint64> fetchItems(int size);
+    QVector<DocId> fetchItems(int size);
     uint size();
 
-    QVector<quint64> toTestVector() const;
+    QVector<DocId> toTestVector() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/documentiddb.cpp b/src/engine/documentiddb.cpp
--- a/src/engine/documentiddb.cpp
+++ b/src/engine/documentiddb.cpp
@@ -57,12 +57,12 @@
     return dbi;
 }
 
-void DocumentIdDB::put(quint64 docId)
+void DocumentIdDB::put(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -73,12 +73,12 @@
     Q_ASSERT_X(rc == 0, "DocumentIdDB::put", mdb_strerror(rc));
 }
 
-bool DocumentIdDB::contains(quint64 docId)
+bool DocumentIdDB::contains(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -91,12 +91,12 @@
     return true;
 }
 
-void DocumentIdDB::del(quint64 docId)
+void DocumentIdDB::del(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
@@ -106,14 +106,14 @@
     Q_ASSERT_X(rc == 0, "DocumentIdDB::del", mdb_strerror(rc));
 }
 
-QVector<quint64> DocumentIdDB::fetchItems(int size)
+QVector<DocId> DocumentIdDB::fetchItems(int size)
 {
     Q_ASSERT(size > 0);
 
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
-    QVector<quint64> vec;
+    QVector<DocId> vec;
 
     for (int i = 0; i < size; i++) {
         MDB_val key;
@@ -123,7 +123,7 @@
         }
         Q_ASSERT_X(rc == 0, "DocumentIdDB::fetchItems", mdb_strerror(rc));
 
-        quint64 id = *(static_cast<quint64*>(key.mv_data));
+        DocId id = *(static_cast<DocId*>(key.mv_data));
         vec << id;
     }
     mdb_cursor_close(cursor);
@@ -140,23 +140,23 @@
     return stat.ms_entries;
 }
 
-QVector<quint64> DocumentIdDB::toTestVector() const
+QVector<DocId> DocumentIdDB::toTestVector() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QVector<quint64> vec;
+    QVector<DocId> vec;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "DocumentTimeDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
         vec << id;
     }
 
diff --git a/src/engine/documenttimedb.h b/src/engine/documenttimedb.h
--- a/src/engine/documenttimedb.h
+++ b/src/engine/documenttimedb.h
@@ -22,6 +22,7 @@
 #define BALOO_DOCUMENTIMEDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 
 #include <QByteArray>
 #include <QVector>
@@ -49,13 +50,13 @@
             return mTime == rhs.mTime && cTime == rhs.cTime;
         }
     };
-    void put(quint64 docId, const TimeInfo& info);
-    TimeInfo get(quint64 docId);
+    void put(DocId docId, const TimeInfo& info);
+    TimeInfo get(DocId docId);
 
-    void del(quint64 docId);
-    bool contains(quint64 docId);
+    void del(DocId docId);
+    bool contains(DocId docId);
 
-    QMap<quint64, TimeInfo> toTestMap() const;
+    QMap<DocId, TimeInfo> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/documenttimedb.cpp b/src/engine/documenttimedb.cpp
--- a/src/engine/documenttimedb.cpp
+++ b/src/engine/documenttimedb.cpp
@@ -55,12 +55,12 @@
     return dbi;
 }
 
-void DocumentTimeDB::put(quint64 docId, const TimeInfo& info)
+void DocumentTimeDB::put(DocId docId, const TimeInfo& info)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = &docId;
 
     MDB_val val;
@@ -71,12 +71,12 @@
     Q_ASSERT_X(rc == 0, "DocumentTimeDB::put", mdb_strerror(rc));
 }
 
-DocumentTimeDB::TimeInfo DocumentTimeDB::get(quint64 docId)
+DocumentTimeDB::TimeInfo DocumentTimeDB::get(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = &docId;
 
     MDB_val val;
@@ -89,12 +89,12 @@
     return *(static_cast<TimeInfo*>(val.mv_data));
 }
 
-void DocumentTimeDB::del(quint64 docId)
+void DocumentTimeDB::del(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
@@ -104,12 +104,12 @@
     Q_ASSERT_X(rc == 0, "DocumentTimeDB::del", mdb_strerror(rc));
 }
 
-bool DocumentTimeDB::contains(quint64 docId)
+bool DocumentTimeDB::contains(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -122,23 +122,23 @@
     return true;
 }
 
-QMap<quint64, DocumentTimeDB::TimeInfo> DocumentTimeDB::toTestMap() const
+QMap<DocId, DocumentTimeDB::TimeInfo> DocumentTimeDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint64, TimeInfo> map;
+    QMap<DocId, TimeInfo> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "DocumentTimeDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
         const TimeInfo ti = *(static_cast<TimeInfo*>(val.mv_data));
         map.insert(id, ti);
     }
diff --git a/src/engine/documenturldb.h b/src/engine/documenturldb.h
--- a/src/engine/documenturldb.h
+++ b/src/engine/documenturldb.h
@@ -42,39 +42,39 @@
      * Returns true if added
      * Returns false is the file no longer exists and could not be added
      */
-    bool put(quint64 docId, const QByteArray& url);
+    bool put(DocId docId, const QByteArray& url);
 
-    QByteArray get(quint64 docId) const;
-    QVector<quint64> getChildren(quint64 docId) const;
+    QByteArray get(DocId docId) const;
+    QVector<DocId> getChildren(DocId docId) const;
 
     /**
      * \arg shouldDeleteFolder This function is called on any empty folder, and is used to
      * determine if that empty folder should be deleted.
      */
     template <typename Functor>
-    void del(quint64 docId, Functor shouldDeleteFolder) {
+    void del(DocId docId, Functor shouldDeleteFolder) {
         replace(docId, QByteArray(), shouldDeleteFolder);
     }
 
     /**
      * If \p url is empty then the docId is deleted
      */
     template <typename Functor>
-    void replace(quint64 docId, const QByteArray& url, Functor shouldDeleteFolder);
+    void replace(DocId docId, const QByteArray& url, Functor shouldDeleteFolder);
 
-    void rename(quint64 docId, const QByteArray& newFileName);
+    void rename(DocId docId, const QByteArray& newFileName);
 
-    quint64 getId(quint64 docId, const QByteArray& fileName) const;
+    DocId getId(DocId docId, const QByteArray& fileName) const;
 
-    PostingIterator* iter(quint64 docId) {
+    PostingIterator* iter(DocId docId) {
         IdTreeDB db(m_idTreeDbi, m_txn);
         return db.iter(docId);
     }
 
-    QMap<quint64, QByteArray> toTestMap() const;
+    QMap<DocId, QByteArray> toTestMap() const;
 
 private:
-    void add(quint64 id, quint64 parentId, const QByteArray& name);
+    void add(DocId id, DocId parentId, const QByteArray& name);
 
     MDB_txn* m_txn;
     MDB_dbi m_idFilenameDbi;
@@ -85,7 +85,7 @@
 
 
 template <typename Functor>
-void DocumentUrlDB::replace(quint64 docId, const QByteArray& url, Functor shouldDeleteFolder)
+void DocumentUrlDB::replace(DocId docId, const QByteArray& url, Functor shouldDeleteFolder)
 {
     Q_ASSERT(docId > 0);
     IdFilenameDB idFilenameDb(m_idFilenameDbi, m_txn);
@@ -98,7 +98,7 @@
     }
     idFilenameDb.del(docId);
 
-    QVector<quint64> subDocs = idTreeDb.get(path.parentId);
+    QVector<DocId> subDocs = idTreeDb.get(path.parentId);
     subDocs.removeOne(docId);
 
     if (!subDocs.isEmpty()) {
@@ -109,12 +109,12 @@
         //
         // Delete every parent directory which only has 1 child
         //
-        quint64 id = path.parentId;
+        DocId id = path.parentId;
         while (id) {
             auto path = idFilenameDb.get(id);
             Q_ASSERT(!path.name.isEmpty());
 
-            QVector<quint64> subDocs = idTreeDb.get(path.parentId);
+            QVector<DocId> subDocs = idTreeDb.get(path.parentId);
             if (subDocs.size() == 1 && shouldDeleteFolder(id)) {
                 idTreeDb.del(path.parentId);
                 idFilenameDb.del(id);
diff --git a/src/engine/documenturldb.cpp b/src/engine/documenturldb.cpp
--- a/src/engine/documenturldb.cpp
+++ b/src/engine/documenturldb.cpp
@@ -39,22 +39,22 @@
 {
 }
 
-bool DocumentUrlDB::put(quint64 docId, const QByteArray& url)
+bool DocumentUrlDB::put(DocId docId, const QByteArray& url)
 {
     Q_ASSERT(docId > 0);
     Q_ASSERT(!url.isEmpty());
     Q_ASSERT(!url.endsWith('/'));
 
     IdFilenameDB idFilenameDb(m_idFilenameDbi, m_txn);
 
-    typedef QPair<quint64, QByteArray> IdNamePath;
+    typedef QPair<DocId, QByteArray> IdNamePath;
 
     QByteArray arr = url;
     //
     // id and parent
     //
     {
-        quint64 id = filePathToId(arr);
+        DocId id = filePathToId(arr);
         if (!id) {
             return false;
         }
@@ -64,7 +64,7 @@
         QByteArray name = arr.mid(pos + 1);
 
         arr.resize(pos);
-        quint64 parentId = filePathToId(arr);
+        DocId parentId = filePathToId(arr);
 
         add(id, parentId, name);
         if (idFilenameDb.contains(parentId))
@@ -76,7 +76,7 @@
     //
     QVector<IdNamePath> list;
     while (!arr.isEmpty()) {
-        quint64 id = filePathToId(arr);
+        DocId id = filePathToId(arr);
         Q_ASSERT(id);
 
         int pos = arr.lastIndexOf('/');
@@ -87,11 +87,11 @@
     }
 
     for (int i = 0; i < list.size(); i++) {
-        quint64 id = list[i].first;
+        DocId id = list[i].first;
         QByteArray name = list[i].second;
 
         // Update the IdTree
-        quint64 parentId = 0;
+        DocId parentId = 0;
         if (i) {
             parentId = list[i-1].first;
         }
@@ -102,15 +102,15 @@
     return true;
 }
 
-void DocumentUrlDB::add(quint64 id, quint64 parentId, const QByteArray& name)
+void DocumentUrlDB::add(DocId id, DocId parentId, const QByteArray& name)
 {
     Q_ASSERT(id > 0);
     Q_ASSERT(!name.isEmpty());
 
     IdFilenameDB idFilenameDb(m_idFilenameDbi, m_txn);
     IdTreeDB idTreeDb(m_idTreeDbi, m_txn);
 
-    QVector<quint64> subDocs = idTreeDb.get(parentId);
+    QVector<DocId> subDocs = idTreeDb.get(parentId);
 
     // insert if not there
     sortedIdInsert(subDocs, id);
@@ -125,7 +125,7 @@
     idFilenameDb.put(id, path);
 }
 
-QByteArray DocumentUrlDB::get(quint64 docId) const
+QByteArray DocumentUrlDB::get(DocId docId) const
 {
     Q_ASSERT(docId > 0);
 
@@ -137,7 +137,7 @@
     }
 
     QByteArray ret = path.name;
-    quint64 id = path.parentId;
+    DocId id = path.parentId;
     while (id) {
         auto p = idFilenameDb.get(id);
         Q_ASSERT(!p.name.isEmpty());
@@ -149,13 +149,13 @@
     return '/' + ret;
 }
 
-QVector<quint64> DocumentUrlDB::getChildren(quint64 docId) const
+QVector<DocId> DocumentUrlDB::getChildren(DocId docId) const
 {
     IdTreeDB idTreeDb(m_idTreeDbi, m_txn);
     return idTreeDb.get(docId);
 }
 
-void DocumentUrlDB::rename(quint64 docId, const QByteArray& newFileName)
+void DocumentUrlDB::rename(DocId docId, const QByteArray& newFileName)
 {
     Q_ASSERT(docId > 0);
 
@@ -166,15 +166,15 @@
     idFilenameDb.put(docId, path);
 }
 
-quint64 DocumentUrlDB::getId(quint64 docId, const QByteArray& fileName) const
+DocId DocumentUrlDB::getId(DocId docId, const QByteArray& fileName) const
 {
     Q_ASSERT(!fileName.isEmpty());
 
     IdFilenameDB idFilenameDb(m_idFilenameDbi, m_txn);
     IdTreeDB idTreeDb(m_idTreeDbi, m_txn);
 
-    QVector<quint64> subFiles = idTreeDb.get(docId);
-    for (quint64 id : subFiles) {
+    QVector<DocId> subFiles = idTreeDb.get(docId);
+    for (DocId id : subFiles) {
         IdFilenameDB::FilePath path = idFilenameDb.get(id);
         if (path.name == fileName) {
             return id;
@@ -184,22 +184,22 @@
     return 0;
 }
 
-QMap<quint64, QByteArray> DocumentUrlDB::toTestMap() const
+QMap<DocId, QByteArray> DocumentUrlDB::toTestMap() const
 {
     IdTreeDB idTreeDb(m_idTreeDbi, m_txn);
 
-    QMap<quint64, QVector<quint64>> idTreeMap = idTreeDb.toTestMap();
-    QSet<quint64> allIds;
+    QMap<DocId, QVector<DocId>> idTreeMap = idTreeDb.toTestMap();
+    QSet<DocId> allIds;
 
     for (auto it = idTreeMap.cbegin(); it != idTreeMap.cend(); it++) {
         allIds.insert(it.key());
-        for (quint64 id : it.value()) {
+        for (DocId id : it.value()) {
             allIds.insert(id);
         }
     }
 
-    QMap<quint64, QByteArray> map;
-    for (quint64 id : allIds) {
+    QMap<DocId, QByteArray> map;
+    for (DocId id : allIds) {
         if (id) {
             QByteArray path = get(id);
             Q_ASSERT(!path.isEmpty());
diff --git a/src/engine/idfilenamedb.h b/src/engine/idfilenamedb.h
--- a/src/engine/idfilenamedb.h
+++ b/src/engine/idfilenamedb.h
@@ -22,6 +22,7 @@
 #define BALOO_IDFILENAMEDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <lmdb.h>
 #include <QByteArray>
 #include <QMap>
@@ -38,20 +39,20 @@
     static MDB_dbi open(MDB_txn* txn);
 
     struct FilePath {
-        quint64 parentId;
+        DocId parentId;
         QByteArray name;
 
         FilePath() : parentId(0) {}
         bool operator == (const FilePath& fp) const {
             return parentId == fp.parentId && name == fp.name;
         }
     };
-    void put(quint64 docId, const FilePath& path);
-    FilePath get(quint64 docId);
-    bool contains(quint64 docId);
-    void del(quint64 docId);
+    void put(DocId docId, const FilePath& path);
+    FilePath get(DocId docId);
+    bool contains(DocId docId);
+    void del(DocId docId);
 
-    QMap<quint64, FilePath> toTestMap() const;
+    QMap<DocId, FilePath> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/idfilenamedb.cpp b/src/engine/idfilenamedb.cpp
--- a/src/engine/idfilenamedb.cpp
+++ b/src/engine/idfilenamedb.cpp
@@ -55,13 +55,13 @@
     return dbi;
 }
 
-void IdFilenameDB::put(quint64 docId, const FilePath& path)
+void IdFilenameDB::put(DocId docId, const FilePath& path)
 {
     Q_ASSERT(docId > 0);
     Q_ASSERT(!path.name.isEmpty());
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     QByteArray data(8 + path.name.size(), Qt::Uninitialized);
@@ -76,12 +76,12 @@
     Q_ASSERT_X(rc == 0, "IdFilenameDB::put", mdb_strerror(rc));
 }
 
-IdFilenameDB::FilePath IdFilenameDB::get(quint64 docId)
+IdFilenameDB::FilePath IdFilenameDB::get(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     FilePath path;
@@ -93,18 +93,18 @@
     }
     Q_ASSERT_X(rc == 0, "IdfilenameDB::get", mdb_strerror(rc));
 
-    path.parentId = static_cast<quint64*>(val.mv_data)[0];
+    path.parentId = static_cast<DocId*>(val.mv_data)[0];
     path.name = QByteArray(static_cast<char*>(val.mv_data) + 8, val.mv_size - 8);
 
     return path;
 }
 
-bool IdFilenameDB::contains(quint64 docId)
+bool IdFilenameDB::contains(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
@@ -116,38 +116,38 @@
     return true;
 }
 
-void IdFilenameDB::del(quint64 docId)
+void IdFilenameDB::del(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
     Q_ASSERT_X(rc == 0, "IdfilenameDB::del", mdb_strerror(rc));
 }
 
-QMap<quint64, IdFilenameDB::FilePath> IdFilenameDB::toTestMap() const
+QMap<DocId, IdFilenameDB::FilePath> IdFilenameDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint64, FilePath> map;
+    QMap<DocId, FilePath> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "IdFilenameDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
 
         FilePath path;
-        path.parentId = static_cast<quint64*>(val.mv_data)[0];
+        path.parentId = static_cast<DocId*>(val.mv_data)[0];
         path.name = QByteArray(static_cast<char*>(val.mv_data) + 8, val.mv_size - 8);
 
         map.insert(id, path);
diff --git a/src/engine/idtreedb.h b/src/engine/idtreedb.h
--- a/src/engine/idtreedb.h
+++ b/src/engine/idtreedb.h
@@ -22,6 +22,7 @@
 #define BALOO_IDTREEDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <lmdb.h>
 #include <QVector>
 #include <QMap>
@@ -38,17 +39,17 @@
     static MDB_dbi create(MDB_txn* txn);
     static MDB_dbi open(MDB_txn* txn);
 
-    void put(quint64 docId, const QVector<quint64> subDocIds);
-    QVector<quint64> get(quint64 docId);
-    void del(quint64 docId);
+    void put(DocId docId, const QVector<DocId> subDocIds);
+    QVector<DocId> get(DocId docId);
+    void del(DocId docId);
 
     /**
      * Returns an iterator which will return all the docIds which use \p docId
      * are the parent docID.
      */
-    PostingIterator* iter(quint64 docId);
+    PostingIterator* iter(DocId docId);
 
-    QMap<quint64, QVector<quint64>> toTestMap() const;
+    QMap<DocId, QVector<DocId>> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/idtreedb.cpp b/src/engine/idtreedb.cpp
--- a/src/engine/idtreedb.cpp
+++ b/src/engine/idtreedb.cpp
@@ -18,6 +18,7 @@
  *
  */
 
+#include "idutils.h"
 #include "idtreedb.h"
 #include "postingiterator.h"
 
@@ -55,47 +56,47 @@
     return dbi;
 }
 
-void IdTreeDB::put(quint64 docId, const QVector<quint64> subDocIds)
+void IdTreeDB::put(DocId docId, const QVector<DocId> subDocIds)
 {
     Q_ASSERT(!subDocIds.isEmpty());
     Q_ASSERT(!subDocIds.contains(0));
 
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
-    val.mv_size = subDocIds.size() * sizeof(quint64);
-    val.mv_data = static_cast<void*>(const_cast<quint64*>(subDocIds.constData()));
+    val.mv_size = subDocIds.size() * sizeof(DocId);
+    val.mv_data = static_cast<void*>(const_cast<DocId*>(subDocIds.constData()));
 
     int rc = mdb_put(m_txn, m_dbi, &key, &val, 0);
     Q_ASSERT_X(rc == 0, "IdTreeDB::put", mdb_strerror(rc));
 }
 
-QVector<quint64> IdTreeDB::get(quint64 docId)
+QVector<DocId> IdTreeDB::get(DocId docId)
 {
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     MDB_val val;
     int rc = mdb_get(m_txn, m_dbi, &key, &val);
     if (rc == MDB_NOTFOUND) {
-        return QVector<quint64>();
+        return QVector<DocId>();
     }
     Q_ASSERT_X(rc == 0, "IdTreeeDB::get", mdb_strerror(rc));
 
     // FIXME: This still makes a copy of the data. Perhaps we can avoid that?
-    QVector<quint64> list(val.mv_size / sizeof(quint64));
+    QVector<DocId> list(val.mv_size / sizeof(DocId));
     memcpy(list.data(), val.mv_data, val.mv_size);
 
     return list;
 }
 
-void IdTreeDB::del(quint64 docId)
+void IdTreeDB::del(DocId docId)
 {
     MDB_val key;
-    key.mv_size = sizeof(quint64);
+    key.mv_size = sizeof(DocId);
     key.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, nullptr);
@@ -107,23 +108,23 @@
 //
 class IdTreePostingIterator : public PostingIterator {
 public:
-    IdTreePostingIterator(const IdTreeDB& db, const QVector<quint64> list)
+    IdTreePostingIterator(const IdTreeDB& db, const QVector<DocId> list)
         : m_db(db), m_pos(-1), m_idList(list) {}
 
-    quint64 docId() const Q_DECL_OVERRIDE {
+    DocId docId() const Q_DECL_OVERRIDE {
         if (m_pos >= 0 && m_pos < m_resultList.size())
             return m_resultList[m_pos];
         return 0;
     }
 
-    quint64 next() Q_DECL_OVERRIDE {
+    DocId next() Q_DECL_OVERRIDE {
         if (m_resultList.isEmpty() && m_idList.isEmpty()) {
             return 0;
         }
 
         if (m_resultList.isEmpty()) {
             while (!m_idList.isEmpty()) {
-                quint64 id = m_idList.takeLast();
+                DocId id = m_idList.takeLast();
                 m_idList << m_db.get(id);
                 m_resultList << id;
             }
@@ -146,37 +147,37 @@
 private:
     IdTreeDB m_db;
     int m_pos;
-    QVector<quint64> m_idList;
-    QVector<quint64> m_resultList;
+    QVector<DocId> m_idList;
+    QVector<DocId> m_resultList;
 };
 
-PostingIterator* IdTreeDB::iter(quint64 docId)
+PostingIterator* IdTreeDB::iter(DocId docId)
 {
     Q_ASSERT(docId > 0);
 
-    QVector<quint64> list = {docId};
+    QVector<DocId> list = {docId};
     return new IdTreePostingIterator(*this, list);
 }
 
-QMap<quint64, QVector<quint64>> IdTreeDB::toTestMap() const
+QMap<DocId, QVector<DocId>> IdTreeDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint64, QVector<quint64>> map;
+    QMap<DocId, QVector<DocId>> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "PostingDB::toTestMap", mdb_strerror(rc));
 
-        const quint64 id = *(static_cast<quint64*>(key.mv_data));
+        const DocId id = *(static_cast<DocId*>(key.mv_data));
 
-        QVector<quint64> list(val.mv_size / sizeof(quint64));
+        QVector<DocId> list(val.mv_size / sizeof(DocId));
         memcpy(list.data(), val.mv_data, val.mv_size);
 
         map.insert(id, list);
diff --git a/src/engine/idutils.h b/src/engine/idutils.h
--- a/src/engine/idutils.h
+++ b/src/engine/idutils.h
@@ -23,37 +23,44 @@
 #ifndef BALOO_ID_UTILS_
 #define BALOO_ID_UTILS_
 
+#include "idutils.h"
+
 #include <qplatformdefs.h>
 #include <qglobal.h>
 
+#include <QByteArray>
+
 #ifdef Q_OS_WIN
 # include <QFileInfo>
 #endif
 
 namespace Baloo {
+    using DocId = quint64;
+    using DeviceId = quint32;
+    using Inode = quint32;
 
-inline quint64 devIdAndInodeToId(quint32 devId, quint32 inode)
+inline DocId devIdAndInodeToId(DeviceId devId, Inode inode)
 {
     quint32 arr[2];
     arr[0] = devId;
     arr[1] = inode;
 
-    return *(reinterpret_cast<quint64*>(arr));
+    return *(reinterpret_cast<DocId*>(arr));
 }
 
 /**
  * Convert the QT_STATBUF into a 64 bit unique identifier for the file.
  * This identifier is combination of the device id and inode number.
  */
-inline quint64 statBufToId(const QT_STATBUF& stBuf)
+inline DocId statBufToId(const QT_STATBUF& stBuf)
 {
     // We're losing 32 bits of info, so this could potentially break
     // on file systems with really large inode and device ids
     return devIdAndInodeToId(static_cast<quint32>(stBuf.st_dev),
                              static_cast<quint32>(stBuf.st_ino));
 }
 
-inline quint64 filePathToId(const QByteArray& filePath)
+inline DocId filePathToId(const QByteArray& filePath)
 {
     QT_STATBUF statBuf;
 #ifndef Q_OS_WIN
@@ -73,13 +80,13 @@
     return statBufToId(statBuf);
 }
 
-inline quint32 idToInode(quint64 id)
+inline quint32 idToInode(DocId id)
 {
     quint32* arr = reinterpret_cast<quint32*>(&id);
     return arr[1];
 }
 
-inline quint32 idToDeviceId(quint64 id)
+inline quint32 idToDeviceId(DocId id)
 {
     quint32* arr = reinterpret_cast<quint32*>(&id);
     return arr[0];
diff --git a/src/engine/mtimedb.h b/src/engine/mtimedb.h
--- a/src/engine/mtimedb.h
+++ b/src/engine/mtimedb.h
@@ -22,6 +22,7 @@
 #define BALOO_MTIMEDB_H
 
 #include "engine_export.h"
+#include "idutils.h"
 #include <lmdb.h>
 #include <QVector>
 #include <QMap>
@@ -43,10 +44,10 @@
     static MDB_dbi create(MDB_txn* txn);
     static MDB_dbi open(MDB_txn* txn);
 
-    void put(quint32 mtime, quint64 docId);
-    QVector<quint64> get(quint32 mtime);
+    void put(quint32 mtime, DocId docId);
+    QVector<DocId> get(quint32 mtime);
 
-    void del(quint32 mtime, quint64 docId);
+    void del(quint32 mtime, DocId docId);
 
     enum Comparator {
         Equal,
@@ -56,7 +57,7 @@
     PostingIterator* iter(quint32 mtime, Comparator com);
     PostingIterator* iterRange(quint32 beginTime, quint32 endTime);
 
-    QMap<quint32, quint64> toTestMap() const;
+    QMap<quint32, DocId> toTestMap() const;
 private:
     MDB_txn* m_txn;
     MDB_dbi m_dbi;
diff --git a/src/engine/mtimedb.cpp b/src/engine/mtimedb.cpp
--- a/src/engine/mtimedb.cpp
+++ b/src/engine/mtimedb.cpp
@@ -57,7 +57,7 @@
     return dbi;
 }
 
-void MTimeDB::put(quint32 mtime, quint64 docId)
+void MTimeDB::put(quint32 mtime, DocId docId)
 {
     Q_ASSERT(mtime > 0);
     Q_ASSERT(docId > 0);
@@ -67,22 +67,22 @@
     key.mv_data = static_cast<void*>(&mtime);
 
     MDB_val val;
-    val.mv_size = sizeof(quint64);
+    val.mv_size = sizeof(DocId);
     val.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_put(m_txn, m_dbi, &key, &val, 0);
     Q_ASSERT_X(rc == 0, "MTimeDB::put", mdb_strerror(rc));
 }
 
-QVector<quint64> MTimeDB::get(quint32 mtime)
+QVector<DocId> MTimeDB::get(quint32 mtime)
 {
     Q_ASSERT(mtime > 0);
 
     MDB_val key;
     key.mv_size = sizeof(quint32);
     key.mv_data = static_cast<void*>(&mtime);
 
-    QVector<quint64> values;
+    QVector<DocId> values;
 
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
@@ -95,25 +95,25 @@
     }
     Q_ASSERT_X(rc == 0, "MTimeDB::get", mdb_strerror(rc));
 
-    values << *static_cast<quint64*>(val.mv_data);
+    values << *static_cast<DocId*>(val.mv_data);
 
     while (1) {
         rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT_DUP);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "MTimeDB::get while", mdb_strerror(rc));
 
-        values << *static_cast<quint64*>(val.mv_data);
+        values << *static_cast<DocId*>(val.mv_data);
     }
 
     mdb_cursor_close(cursor);
     std::sort(values.begin(), values.end());
     values.erase(std::unique(values.begin(), values.end()), values.end());
     return values;
 }
 
-void MTimeDB::del(quint32 mtime, quint64 docId)
+void MTimeDB::del(quint32 mtime, DocId docId)
 {
     Q_ASSERT(mtime > 0);
     Q_ASSERT(docId > 0);
@@ -123,7 +123,7 @@
     key.mv_data = static_cast<void*>(&mtime);
 
     MDB_val val;
-    val.mv_size = sizeof(quint64);
+    val.mv_size = sizeof(DocId);
     val.mv_data = static_cast<void*>(&docId);
 
     int rc = mdb_del(m_txn, m_dbi, &key, &val);
@@ -158,8 +158,8 @@
     }
     Q_ASSERT_X(rc == 0, "MTimeDB::iter", mdb_strerror(rc));
 
-    QVector<quint64> results;
-    results << *static_cast<quint64*>(val.mv_data);
+    QVector<DocId> results;
+    results << *static_cast<DocId*>(val.mv_data);
 
     if (com == GreaterEqual) {
         while (1) {
@@ -169,7 +169,7 @@
             }
             Q_ASSERT_X(rc == 0, "MTimeDB::iter >=", mdb_strerror(rc));
 
-            results << *static_cast<quint64*>(val.mv_data);
+            results << *static_cast<DocId*>(val.mv_data);
         }
     }
     else {
@@ -180,7 +180,7 @@
             }
             Q_ASSERT_X(rc == 0, "MTimeDB::iter >=", mdb_strerror(rc));
 
-            quint64 id = *static_cast<quint64*>(val.mv_data);
+            DocId id = *static_cast<DocId*>(val.mv_data);
             results.push_front(id);
         }
     }
@@ -211,8 +211,8 @@
     }
     Q_ASSERT_X(rc == 0, "MTimeDB::iterRange", mdb_strerror(rc));
 
-    QVector<quint64> results;
-    results << *static_cast<quint64*>(val.mv_data);
+    QVector<DocId> results;
+    results << *static_cast<DocId*>(val.mv_data);
 
     while (1) {
         rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
@@ -225,33 +225,33 @@
         if (time > endTime) {
             break;
         }
-        results << *static_cast<quint64*>(val.mv_data);
+        results << *static_cast<DocId*>(val.mv_data);
     }
 
     mdb_cursor_close(cursor);
     std::sort(results.begin(), results.end());
     results.erase(std::unique(results.begin(), results.end()), results.end());
     return new VectorPostingIterator(results);
 }
 
-QMap<quint32, quint64> MTimeDB::toTestMap() const
+QMap<quint32, DocId> MTimeDB::toTestMap() const
 {
     MDB_cursor* cursor;
     mdb_cursor_open(m_txn, m_dbi, &cursor);
 
     MDB_val key = {0, nullptr};
     MDB_val val;
 
-    QMap<quint32, quint64> map;
+    QMap<quint32, DocId> map;
     while (1) {
         int rc = mdb_cursor_get(cursor, &key, &val, MDB_NEXT);
         if (rc == MDB_NOTFOUND) {
             break;
         }
         Q_ASSERT_X(rc == 0, "MTimeDB::toTestMap", mdb_strerror(rc));
 
         const quint32 time = *(static_cast<quint32*>(key.mv_data));
-        const quint64 id = *(static_cast<quint64*>(val.mv_data));
+        const DocId id = *(static_cast<DocId*>(val.mv_data));
         map.insert(time, id);
     }
 
diff --git a/src/engine/orpostingiterator.h b/src/engine/orpostingiterator.h
--- a/src/engine/orpostingiterator.h
+++ b/src/engine/orpostingiterator.h
@@ -32,12 +32,12 @@
     explicit OrPostingIterator(const QVector<PostingIterator*>& iterators);
     ~OrPostingIterator();
 
-    quint64 next() Q_DECL_OVERRIDE;
-    quint64 docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
 
 private:
     QVector<PostingIterator*> m_iterators;
-    quint64 m_docId;
+    DocId m_docId;
 };
 }
 
diff --git a/src/engine/orpostingiterator.cpp b/src/engine/orpostingiterator.cpp
--- a/src/engine/orpostingiterator.cpp
+++ b/src/engine/orpostingiterator.cpp
@@ -33,12 +33,12 @@
     qDeleteAll(m_iterators);
 }
 
-quint64 OrPostingIterator::docId() const
+DocId OrPostingIterator::docId() const
 {
     return m_docId;
 }
 
-quint64 OrPostingIterator::next()
+DocId OrPostingIterator::next()
 {
     m_docId = 0;
     if (m_iterators.isEmpty()) {
diff --git a/src/engine/phraseanditerator.h b/src/engine/phraseanditerator.h
--- a/src/engine/phraseanditerator.h
+++ b/src/engine/phraseanditerator.h
@@ -33,12 +33,12 @@
     explicit PhraseAndIterator(const QVector<PostingIterator*>& iterators);
     ~PhraseAndIterator();
 
-    quint64 next() Q_DECL_OVERRIDE;
-    quint64 docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
 
 private:
     QVector<PostingIterator*> m_iterators;
-    quint64 m_docId;
+    DocId m_docId;
 
     bool checkIfPositionsMatch();
 };
diff --git a/src/engine/phraseanditerator.cpp b/src/engine/phraseanditerator.cpp
--- a/src/engine/phraseanditerator.cpp
+++ b/src/engine/phraseanditerator.cpp
@@ -39,7 +39,7 @@
     qDeleteAll(m_iterators);
 }
 
-quint64 PhraseAndIterator::docId() const
+DocId PhraseAndIterator::docId() const
 {
     return m_docId;
 }
@@ -86,7 +86,7 @@
     return !vec.isEmpty();
 }
 
-quint64 PhraseAndIterator::next()
+DocId PhraseAndIterator::next()
 {
     if (m_iterators.isEmpty()) {
         m_docId = 0;
diff --git a/src/engine/positiondb.cpp b/src/engine/positiondb.cpp
--- a/src/engine/positiondb.cpp
+++ b/src/engine/positiondb.cpp
@@ -129,16 +129,16 @@
         m_vec = codec.decode(QByteArray(static_cast<char*>(data), size));
     }
 
-    quint64 next() Q_DECL_OVERRIDE {
+    DocId next() Q_DECL_OVERRIDE {
         m_pos++;
         if (m_pos >= m_vec.size()) {
             return 0;
         }
 
         return m_vec[m_pos].docId;
     }
 
-    quint64 docId() const Q_DECL_OVERRIDE {
+    DocId docId() const Q_DECL_OVERRIDE {
         if (m_pos < 0 || m_pos >= m_vec.size()) {
             return 0;
         }
diff --git a/src/engine/positioninfo.h b/src/engine/positioninfo.h
--- a/src/engine/positioninfo.h
+++ b/src/engine/positioninfo.h
@@ -21,18 +21,20 @@
 #ifndef BALOO_POSITIONINFO_H
 #define BALOO_POSITIONINFO_H
 
+#include "idutils.h"
+
 #include <QByteArray>
 #include <QVector>
 #include <QDebug>
 
 namespace Baloo {
 
 class PositionInfo {
 public:
-    quint64 docId;
+    DocId docId;
     QVector<uint> positions;
 
-    PositionInfo(quint64 id = 0, const QVector<uint> posList = QVector<uint>())
+    PositionInfo(DocId id = 0, const QVector<uint> posList = QVector<uint>())
         : docId(id), positions(posList) {}
 
     bool operator ==(const PositionInfo& rhs) const {
diff --git a/src/engine/postingdb.h b/src/engine/postingdb.h
--- a/src/engine/postingdb.h
+++ b/src/engine/postingdb.h
@@ -31,7 +31,7 @@
 
 namespace Baloo {
 
-typedef QVector<quint64> PostingList;
+typedef QVector<DocId> PostingList;
 
 /**
  * The PostingDB is the main database that maps <term> -> <id1> <id2> <id2> ...
diff --git a/src/engine/postingdb.cpp b/src/engine/postingdb.cpp
--- a/src/engine/postingdb.cpp
+++ b/src/engine/postingdb.cpp
@@ -145,11 +145,11 @@
 class DBPostingIterator : public PostingIterator {
 public:
     DBPostingIterator(void* data, uint size);
-    quint64 docId() const Q_DECL_OVERRIDE;
-    quint64 next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
 
 private:
-    const QVector<quint64> m_vec;
+    const QVector<DocId> m_vec;
     int m_pos;
 };
 
@@ -178,16 +178,16 @@
 {
 }
 
-quint64 DBPostingIterator::docId() const
+DocId DBPostingIterator::docId() const
 {
     if (m_pos < 0 || m_pos >= m_vec.size()) {
         return 0;
     }
 
     return m_vec[m_pos];
 }
 
-quint64 DBPostingIterator::next()
+DocId DBPostingIterator::next()
 {
     if (m_pos >= m_vec.size() - 1) {
         m_pos = m_vec.size();
diff --git a/src/engine/postingiterator.h b/src/engine/postingiterator.h
--- a/src/engine/postingiterator.h
+++ b/src/engine/postingiterator.h
@@ -23,6 +23,7 @@
 
 #include <QVector>
 #include "engine_export.h"
+#include "idutils.h"
 
 namespace Baloo {
 
@@ -37,9 +38,9 @@
 public:
     virtual ~PostingIterator();
 
-    virtual quint64 next() = 0;
-    virtual quint64 docId() const = 0;
-    virtual quint64 skipTo(quint64 docId);
+    virtual DocId next() = 0;
+    virtual DocId docId() const = 0;
+    virtual DocId skipTo(DocId docId);
 
     virtual QVector<uint> positions();
 };
diff --git a/src/engine/postingiterator.cpp b/src/engine/postingiterator.cpp
--- a/src/engine/postingiterator.cpp
+++ b/src/engine/postingiterator.cpp
@@ -26,7 +26,7 @@
 {
 }
 
-quint64 PostingIterator::skipTo(quint64 id)
+DocId PostingIterator::skipTo(DocId id)
 {
     while (docId() && docId() < id) {
         next();
diff --git a/src/engine/transaction.h b/src/engine/transaction.h
--- a/src/engine/transaction.h
+++ b/src/engine/transaction.h
@@ -53,40 +53,40 @@
     //
     // Getters
     //
-    bool hasDocument(quint64 id) const;
-    bool inPhaseOne(quint64 id) const;
-    bool hasFailed(quint64 id) const;
-    QByteArray documentUrl(quint64 id) const;
+    bool hasDocument(DocId id) const;
+    bool inPhaseOne(DocId id) const;
+    bool hasFailed(DocId id) const;
+    QByteArray documentUrl(DocId id) const;
 
     /**
      * This method is not cheap, and does not stat the filesystem in order to convert the path
      * \p path into an id.
      */
-    quint64 documentId(const QByteArray& path) const;
-    QByteArray documentData(quint64 id) const;
+    DocId documentId(const QByteArray& path) const;
+    QByteArray documentData(DocId id) const;
 
-    DocumentTimeDB::TimeInfo documentTimeInfo(quint64 id) const;
+    DocumentTimeDB::TimeInfo documentTimeInfo(DocId id) const;
 
-    QVector<quint64> exec(const EngineQuery& query, int limit = -1) const;
+    QVector<DocId> exec(const EngineQuery& query, int limit = -1) const;
 
     PostingIterator* postingIterator(const EngineQuery& query) const;
     PostingIterator* postingCompIterator(const QByteArray& prefix, const QByteArray& value, PostingDB::Comparator com) const;
     PostingIterator* mTimeIter(quint32 mtime, MTimeDB::Comparator com) const;
     PostingIterator* mTimeRangeIter(quint32 beginTime, quint32 endTime) const;
-    PostingIterator* docUrlIter(quint64 id) const;
+    PostingIterator* docUrlIter(DocId id) const;
 
-    QVector<quint64> fetchPhaseOneIds(int size) const;
+    QVector<DocId> fetchPhaseOneIds(int size) const;
     uint phaseOneSize() const;
     uint size() const;
 
     QVector<QByteArray> fetchTermsStartingWith(const QByteArray& term) const;
 
     //
     // Introspecing document data
     //
-    QVector<QByteArray> documentTerms(quint64 docId) const;
-    QVector<QByteArray> documentFileNameTerms(quint64 docId) const;
-    QVector<QByteArray> documentXattrTerms(quint64 docId) const;
+    QVector<QByteArray> documentTerms(DocId docId) const;
+    QVector<QByteArray> documentFileNameTerms(DocId docId) const;
+    QVector<QByteArray> documentXattrTerms(DocId docId) const;
 
     DatabaseSize dbSize();
 
@@ -101,21 +101,21 @@
     // Write Methods
     //
     void addDocument(const Document& doc);
-    void removeDocument(quint64 id);
-    void removeRecursively(quint64 parentId);
-    void addFailed(quint64 id);
+    void removeDocument(DocId id);
+    void removeRecursively(DocId parentId);
+    void addFailed(DocId id);
 
     template <typename Functor>
-    void removeRecursively(quint64 id, Functor shouldDelete) {
+    void removeRecursively(DocId id, Functor shouldDelete) {
         Q_ASSERT(m_txn);
         Q_ASSERT(m_writeTrans);
 
         m_writeTrans->removeRecursively(id, shouldDelete);
     }
 
     void replaceDocument(const Document& doc, DocumentOperations operations);
-    void setPhaseOne(quint64 id);
-    void removePhaseOne(quint64 id);
+    void setPhaseOne(DocId id);
+    void removePhaseOne(DocId id);
 
     // Debugging
     void checkFsTree();
diff --git a/src/engine/transaction.cpp b/src/engine/transaction.cpp
--- a/src/engine/transaction.cpp
+++ b/src/engine/transaction.cpp
@@ -73,46 +73,46 @@
     }
 }
 
-bool Transaction::hasDocument(quint64 id) const
+bool Transaction::hasDocument(DocId id) const
 {
     Q_ASSERT(id > 0);
 
     IdFilenameDB idFilenameDb(m_dbis.idFilenameDbi, m_txn);
     return idFilenameDb.contains(id);
 }
 
-bool Transaction::inPhaseOne(quint64 id) const
+bool Transaction::inPhaseOne(DocId id) const
 {
     Q_ASSERT(id > 0);
     DocumentIdDB contentIndexingDb(m_dbis.contentIndexingDbi, m_txn);
     return contentIndexingDb.contains(id);
 }
 
-bool Transaction::hasFailed(quint64 id) const
+bool Transaction::hasFailed(DocId id) const
 {
     Q_ASSERT(id > 0);
     DocumentIdDB failedIdDb(m_dbis.failedIdDbi, m_txn);
     return failedIdDb.contains(id);
 }
 
-QByteArray Transaction::documentUrl(quint64 id) const
+QByteArray Transaction::documentUrl(DocId 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
+DocId 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;
+    DocId parentId = 0;
     for (const QByteArray& fileName : li) {
         if (fileName.isEmpty()) {
             continue;
@@ -127,15 +127,15 @@
     return parentId;
 }
 
-DocumentTimeDB::TimeInfo Transaction::documentTimeInfo(quint64 id) const
+DocumentTimeDB::TimeInfo Transaction::documentTimeInfo(DocId id) const
 {
     Q_ASSERT(m_txn);
 
     DocumentTimeDB docTimeDb(m_dbis.docTimeDbi, m_txn);
     return docTimeDb.get(id);
 }
 
-QByteArray Transaction::documentData(quint64 id) const
+QByteArray Transaction::documentData(DocId id) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
@@ -151,7 +151,7 @@
     return m_writeTrans->hasChanges();
 }
 
-QVector<quint64> Transaction::fetchPhaseOneIds(int size) const
+QVector<DocId> Transaction::fetchPhaseOneIds(int size) const
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(size > 0);
@@ -187,7 +187,7 @@
 //
 // Write Operations
 //
-void Transaction::setPhaseOne(quint64 id)
+void Transaction::setPhaseOne(DocId id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
@@ -197,7 +197,7 @@
     contentIndexingDb.put(id);
 }
 
-void Transaction::removePhaseOne(quint64 id)
+void Transaction::removePhaseOne(DocId id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
@@ -207,7 +207,7 @@
     contentIndexingDb.del(id);
 }
 
-void Transaction::addFailed(quint64 id)
+void Transaction::addFailed(DocId id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
@@ -226,16 +226,16 @@
     m_writeTrans->addDocument(doc);
 }
 
-void Transaction::removeDocument(quint64 id)
+void Transaction::removeDocument(DocId id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
     Q_ASSERT(m_writeTrans);
 
     m_writeTrans->removeDocument(id);
 }
 
-void Transaction::removeRecursively(quint64 id)
+void Transaction::removeRecursively(DocId id)
 {
     Q_ASSERT(m_txn);
     Q_ASSERT(id > 0);
@@ -347,17 +347,17 @@
     return mTimeDb.iterRange(beginTime, endTime);
 }
 
-PostingIterator* Transaction::docUrlIter(quint64 id) const
+PostingIterator* Transaction::docUrlIter(DocId 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
+QVector<DocId> Transaction::exec(const EngineQuery& query, int limit) const
 {
     Q_ASSERT(m_txn);
 
-    QVector<quint64> results;
+    QVector<DocId> results;
     PostingIterator* it = postingIterator(query);
     if (!it) {
         return results;
@@ -375,23 +375,23 @@
 // Introspection
 //
 
-QVector<QByteArray> Transaction::documentTerms(quint64 docId) const
+QVector<QByteArray> Transaction::documentTerms(DocId docId) const
 {
     Q_ASSERT(docId);
 
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     return documentTermsDB.get(docId);
 }
 
-QVector<QByteArray> Transaction::documentFileNameTerms(quint64 docId) const
+QVector<QByteArray> Transaction::documentFileNameTerms(DocId docId) const
 {
     Q_ASSERT(docId);
 
     DocumentDB documentFileNameTermsDB(m_dbis.docFilenameTermsDbi, m_txn);
     return documentFileNameTermsDB.get(docId);
 }
 
-QVector<QByteArray> Transaction::documentXattrTerms(quint64 docId) const
+QVector<QByteArray> Transaction::documentXattrTerms(DocId docId) const
 {
     Q_ASSERT(docId);
 
@@ -454,18 +454,18 @@
 
     auto map = postingDb.toTestMap();
 
-    QSet<quint64> allIds;
+    QSet<DocId> allIds;
     Q_FOREACH (const auto& list, map) {
-        for (quint64 id : list) {
+        for (DocId id : list) {
             allIds << id;
         }
     }
 
     QTextStream out(stdout);
     out << "Total Document IDs: " << allIds.size() << endl;
 
     int count = 0;
-    for (quint64 id: allIds) {
+    for (DocId id: allIds) {
         QByteArray url = docUrlDb.get(id);
         if (url.isEmpty()) {
             auto terms = documentTermsDB.get(id);
@@ -526,16 +526,16 @@
 
     auto map = postingDb.toTestMap();
 
-    QSet<quint64> allIds;
+    QSet<DocId> allIds;
     Q_FOREACH (const auto& list, map) {
-        for (quint64 id : list) {
+        for (DocId id : list) {
             allIds << id;
         }
     }
 
     QTextStream out(stdout);
     out << "PostingDB check .." << endl;
-    for (quint64 id : allIds) {
+    for (DocId id : allIds) {
         QVector<QByteArray> terms = documentTermsDB.get(id);
         terms += documentXattrTermsDB.get(id);
         terms += documentFileNameTermsDB.get(id);
@@ -566,7 +566,7 @@
 
         const QByteArray& term = it.key();
         const PostingList& list = it.value();
-        for (quint64 id : list) {
+        for (DocId id : list) {
             if (documentTermsDB.get(id).contains(term)) {
                 continue;
             }
diff --git a/src/engine/vectorpositioninfoiterator.h b/src/engine/vectorpositioninfoiterator.h
--- a/src/engine/vectorpositioninfoiterator.h
+++ b/src/engine/vectorpositioninfoiterator.h
@@ -31,8 +31,8 @@
 public:
     explicit VectorPositionInfoIterator(const QVector<PositionInfo>& vector);
 
-    quint64 docId() const Q_DECL_OVERRIDE;
-    quint64 next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
     QVector<uint> positions() Q_DECL_OVERRIDE;
 
 private:
diff --git a/src/engine/vectorpositioninfoiterator.cpp b/src/engine/vectorpositioninfoiterator.cpp
--- a/src/engine/vectorpositioninfoiterator.cpp
+++ b/src/engine/vectorpositioninfoiterator.cpp
@@ -29,7 +29,7 @@
 {
 }
 
-quint64 VectorPositionInfoIterator::next()
+DocId VectorPositionInfoIterator::next()
 {
     if (m_pos >= m_vector.size() - 1) {
         m_pos = m_vector.size();
@@ -41,7 +41,7 @@
     return m_vector[m_pos].docId;
 }
 
-quint64 VectorPositionInfoIterator::docId() const
+DocId VectorPositionInfoIterator::docId() const
 {
     if (m_pos < 0 || m_pos >= m_vector.size()) {
         return 0;
diff --git a/src/engine/vectorpostingiterator.h b/src/engine/vectorpostingiterator.h
--- a/src/engine/vectorpostingiterator.h
+++ b/src/engine/vectorpostingiterator.h
@@ -29,13 +29,13 @@
 class BALOO_ENGINE_EXPORT VectorPostingIterator :  public PostingIterator
 {
 public:
-    explicit VectorPostingIterator(const QVector<quint64>& values);
+    explicit VectorPostingIterator(const QVector<DocId>& values);
 
-    quint64 docId() const Q_DECL_OVERRIDE;
-    quint64 next() Q_DECL_OVERRIDE;
+    DocId docId() const Q_DECL_OVERRIDE;
+    DocId next() Q_DECL_OVERRIDE;
 
 private:
-    QVector<quint64> m_values;
+    QVector<DocId> m_values;
     int m_pos;
 };
 
diff --git a/src/engine/vectorpostingiterator.cpp b/src/engine/vectorpostingiterator.cpp
--- a/src/engine/vectorpostingiterator.cpp
+++ b/src/engine/vectorpostingiterator.cpp
@@ -22,22 +22,22 @@
 
 using namespace Baloo;
 
-VectorPostingIterator::VectorPostingIterator(const QVector<quint64>& values)
+VectorPostingIterator::VectorPostingIterator(const QVector<DocId>& values)
     : m_values(values)
     , m_pos(-1)
 {
 }
 
-quint64 VectorPostingIterator::docId() const
+DocId VectorPostingIterator::docId() const
 {
     if (m_pos < 0 || m_pos >= m_values.size()) {
         return 0;
     }
 
     return m_values[m_pos];
 }
 
-quint64 VectorPostingIterator::next()
+DocId VectorPostingIterator::next()
 {
     if (m_pos >= m_values.size() - 1) {
         m_pos = m_values.size();
diff --git a/src/engine/writetransaction.h b/src/engine/writetransaction.h
--- a/src/engine/writetransaction.h
+++ b/src/engine/writetransaction.h
@@ -38,34 +38,34 @@
     {}
 
     void addDocument(const Document& doc);
-    void removeDocument(quint64 id);
+    void removeDocument(DocId id);
 
     /**
      * Remove the document with id \p parentId and all its children.
      */
-    void removeRecursively(quint64 parentId);
+    void removeRecursively(DocId parentId);
 
     /**
      * Goes through every document in the database, and remove the ones for which \p shouldDelete
      * returns false. It starts searching from \p parentId, which can be 0 to search
      * through everything.
      *
-     * \arg shouldDelete takes a quint64 as a parameter
+     * \arg shouldDelete takes a DocId as a parameter
      *
      * This function should typically be called when there are no other ReadTransaction in process
      * as that would otherwise baloon the size of the database.
      */
     template <typename Functor>
-    void removeRecursively(quint64 parentId, Functor shouldDelete) {
+    void removeRecursively(DocId parentId, Functor shouldDelete) {
         DocumentUrlDB docUrlDB(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
 
         if (shouldDelete(parentId)) {
             removeRecursively(parentId);
             return;
         }
 
-        const QVector<quint64> children = docUrlDB.getChildren(parentId);
-        for (quint64 id : children) {
+        const QVector<DocId> children = docUrlDB.getChildren(parentId);
+        for (DocId id : children) {
             removeRecursively(id, shouldDelete);
         }
     }
@@ -90,10 +90,10 @@
      * Adds an 'addId' operation to the pending queue for each term.
      * Returns the list of all the terms.
      */
-    QVector<QByteArray> addTerms(quint64 id, const QMap<QByteArray, Document::TermData>& terms);
-    QVector<QByteArray> replaceTerms(quint64 id, const QVector<QByteArray>& prevTerms,
+    QVector<QByteArray> addTerms(DocId id, const QMap<QByteArray, Document::TermData>& terms);
+    QVector<QByteArray> replaceTerms(DocId id, const QVector<QByteArray>& prevTerms,
                                      const QMap<QByteArray, Document::TermData>& terms);
-    void removeTerms(quint64 id, const QVector<QByteArray>& terms);
+    void removeTerms(DocId id, const QVector<QByteArray>& terms);
 
     QHash<QByteArray, QVector<Operation> > m_pendingOperations;
 
diff --git a/src/engine/writetransaction.cpp b/src/engine/writetransaction.cpp
--- a/src/engine/writetransaction.cpp
+++ b/src/engine/writetransaction.cpp
@@ -36,7 +36,7 @@
 
 void WriteTransaction::addDocument(const Document& doc)
 {
-    quint64 id = doc.id();
+    DocId id = doc.id();
 
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
@@ -86,7 +86,7 @@
     }
 }
 
-QVector<QByteArray> WriteTransaction::addTerms(quint64 id, const QMap<QByteArray, Document::TermData>& terms)
+QVector<QByteArray> WriteTransaction::addTerms(DocId id, const QMap<QByteArray, Document::TermData>& terms)
 {
     QVector<QByteArray> termList;
     termList.reserve(terms.size());
@@ -108,7 +108,7 @@
 }
 
 
-void WriteTransaction::removeDocument(quint64 id)
+void WriteTransaction::removeDocument(DocId id)
 {
     DocumentDB documentTermsDB(m_dbis.docTermsDbi, m_txn);
     DocumentDB documentXattrTermsDB(m_dbis.docXattrTermsDbi, m_txn);
@@ -128,7 +128,7 @@
     documentXattrTermsDB.del(id);
     documentFileNameTermsDB.del(id);
 
-    docUrlDB.del(id, [&docTimeDB](quint64 id) {
+    docUrlDB.del(id, [&docTimeDB](DocId id) {
         return !docTimeDB.contains(id);
     });
 
@@ -144,7 +144,7 @@
     docDataDB.del(id);
 }
 
-void WriteTransaction::removeTerms(quint64 id, const QVector<QByteArray>& terms)
+void WriteTransaction::removeTerms(DocId id, const QVector<QByteArray>& terms)
 {
     for (const QByteArray& term : terms) {
         Operation op;
@@ -155,12 +155,12 @@
     }
 }
 
-void WriteTransaction::removeRecursively(quint64 parentId)
+void WriteTransaction::removeRecursively(DocId parentId)
 {
     DocumentUrlDB docUrlDB(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
 
-    const QVector<quint64> children = docUrlDB.getChildren(parentId);
-    for (quint64 id : children) {
+    const QVector<DocId> children = docUrlDB.getChildren(parentId);
+    for (DocId id : children) {
         removeRecursively(id);
     }
     removeDocument(parentId);
@@ -176,7 +176,7 @@
     MTimeDB mtimeDB(m_dbis.mtimeDbi, m_txn);
     DocumentUrlDB docUrlDB(m_dbis.idTreeDbi, m_dbis.idFilenameDbi, m_txn);
 
-    const quint64 id = doc.id();
+    const DocId id = doc.id();
 
     if (operations & DocumentTerms) {
         Q_ASSERT(!doc.m_terms.isEmpty());
@@ -224,13 +224,13 @@
     }
 
     if (operations & DocumentUrl) {
-        docUrlDB.replace(id, doc.url(), [&docTimeDB](quint64 id) {
+        docUrlDB.replace(id, doc.url(), [&docTimeDB](DocId id) {
             return !docTimeDB.contains(id);
         });;
     }
 }
 
-QVector< QByteArray > WriteTransaction::replaceTerms(quint64 id, const QVector<QByteArray>& prevTerms,
+QVector< QByteArray > WriteTransaction::replaceTerms(DocId id, const QVector<QByteArray>& prevTerms,
                                                      const QMap<QByteArray, Document::TermData>& terms)
 {
     for (const QByteArray& term : prevTerms) {
@@ -262,7 +262,7 @@
         QVector<PositionInfo> positionList;
 
         for (const Operation& op : operations) {
-            quint64 id = op.data.docId;
+            DocId id = op.data.docId;
 
             if (op.type == AddId) {
                 sortedIdInsert(list, id);
diff --git a/src/file/extractor/app.h b/src/file/extractor/app.h
--- a/src/file/extractor/app.h
+++ b/src/file/extractor/app.h
@@ -36,6 +36,7 @@
 #include "../fileindexerconfig.h"
 #include "iohandler.h"
 #include "idlestatemonitor.h"
+#include "idutils.h"
 
 namespace Baloo {
 
@@ -53,7 +54,7 @@
     void processNextFile();
 
 private:
-    void index(Transaction* tr, const QString& filePath, quint64 id);
+    void index(Transaction* tr, const QString& filePath, DocId id);
 
     QMimeDatabase m_mimeDb;
 
diff --git a/src/file/extractor/app.cpp b/src/file/extractor/app.cpp
--- a/src/file/extractor/app.cpp
+++ b/src/file/extractor/app.cpp
@@ -22,8 +22,8 @@
 
 #include "app.h"
 #include "basicindexingjob.h"
-#include "result.h"
 #include "idutils.h"
+#include "result.h"
 #include "transaction.h"
 #include "baloodebug.h"
 #include "global.h"
@@ -80,7 +80,7 @@
     if (!m_io.atEnd()) {
         int delay = m_idleMonitor.isIdle() ? 0 : 10;
 
-        quint64 id = m_io.nextId();
+        DocId id = m_io.nextId();
 
         QString url = QFile::decodeName(m_tr->documentUrl(id));
         if (!QFile::exists(url)) {
@@ -124,7 +124,7 @@
     }
 }
 
-void App::index(Transaction* tr, const QString& url, quint64 id)
+void App::index(Transaction* tr, const QString& url, DocId id)
 {
     QString mimetype = m_mimeDb.mimeTypeForFile(url).name();
 
diff --git a/src/file/extractor/autotests/iohandlertest.cpp b/src/file/extractor/autotests/iohandlertest.cpp
--- a/src/file/extractor/autotests/iohandlertest.cpp
+++ b/src/file/extractor/autotests/iohandlertest.cpp
@@ -47,16 +47,16 @@
     stdIn.open();
     IOHandler io(stdIn.handle());
 
-    QVector<quint64> ids;
+    QVector<DocId> ids;
     quint32 size = 10;
     ids.reserve(size);
     QByteArray ba;
     ba.append(reinterpret_cast<char*>(&size), sizeof(quint32));
 
-    for (quint64 i = 0; i < 10; ++i) {
-        quint64 a = std::pow(16, i);
+    for (DocId i = 0; i < 10; ++i) {
+        DocId a = std::pow(16, i);
         ids.append(a);
-        ba.append(reinterpret_cast<char*>(&a), sizeof(quint64));
+        ba.append(reinterpret_cast<char*>(&a), sizeof(DocId));
     }
 
     stdIn.write(ba.data(), ba.size());
diff --git a/src/file/extractor/iohandler.h b/src/file/extractor/iohandler.h
--- a/src/file/extractor/iohandler.h
+++ b/src/file/extractor/iohandler.h
@@ -23,6 +23,8 @@
 #ifndef EXTRACTOR_IOHANDLER_H
 #define EXTRACTOR_IOHANDLER_H
 
+#include "idutils.h"
+
 #include <QObject>
 #include <QTextStream>
 
@@ -32,7 +34,7 @@
 {
 public:
     IOHandler(int stdin);
-    quint64 nextId();
+    DocId nextId();
     bool atEnd() const;
 
     void newBatch();
diff --git a/src/file/extractor/iohandler.cpp b/src/file/extractor/iohandler.cpp
--- a/src/file/extractor/iohandler.cpp
+++ b/src/file/extractor/iohandler.cpp
@@ -40,11 +40,11 @@
     Q_ASSERT(m_batchSize != 0);
 }
 
-quint64 IOHandler::nextId()
+DocId IOHandler::nextId()
 {
     Q_ASSERT(!atEnd());
-    quint64 id = 0;
-    read(m_stdinHandle, &id, sizeof(quint64));
+    DocId id = 0;
+    read(m_stdinHandle, &id, sizeof(DocId));
     --m_batchSize;
     Q_ASSERT(id != 0);
     return id;
diff --git a/src/file/extractor/result.h b/src/file/extractor/result.h
--- a/src/file/extractor/result.h
+++ b/src/file/extractor/result.h
@@ -23,11 +23,12 @@
 #ifndef EXTRACTIONRESULT_H
 #define EXTRACTIONRESULT_H
 
-#include <KFileMetaData/ExtractionResult>
 
 #include "document.h"
 #include "termgenerator.h"
 
+#include <KFileMetaData/ExtractionResult>
+
 class Result : public KFileMetaData::ExtractionResult
 {
 public:
@@ -40,7 +41,7 @@
 
     void setDocument(const Baloo::Document& doc);
 
-    quint64 id() const;
+    Baloo::DocId id() const;
     QVariantMap map() const;
 
     Baloo::Document& document() {
@@ -54,7 +55,7 @@
     void finish();
 
 private:
-    quint64 m_docId;
+    Baloo::DocId m_docId;
     Baloo::Document m_doc;
     Baloo::TermGenerator m_termGen;
     Baloo::TermGenerator m_termGenForText;
diff --git a/src/file/extractor/result.cpp b/src/file/extractor/result.cpp
--- a/src/file/extractor/result.cpp
+++ b/src/file/extractor/result.cpp
@@ -130,7 +130,7 @@
     m_termGenForText.setPosition(10000);
 }
 
-quint64 Result::id() const
+Baloo::DocId Result::id() const
 {
     return m_docId;
 }
diff --git a/src/file/extractorprocess.h b/src/file/extractorprocess.h
--- a/src/file/extractorprocess.h
+++ b/src/file/extractorprocess.h
@@ -20,6 +20,8 @@
 #ifndef BALOO_EXTRACTORPROCESS_H
 #define BALOO_EXTRACTORPROCESS_H
 
+#include "idutils.h"
+
 #include <QProcess>
 #include <QObject>
 #include <QTimer>
@@ -34,7 +36,7 @@
     explicit ExtractorProcess(QObject* parent = nullptr);
     ~ExtractorProcess();
 
-    void index(const QVector<quint64>& fileIds);
+    void index(const QVector<DocId>& fileIds);
 
 Q_SIGNALS:
     void startedIndexingFile(QString filePath);
diff --git a/src/file/extractorprocess.cpp b/src/file/extractorprocess.cpp
--- a/src/file/extractorprocess.cpp
+++ b/src/file/extractorprocess.cpp
@@ -42,7 +42,7 @@
     m_extractorProcess.close();
 }
 
-void ExtractorProcess::index(const QVector<quint64>& fileIds)
+void ExtractorProcess::index(const QVector<DocId>& fileIds)
 {
     Q_ASSERT(m_extractorProcess.state() == QProcess::Running);
     Q_ASSERT(m_extractorIdle);
@@ -52,8 +52,8 @@
 
     quint32 batchSize = fileIds.size();
     batchData.append(reinterpret_cast<char*>(&batchSize), sizeof(quint32));
-    for (quint64 id : fileIds) {
-        batchData.append(reinterpret_cast<char*>(&id), sizeof(quint64));
+    for (DocId id : fileIds) {
+        batchData.append(reinterpret_cast<char*>(&id), sizeof(DocId));
     }
 
     m_extractorIdle = false;
diff --git a/src/file/filecontentindexer.cpp b/src/file/filecontentindexer.cpp
--- a/src/file/filecontentindexer.cpp
+++ b/src/file/filecontentindexer.cpp
@@ -62,7 +62,7 @@
         QElapsedTimer timer;
         timer.start();
 
-        QVector<quint64> idList = m_provider->fetch(m_batchSize);
+        QVector<DocId> idList = m_provider->fetch(m_batchSize);
         if (idList.isEmpty() || m_stop.load()) {
             break;
         }
diff --git a/src/file/filecontentindexerprovider.h b/src/file/filecontentindexerprovider.h
--- a/src/file/filecontentindexerprovider.h
+++ b/src/file/filecontentindexerprovider.h
@@ -20,6 +20,8 @@
 #ifndef BALOO_FILECONTENTINDEXERPROVIDER_H
 #define BALOO_FILECONTENTINDEXERPROVIDER_H
 
+#include "idutils.h"
+
 #include <QVector>
 
 namespace Baloo {
@@ -32,7 +34,7 @@
     explicit FileContentIndexerProvider(Database* db);
 
     uint size();
-    QVector<quint64> fetch(uint size);
+    QVector<DocId> fetch(uint size);
 
 private:
     Database* m_db;
diff --git a/src/file/filecontentindexerprovider.cpp b/src/file/filecontentindexerprovider.cpp
--- a/src/file/filecontentindexerprovider.cpp
+++ b/src/file/filecontentindexerprovider.cpp
@@ -29,7 +29,7 @@
 {
 }
 
-QVector<quint64> FileContentIndexerProvider::fetch(uint size)
+QVector<DocId> FileContentIndexerProvider::fetch(uint size)
 {
     Transaction tr(m_db, Transaction::ReadOnly);
     return tr.fetchPhaseOneIds(size);
diff --git a/src/file/indexcleaner.cpp b/src/file/indexcleaner.cpp
--- a/src/file/indexcleaner.cpp
+++ b/src/file/indexcleaner.cpp
@@ -44,7 +44,7 @@
 
     Transaction tr(m_db, Transaction::ReadWrite);
 
-    auto shouldDelete = [&](quint64 id) {
+    auto shouldDelete = [&](DocId id) {
         if (!id) {
             return false;
         }
@@ -72,7 +72,7 @@
     };
 
     for (const QString& folder : m_config->includeFolders()) {
-        quint64 id = filePathToId(QFile::encodeName(folder));
+        DocId id = filePathToId(QFile::encodeName(folder));
         tr.removeRecursively(id, shouldDelete);
     }
     tr.commit();
diff --git a/src/file/metadatamover.cpp b/src/file/metadatamover.cpp
--- a/src/file/metadatamover.cpp
+++ b/src/file/metadatamover.cpp
@@ -71,7 +71,7 @@
 {
     Q_ASSERT(!url.isEmpty());
 
-    quint64 id = tr->documentId(QFile::encodeName(url));
+    DocId id = tr->documentId(QFile::encodeName(url));
     if (!id) {
         Q_EMIT fileRemoved(url);
         return;
@@ -95,7 +95,7 @@
     Q_ASSERT(to[to.size()-1] != QLatin1Char('/'));
 
     QByteArray toPath = QFile::encodeName(to);
-    quint64 id = filePathToId(toPath);
+    DocId id = filePathToId(toPath);
     if (!id) {
         qWarning() << "File moved to path which now no longer exists -" << to;
         return;
diff --git a/src/file/modifiedfileindexer.cpp b/src/file/modifiedfileindexer.cpp
--- a/src/file/modifiedfileindexer.cpp
+++ b/src/file/modifiedfileindexer.cpp
@@ -61,7 +61,7 @@
             continue;
         }
 
-        quint64 fileId = filePathToId(QFile::encodeName(filePath));
+        DocId fileId = filePathToId(QFile::encodeName(filePath));
         if (!fileId) {
             continue;
         }
diff --git a/src/file/unindexedfileindexer.cpp b/src/file/unindexedfileindexer.cpp
--- a/src/file/unindexedfileindexer.cpp
+++ b/src/file/unindexedfileindexer.cpp
@@ -55,7 +55,7 @@
             job.index();
 
             // We handle modified files by simply updating the mTime and filename in the Db and marking them for ContentIndexing
-            const quint64 id = job.document().id();
+            const DocId id = job.document().id();
             if (tr.hasDocument(id)) {
 
                 DocumentOperations ops = DocumentTime;
diff --git a/src/file/unindexedfileiterator.cpp b/src/file/unindexedfileiterator.cpp
--- a/src/file/unindexedfileiterator.cpp
+++ b/src/file/unindexedfileiterator.cpp
@@ -94,7 +94,7 @@
     if (!fileInfo.exists())
         return false;
 
-    quint64 fileId = filePathToId(QFile::encodeName(filePath));
+    DocId fileId = filePathToId(QFile::encodeName(filePath));
     Q_ASSERT_X(fileId, "UnIndexedFileIterator::shouldIndex", "file id is 0");
     if (!fileId) {
         return true;
diff --git a/src/lib/file.cpp b/src/lib/file.cpp
--- a/src/lib/file.cpp
+++ b/src/lib/file.cpp
@@ -100,7 +100,7 @@
         return false;
     }
 
-    quint64 id = filePathToId(QFile::encodeName(d->url));
+    DocId id = filePathToId(QFile::encodeName(d->url));
     if (!id) {
         return false;
     }
diff --git a/src/lib/searchstore.cpp b/src/lib/searchstore.cpp
--- a/src/lib/searchstore.cpp
+++ b/src/lib/searchstore.cpp
@@ -79,9 +79,9 @@
     }
 
     if (sortResults) {
-        QVector<quint64> resultIds;
+        QVector<DocId> resultIds;
         while (it->next()) {
-            quint64 id = it->docId();
+            DocId id = it->docId();
             resultIds << id;
 
             Q_ASSERT(id > 0);
@@ -92,7 +92,7 @@
             return QStringList();
         }
 
-        auto compFunc = [&tr](const quint64 lhs, const quint64 rhs) {
+        auto compFunc = [&tr](const DocId lhs, const DocId rhs) {
             return tr.documentTimeInfo(lhs).mTime > tr.documentTimeInfo(rhs).mTime;
         };
 
@@ -104,7 +104,7 @@
         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];
+            const DocId id = resultIds[i];
             const QString filePath = tr.documentUrl(id);
 
             results << filePath;
@@ -118,7 +118,7 @@
         const uint end = offset + static_cast<uint>(limit);
 
         while (it->next() && (limit < 0 || i < end)) {
-            quint64 id = it->docId();
+            DocId id = it->docId();
             Q_ASSERT(id > 0);
 
             if (i >= offset) {
@@ -195,7 +195,7 @@
         Q_ASSERT(!folder.isEmpty());
         Q_ASSERT(folder.startsWith('/'));
 
-        quint64 id = filePathToId(folder);
+        DocId id = filePathToId(folder);
         if (!id) {
             qDebug() << "Folder" << value.toString() << "does not exist";
             return nullptr;
diff --git a/src/tools/balooctl/main.cpp b/src/tools/balooctl/main.cpp
--- a/src/tools/balooctl/main.cpp
+++ b/src/tools/balooctl/main.cpp
@@ -214,7 +214,7 @@
 
         for (int i = 1; i < parser.positionalArguments().size(); ++i) {
             const QString url = QFileInfo(parser.positionalArguments().at(i)).absoluteFilePath();
-            quint64 id = filePathToId(QFile::encodeName(url));
+            DocId id = filePathToId(QFile::encodeName(url));
             if (id == 0) {
                 out << "Could not stat file: " << url << endl;
                 continue;
@@ -253,7 +253,7 @@
 
         for (int i = 1; i < parser.positionalArguments().size(); ++i) {
             const QString url = QFileInfo(parser.positionalArguments().at(i)).absoluteFilePath();
-            quint64 id = filePathToId(QFile::encodeName(url));
+            DocId id = filePathToId(QFile::encodeName(url));
             if (id == 0) {
                 out << "Could not stat file: " << url << endl;
                 continue;
diff --git a/src/tools/balooctl/statuscommand.cpp b/src/tools/balooctl/statuscommand.cpp
--- a/src/tools/balooctl/statuscommand.cpp
+++ b/src/tools/balooctl/statuscommand.cpp
@@ -50,7 +50,7 @@
     QTextStream err(stderr);
     for (const QString& arg : args) {
       QString filePath = QFileInfo(arg).absoluteFilePath();
-      quint64 id = filePathToId(QFile::encodeName(filePath));
+      DocId id = filePathToId(QFile::encodeName(filePath));
       if (id == 0) {
         err << i18n("Ignoring non-existent file %1", filePath) << endl;
         continue;
@@ -88,7 +88,7 @@
     QTextStream err(stderr);
     for (const QString& arg : args) {
       QString filePath = QFileInfo(arg).absoluteFilePath();
-      quint64 id = filePathToId(QFile::encodeName(filePath));
+      DocId id = filePathToId(QFile::encodeName(filePath));
       if (id == 0) {
         err << i18n("Ignoring non-existent file %1", filePath) << endl;
         continue;
@@ -128,7 +128,7 @@
   QJsonArray filesInfo;
   for (const QString& arg : args) {
       QString filePath = QFileInfo(arg).absoluteFilePath();
-      quint64 id = filePathToId(QFile::encodeName(filePath));
+      DocId id = filePathToId(QFile::encodeName(filePath));
       
       if (id == 0) {
           QTextStream err(stderr);
diff --git a/src/tools/balooshow/main.cpp b/src/tools/balooshow/main.cpp
--- a/src/tools/balooshow/main.cpp
+++ b/src/tools/balooshow/main.cpp
@@ -35,7 +35,6 @@
 #include <QJsonObject>
 
 #include "global.h"
-#include "idutils.h"
 #include "database.h"
 #include "transaction.h"
 
@@ -112,13 +111,13 @@
     Baloo::Transaction tr(db, Baloo::Transaction::ReadOnly);
 
     for (QString url : urls) {
-        quint64 fid = 0;
+        Baloo::DocId fid = 0;
         if (url.startsWith(QLatin1String("file:"))) {
             fid = url.midRef(5).toULongLong();
             url = QFile::decodeName(tr.documentUrl(fid));
 
             // Debugging aid
-            quint64 actualFid = Baloo::filePathToId(QFile::encodeName(url));
+            Baloo::DocId actualFid = Baloo::filePathToId(QFile::encodeName(url));
             if (fid != actualFid) {
                 stream << i18n("The fileID is not equal to the actual Baloo fileID") <<  "\n";
                 stream << i18n("This is a bug") <<  "\n";