qsqlquery.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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
 
#include "qsqlquery.h"
 
//#define QT_DEBUG_SQL
 
#include "qatomic.h"
#include "qdebug.h"
#include "qloggingcategory.h"
#include "qsqlrecord.h"
#include "qsqlresult.h"
#include "qsqldriver.h"
#include "qsqldatabase.h"
#include "private/qsqlnulldriver_p.h"
 
#ifdef QT_DEBUG_SQL
#include "qelapsedtimer.h"
#endif
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcSqlQuery, "qt.sql.qsqlquery")
 
class QSqlQueryPrivate
{
public:
    QSqlQueryPrivate(QSqlResult* result);
    ~QSqlQueryPrivate();
    QAtomicInt ref;
    QSqlResult* sqlResult;
 
    static QSqlQueryPrivate* shared_null();
};
 
Q_GLOBAL_STATIC_WITH_ARGS(QSqlQueryPrivate, nullQueryPrivate, (nullptr))
Q_GLOBAL_STATIC(QSqlNullDriver, nullDriver)
Q_GLOBAL_STATIC_WITH_ARGS(QSqlNullResult, nullResult, (nullDriver()))
 
QSqlQueryPrivate* QSqlQueryPrivate::shared_null()
{
    QSqlQueryPrivate *null = nullQueryPrivate();
    null->ref.ref();
    return null;
}
 
QSqlQueryPrivate::QSqlQueryPrivate(QSqlResult* result)
    : ref(1), sqlResult(result)
{
    if (!sqlResult)
        sqlResult = nullResult();
}
 
QSqlQueryPrivate::~QSqlQueryPrivate()
{
    QSqlResult *nr = nullResult();
    if (!nr || sqlResult == nr)
        return;
    delete sqlResult;
}
 
QSqlQuery::QSqlQuery(QSqlResult *result)
{
    d = new QSqlQueryPrivate(result);
}
 
QSqlQuery::~QSqlQuery()
{
    if (d && !d->ref.deref())
        delete d;
}
 
#if QT_DEPRECATED_SINCE(6, 2)
QSqlQuery::QSqlQuery(const QSqlQuery& other)
{
    d = other.d;
    d->ref.ref();
}
 
QSqlQuery& QSqlQuery::operator=(const QSqlQuery& other)
{
    qAtomicAssign(d, other.d);
    return *this;
}
#endif
 
static void qInit(QSqlQuery *q, const QString& query, const QSqlDatabase &db)
{
    QSqlDatabase database = db;
    if (!database.isValid()) {
        database =
                QSqlDatabase::database(QLatin1StringView(QSqlDatabase::defaultConnection), false);
    }
    if (database.isValid())
        *q = QSqlQuery(database.driver()->createResult());
 
    if (!query.isEmpty())
        q->exec(query);
}
 
QSqlQuery::QSqlQuery(const QString& query, const QSqlDatabase &db)
{
    d = QSqlQueryPrivate::shared_null();
    qInit(this, query, db);
}
 
QSqlQuery::QSqlQuery(const QSqlDatabase &db)
{
    d = QSqlQueryPrivate::shared_null();
    qInit(this, QString(), db);
}
 
bool QSqlQuery::isNull(int field) const
{
    return !d->sqlResult->isActive()
             || !d->sqlResult->isValid()
             || d->sqlResult->isNull(field);
}
 
bool QSqlQuery::isNull(QAnyStringView name) const
{
    qsizetype index = d->sqlResult->record().indexOf(name);
    if (index > -1)
        return isNull(index);
    qCWarning(lcSqlQuery, "QSqlQuery::isNull: unknown field name '%ls'", qUtf16Printable(name.toString()));
    return true;
}
 
bool QSqlQuery::exec(const QString& query)
{
#ifdef QT_DEBUG_SQL
    QElapsedTimer t;
    t.start();
#endif
    if (!driver()) {
        qCWarning(lcSqlQuery, "QSqlQuery::exec: called before driver has been set up");
        return false;
    }
    if (d->ref.loadRelaxed() != 1) {
        bool fo = isForwardOnly();
        *this = QSqlQuery(driver()->createResult());
        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
        setForwardOnly(fo);
    } else {
        d->sqlResult->clear();
        d->sqlResult->setActive(false);
        d->sqlResult->setLastError(QSqlError());
        d->sqlResult->setAt(QSql::BeforeFirstRow);
        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
    }
    d->sqlResult->setQuery(query.trimmed());
    if (!driver()->isOpen() || driver()->isOpenError()) {
        qCWarning(lcSqlQuery, "QSqlQuery::exec: database not open");
        return false;
    }
    if (query.isEmpty()) {
        qCWarning(lcSqlQuery, "QSqlQuery::exec: empty query");
        return false;
    }
 
    bool retval = d->sqlResult->reset(query);
#ifdef QT_DEBUG_SQL
    qCDebug(lcSqlQuery()).nospace() << "Executed query (" << t.elapsed() << "ms, "
                                    << d->sqlResult->size()
                                    << " results, " << d->sqlResult->numRowsAffected()
                                    << " affected): " << d->sqlResult->lastQuery();
#endif
    return retval;
}
 
