qsqldriver.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 "qsqldriver.h"
 
#include "qdatetime.h"
#include "qsqlerror.h"
#include "qsqlfield.h"
#include "qsqlindex.h"
#include "private/qsqldriver_p.h"
#include "private/qtools_p.h"
 
#include <limits.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static QString prepareIdentifier(const QString &identifier,
        QSqlDriver::IdentifierType type, const QSqlDriver *driver)
{
    Q_ASSERT(driver != nullptr);
    QString ret = identifier;
    if (!driver->isIdentifierEscaped(identifier, type))
        ret = driver->escapeIdentifier(identifier, type);
    return ret;
}
 
QSqlDriver::QSqlDriver(QObject *parent)
    : QObject(*new QSqlDriverPrivate, parent)
{
}
 
QSqlDriver::QSqlDriver(QSqlDriverPrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
}
 
QSqlDriver::~QSqlDriver()
{
}
 
bool QSqlDriver::isOpen() const
{
    Q_D(const QSqlDriver);
    return d->isOpen;
}
 
bool QSqlDriver::isOpenError() const
{
    Q_D(const QSqlDriver);
    return d->isOpenError;
}
 
void QSqlDriver::setOpen(bool open)
{
    Q_D(QSqlDriver);
    d->isOpen = open;
}
 
void QSqlDriver::setOpenError(bool error)
{
    Q_D(QSqlDriver);
    d->isOpenError = error;
    if (error)
        d->isOpen = false;
}
 
bool QSqlDriver::beginTransaction()
{
    return false;
}
 
bool QSqlDriver::commitTransaction()
{
    return false;
}
 
bool QSqlDriver::rollbackTransaction()
{
    return false;
}
 
void QSqlDriver::setLastError(const QSqlError &error)
{
    Q_D(QSqlDriver);
    d->error = error;
}
 
QSqlError QSqlDriver::lastError() const
{
    Q_D(const QSqlDriver);
    return d->error;
}
 
QStringList QSqlDriver::tables(QSql::TableType) const
{
    return QStringList();
}
 
QSqlIndex QSqlDriver::primaryIndex(const QString&) const
{
    return QSqlIndex();
}
 
 
QSqlRecord QSqlDriver::record(const QString & /* tableName */) const
{
    return QSqlRecord();
}
 
QString QSqlDriver::escapeIdentifier(const QString &identifier, IdentifierType) const
{
    return identifier;
}
 
bool QSqlDriver::isIdentifierEscaped(const QString &identifier, IdentifierType type) const
{
    Q_UNUSED(type);
    return identifier.size() > 2
        && identifier.startsWith(u'"') //left delimited
        && identifier.endsWith(u'"'); //right delimited
}
 
QString QSqlDriver::stripDelimiters(const QString &identifier, IdentifierType type) const
{
    QString ret;
    if (isIdentifierEscaped(identifier, type)) {
        ret = identifier.mid(1);
        ret.chop(1);
    } else {
        ret = identifier;
    }
    return ret;
}
 
QString QSqlDriver::sqlStatement(StatementType type, const QString &tableName,
                                 const QSqlRecord &rec, bool preparedStatement) const
{
    const auto tableNameString = tableName.isEmpty() ? QString()
                                    : prepareIdentifier(tableName, QSqlDriver::TableName, this);
    QString s;
    s.reserve(128);
    switch (type) {
    case SelectStatement:
        for (qsizetype i = 0; i < rec.count(); ++i) {
            if (rec.isGenerated(i))
                s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(", "_L1);
        }
        if (s.isEmpty())
            return s;
        s.chop(2);
        s = "SELECT "_L1 + s + " FROM "_L1 + tableNameString;
        break;
    case WhereStatement:
    {
        const QString tableNamePrefix = tableNameString.isEmpty()
                                            ? QString() : tableNameString + u'.';
        for (qsizetype i = 0; i < rec.count(); ++i) {
            if (!rec.isGenerated(i))
                continue;
            s.append(s.isEmpty() ? "WHERE "_L1 : " AND "_L1);
            s.append(tableNamePrefix);
            s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this));
            if (rec.isNull(i))
                s.append(" IS NULL"_L1);
            else if (preparedStatement)
                s.append(" = ?"_L1);
            else
                s.append(" = "_L1).append(formatValue(rec.field(i)));
        }
        break;
    }
    case UpdateStatement:
        s = s + "UPDATE "_L1 + tableNameString + " SET "_L1;
        for (qsizetype i = 0; i < rec.count(); ++i) {
            if (!rec.isGenerated(i))
                continue;
            s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(u'=');
            if (preparedStatement)
                s.append(u'?');
            else
                s.append(formatValue(rec.field(i)));
            s.append(", "_L1);
        }
        if (s.endsWith(", "_L1))
            s.chop(2);
        else
            s.clear();
        break;
    case DeleteStatement:
        s = s + "DELETE FROM "_L1 + tableNameString;
        break;
    case InsertStatement: {
        s = s + "INSERT INTO "_L1 + tableNameString + " ("_L1;
        QString vals;
        for (qsizetype i = 0; i < rec.count(); ++i) {
            if (!rec.isGenerated(i))
                continue;
            s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(", "_L1);
            if (preparedStatement)
                vals.append(u'?');
            else
                vals.append(formatValue(rec.field(i)));
            vals.append(", "_L1);
        }
        if (vals.isEmpty()) {
            s.clear();
        } else {
            vals.chop(2); // remove trailing comma
            s[s.size() - 2] = u')';
            s.append("VALUES ("_L1).append(vals).append(u')');
        }
        break; }
    }
    return s;
}
 
