qsqldatabase.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 "qsqldatabase.h"
#include "qsqlquery.h"
#include "qloggingcategory.h"
#include "qcoreapplication.h"
#include "qreadwritelock.h"
#include "qsqldriver.h"
#include "qsqldriver_p.h"
#include "qsqldriverplugin.h"
#include "qsqlindex.h"
#include "QtCore/qapplicationstatic.h"
#include "private/qfactoryloader_p.h"
#include "private/qsqlnulldriver_p.h"
#include "qhash.h"
#include "qthread.h"
 
QT_BEGIN_NAMESPACE
 
static Q_LOGGING_CATEGORY(lcSqlDb, "qt.sql.qsqldatabase")
 
using namespace Qt::StringLiterals;
 
#define CHECK_QCOREAPPLICATION \
    if (Q_UNLIKELY(!QCoreApplication::instance())) { \
        qCWarning(lcSqlDb, "QSqlDatabase requires a QCoreApplication"); \
        return; \
    }
#define CHECK_QCOREAPPLICATION_RETVAL \
    if (Q_UNLIKELY(!QCoreApplication::instance())) { \
        qCWarning(lcSqlDb, "QSqlDatabase requires a QCoreApplication"); \
        return {}; \
    }
 
Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
                          (QSqlDriverFactoryInterface_iid, "/sqldrivers"_L1))
 
const char *QSqlDatabase::defaultConnection = "qt_sql_default_connection";
 
namespace {
    struct QtSqlGlobals
    {
        ~QtSqlGlobals();
        QSqlDatabase connection(const QString &key) const
        {
          QReadLocker locker(&lock);
          return connections.value(key);
        }
        bool connectionExists(const QString &key) const
        {
            QReadLocker locker(&lock);
            return connections.contains(key);
        }
        QStringList connectionNames() const
        {
            QReadLocker locker(&lock);
            return connections.keys();
        }
        mutable QReadWriteLock lock;
        QHash<QString, QSqlDriverCreatorBase*> registeredDrivers;
        QHash<QString, QSqlDatabase> connections;
    };
}
Q_APPLICATION_STATIC(QtSqlGlobals, s_sqlGlobals)
 
class QSqlDatabasePrivate
{
public:
    QSqlDatabasePrivate(QSqlDriver *dr):
        ref(1),
        driver(dr),
        port(-1)
    {
        precisionPolicy = QSql::LowPrecisionDouble;
    }
    QSqlDatabasePrivate(const QSqlDatabasePrivate &other);
    ~QSqlDatabasePrivate();
    void init(const QString& type);
    void copy(const QSqlDatabasePrivate *other);
    void disable();
 
    QAtomicInt ref;
    QSqlDriver* driver;
    QString dbname;
    QString uname;
    QString pword;
    QString hname;
    QString drvName;
    int port;
    QString connOptions;
    QString connName;
    QSql::NumericalPrecisionPolicy precisionPolicy;
 
    static QSqlDatabasePrivate *shared_null();
    static QSqlDatabase database(const QString& name, bool open);
    static void addDatabase(const QSqlDatabase &db, const QString & name);
    static void removeDatabase(const QString& name);
    static void invalidateDb(const QSqlDatabase &db, const QString &name, bool doWarn = true);
};
 
QSqlDatabasePrivate::QSqlDatabasePrivate(const QSqlDatabasePrivate &other) : ref(1)
{
    dbname = other.dbname;
    uname = other.uname;
    pword = other.pword;
    hname = other.hname;
    drvName = other.drvName;
    port = other.port;
    connOptions = other.connOptions;
    driver = other.driver;
    precisionPolicy = other.precisionPolicy;
    if (driver)
        driver->setNumericalPrecisionPolicy(other.driver->numericalPrecisionPolicy());
}
 
QSqlDatabasePrivate::~QSqlDatabasePrivate()
{
    if (driver != shared_null()->driver)
        delete driver;
}
 
QtSqlGlobals::~QtSqlGlobals()
{
    qDeleteAll(registeredDrivers);
    for (const auto &[k, v] : std::as_const(connections).asKeyValueRange())
        QSqlDatabasePrivate::invalidateDb(v, k, false);
}
 
QSqlDatabasePrivate *QSqlDatabasePrivate::shared_null()
{
    static QSqlNullDriver dr;
    static QSqlDatabasePrivate n(&dr);
    return &n;
}
 
