qsqlresult.cpp

Go to the documentation of this file.

// 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
 
#include "qsqlresult.h"
 
#include "qlist.h"
#include "qsqldriver.h"
#include "qsqlerror.h"
#include "qsqlfield.h"
#include "qsqlrecord.h"
#include "qsqlresult_p.h"
#include "quuid.h"
#include "qvariant.h"
#include "qdatetime.h"
#include "private/qsqldriver_p.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QString QSqlResultPrivate::holderAt(int index) const
{
    return holders.size() > index ? holders.at(index).holderName : fieldSerial(index);
}
 
QString QSqlResultPrivate::fieldSerial(qsizetype i) const
{
    return QString(":%1"_L1).arg(i);
}
 
static bool qIsAlnum(QChar ch)
{
    uint u = uint(ch.unicode());
    // matches [a-zA-Z0-9_]
    return u - 'a' < 26 || u - 'A' < 26 || u - '0' < 10 || u == '_';
}
 
QString QSqlResultPrivate::positionalToNamedBinding(const QString &query) const
{
    if (!positionalBindingEnabled)
        return query;
 
    const qsizetype n = query.size();
 
    QString result;
    result.reserve(n * 5 / 4);
    QChar closingQuote;
    qsizetype count = 0;
    bool ignoreBraces = (sqldriver->dbmsType() == QSqlDriver::PostgreSQL);
 
    for (qsizetype i = 0; i < n; ++i) {
        QChar ch = query.at(i);
        if (!closingQuote.isNull()) {
            if (ch == closingQuote) {
                if (closingQuote == u']'
                    && i + 1 < n && query.at(i + 1) == closingQuote) {
                    // consume the extra character. don't close.
                    ++i;
                    result += ch;
                } else {
                    closingQuote = QChar();
                }
            }
            result += ch;
        } else {
            if (ch == u'?') {
                result += fieldSerial(count++);
            } else {
                if (ch == u'\'' || ch == u'"' || ch == u'`')
                    closingQuote = ch;
                else if (!ignoreBraces && ch == u'[')
                    closingQuote = u']';
                result += ch;
            }
        }
    }
    result.squeeze();
    return result;
}
 
QString QSqlResultPrivate::namedToPositionalBinding(const QString &query)
{
    // In the Interbase case if it is an EXECUTE BLOCK then it is up to the
    // caller to make sure that it is not using named bindings for the wrong
    // parts of the query since Interbase uses them literally
    if (sqldriver->dbmsType() == QSqlDriver::Interbase &&
        query.trimmed().startsWith("EXECUTE BLOCK"_L1, Qt::CaseInsensitive))
        return query;
 
    const qsizetype n = query.size();
 
    QString result;
    result.reserve(n);
    QChar closingQuote;
    int count = 0;
    qsizetype i = 0;
    bool ignoreBraces = (sqldriver->dbmsType() == QSqlDriver::PostgreSQL);
    const bool qmarkNotationSupported = (sqldriver->dbmsType() != QSqlDriver::PostgreSQL);
 
    while (i < n) {
        QChar ch = query.at(i);
        if (!closingQuote.isNull()) {
            if (ch == closingQuote) {
                if (closingQuote == u']'
                        && i + 1 < n && query.at(i + 1) == closingQuote) {
                    // consume the extra character. don't close.
                    ++i;
                    result += ch;
                } else {
                    closingQuote = QChar();
                }
            }
            result += ch;
            ++i;
        } else {
            if (ch == u':'
                    && (i == 0 || query.at(i - 1) != u':')
                    && (i + 1 < n && qIsAlnum(query.at(i + 1)))) {
                int pos = i + 2;
                while (pos < n && qIsAlnum(query.at(pos)))
                    ++pos;
                // if question mark notation is not supported we have to use
                // the native binding.  fieldSerial() should be renamed
                // to toNativeBinding() and used unconditionally here
                if (qmarkNotationSupported)
                    result += u'?';
                else
                    result += fieldSerial(count);
                QString holder(query.mid(i, pos - i));
                indexes[holder].append(count++);
                holders.append(QHolder(holder, i));
                i = pos;
            } else {
                if (ch == u'\'' || ch == u'"' || ch == u'`')
                    closingQuote = ch;
                else if (!ignoreBraces && ch == u'[')
                    closingQuote = u']';
                result += ch;
                ++i;
            }
        }
    }
    result.squeeze();
    values.resize(holders.size());
    return result;
}
 
