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

**

** Copyright (C) 2009 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 "qsqldriver.h"

#include "qdatetime.h"

#include "qsqlerror.h"

#include "qsqlfield.h"

#include "qsqlindex.h"

#include "private/qobject_p.h"

QT_BEGIN_NAMESPACE

static QString prepareIdentifier(const QString &identifier,

        QSqlDriver::IdentifierType type, const QSqlDriver *driver)

{

    Q_ASSERT( driver != NULL );

    QString ret = identifier;

    if (!driver->isIdentifierEscaped(identifier, type)) {

        ret = driver->escapeIdentifier(identifier, type);

    }

    return ret;

}

class QSqlDriverPrivate : public QObjectPrivate

{

public:

    QSqlDriverPrivate();

    virtual ~QSqlDriverPrivate();

public:

    // @CHECK: this member is never used. It was named q, which expanded to q_func().

    QSqlDriver *q_func();

    uint isOpen : 1;

    uint isOpenError : 1;

    QSqlError error;

    QSql::NumericalPrecisionPolicy precisionPolicy;

};

inline QSqlDriverPrivate::QSqlDriverPrivate()

    : QObjectPrivate(), isOpen(false), isOpenError(false), precisionPolicy(QSql::LowPrecisionDouble)

{

}

QSqlDriverPrivate::~QSqlDriverPrivate()

{

}

/*!

    \class QSqlDriver

    \brief The QSqlDriver class is an abstract base class for accessing

    specific SQL databases.

    \ingroup database

    \inmodule QtSql

    This class should not be used directly. Use QSqlDatabase instead.

    If you want to create your own SQL drivers, you can subclass this

    class and reimplement its pure virtual functions and those

    virtual functions that you need. See \l{How to Write Your Own

    Database Driver} for more information.

    \sa QSqlDatabase, QSqlResult

*/

/*!

    Constructs a new driver with the given \a parent.

*/

QSqlDriver::QSqlDriver(QObject *parent)

    : QObject(*new QSqlDriverPrivate, parent)

{

}

/*!

    Destroys the object and frees any allocated resources.

*/

QSqlDriver::~QSqlDriver()

{

}

/*!

    \since 4.4

    \fn QSqlDriver::notification(const QString &name)

    This signal is emitted when the database posts an event notification

    that the driver subscribes to. \a name identifies the event notification.

    \sa subscribeToNotification()

*/

/*!

    \fn bool QSqlDriver::open(const QString &db, const QString &user, const QString& password,

                              const QString &host, int port, const QString &options)

    Derived classes must reimplement this pure virtual function to

    open a database connection on database \a db, using user name \a

    user, password \a password, host \a host, port \a port and

    connection options \a options.

    The function must return true on success and false on failure.

    \sa setOpen()

*/

/*!

    \fn bool QSqlDriver::close()

    Derived classes must reimplement this pure virtual function in

    order to close the database connection. Return true on success,

    false on failure.

    \sa open(), setOpen()

*/

/*!

    \fn QSqlResult *QSqlDriver::createResult() const

    Creates an empty SQL result on the database. Derived classes must

    reimplement this function and return a QSqlResult object

    appropriate for their database to the caller.

*/

/*!

    Returns true if the database connection is open; otherwise returns

    false.

*/

bool QSqlDriver::isOpen() const

{

    return d_func()->isOpen;

}

/*!

    Returns true if the there was an error opening the database

    connection; otherwise returns false.

*/

bool QSqlDriver::isOpenError() const

{

    return d_func()->isOpenError;

}

/*!

    \enum QSqlDriver::DriverFeature

    This enum contains a list of features a driver might support. Use

    hasFeature() to query whether a feature is supported or not.

    \value Transactions  Whether the driver supports SQL transactions.

    \value QuerySize  Whether the database is capable of reporting the size

    of a query. Note that some databases do not support returning the size

    (i.e. number of rows returned) of a query, in which case

    QSqlQuery::size() will return -1.

    \value BLOB  Whether the driver supports Binary Large Object fields.

    \value Unicode  Whether the driver supports Unicode strings if the

    database server does.

    \value PreparedQueries  Whether the driver supports prepared query execution.

    \value NamedPlaceholders  Whether the driver supports the use of named placeholders.

    \value PositionalPlaceholders  Whether the driver supports the use of positional placeholders.

    \value LastInsertId  Whether the driver supports returning the Id of the last touched row.

    \value BatchOperations  Whether the driver supports batched operations, see QSqlQuery::execBatch()

    \value SimpleLocking  Whether the driver disallows a write lock on a table while other queries have a read lock on it.

    \value LowPrecisionNumbers  Whether the driver allows fetching numerical values with low precision.

    \value EventNotifications Whether the driver supports database event notifications.

    \value FinishQuery Whether the driver can do any low-level resource cleanup when QSqlQuery::finish() is called.

    \value MultipleResultSets Whether the driver can access multiple result sets returned from batched statements or stored procedures.

    More information about supported features can be found in the

    \l{sql-driver.html}{Qt SQL driver} documentation.

    \sa hasFeature()

*/