void QSqlDatabasePrivate::invalidateDb(const QSqlDatabase &db, const QString &name, bool doWarn)
{
    if (db.d->ref.loadRelaxed() != 1 && doWarn) {
        qCWarning(lcSqlDb, "QSqlDatabasePrivate::removeDatabase: connection '%ls' is still in use, "
                 "all queries will cease to work.", qUtf16Printable(name));
        db.d->disable();
        db.d->connName.clear();
    }
}
 
void QSqlDatabasePrivate::removeDatabase(const QString &name)
{
    CHECK_QCOREAPPLICATION
    QtSqlGlobals *sqlGlobals = s_sqlGlobals();
    QWriteLocker locker(&sqlGlobals->lock);
 
    if (!sqlGlobals->connections.contains(name))
        return;
 
    invalidateDb(sqlGlobals->connections.take(name), name);
}
 
void QSqlDatabasePrivate::addDatabase(const QSqlDatabase &db, const QString &name)
{
    CHECK_QCOREAPPLICATION
    QtSqlGlobals *sqlGlobals = s_sqlGlobals();
    QWriteLocker locker(&sqlGlobals->lock);
 
    if (sqlGlobals->connections.contains(name)) {
        invalidateDb(sqlGlobals->connections.take(name), name);
        qCWarning(lcSqlDb, "QSqlDatabasePrivate::addDatabase: duplicate connection name '%ls', old "
                 "connection removed.", qUtf16Printable(name));
    }
    sqlGlobals->connections.insert(name, db);
    db.d->connName = name;
}
 
QSqlDatabase QSqlDatabasePrivate::database(const QString& name, bool open)
{
    CHECK_QCOREAPPLICATION_RETVAL
    QSqlDatabase db = s_sqlGlobals()->connection(name);
    if (!db.isValid())
        return db;
    if (db.driver()->thread() != QThread::currentThread()) {
        qCWarning(lcSqlDb, "QSqlDatabasePrivate::database: requested database does not belong to the calling thread.");
        return QSqlDatabase();
    }
 
    if (open && !db.isOpen()) {
        if (!db.open())
            qCWarning(lcSqlDb) << "QSqlDatabasePrivate::database: unable to open database:" << db.lastError().text();
 
    }
    return db;
}
 
 
void QSqlDatabasePrivate::copy(const QSqlDatabasePrivate *other)
{
    dbname = other->dbname;
    uname = other->uname;
    pword = other->pword;
    hname = other->hname;
    drvName = other->drvName;
    port = other->port;
    connOptions = other->connOptions;
    precisionPolicy = other->precisionPolicy;
    if (driver)
        driver->setNumericalPrecisionPolicy(other->driver->numericalPrecisionPolicy());
}
 
void QSqlDatabasePrivate::disable()
{
    if (driver != shared_null()->driver) {
        delete driver;
        driver = shared_null()->driver;
    }
}
 
QSqlDriverCreatorBase::~QSqlDriverCreatorBase()
    = default;
 
QSqlDatabase QSqlDatabase::addDatabase(const QString &type, const QString &connectionName)
{
    QSqlDatabase db(type);
    QSqlDatabasePrivate::addDatabase(db, connectionName);
    return db;
}
 
QSqlDatabase QSqlDatabase::database(const QString& connectionName, bool open)
{
    return QSqlDatabasePrivate::database(connectionName, open);
}
 
void QSqlDatabase::removeDatabase(const QString& connectionName)
{
    QSqlDatabasePrivate::removeDatabase(connectionName);
}
 
QStringList QSqlDatabase::drivers()
{
    CHECK_QCOREAPPLICATION_RETVAL
    QStringList list;
 
    if (QFactoryLoader *fl = loader()) {
        typedef QMultiMap<int, QString> PluginKeyMap;
 
        const PluginKeyMap keyMap = fl->keyMap();
        for (const QString &val : keyMap) {
            if (!list.contains(val))
                list << val;
        }
    }
 
    QtSqlGlobals *sqlGlobals = s_sqlGlobals();
    QReadLocker locker(&sqlGlobals->lock);
    const auto &dict = sqlGlobals->registeredDrivers;
    for (const auto &[k, _] : dict.asKeyValueRange()) {
        if (!list.contains(k))
            list << k;
    }
 
    return list;
}
 