QSqlResult::QSqlResult(const QSqlDriver *db)
{
    d_ptr = new QSqlResultPrivate(this, db);
    Q_D(QSqlResult);
    if (d->sqldriver)
        setNumericalPrecisionPolicy(d->sqldriver->numericalPrecisionPolicy());
}
 
QSqlResult::QSqlResult(QSqlResultPrivate &dd)
    : d_ptr(&dd)
{
    Q_D(QSqlResult);
    if (d->sqldriver)
        setNumericalPrecisionPolicy(d->sqldriver->numericalPrecisionPolicy());
}
 
QSqlResult::~QSqlResult()
{
    Q_D(QSqlResult);
    delete d;
}
 
void QSqlResult::setQuery(const QString& query)
{
    Q_D(QSqlResult);
    d->sql = query;
}
 
QString QSqlResult::lastQuery() const
{
    Q_D(const QSqlResult);
    return d->sql;
}
 
int QSqlResult::at() const
{
    Q_D(const QSqlResult);
    return d->idx;
}
 
 
bool QSqlResult::isValid() const
{
    Q_D(const QSqlResult);
    return d->idx != QSql::BeforeFirstRow && d->idx != QSql::AfterLastRow;
}
 
bool QSqlResult::isActive() const
{
    Q_D(const QSqlResult);
    return d->active;
}
 
void QSqlResult::setAt(int index)
{
    Q_D(QSqlResult);
    d->idx = index;
}
 
 
void QSqlResult::setSelect(bool select)
{
    Q_D(QSqlResult);
    d->isSel = select;
}
 
bool QSqlResult::isSelect() const
{
    Q_D(const QSqlResult);
    return d->isSel;
}
 
const QSqlDriver *QSqlResult::driver() const
{
    Q_D(const QSqlResult);
    return d->sqldriver;
}
 
 
void QSqlResult::setActive(bool active)
{
    Q_D(QSqlResult);
    if (active)
        d->executedQuery = d->sql;
 
    d->active = active;
}
 
void QSqlResult::setLastError(const QSqlError &error)
{
    Q_D(QSqlResult);
    d->error = error;
}
 
 
QSqlError QSqlResult::lastError() const
{
    Q_D(const QSqlResult);
    return d->error;
}
 
bool QSqlResult::fetchNext()
{
    return fetch(at() + 1);
}
 
bool QSqlResult::fetchPrevious()
{
    return fetch(at() - 1);
}
 
bool QSqlResult::isForwardOnly() const
{
    Q_D(const QSqlResult);
    return d->forwardOnly;
}
 
void QSqlResult::setForwardOnly(bool forward)
{
    Q_D(QSqlResult);
    d->forwardOnly = forward;
}
 
bool QSqlResult::savePrepare(const QString& query)
{
    Q_D(QSqlResult);
    if (!driver())
        return false;
    d->clear();
    d->sql = query;
    if (!driver()->hasFeature(QSqlDriver::PreparedQueries))
        return prepare(query);
 
    // parse the query to memorize parameter location
    d->executedQuery = d->namedToPositionalBinding(query);
 
    if (driver()->hasFeature(QSqlDriver::NamedPlaceholders))
        d->executedQuery = d->positionalToNamedBinding(query);
 
    return prepare(d->executedQuery);
}
 
bool QSqlResult::prepare(const QString& query)
{
    Q_D(QSqlResult);
    d->sql = query;
    if (d->holders.isEmpty()) {
        // parse the query to memorize parameter location
        d->namedToPositionalBinding(query);
    }
    return true; // fake prepares should always succeed
}
 