/*!

    \enum QSqlDriver::StatementType

    This enum contains a list of SQL statement (or clause) types the

    driver can create.

    \value WhereStatement  An SQL \c WHERE statement (e.g., \c{WHERE f = 5}).

    \value SelectStatement An SQL \c SELECT statement (e.g., \c{SELECT f FROM t}).

    \value UpdateStatement An SQL \c UPDATE statement (e.g., \c{UPDATE TABLE t set f = 1}).

    \value InsertStatement An SQL \c INSERT statement (e.g., \c{INSERT INTO t (f) values (1)}).

    \value DeleteStatement An SQL \c DELETE statement (e.g., \c{DELETE FROM t}).

    \sa sqlStatement()

*/

/*!

    \enum QSqlDriver::IdentifierType

    This enum contains a list of SQL identifier types.

    \value FieldName A SQL field name

    \value TableName A SQL table name

*/

/*!

    \fn bool QSqlDriver::hasFeature(DriverFeature feature) const

    Returns true if the driver supports feature \a feature; otherwise

    returns false.

    Note that some databases need to be open() before this can be

    determined.

    \sa DriverFeature

*/

/*!

    This function sets the open state of the database to \a open.

    Derived classes can use this function to report the status of

    open().

    \sa open(), setOpenError()

*/

void QSqlDriver::setOpen(bool open)

{

    d_func()->isOpen = open;

}

/*!

    This function sets the open error state of the database to \a

    error. Derived classes can use this function to report the status

    of open(). Note that if \a error is true the open state of the

    database is set to closed (i.e., isOpen() returns false).

    \sa open(), setOpen()

*/

void QSqlDriver::setOpenError(bool error)

{

    d_func()->isOpenError = error;

    if (error)

        d_func()->isOpen = false;

}

/*!

    This function is called to begin a transaction. If successful,

    return true, otherwise return false. The default implementation

    does nothing and returns false.

    \sa commitTransaction(), rollbackTransaction()

*/

bool QSqlDriver::beginTransaction()

{

    return false;

}

/*!

    This function is called to commit a transaction. If successful,

    return true, otherwise return false. The default implementation

    does nothing and returns false.

    \sa beginTransaction(), rollbackTransaction()

*/

bool QSqlDriver::commitTransaction()

{

    return false;

}

/*!

    This function is called to rollback a transaction. If successful,

    return true, otherwise return false. The default implementation

    does nothing and returns false.

    \sa beginTransaction(), commitTransaction()

*/

bool QSqlDriver::rollbackTransaction()

{

    return false;

}

/*!

    This function is used to set the value of the last error, \a error,

    that occurred on the database.

    \sa lastError()

*/

void QSqlDriver::setLastError(const QSqlError &error)

{

    d_func()->error = error;

}

/*!

    Returns a QSqlError object which contains information about the

    last error that occurred on the database.

*/

QSqlError QSqlDriver::lastError() const

{

    return d_func()->error;

}

/*!

    Returns a list of the names of the tables in the database. The

    default implementation returns an empty list.

    The \a tableType argument describes what types of tables

    should be returned. Due to binary compatibility, the string

    contains the value of the enum QSql::TableTypes as text.

    An empty string should be treated as QSql::Tables for

    backward compatibility.

*/

QStringList QSqlDriver::tables(QSql::TableType) const

{

    return QStringList();

}

/*!

    Returns the primary index for table \a tableName. Returns an empty

    QSqlIndex if the table doesn't have a primary index. The default

    implementation returns an empty index.

*/

QSqlIndex QSqlDriver::primaryIndex(const QString&) const

{

    return QSqlIndex();

}

/*!

    Returns a QSqlRecord populated with the names of the fields in

    table \a tableName. If no such table exists, an empty record is

    returned. The default implementation returns an empty record.

*/

QSqlRecord QSqlDriver::record(const QString & /* tableName */) const

{

    return QSqlRecord();

}

/*!

    Returns the \a identifier escaped according to the database rules.

    \a identifier can either be a table name or field name, dependent

    on \a type.

    The default implementation does nothing.

    \sa isIdentifierEscaped()

 */

QString QSqlDriver::escapeIdentifier(const QString &identifier, IdentifierType) const

{

    return identifier;

}

/*!

    Returns whether \a identifier is escaped according to the database rules.

    \a identifier can either be a table name or field name, dependent

    on \a type.

    \warning Because of binary compatability constraints, this function is not virtual.

    If you want to provide your own implementation in your QSqlDriver subclass,

    reimplement the isIdentifierEscapedImplementation() slot in your subclass instead.

    The isIdentifierEscapedFunction() will dynamically detect the slot and call it.

    \sa stripDelimiters(), escapeIdentifier()

 */