QVariant QSqlQuery::value(int index) const
{
    if (isActive() && isValid() && (index > -1))
        return d->sqlResult->data(index);
    qCWarning(lcSqlQuery, "QSqlQuery::value: not positioned on a valid record");
    return QVariant();
}
 
QVariant QSqlQuery::value(QAnyStringView name) const
{
    qsizetype index = d->sqlResult->record().indexOf(name);
    if (index > -1)
        return value(index);
    qCWarning(lcSqlQuery, "QSqlQuery::value: unknown field name '%ls'", qUtf16Printable(name.toString()));
    return QVariant();
}
 
int QSqlQuery::at() const
{
    return d->sqlResult->at();
}
 
QString QSqlQuery::lastQuery() const
{
    return d->sqlResult->lastQuery();
}
 
const QSqlDriver *QSqlQuery::driver() const
{
    return d->sqlResult->driver();
}
 
const QSqlResult* QSqlQuery::result() const
{
    return d->sqlResult;
}
 
bool QSqlQuery::seek(int index, bool relative)
{
    if (!isSelect() || !isActive())
        return false;
    int actualIdx;
    if (!relative) { // arbitrary seek
        if (index < 0) {
            d->sqlResult->setAt(QSql::BeforeFirstRow);
            return false;
        }
        actualIdx = index;
    } else {
        switch (at()) { // relative seek
        case QSql::BeforeFirstRow:
            if (index > 0)
                actualIdx = index - 1;
            else {
                return false;
            }
            break;
        case QSql::AfterLastRow:
            if (index < 0) {
                d->sqlResult->fetchLast();
                actualIdx = at() + index + 1;
            } else {
                return false;
            }
            break;
        default:
            if ((at() + index) < 0) {
                d->sqlResult->setAt(QSql::BeforeFirstRow);
                return false;
            }
            actualIdx = at() + index;
            break;
        }
    }
    // let drivers optimize
    if (isForwardOnly() && actualIdx < at()) {
        qCWarning(lcSqlQuery, "QSqlQuery::seek: cannot seek backwards in a forward only query");
        return false;
    }
    if (actualIdx == (at() + 1) && at() != QSql::BeforeFirstRow) {
        if (!d->sqlResult->fetchNext()) {
            d->sqlResult->setAt(QSql::AfterLastRow);
            return false;
        }
        return true;
    }
    if (actualIdx == (at() - 1)) {
        if (!d->sqlResult->fetchPrevious()) {
            d->sqlResult->setAt(QSql::BeforeFirstRow);
            return false;
        }
        return true;
    }
    if (!d->sqlResult->fetch(actualIdx)) {
        d->sqlResult->setAt(QSql::AfterLastRow);
        return false;
    }
    return true;
}
 
bool QSqlQuery::next()
{
    if (!isSelect() || !isActive())
        return false;
 
    switch (at()) {
    case QSql::BeforeFirstRow:
        return d->sqlResult->fetchFirst();
    case QSql::AfterLastRow:
        return false;
    default:
        if (!d->sqlResult->fetchNext()) {
            d->sqlResult->setAt(QSql::AfterLastRow);
            return false;
        }
        return true;
    }
}
 
bool QSqlQuery::previous()
{
    if (!isSelect() || !isActive())
        return false;
    if (isForwardOnly()) {
        qCWarning(lcSqlQuery, "QSqlQuery::seek: cannot seek backwards in a forward only query");
        return false;
    }
 
    switch (at()) {
    case QSql::BeforeFirstRow:
        return false;
    case QSql::AfterLastRow:
        return d->sqlResult->fetchLast();
    default:
        if (!d->sqlResult->fetchPrevious()) {
            d->sqlResult->setAt(QSql::BeforeFirstRow);
            return false;
        }
        return true;
    }
}
 
bool QSqlQuery::first()
{
    if (!isSelect() || !isActive())
        return false;
    if (isForwardOnly() && at() > QSql::BeforeFirstRow) {
        qCWarning(lcSqlQuery, "QSqlQuery::seek: cannot seek backwards in a forward only query");
        return false;
    }
    return d->sqlResult->fetchFirst();
}
 
bool QSqlQuery::last()
{
    if (!isSelect() || !isActive())
        return false;
    return d->sqlResult->fetchLast();
}
 
int QSqlQuery::size() const
{
    if (isActive() && d->sqlResult->driver()->hasFeature(QSqlDriver::QuerySize))
        return d->sqlResult->size();
    return -1;
}
 
int QSqlQuery::numRowsAffected() const
{
    if (isActive())
        return d->sqlResult->numRowsAffected();
    return -1;
}
 
QSqlError QSqlQuery::lastError() const
{
    return d->sqlResult->lastError();
}
 
bool QSqlQuery::isValid() const
{
    return d->sqlResult->isValid();
}
 
bool QSqlQuery::isActive() const
{
    return d->sqlResult->isActive();
}
 
bool QSqlQuery::isSelect() const
{
    return d->sqlResult->isSelect();
}
 