bool QSqlResultPrivate::isVariantNull(const QVariant &variant)
{
    if (variant.isNull())
        return true;
 
    switch (variant.typeId()) {
    case qMetaTypeId<QString>():
        return static_cast<const QString*>(variant.constData())->isNull();
    case qMetaTypeId<QByteArray>():
        return static_cast<const QByteArray*>(variant.constData())->isNull();
    case qMetaTypeId<QDateTime>():
        // We treat invalid date-time as null, since its ISODate would be empty.
        return !static_cast<const QDateTime*>(variant.constData())->isValid();
    case qMetaTypeId<QDate>():
        return static_cast<const QDate*>(variant.constData())->isNull();
    case qMetaTypeId<QTime>():
        // As for QDateTime, QTime can be invalid without being null.
        return !static_cast<const QTime*>(variant.constData())->isValid();
    case qMetaTypeId<QUuid>():
        return static_cast<const QUuid*>(variant.constData())->isNull();
    default:
        break;
    }
 
    return false;
}
 
bool QSqlResult::exec()
{
    Q_D(QSqlResult);
    bool ret;
    // fake preparation - just replace the placeholders..
    QString query = lastQuery();
    if (d->binds == NamedBinding) {
        for (qsizetype i = d->holders.size() - 1; i >= 0; --i) {
            const QString &holder = d->holders.at(i).holderName;
            const QVariant val = d->values.value(d->indexes.value(holder).value(0,-1));
            QSqlField f(""_L1, val.metaType());
            if (QSqlResultPrivate::isVariantNull(val))
                f.setValue(QVariant());
            else
                f.setValue(val);
            query = query.replace(d->holders.at(i).holderPos,
                                   holder.size(), driver()->formatValue(f));
        }
    } else {
        qsizetype i = 0;
        for (const QVariant &var : std::as_const(d->values)) {
            i = query.indexOf(u'?', i);
            if (i == -1)
                continue;
            QSqlField f(""_L1, var.metaType());
            if (QSqlResultPrivate::isVariantNull(var))
                f.clear();
            else
                f.setValue(var);
            const QString val = driver()->formatValue(f);
            query = query.replace(i, 1, val);
            i += val.size();
        }
    }
 
    // have to retain the original query with placeholders
    QString orig = lastQuery();
    ret = reset(query);
    d->executedQuery = query;
    setQuery(orig);
    d->resetBindCount();
    return ret;
}
 
void QSqlResult::bindValue(int index, const QVariant& val, QSql::ParamType paramType)
{
    Q_D(QSqlResult);
    d->binds = PositionalBinding;
    QList<int> &indexes = d->indexes[d->fieldSerial(index)];
    if (!indexes.contains(index))
        indexes.append(index);
    if (d->values.size() <= index)
        d->values.resize(index + 1);
    d->values[index] = val;
    if (paramType != QSql::In || !d->types.isEmpty())
        d->types[index] = paramType;
}
 
void QSqlResult::bindValue(const QString& placeholder, const QVariant& val,
                           QSql::ParamType paramType)
{
    Q_D(QSqlResult);
    d->binds = NamedBinding;
    // if the index has already been set when doing emulated named
    // bindings - don't reset it
    const QList<int> indexes = d->indexes.value(placeholder);
    for (int idx : indexes) {
        if (d->values.size() <= idx)
            d->values.resize(idx + 1);
        d->values[idx] = val;
        if (paramType != QSql::In || !d->types.isEmpty())
            d->types[idx] = paramType;
    }
}
 
void QSqlResult::addBindValue(const QVariant& val, QSql::ParamType paramType)
{
    Q_D(QSqlResult);
    d->binds = PositionalBinding;
    bindValue(d->bindCount, val, paramType);
    ++d->bindCount;
}
 
QVariant QSqlResult::boundValue(int index) const
{
    Q_D(const QSqlResult);
    return d->values.value(index);
}
 
