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 "qdebug.h"
#include "qcoreapplication.h"
#include "qreadwritelock.h"
#include "qsqldriver.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
 
using namespace Qt::StringLiterals;
 
Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
                          (QSqlDriverFactoryInterface_iid, "/sqldrivers"_L1))
 
const char *QSqlDatabase::defaultConnection = "qt_sql_default_connection";
 
class QConnectionDict: public QHash<QString, QSqlDatabase>
{
public:
    QSqlDatabase value_ts(const QString &key) const
    {
      QReadLocker locker(&lock);
      return value(key);
    }
    bool contains_ts(const QString &key) const
    {
        QReadLocker locker(&lock);
        return contains(key);
    }
    QStringList keys_ts() const
    {
        QReadLocker locker(&lock);
        return keys();
    }
 
    mutable QReadWriteLock lock;
};
Q_GLOBAL_STATIC(QConnectionDict, dbDict)
 
namespace {
    struct DriverDict : public QHash<QString, QSqlDriverCreatorBase*>
    {
        ~DriverDict();
    };
}
Q_APPLICATION_STATIC(DriverDict, qtDriverDict)
 
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);
    static DriverDict &driverDict();
    static void cleanConnections();
};
 
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;
}
 
void QSqlDatabasePrivate::cleanConnections()
{
    QConnectionDict *dict = dbDict();
    Q_ASSERT(dict);
    QWriteLocker locker(&dict->lock);
 
    QConnectionDict::iterator it = dict->begin();
    while (it != dict->end()) {
        invalidateDb(it.value(), it.key(), false);
        ++it;
    }
    dict->clear();
}
 
DriverDict::~DriverDict()
{
    qDeleteAll(*this);
    QSqlDatabasePrivate::cleanConnections();
}
 
DriverDict &QSqlDatabasePrivate::driverDict()
{
    return *qtDriverDict();
}
 
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) {
        qWarning("QSqlDatabasePrivate::removeDatabase: connection '%s' is still in use, "
                 "all queries will cease to work.", name.toLocal8Bit().constData());
        db.d->disable();
        db.d->connName.clear();
    }
}
 
void QSqlDatabasePrivate::removeDatabase(const QString &name)
{
    QConnectionDict *dict = dbDict();
    Q_ASSERT(dict);
    QWriteLocker locker(&dict->lock);
 
    if (!dict->contains(name))
        return;
 
    invalidateDb(dict->take(name), name);
}
 
void QSqlDatabasePrivate::addDatabase(const QSqlDatabase &db, const QString &name)
{
    QConnectionDict *dict = dbDict();
    Q_ASSERT(dict);
    QWriteLocker locker(&dict->lock);
 
    if (dict->contains(name)) {
        invalidateDb(dict->take(name), name);
        qWarning("QSqlDatabasePrivate::addDatabase: duplicate connection name '%s', old "
                 "connection removed.", name.toLocal8Bit().data());
    }
    dict->insert(name, db);
    db.d->connName = name;
}
 
QSqlDatabase QSqlDatabasePrivate::database(const QString& name, bool open)
{
    const QConnectionDict *dict = dbDict();
    Q_ASSERT(dict);
 
    QSqlDatabase db = dict->value_ts(name);
    if (!db.isValid())
        return db;
    if (db.driver()->thread() != QThread::currentThread()) {
        qWarning("QSqlDatabasePrivate::database: requested database does not belong to the calling thread.");
        return QSqlDatabase();
    }
 
    if (open && !db.isOpen()) {
        if (!db.open())
            qWarning() << "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;
    }
}
 
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()
{
    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;
        }
    }
 
    QReadLocker locker(&dbDict()->lock);
    const DriverDict &dict = QSqlDatabasePrivate::driverDict();
    for (const auto &[k, _] : dict.asKeyValueRange()) {
        if (!list.contains(k))
            list << k;
    }
 
    return list;
}
 
void QSqlDatabase::registerSqlDriver(const QString& name, QSqlDriverCreatorBase *creator)
{
    QWriteLocker locker(&dbDict()->lock);
    delete QSqlDatabasePrivate::driverDict().take(name);
    if (creator)
        QSqlDatabasePrivate::driverDict().insert(name, creator);
}
 
bool QSqlDatabase::contains(const QString& connectionName)
{
    return dbDict()->contains_ts(connectionName);
}
 
QStringList QSqlDatabase::connectionNames()
{
    return dbDict()->keys_ts();
}
 
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)
{
    drvName = type;
 
    if (!driver) {
        QReadLocker locker(&dbDict()->lock);
        const DriverDict &dict = QSqlDatabasePrivate::driverDict();
        for (DriverDict::const_iterator it = dict.constBegin();
             it != dict.constEnd() && !driver; ++it) {
            if (type == it.key()) {
                driver = ((QSqlDriverCreatorBase*)(*it))->createObject();
            }
        }
    }
 
    if (!driver && loader())
        driver = qLoadPlugin<QSqlDriver, QSqlDriverPlugin>(loader(), type);
 
    if (!driver) {
        qWarning("QSqlDatabase: %s driver not loaded", type.toLatin1().data());
        qWarning("QSqlDatabase: available drivers: %s",
                        QSqlDatabase::drivers().join(u' ').toLatin1().data());
        if (QCoreApplication::instance() == nullptr)
            qWarning("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)
{
    const QConnectionDict *dict = dbDict();
    Q_ASSERT(dict);
 
    return cloneDatabase(dict->value_ts(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;
}
 
 
#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