Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
#include "qhelpdbreader_p.h"
#include "qhelp_global.h"
#include <QtCore/qfile.h>
#include <QtCore/qmap.h>
#include <QtCore/qvariant.h>
#include <QtCore/qversionnumber.h>
#include <QtSql/qsqldatabase.h>
#include <QtSql/qsqlerror.h>
#include <QtSql/qsqlquery.h>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
QHelpDBReader::QHelpDBReader(const QString &dbName)
: m_dbName(dbName)
, m_uniqueId(QHelpGlobal::uniquifyConnectionName("QHelpDBReader"_L1, this))
{}
QHelpDBReader::QHelpDBReader(const QString &dbName, const QString &uniqueId, QObject *parent)
: QObject(parent)
, m_dbName(dbName)
, m_uniqueId(uniqueId)
{}
QHelpDBReader::~QHelpDBReader()
{
if (m_initDone)
QSqlDatabase::removeDatabase(m_uniqueId);
}
bool QHelpDBReader::init()
{
if (m_initDone)
return true;
if (!QFile::exists(m_dbName))
return false;
if (!initDB()) {
QSqlDatabase::removeDatabase(m_uniqueId);
return false;
}
m_initDone = true;
m_query.reset(new QSqlQuery(QSqlDatabase::database(m_uniqueId)));
return true;
}
bool QHelpDBReader::initDB()
{
QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE"_L1, m_uniqueId);
db.setConnectOptions("QSQLITE_OPEN_READONLY"_L1);
db.setDatabaseName(m_dbName);
if (!db.open()) {
/*: The placeholders are: %1 - The name of the database which cannot be opened
%2 - The unique id for the connection
%3 - The actual error string */
m_error = tr("Cannot open database \"%1\" \"%2\": %3").arg(m_dbName, m_uniqueId, db.lastError().text());
return false;
}
return true;
}
QString QHelpDBReader::namespaceName() const
{
if (!m_namespace.isEmpty())
return m_namespace;
if (m_query) {
m_query->exec("SELECT Name FROM NamespaceTable"_L1);
if (m_query->next())
m_namespace = m_query->value(0).toString();
}
return m_namespace;
}
QString QHelpDBReader::virtualFolder() const
{
if (m_query) {
m_query->exec("SELECT Name FROM FolderTable WHERE Id=1"_L1);
if (m_query->next())
return m_query->value(0).toString();
}
return {};
}
QString QHelpDBReader::version() const
{
const QString versionString = metaData("version"_L1).toString();
if (versionString.isEmpty())
return qtVersionHeuristic();
return versionString;
}
struct VersionData
{
QString tail;
int major = -1;
int minor = -1;
int patch = -1;
};
static VersionData getVersionData(const QString &nameSpace)
{
VersionData result;
if (!nameSpace.startsWith("org.qt-project."_L1))
return result;
// We take the namespace tail, starting from the last letter in namespace name.
// We drop any non digit characters.
const QChar dot(u'.');
QString &tail = result.tail;
for (int i = nameSpace.size(); i > 0; --i) {
const QChar c = nameSpace.at(i - 1);
if (c.isDigit() || c == dot)
tail.prepend(c);
if (c.isLetter())
break;
}
if (!tail.startsWith(dot) && tail.count(dot) == 1) {
// The org.qt-project.qtquickcontrols2.5120 case,
// tail = 2.5120 here. We need to cut "2." here.
const int dotIndex = tail.indexOf(dot);
if (dotIndex > 0)
tail = tail.mid(dotIndex);
}
// Drop beginning dots
while (tail.startsWith(dot))
tail = tail.mid(1);
// Drop ending dots
while (tail.endsWith(dot))
tail.chop(1);
if (tail.size() >= 3 && tail.size() <= 5 && tail.count(dot) == 0) {
// When we have 3 digits, we split it like: ABC -> A.B.C
// When we have 4 digits, we split it like: ABCD -> A.BC.D
// When we have 5 digits, we split it like: ABCDE -> A.BC.DE
QStringView tail{result.tail};
result.major = tail.left(1).toInt();
result.minor = tail.size() == 3 ? tail.mid(1, 1).toInt() : tail.mid(1, 2).toInt();
result.patch = tail.size() == 5 ? tail.right(2).toInt() : tail.right(1).toInt();
}
return result;
}
QString QHelpDBReader::qtVersionHeuristic() const
{
VersionData version = getVersionData(namespaceName());
return version.major >= 0
? QString::number(version.major) + u'.' + QString::number(version.minor) + u'.' + QString::number(version.patch)
: version.tail;
}
QVersionNumber QHelpDBReader::versionHeuristic(const QString &namespaceName)
{
VersionData version = getVersionData(namespaceName);
return version.major >= 0 ? QVersionNumber{version.major, version.minor, version.patch}
: QVersionNumber::fromString(version.tail);
}
static bool isAttributeUsed(QSqlQuery *query, const QString &tableName, int attributeId)
{
query->prepare(QString::fromLatin1("SELECT FilterAttributeId "
"FROM %1 "
"WHERE FilterAttributeId = ? "
"LIMIT 1").arg(tableName));
query->bindValue(0, attributeId);
query->exec();
return query->next(); // if we got a result it means it was used
}
static int filterDataCount(QSqlQuery *query, const QString &tableName)
{
query->exec(QString::fromLatin1("SELECT COUNT(*) FROM"
"(SELECT DISTINCT * FROM %1)").arg(tableName));
query->next();
return query->value(0).toInt();
}
QHelpDBReader::IndexTable QHelpDBReader::indexTable() const
{
IndexTable table;
if (!m_query)
return table;
// Don't let the queries cache the already fetched rows, as all the data is copied
// into the table anyway.
m_query->setForwardOnly(true);
QMap<int, QString> attributeIds;
m_query->exec("SELECT DISTINCT Id, Name FROM FilterAttributeTable ORDER BY Id"_L1);
while (m_query->next())
attributeIds.insert(m_query->value(0).toInt(), m_query->value(1).toString());
// Maybe some are unused and specified erroneously in the named filter only,
// like it was in case of qtlocation.qch <= qt 5.9
QList<int> usedAttributeIds;
for (auto it = attributeIds.cbegin(), end = attributeIds.cend(); it != end; ++it) {
const int attributeId = it.key();
if (isAttributeUsed(m_query.get(), "IndexFilterTable"_L1, attributeId)
|| isAttributeUsed(m_query.get(), "ContentsFilterTable"_L1, attributeId)
|| isAttributeUsed(m_query.get(), "FileFilterTable"_L1, attributeId)) {
usedAttributeIds.append(attributeId);
}
}
bool legacy = false;
m_query->exec("SELECT * FROM pragma_table_info('IndexTable') WHERE name='ContextName'"_L1);
if (m_query->next())
legacy = true;
const QString identifierColumnName = legacy ? "ContextName"_L1 : "Identifier"_L1;
const int usedAttributeCount = usedAttributeIds.size();
QMap<int, IndexItem> idToIndexItem;
m_query->exec(QString::fromLatin1("SELECT Name, %1, FileId, Anchor, Id "
"FROM IndexTable "
"ORDER BY Id").arg(identifierColumnName));
while (m_query->next()) {
IndexItem indexItem;
indexItem.name = m_query->value(0).toString();
indexItem.identifier = m_query->value(1).toString();
indexItem.fileId = m_query->value(2).toInt();
indexItem.anchor = m_query->value(3).toString();
const int indexId = m_query->value(4).toInt();
idToIndexItem.insert(indexId, indexItem);
}
QMap<int, FileItem> idToFileItem;
QMap<int, int> originalFileIdToNewFileId;
int filesCount = 0;
m_query->exec(
"SELECT "
"FileNameTable.FileId, "
"FileNameTable.Name, "
"FileNameTable.Title "
"FROM FileNameTable, FolderTable "
"WHERE FileNameTable.FolderId = FolderTable.Id "
"ORDER BY FileId"_L1);
while (m_query->next()) {
const int fileId = m_query->value(0).toInt();
FileItem fileItem;
fileItem.name = m_query->value(1).toString();
fileItem.title = m_query->value(2).toString();
idToFileItem.insert(fileId, fileItem);
originalFileIdToNewFileId.insert(fileId, filesCount);
++filesCount;
}
QMap<int, ContentsItem> idToContentsItem;
m_query->exec("SELECT Data, Id FROM ContentsTable ORDER BY Id"_L1);
while (m_query->next()) {
ContentsItem contentsItem;
contentsItem.data = m_query->value(0).toByteArray();
const int contentsId = m_query->value(1).toInt();
idToContentsItem.insert(contentsId, contentsItem);
}
bool optimized = true;
if (usedAttributeCount) {
// May optimize only when all usedAttributes are attached to every
// index and file. It means the number of rows in the
// IndexTable multiplied by number of used attributes
// must equal the number of rows inside IndexFilterTable
// (yes, we have a combinatorial explosion of data in IndexFilterTable,
// which we want to optimize). The same with FileNameTable and
// FileFilterTable.
const bool mayOptimizeIndexTable = filterDataCount(m_query.get(), "IndexFilterTable"_L1)
== idToIndexItem.size() * usedAttributeCount;
const bool mayOptimizeFileTable = filterDataCount(m_query.get(), "FileFilterTable"_L1)
== idToFileItem.size() * usedAttributeCount;
const bool mayOptimizeContentsTable =
filterDataCount(m_query.get(), "ContentsFilterTable"_L1)
== idToContentsItem.size() * usedAttributeCount;
optimized = mayOptimizeIndexTable && mayOptimizeFileTable && mayOptimizeContentsTable;
if (!optimized) {
m_query->exec(
"SELECT "
"IndexFilterTable.IndexId, "
"FilterAttributeTable.Name "
"FROM "
"IndexFilterTable, "
"FilterAttributeTable "
"WHERE "
"IndexFilterTable.FilterAttributeId = FilterAttributeTable.Id"_L1);
while (m_query->next()) {
const int indexId = m_query->value(0).toInt();
auto it = idToIndexItem.find(indexId);
if (it != idToIndexItem.end())
it.value().filterAttributes.append(m_query->value(1).toString());
}
m_query->exec(
"SELECT "
"FileFilterTable.FileId, "
"FilterAttributeTable.Name "
"FROM "
"FileFilterTable, "
"FilterAttributeTable "
"WHERE "
"FileFilterTable.FilterAttributeId = FilterAttributeTable.Id"_L1);
while (m_query->next()) {
const int fileId = m_query->value(0).toInt();
auto it = idToFileItem.find(fileId);
if (it != idToFileItem.end())
it.value().filterAttributes.append(m_query->value(1).toString());
}
m_query->exec(
"SELECT "
"ContentsFilterTable.ContentsId, "
"FilterAttributeTable.Name "
"FROM "
"ContentsFilterTable, "
"FilterAttributeTable "
"WHERE "
"ContentsFilterTable.FilterAttributeId = FilterAttributeTable.Id"_L1);
while (m_query->next()) {
const int contentsId = m_query->value(0).toInt();
auto it = idToContentsItem.find(contentsId);
if (it != idToContentsItem.end())
it.value().filterAttributes.append(m_query->value(1).toString());
}
}
}
// reindex fileId references
for (auto it = idToIndexItem.cbegin(), end = idToIndexItem.cend(); it != end; ++it) {
IndexItem item = it.value();
// An unknown file id is kept invalid, it's rejected when registering the index.
item.fileId = originalFileIdToNewFileId.value(item.fileId, -1);
table.indexItems.append(item);
}
table.fileItems = idToFileItem.values();
table.contentsItems = idToContentsItem.values();
if (optimized) {
for (int attributeId : std::as_const(usedAttributeIds))
table.usedFilterAttributes.append(attributeIds.value(attributeId));
}
m_query->finish();
m_query->setForwardOnly(false);
return table;
}
QList<QStringList> QHelpDBReader::filterAttributeSets() const
{
QList<QStringList> result;
if (m_query) {
m_query->exec(
"SELECT "
"FileAttributeSetTable.Id, "
"FilterAttributeTable.Name "
"FROM "
"FileAttributeSetTable, "
"FilterAttributeTable "
"WHERE FileAttributeSetTable.FilterAttributeId = FilterAttributeTable.Id "
"ORDER BY FileAttributeSetTable.Id"_L1);
int oldId = -1;
while (m_query->next()) {
const int id = m_query->value(0).toInt();
if (id != oldId) {
result.append(QStringList());
oldId = id;
}
result.last().append(m_query->value(1).toString());
}
}
return result;
}
QByteArray QHelpDBReader::fileData(const QString &virtualFolder,
const QString &filePath) const
{
QByteArray ba;
if (virtualFolder.isEmpty() || filePath.isEmpty() || !m_query)
return ba;
namespaceName();
m_query->prepare(
"SELECT "
"FileDataTable.Data "
"FROM "
"FileDataTable, "
"FileNameTable, "
"FolderTable, "
"NamespaceTable "
"WHERE FileDataTable.Id = FileNameTable.FileId "
"AND (FileNameTable.Name = ? OR FileNameTable.Name = ?) "
"AND FileNameTable.FolderId = FolderTable.Id "
"AND FolderTable.Name = ? "
"AND FolderTable.NamespaceId = NamespaceTable.Id "
"AND NamespaceTable.Name = ?"_L1);
m_query->bindValue(0, filePath);
m_query->bindValue(1, QString("./"_L1 + filePath));
m_query->bindValue(2, virtualFolder);
m_query->bindValue(3, m_namespace);
m_query->exec();
if (m_query->next() && m_query->isValid())
ba = qUncompress(m_query->value(0).toByteArray());
return ba;
}
QStringList QHelpDBReader::customFilters() const
{
QStringList lst;
if (m_query) {
m_query->exec("SELECT Name FROM FilterNameTable"_L1);
while (m_query->next())
lst.append(m_query->value(0).toString());
}
return lst;
}
QStringList QHelpDBReader::filterAttributes(const QString &filterName) const
{
QStringList lst;
if (m_query) {
if (filterName.isEmpty()) {
m_query->prepare("SELECT Name FROM FilterAttributeTable"_L1);
} else {
m_query->prepare(
"SELECT "
"FilterAttributeTable.Name "
"FROM "
"FilterAttributeTable, "
"FilterTable, "
"FilterNameTable "
"WHERE FilterNameTable.Name = ? "
"AND FilterNameTable.Id = FilterTable.NameId "
"AND FilterTable.FilterAttributeId = FilterAttributeTable.Id"_L1);
m_query->bindValue(0, filterName);
}
m_query->exec();
while (m_query->next())
lst.append(m_query->value(0).toString());
}
return lst;
}
void QHelpDBReader::filesData(const QStringList &filterAttributes,
const QStringList &extensionFilters,
const std::function<bool(const QString &fileName,
const QByteArray &data)> &handler) const
{
if (!m_query)
return;
QString query;
QString extension;
if (!extensionFilters.isEmpty()) {
QStringList conditions;
for (const QString &extensionFilter : extensionFilters)
conditions.append("FileNameTable.Name LIKE \'%.%1\'"_L1.arg(extensionFilter));
extension = "AND (%1)"_L1.arg(conditions.join(" OR "_L1));
}
if (filterAttributes.isEmpty()) {
query =
"SELECT "
"FileNameTable.Name, "
"FileDataTable.Data "
"FROM "
"FolderTable, "
"FileNameTable, "
"FileDataTable "
"WHERE FileDataTable.Id = FileNameTable.FileId "
"AND FileNameTable.FolderId = FolderTable.Id %1"_L1.arg(extension);
} else {
for (int i = 0; i < filterAttributes.size(); ++i) {
if (i > 0)
query.append(" INTERSECT "_L1);
query.append(
"SELECT "
"FileNameTable.Name, "
"FileDataTable.Data "
"FROM "
"FolderTable, "
"FileNameTable, "
"FileDataTable, "
"FileFilterTable, "
"FilterAttributeTable "
"WHERE FileDataTable.Id = FileNameTable.FileId "
"AND FileNameTable.FolderId = FolderTable.Id "
"AND FileNameTable.FileId = FileFilterTable.FileId "
"AND FileFilterTable.FilterAttributeId = FilterAttributeTable.Id "
"AND FilterAttributeTable.Name = \'%1\' %2"_L1
.arg(quote(filterAttributes.at(i)), extension));
}
}
// Don't let the query cache the already fetched rows, so that only one file is held
// in memory at a time.
m_query->setForwardOnly(true);
m_query->exec(query);
while (m_query->next()) {
if (!handler(m_query->value(0).toString(),
qUncompress(m_query->value(1).toByteArray()))) {
break;
}
}
m_query->finish();
m_query->setForwardOnly(false);
}
QVariant QHelpDBReader::metaData(const QString &name) const
{
if (!m_query)
return {};
m_query->prepare("SELECT COUNT(Value), Value FROM MetaDataTable WHERE Name=?"_L1);
m_query->bindValue(0, name);
if (m_query->exec() && m_query->next() && m_query->value(0).toInt() == 1)
return m_query->value(1);
return {};
}
QString QHelpDBReader::quote(const QString &string) const
{
QString s = string;
s.replace(u'\'', "\'\'"_L1);
return s;
}
QT_END_NAMESPACE