QVariant QSqlResult::boundValue(const QString& placeholder) const
{
    Q_D(const QSqlResult);
    const QList<int> indexes = d->indexes.value(placeholder);
    return d->values.value(indexes.value(0,-1));
}
 
QSql::ParamType QSqlResult::bindValueType(int index) const
{
    Q_D(const QSqlResult);
    return d->types.value(index, QSql::In);
}
 
QSql::ParamType QSqlResult::bindValueType(const QString& placeholder) const
{
    Q_D(const QSqlResult);
    return d->types.value(d->indexes.value(placeholder).value(0,-1), QSql::In);
}
 
int QSqlResult::boundValueCount() const
{
    Q_D(const QSqlResult);
    return d->values.size();
}
 
QVariantList QSqlResult::boundValues(QT6_IMPL_NEW_OVERLOAD) const
{
    Q_D(const QSqlResult);
    return d->values;
}
 
QVariantList &QSqlResult::boundValues(QT6_IMPL_NEW_OVERLOAD)
{
    Q_D(QSqlResult);
    return d->values;
}
 
 
QSqlResult::BindingSyntax QSqlResult::bindingSyntax() const
{
    Q_D(const QSqlResult);
    return d->binds;
}
 
void QSqlResult::clear()
{
    Q_D(QSqlResult);
    d->clear();
}
 
QString QSqlResult::executedQuery() const
{
    Q_D(const QSqlResult);
    return d->executedQuery;
}
 
void QSqlResult::resetBindCount()
{
    Q_D(QSqlResult);
    d->resetBindCount();
}
 
QStringList QSqlResult::boundValueNames() const
{
    Q_D(const QSqlResult);
    QList<QString> ret;
    for (const QHolder &holder : std::as_const(d->holders))
        ret.push_back(holder.holderName);
    return ret;
}
 
QString QSqlResult::boundValueName(int index) const
{
    Q_D(const QSqlResult);
    return d->holderAt(index);
}
 
bool QSqlResult::hasOutValues() const
{
    Q_D(const QSqlResult);
    if (d->types.isEmpty())
        return false;
    QHash<int, QSql::ParamType>::ConstIterator it;
    for (it = d->types.constBegin(); it != d->types.constEnd(); ++it) {
        if (it.value() != QSql::In)
            return true;
    }
    return false;
}
 
QSqlRecord QSqlResult::record() const
{
    return QSqlRecord();
}
 
QVariant QSqlResult::lastInsertId() const
{
    return QVariant();
}
 
void QSqlResult::virtual_hook(int, void *)
{
}
 
bool QSqlResult::execBatch(bool arrayBind)
{
    Q_UNUSED(arrayBind);
    Q_D(QSqlResult);
 
    const QList<QVariant> values = d->values;
    if (values.size() == 0)
        return false;
    const qsizetype batchCount = values.at(0).toList().size();
    const qsizetype valueCount = values.size();
    for (qsizetype i = 0; i < batchCount; ++i) {
        for (qsizetype j = 0; j < valueCount; ++j)
            bindValue(j, values.at(j).toList().at(i), QSql::In);
        if (!exec())
            return false;
    }
    return true;
}
 
void QSqlResult::detachFromResultSet()
{
}
 
void QSqlResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)
{
    Q_D(QSqlResult);
    d->precisionPolicy = policy;
}
 
QSql::NumericalPrecisionPolicy QSqlResult::numericalPrecisionPolicy() const
{
    Q_D(const QSqlResult);
    return d->precisionPolicy;
}
 
void QSqlResult::setPositionalBindingEnabled(bool enable)
{
    Q_D(QSqlResult);
    d->positionalBindingEnabled = enable;
}
 
bool QSqlResult::isPositionalBindingEnabled() const
{
    Q_D(const QSqlResult);
    return d->positionalBindingEnabled;
}
 
 
bool QSqlResult::nextResult()
{
    return false;
}
 
QVariant QSqlResult::handle() const
{
    return QVariant();
}
 
QT_END_NAMESPACE