void QSqlDatabase::registerSqlDriver(const QString& name, QSqlDriverCreatorBase *creator)
{
    CHECK_QCOREAPPLICATION
    QtSqlGlobals *sqlGlobals = s_sqlGlobals();
    QWriteLocker locker(&sqlGlobals->lock);
    delete sqlGlobals->registeredDrivers.take(name);
    if (creator)
        sqlGlobals->registeredDrivers.insert(name, creator);
}
 
bool QSqlDatabase::contains(const QString& connectionName)
{
    CHECK_QCOREAPPLICATION_RETVAL
    return s_sqlGlobals()->connectionExists(connectionName);
}
 
QStringList QSqlDatabase::connectionNames()
{
    CHECK_QCOREAPPLICATION_RETVAL
    return s_sqlGlobals()->connectionNames();
}
 
QSqlDatabase::QSqlDatabase(const QString &type)
   : d(new QSqlDatabasePrivate(nullptr))
{
    d->init(type);
}
 
QSqlDatabase::QSqlDatabase(QSqlDriver *driver)
    : d(new QSqlDatabasePrivate(driver))
{
}
 
QSqlDatabase::QSqlDatabase()
    : d(QSqlDatabasePrivate::shared_null())
{
    d->ref.ref();
}
 
QSqlDatabase::QSqlDatabase(const QSqlDatabase &other)
{
    d = other.d;
    d->ref.ref();
}
 
QSqlDatabase &QSqlDatabase::operator=(const QSqlDatabase &other)
{
    qAtomicAssign(d, other.d);
    return *this;
}
 
void QSqlDatabasePrivate::init(const QString &type)
{
    CHECK_QCOREAPPLICATION
    drvName = type;
 
    if (!driver) {
        QtSqlGlobals *sqlGlobals = s_sqlGlobals();
        QReadLocker locker(&sqlGlobals->lock);
        const auto &dict = sqlGlobals->registeredDrivers;
        auto it = dict.find(type);
        if (it != dict.end())
            driver = it.value()->createObject();
    }
 
    if (!driver && loader())
        driver = qLoadPlugin<QSqlDriver, QSqlDriverPlugin>(loader(), type);
 
    if (!driver) {
        qCWarning(lcSqlDb, "QSqlDatabase: %ls driver not loaded", qUtf16Printable(type));
        qCWarning(lcSqlDb, "QSqlDatabase: available drivers: %ls",
                  qUtf16Printable(QSqlDatabase::drivers().join(u' ')));
        if (QCoreApplication::instance() == nullptr)
            qCWarning(lcSqlDb, "QSqlDatabase: an instance of QCoreApplication is required for loading driver plugins");
        driver = shared_null()->driver;
    }
}
 
QSqlDatabase::~QSqlDatabase()
{
    if (!d->ref.deref()) {
        close();
        delete d;
    }
}
 
#if QT_DEPRECATED_SINCE(6, 6)
QSqlQuery QSqlDatabase::exec(const QString & query) const
{
    QSqlQuery r(d->driver->createResult());
    if (!query.isEmpty()) {
        r.exec(query);
        d->driver->setLastError(r.lastError());
    }
    return r;
}
#endif
 
bool QSqlDatabase::open()
{
    return d->driver->open(d->dbname, d->uname, d->pword, d->hname,
                            d->port, d->connOptions);
}
 
bool QSqlDatabase::open(const QString& user, const QString& password)
{
    setUserName(user);
    return d->driver->open(d->dbname, user, password, d->hname,
                            d->port, d->connOptions);
}
 
void QSqlDatabase::close()
{
    d->driver->close();
}
 
bool QSqlDatabase::isOpen() const
{
    return d->driver->isOpen();
}
 
bool QSqlDatabase::isOpenError() const
{
    return d->driver->isOpenError();
}
 
bool QSqlDatabase::transaction()
{
    if (!d->driver->hasFeature(QSqlDriver::Transactions))
        return false;
    return d->driver->beginTransaction();
}
 
bool QSqlDatabase::commit()
{
    if (!d->driver->hasFeature(QSqlDriver::Transactions))
        return false;
    return d->driver->commitTransaction();
}
 
bool QSqlDatabase::rollback()
{
    if (!d->driver->hasFeature(QSqlDriver::Transactions))
        return false;
    return d->driver->rollbackTransaction();
}
 
void QSqlDatabase::setDatabaseName(const QString& name)
{
    if (isValid())
        d->dbname = name;
}
 
void QSqlDatabase::setUserName(const QString& name)
{
    if (isValid())
        d->uname = name;
}
 