bool QSqlDriver::isIdentifierEscaped(const QString &identifier, IdentifierType type) const

{

    bool result;

    QMetaObject::invokeMethod(const_cast<QSqlDriver*>(this),

                            "isIdentifierEscapedImplementation", Qt::DirectConnection,

                            Q_RETURN_ARG(bool, result),

                            Q_ARG(QString, identifier),

                            Q_ARG(IdentifierType, type));

    return result;

}

/*!

    Returns the \a identifier with the leading and trailing delimiters removed,

    \a identifier can either be a table name or field name,

    dependent on \a type.  If \a identifier does not have leading

    and trailing delimiter characters, \a identifier is returned without

    modification.

    \warning Because of binary compatability constraints, this function is not virtual,

    If you want to provide your own implementation in your QSqlDriver subclass,

    reimplement the stripDelimitersImplementation() slot in your subclass instead.

    The stripDelimiters() function will dynamically detect the slot and call it.

    \since 4.5

    \sa isIdentifierEscaped()

 */

QString QSqlDriver::stripDelimiters(const QString &identifier, IdentifierType type) const

{

    QString result;

    QMetaObject::invokeMethod(const_cast<QSqlDriver*>(this),

                            "stripDelimitersImplementation", Qt::DirectConnection,

                            Q_RETURN_ARG(QString, result),

                            Q_ARG(QString, identifier),

                            Q_ARG(IdentifierType, type));

    return result;

}

/*!

    Returns a SQL statement of type \a type for the table \a tableName

    with the values from \a rec. If \a preparedStatement is true, the

    string will contain placeholders instead of values.

    This method can be used to manipulate tables without having to worry

    about database-dependent SQL dialects. For non-prepared statements,

    the values will be properly escaped.

*/

QString QSqlDriver::sqlStatement(StatementType type, const QString &tableName,

                                 const QSqlRecord &rec, bool preparedStatement) const

{

    int i;

    QString s;

    s.reserve(128);

    switch (type) {

    case SelectStatement:

        for (i = 0; i < rec.count(); ++i) {

            if (rec.isGenerated(i))

                s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(QLatin1String(", "));

        }

        if (s.isEmpty())

            return s;

        s.chop(2);

        s.prepend(QLatin1String("SELECT ")).append(QLatin1String(" FROM ")).append(tableName);

        break;

    case WhereStatement:

        if (preparedStatement) {

            for (int i = 0; i < rec.count(); ++i) {

                s.append(prepareIdentifier(rec.fieldName(i), FieldName,this));

                if (rec.isNull(i))

                    s.append(QLatin1String(" IS NULL"));

                else

                    s.append(QLatin1String(" = ?"));

                s.append(QLatin1String(" AND "));

            }

        } else {

            for (i = 0; i < rec.count(); ++i) {

                s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this));

                QString val = formatValue(rec.field(i));

                if (val == QLatin1String("NULL"))

                    s.append(QLatin1String(" IS NULL"));

                else

                    s.append(QLatin1String(" = ")).append(val);

                s.append(QLatin1String(" AND "));

            }

        }

        if (!s.isEmpty()) {

            s.prepend(QLatin1String("WHERE "));

            s.chop(5); // remove tailing AND

        }

        break;

    case UpdateStatement:

        s.append(QLatin1String("UPDATE ")).append(tableName).append(

                 QLatin1String(" SET "));

        for (i = 0; i < rec.count(); ++i) {

            if (!rec.isGenerated(i) || !rec.value(i).isValid())

                continue;

            s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(QLatin1Char('='));

            if (preparedStatement)

                s.append(QLatin1Char('?'));

            else

                s.append(formatValue(rec.field(i)));

            s.append(QLatin1String(", "));

        }

        if (s.endsWith(QLatin1String(", ")))

            s.chop(2);

        else

            s.clear();

        break;

    case DeleteStatement:

        s.append(QLatin1String("DELETE FROM ")).append(tableName);

        break;

    case InsertStatement: {

        s.append(QLatin1String("INSERT INTO ")).append(tableName).append(QLatin1String(" ("));

        QString vals;

        for (i = 0; i < rec.count(); ++i) {

            if (!rec.isGenerated(i) || !rec.value(i).isValid())

                continue;

            s.append(prepareIdentifier(rec.fieldName(i), QSqlDriver::FieldName, this)).append(QLatin1String(", "));

            if (preparedStatement)

                vals.append(QLatin1Char('?'));

            else

                vals.append(formatValue(rec.field(i)));

            vals.append(QLatin1String(", "));

        }