QString QSqlDriver::formatValue(const QSqlField &field, bool trimStrings) const
{
    const auto nullTxt = "NULL"_L1;
 
    QString r;
    if (field.isNull())
        r = nullTxt;
    else {
        switch (field.metaType().id()) {
        case QMetaType::Int:
        case QMetaType::UInt:
            if (field.value().userType() == QMetaType::Bool)
                r = field.value().toBool() ? "1"_L1 : "0"_L1;
            else
                r = field.value().toString();
            break;
#if QT_CONFIG(datestring)
        case QMetaType::QDate:
            if (field.value().toDate().isValid())
                r = u'\'' + field.value().toDate().toString(Qt::ISODate) + u'\'';
            else
                r = nullTxt;
            break;
        case QMetaType::QTime:
            if (field.value().toTime().isValid())
                r =  u'\'' + field.value().toTime().toString(Qt::ISODate) + u'\'';
            else
                r = nullTxt;
            break;
        case QMetaType::QDateTime:
            if (field.value().toDateTime().isValid())
                r = u'\'' + field.value().toDateTime().toString(Qt::ISODate) + u'\'';
            else
                r = nullTxt;
            break;
#endif
        case QMetaType::QString:
        case QMetaType::QChar:
        {
            QString result = field.value().toString();
            if (trimStrings) {
                int end = result.size();
                while (end && result.at(end-1).isSpace()) /* skip white space from end */
                    end--;
                result.truncate(end);
            }
            /* escape the "'" character */
            result.replace(u'\'', "''"_L1);
            r = u'\'' + result + u'\'';
            break;
        }
        case QMetaType::Bool:
            r = QString::number(field.value().toBool());
            break;
        case QMetaType::QByteArray : {
            if (hasFeature(BLOB)) {
                const QByteArray ba = field.value().toByteArray();
                r.reserve((ba.size() + 1) * 2);
                r += u'\'';
                for (const char c : ba) {
                    const uchar s = uchar(c);
                    r += QLatin1Char(QtMiscUtils::toHexLower(s >> 4));
                    r += QLatin1Char(QtMiscUtils::toHexLower(s & 0x0f));
                }
                r += u'\'';
                break;
            }
        }
            Q_FALLTHROUGH();
        default:
            r = field.value().toString();
            break;
        }
    }
    return r;
}
 
QVariant QSqlDriver::handle() const
{
    return QVariant();
}
 
bool QSqlDriver::subscribeToNotification(const QString &name)
{
    Q_UNUSED(name);
    return false;
}
 
bool QSqlDriver::unsubscribeFromNotification(const QString &name)
{
    Q_UNUSED(name);
    return false;
}
 
QStringList QSqlDriver::subscribedToNotifications() const
{
    return QStringList();
}
 
void QSqlDriver::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
{
    Q_D(QSqlDriver);
    d->precisionPolicy = precisionPolicy;
}
 
QSql::NumericalPrecisionPolicy QSqlDriver::numericalPrecisionPolicy() const
{
    Q_D(const QSqlDriver);
    return d->precisionPolicy;
}
 
QSqlDriver::DbmsType QSqlDriver::dbmsType() const
{
    Q_D(const QSqlDriver);
    return d->dbmsType;
}
 
bool QSqlDriver::cancelQuery()
{
    return false;
}
 
int QSqlDriver::maximumIdentifierLength(QSqlDriver::IdentifierType type) const
{
    Q_UNUSED(type);
    return INT_MAX;
}
 
QT_END_NAMESPACE
 
#include "moc_qsqldriver.cpp"