bool QSqlQuery::isForwardOnly() const
{
    return d->sqlResult->isForwardOnly();
}
 
void QSqlQuery::setForwardOnly(bool forward)
{
    d->sqlResult->setForwardOnly(forward);
}
 
QSqlRecord QSqlQuery::record() const
{
    QSqlRecord rec = d->sqlResult->record();
 
    if (isValid()) {
        for (qsizetype i = 0; i < rec.count(); ++i)
            rec.setValue(i, value(i));
    }
    return rec;
}
 
void QSqlQuery::clear()
{
    *this = QSqlQuery(driver()->createResult());
}
 
bool QSqlQuery::prepare(const QString& query)
{
    if (d->ref.loadRelaxed() != 1) {
        bool fo = isForwardOnly();
        *this = QSqlQuery(driver()->createResult());
        setForwardOnly(fo);
        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
    } else {
        d->sqlResult->setActive(false);
        d->sqlResult->setLastError(QSqlError());
        d->sqlResult->setAt(QSql::BeforeFirstRow);
        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
    }
    if (!driver()) {
        qCWarning(lcSqlQuery, "QSqlQuery::prepare: no driver");
        return false;
    }
    if (!driver()->isOpen() || driver()->isOpenError()) {
        qCWarning(lcSqlQuery, "QSqlQuery::prepare: database not open");
        return false;
    }
    if (query.isEmpty()) {
        qCWarning(lcSqlQuery, "QSqlQuery::prepare: empty query");
        return false;
    }
#ifdef QT_DEBUG_SQL
    qCDebug(lcSqlQuery, "\n QSqlQuery::prepare: %ls", qUtf16Printable(query));
#endif
    return d->sqlResult->savePrepare(query);
}
 
bool QSqlQuery::exec()
{
#ifdef QT_DEBUG_SQL
    QElapsedTimer t;
    t.start();
#endif
    d->sqlResult->resetBindCount();
 
    if (d->sqlResult->lastError().isValid())
        d->sqlResult->setLastError(QSqlError());
 
    bool retval = d->sqlResult->exec();
#ifdef QT_DEBUG_SQL
    qCDebug(lcSqlQuery).nospace() << "Executed prepared query (" << t.elapsed() << "ms, "
                                  << d->sqlResult->size() << " results, " << d->sqlResult->numRowsAffected()
                                  << " affected): " << d->sqlResult->lastQuery();
#endif
    return retval;
}
 
bool QSqlQuery::execBatch(BatchExecutionMode mode)
{
    d->sqlResult->resetBindCount();
    return d->sqlResult->execBatch(mode == ValuesAsColumns);
}
 
void QSqlQuery::bindValue(const QString& placeholder, const QVariant& val,
                          QSql::ParamType paramType
)
{
    d->sqlResult->bindValue(placeholder, val, paramType);
}
 
void QSqlQuery::bindValue(int pos, const QVariant& val, QSql::ParamType paramType)
{
    d->sqlResult->bindValue(pos, val, paramType);
}
 
void QSqlQuery::addBindValue(const QVariant& val, QSql::ParamType paramType)
{
    d->sqlResult->addBindValue(val, paramType);
}
 
QVariant QSqlQuery::boundValue(const QString& placeholder) const
{
    return d->sqlResult->boundValue(placeholder);
}
 
QVariant QSqlQuery::boundValue(int pos) const
{
    return d->sqlResult->boundValue(pos);
}
 
QVariantList QSqlQuery::boundValues() const
{
    const QVariantList values(d->sqlResult->boundValues());
    return values;
}
 
QStringList QSqlQuery::boundValueNames() const
{
    return d->sqlResult->boundValueNames();
}
 
QString QSqlQuery::boundValueName(int pos) const
{
    return d->sqlResult->boundValueName(pos);
}
 
QString QSqlQuery::executedQuery() const
{
    return d->sqlResult->executedQuery();
}
 
QVariant QSqlQuery::lastInsertId() const
{
    return d->sqlResult->lastInsertId();
}
 
void QSqlQuery::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
{
    d->sqlResult->setNumericalPrecisionPolicy(precisionPolicy);
}
 
QSql::NumericalPrecisionPolicy QSqlQuery::numericalPrecisionPolicy() const
{
    return d->sqlResult->numericalPrecisionPolicy();
}
 
void QSqlQuery::setPositionalBindingEnabled(bool enable)
{
    d->sqlResult->setPositionalBindingEnabled(enable);
}
 
bool QSqlQuery::isPositionalBindingEnabled() const
{
    return d->sqlResult->isPositionalBindingEnabled();
}
 
 
void QSqlQuery::finish()
{
    if (isActive()) {
        d->sqlResult->setLastError(QSqlError());
        d->sqlResult->setAt(QSql::BeforeFirstRow);
        d->sqlResult->detachFromResultSet();
        d->sqlResult->setActive(false);
    }
}
 
bool QSqlQuery::nextResult()
{
    if (isActive())
        return d->sqlResult->nextResult();
    return false;
}
 
QT_END_NAMESPACE
 
#include "moc_qsqlquery.cpp"