/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtSql module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsqldatabase.h"

#include "qsqlquery.h"

#ifdef Q_OS_WIN32

// Conflicting declarations of LPCBYTE in sqlfront.h and winscard.h

#define _WINSCARD_H_

#endif

#ifdef QT_SQL_PSQL

#include "../drivers/psql/qsql_psql.h"

#endif

#ifdef QT_SQL_MYSQL

#include "../drivers/mysql/qsql_mysql.h"

#endif

#ifdef QT_SQL_ODBC

#include "../drivers/odbc/qsql_odbc.h"

#endif

#ifdef QT_SQL_OCI

#include "../drivers/oci/qsql_oci.h"

#endif

#ifdef QT_SQL_TDS

#include "../drivers/tds/qsql_tds.h"

#endif

#ifdef QT_SQL_DB2

#include "../drivers/db2/qsql_db2.h"

#endif

#ifdef QT_SQL_SQLITE

#include "../drivers/sqlite/qsql_sqlite.h"

#endif

#ifdef QT_SQL_SQLITE2

#include "../drivers/sqlite2/qsql_sqlite2.h"

#endif

#ifdef QT_SQL_IBASE

#undef SQL_FLOAT  // avoid clash with ODBC

#undef SQL_DOUBLE

#undef SQL_TIMESTAMP

#undef SQL_TYPE_TIME

#undef SQL_TYPE_DATE

#undef SQL_DATE

#define SCHAR IBASE_SCHAR  // avoid clash with ODBC (older versions of ibase.h with Firebird)

#include "../drivers/ibase/qsql_ibase.h"

#undef SCHAR

#endif

#include "qdebug.h"

#include "qcoreapplication.h"

#include "qreadwritelock.h"

#include "qsqlresult.h"

#include "qsqldriver.h"

#include "qsqldriverplugin.h"

#include "qsqlindex.h"

#include "private/qfactoryloader_p.h"

#include "private/qsqlnulldriver_p.h"

#include "qmutex.h"

#include "qhash.h"

#include <stdlib.h>

QT_BEGIN_NAMESPACE

#ifndef QT_NO_LIBRARY

Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,

                          (QSqlDriverFactoryInterface_iid,

                           QLatin1String("/sqldrivers")))

#endif

QT_STATIC_CONST_IMPL char *QSqlDatabase::defaultConnection = "qt_sql_default_connection";

typedef QHash<QString, QSqlDriverCreatorBase*> DriverDict;

class QConnectionDict: public QHash<QString, QSqlDatabase>

{

public:

    inline bool contains_ts(const QString &key)

    {

        QReadLocker locker(&lock);

        return contains(key);

    }

    inline QStringList keys_ts() const

    {

        QReadLocker locker(&lock);

        return keys();

    }

    mutable QReadWriteLock lock;

};

Q_GLOBAL_STATIC(QConnectionDict, dbDict)

class QSqlDatabasePrivate

{

public:

    QSqlDatabasePrivate(QSqlDatabase *d, QSqlDriver *dr = 0):

        q(d),

        driver(dr),

        port(-1)

    {

        ref = 1;

        if(driver)

            precisionPolicy = driver->numericalPrecisionPolicy();

        else

            precisionPolicy= QSql::LowPrecisionDouble;

    }

    QSqlDatabasePrivate(const QSqlDatabasePrivate &other);

    ~QSqlDatabasePrivate();

    void init(const QString& type);

    void copy(const QSqlDatabasePrivate *other);

    void disable();

    QAtomicInt ref;

    QSqlDatabase *q;

    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);

    static DriverDict &driverDict();

    static void cleanConnections();

};

QSqlDatabasePrivate::QSqlDatabasePrivate(const QSqlDatabasePrivate &other)

{

    ref = 1;

    q = other.q;

    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;

}

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());

        ++it;

    }

    dict->clear();

}

static bool qDriverDictInit = false;

static void cleanDriverDict()

{

    qDeleteAll(QSqlDatabasePrivate::driverDict());

    QSqlDatabasePrivate::driverDict().clear();

    QSqlDatabasePrivate::cleanConnections();

    qDriverDictInit = false;

}

DriverDict &QSqlDatabasePrivate::driverDict()