void QSqlDatabase::setPassword(const QString& password)
{
    if (isValid())
        d->pword = password;
}
 
void QSqlDatabase::setHostName(const QString& host)
{
    if (isValid())
        d->hname = host;
}
 
void QSqlDatabase::setPort(int port)
{
    if (isValid())
        d->port = port;
}
 
QString QSqlDatabase::databaseName() const
{
    return d->dbname;
}
 
QString QSqlDatabase::userName() const
{
    return d->uname;
}
 
QString QSqlDatabase::password() const
{
    return d->pword;
}
 
QString QSqlDatabase::hostName() const
{
    return d->hname;
}
 
QString QSqlDatabase::driverName() const
{
    return d->drvName;
}
 
int QSqlDatabase::port() const
{
    return d->port;
}
 
QSqlDriver* QSqlDatabase::driver() const
{
    return d->driver;
}
 
QSqlError QSqlDatabase::lastError() const
{
    return d->driver->lastError();
}
 
 
QStringList QSqlDatabase::tables(QSql::TableType type) const
{
    return d->driver->tables(type);
}
 
QSqlIndex QSqlDatabase::primaryIndex(const QString& tablename) const
{
    return d->driver->primaryIndex(tablename);
}
 
 
QSqlRecord QSqlDatabase::record(const QString& tablename) const
{
    return d->driver->record(tablename);
}
 
 
void QSqlDatabase::setConnectOptions(const QString &options)
{
    if (isValid())
        d->connOptions = options;
}
 
QString QSqlDatabase::connectOptions() const
{
    return d->connOptions;
}
 
bool QSqlDatabase::isDriverAvailable(const QString& name)
{
    return drivers().contains(name);
}
 
QSqlDatabase QSqlDatabase::addDatabase(QSqlDriver* driver, const QString& connectionName)
{
    QSqlDatabase db(driver);
    QSqlDatabasePrivate::addDatabase(db, connectionName);
    return db;
}
 
bool QSqlDatabase::isValid() const
{
    return d->driver && d->driver != d->shared_null()->driver;
}
 
QSqlDatabase QSqlDatabase::cloneDatabase(const QSqlDatabase &other, const QString &connectionName)
{
    if (!other.isValid())
        return QSqlDatabase();
 
    QSqlDatabase db(other.driverName());
    db.d->copy(other.d);
    QSqlDatabasePrivate::addDatabase(db, connectionName);
    return db;
}
 
QSqlDatabase QSqlDatabase::cloneDatabase(const QString &other, const QString &connectionName)
{
    CHECK_QCOREAPPLICATION_RETVAL
    return cloneDatabase(s_sqlGlobals()->connection(other), connectionName);
}
 
QString QSqlDatabase::connectionName() const
{
    return d->connName;
}
 
void QSqlDatabase::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
{
    if (driver())
        driver()->setNumericalPrecisionPolicy(precisionPolicy);
    d->precisionPolicy = precisionPolicy;
}
 
QSql::NumericalPrecisionPolicy QSqlDatabase::numericalPrecisionPolicy() const
{
    if (driver())
        return driver()->numericalPrecisionPolicy();
    else
        return d->precisionPolicy;
}
 
bool QSqlDatabase::moveToThread(QThread *targetThread)
{
    if (auto drv = driver()) {
        if (drv != QSqlDatabasePrivate::shared_null()->driver) {
            // two instances are alive - the one here and the one in dbDict()
            if (d->ref.loadRelaxed() > 2) {
                qWarning("QSqlDatabasePrivate::moveToThread: connection '%ls' is still in use "
                         "in the current thread.", qUtf16Printable(d->connName));
                return false;
            }
            return drv->moveToThread(targetThread);
        }
    }
    return false;
}
 
QThread *QSqlDatabase::currentThread() const
{
    if (auto drv = driver())
        return drv->thread();
    return nullptr;
}
 
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QSqlDatabase &d)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    dbg.noquote();
    if (!d.isValid()) {
        dbg << "QSqlDatabase(invalid)";
        return dbg;
    }
 
    dbg << "QSqlDatabase(driver=\"" << d.driverName() << "\", database=\""
        << d.databaseName() << "\", host=\"" << d.hostName() << "\", port=" << d.port()
        << ", user=\"" << d.userName() << "\", open=" << d.isOpen() << ')';
    return dbg;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qsqldatabase.cpp"