{

    static DriverDict dict;

    if (!qDriverDictInit) {

        qDriverDictInit = true;

        qAddPostRoutine(cleanDriverDict);

    }

    return dict;

}

QSqlDatabasePrivate *QSqlDatabasePrivate::shared_null()

{

    static QSqlNullDriver dr;

    static QSqlDatabasePrivate n(NULL, &dr);

    return &n;

}

void QSqlDatabasePrivate::invalidateDb(const QSqlDatabase &db, const QString &name)

{

    if (db.d->ref != 1) {

        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;

}

/*! \internal

*/

QSqlDatabase QSqlDatabasePrivate::database(const QString& name, bool open)

{

    const QConnectionDict *dict = dbDict();

    Q_ASSERT(dict);

    dict->lock.lockForRead();

    QSqlDatabase db = dict->value(name);

    dict->lock.unlock();

    if (db.isValid() && !db.isOpen() && open) {

        if (!db.open())

            qWarning() << "QSqlDatabasePrivate::database: unable to open database:" << db.lastError().text();

    }

    return db;

}

/*! \internal

    Copies the connection data from \a other.

*/

void QSqlDatabasePrivate::copy(const QSqlDatabasePrivate *other)

{

    q = other->q;

    dbname = other->dbname;

    uname = other->uname;

    pword = other->pword;

    hname = other->hname;

    drvName = other->drvName;

    port = other->port;

    connOptions = other->connOptions;

    precisionPolicy = other->precisionPolicy;

}

void QSqlDatabasePrivate::disable()

{

    if (driver != shared_null()->driver) {

        delete driver;

        driver = shared_null()->driver;

    }

}

/*!

    \class QSqlDriverCreatorBase

    \brief The QSqlDriverCreatorBase class is the base class for

    SQL driver factories.

    \ingroup database

    \inmodule QtSql

    Reimplement createObject() to return an instance of the specific

    QSqlDriver subclass that you want to provide.

    See QSqlDatabase::registerSqlDriver() for details.

    \sa QSqlDriverCreator

*/

/*!

    \fn QSqlDriverCreatorBase::~QSqlDriverCreatorBase()

    Destroys the SQL driver creator object.

*/

/*!

    \fn QSqlDriver *QSqlDriverCreatorBase::createObject() const

    Reimplement this function to returns a new instance of a

    QSqlDriver subclass.

*/

/*!

    \class QSqlDriverCreator

    \brief The QSqlDriverCreator class is a template class that

    provides a SQL driver factory for a specific driver type.

    \ingroup database

    \inmodule QtSql

    QSqlDriverCreator<T> instantiates objects of type T, where T is a

    QSqlDriver subclass.

    See QSqlDatabase::registerSqlDriver() for details.

*/

/*!

    \fn QSqlDriver *QSqlDriverCreator::createObject() const

    \reimp

*/

/*!

    \class QSqlDatabase

    \brief The QSqlDatabase class represents a connection to

    a database.

    \ingroup database

    \inmodule QtSql

    The QSqlDatabase class provides an interface for accessing a

    database through a connection. An instance of QSqlDatabase

    represents the connection. The connection provides access to the

    database via one of the \l{SQL Database Drivers#Supported

    Databases} {supported database drivers}, which are derived from

    QSqlDriver.  Alternatively, you can subclass your own database

    driver from QSqlDriver. See \l{How to Write Your Own Database

    Driver} for more information.

    Create a connection (i.e., an instance of QSqlDatabase) by calling

    one of the static addDatabase() functions, where you specify

    \l{SQL Database Drivers#Supported Databases} {the driver or type

    of driver} to use (i.e., what kind of database will you access?)

    and a connection name. A connection is known by its own name,

    \e{not} by the name of the database it connects to. You can have

    multiple connections to one database. QSqlDatabase also supports

    the concept of a \e{default} connection, which is the unnamed

    connection. To create the default connection, don't pass the

    connection name argument when you call addDatabase().

    Subsequently, when you call any static member function that takes

    the connection name argument, if you don't pass the connection

    name argument, the default connection is assumed. The following

    snippet shows how to create and open a default connection to a

    PostgreSQL database:

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 0

    Once the QSqlDatabase object has been created, set the connection

    parameters with setDatabaseName(), setUserName(), setPassword(),

    setHostName(), setPort(), and setConnectOptions(). Then call

    open() to activate the physical connection to the database. The

    connection is not usable until you open it.

    The connection defined above will be the \e{default} connection,

    because we didn't give a connection name to \l{QSqlDatabase::}

    {addDatabase()}. Subsequently, you can get the default connection

    by calling database() without the connection name argument:

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 1

    QSqlDatabase is a value class. Changes made to a database

    connection via one instance of QSqlDatabase will affect other

    instances of QSqlDatabase that represent the same connection. Use

    cloneDatabase() to create an independent database connection based

    on an existing one.

    If you create multiple database connections, specify a unique

    connection name for each one, when you call addDatabase(). Use

    database() with a connection name to get that connection. Use

    removeDatabase() with a connection name to remove a connection.

    QSqlDatabase outputs a warning if you try to remove a connection

    referenced by other QSqlDatabase objects. Use contains() to see if

    a given connection name is in the list of connections.

    Once a connection is established, you can call tables() to get the

    list of tables in the database, call primaryIndex() to get a

    table's primary index, and call record() to get meta-information

    about a table's fields (e.g., field names).

    \note QSqlDatabase::exec() is deprecated. Use QSqlQuery::exec()

    instead.

    If the driver supports transactions, use transaction() to start a

    transaction, and commit() or rollback() to complete it. Use

    \l{QSqlDriver::} {hasFeature()} to ask if the driver supports

    transactions. \note When using transactions, you must start the

    transaction before you create your query.

    If an error occurrs, lastError() will return information about it.

    Get the names of the available SQL drivers with drivers().  Check

    for the presence of a particular driver with isDriverAvailable().

    If you have created your own custom driver, you must register it

    with registerSqlDriver().

    \sa QSqlDriver, QSqlQuery, {QtSql Module}, {Threads and the SQL Module}

*/

/*! \fn QSqlDatabase QSqlDatabase::addDatabase(const QString &type, const QString &connectionName)

    \threadsafe

    Adds a database to the list of database connections using the

    driver \a type and the connection name \a connectionName. If

    there already exists a database connection called \a

    connectionName, that connection is removed.

    The database connection is referred to by \a connectionName. The

    newly added database connection is returned.

    If \a type is not available or could not be loaded, isValid() returns false.

    If \a connectionName is not specified, the new connection becomes

    the default connection for the application, and subsequent calls

    to database() without the connection name argument will return the

    default connection. If a \a connectionName is provided here, use

    database(\a connectionName) to retrieve the connection.

    \warning If you add a connection with the same name as an existing

    connection, the new connection replaces the old one.  If you call

    this function more than once without specifying \a connectionName,

    the default connection will be the one replaced.

    Before using the connection, it must be initialized. e.g., call

    some or all of setDatabaseName(), setUserName(), setPassword(),

    setHostName(), setPort(), and setConnectOptions(), and, finally,

    open().

    \sa database() removeDatabase() {Threads and the SQL Module}

*/

QSqlDatabase QSqlDatabase::addDatabase(const QString &type, const QString &connectionName)

{

    QSqlDatabase db(type);

    QSqlDatabasePrivate::addDatabase(db, connectionName);

    return db;

}

/*!

    \threadsafe

    Returns the database connection called \a connectionName. The

    database connection must have been previously added with

    addDatabase(). If \a open is true (the default) and the database

    connection is not already open it is opened now. If no \a

    connectionName is specified the default connection is used. If \a

    connectionName does not exist in the list of databases, an invalid

    connection is returned.

    \sa isOpen() {Threads and the SQL Module}

*/

QSqlDatabase QSqlDatabase::database(const QString& connectionName, bool open)

{

    return QSqlDatabasePrivate::database(connectionName, open);

}

/*!

    \threadsafe

    Removes the database connection \a connectionName from the list of

    database connections.

    \warning There should be no open queries on the database

    connection when this function is called, otherwise a resource leak

    will occur.

    Example:

    \snippet doc/src/snippets/code/src_sql_kernel_qsqldatabase.cpp 0

    The correct way to do it:

    \snippet doc/src/snippets/code/src_sql_kernel_qsqldatabase.cpp 1

    To remove the default connection, which may have been created with a

    call to addDatabase() not specifying a connection name, you can

    retrieve the default connection name by calling connectionName() on

    the database returned by database(). Note that if a default database