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

**

** 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 "qsql_psql.h"

#include <qcoreapplication.h>

#include <qvariant.h>

#include <qdatetime.h>

#include <qregexp.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlrecord.h>

#include <qsqlquery.h>

#include <qsocketnotifier.h>

#include <qstringlist.h>

#include <qmutex.h>

#include <libpq-fe.h>

#include <pg_config.h>

#include <stdlib.h>

#include <math.h>

// below code taken from an example at http://www.gnu.org/software/hello/manual/autoconf/Function-Portability.html

#ifndef isnan

    # define isnan(x) \

        (sizeof (x) == sizeof (long double) ? isnan_ld (x) \

        : sizeof (x) == sizeof (double) ? isnan_d (x) \

        : isnan_f (x))

    static inline int isnan_f  (float       x) { return x != x; }

    static inline int isnan_d  (double      x) { return x != x; }

    static inline int isnan_ld (long double x) { return x != x; }

#endif

#ifndef isinf

    # define isinf(x) \

        (sizeof (x) == sizeof (long double) ? isinf_ld (x) \

        : sizeof (x) == sizeof (double) ? isinf_d (x) \

        : isinf_f (x))

    static inline int isinf_f  (float       x) { return isnan (x - x); }

    static inline int isinf_d  (double      x) { return isnan (x - x); }

    static inline int isinf_ld (long double x) { return isnan (x - x); }

#endif

// workaround for postgres defining their OIDs in a private header file

#define QBOOLOID 16

#define QINT8OID 20

#define QINT2OID 21

#define QINT4OID 23

#define QNUMERICOID 1700

#define QFLOAT4OID 700

#define QFLOAT8OID 701

#define QABSTIMEOID 702

#define QRELTIMEOID 703

#define QDATEOID 1082

#define QTIMEOID 1083

#define QTIMETZOID 1266

#define QTIMESTAMPOID 1114

#define QTIMESTAMPTZOID 1184

#define QOIDOID 2278

#define QBYTEAOID 17

#define QREGPROCOID 24

#define QXIDOID 28

#define QCIDOID 29

/* This is a compile time switch - if PQfreemem is declared, the compiler will use that one,

   otherwise it'll run in this template */

template <typename T>

inline void PQfreemem(T *t, int = 0) { free(t); }

Q_DECLARE_METATYPE(PGconn*)

Q_DECLARE_METATYPE(PGresult*)

QT_BEGIN_NAMESPACE

inline void qPQfreemem(void *buffer)

{

    PQfreemem(buffer);

}

class QPSQLDriverPrivate

{

public:

    QPSQLDriverPrivate() : connection(0), isUtf8(false), pro(QPSQLDriver::Version6), sn(0) {}

    PGconn *connection;

    bool isUtf8;

    QPSQLDriver::Protocol pro;

    QSocketNotifier *sn;

    QStringList seid;

    void appendTables(QStringList &tl, QSqlQuery &t, QChar type);

};

void QPSQLDriverPrivate::appendTables(QStringList &tl, QSqlQuery &t, QChar type)

{

    QString query;

    if (pro >= QPSQLDriver::Version73) {

        query = QString::fromLatin1("select pg_class.relname, pg_namespace.nspname from pg_class "

                  "left join pg_namespace on (pg_class.relnamespace = pg_namespace.oid) "

                  "where (pg_class.relkind = '%1') and (pg_class.relname !~ '^Inv') "

                  "and (pg_class.relname !~ '^pg_') "

                  "and (pg_namespace.nspname != 'information_schema') ").arg(type);

    } else {

        query = QString::fromLatin1("select relname, null from pg_class where (relkind = '%1') "

                  "and (relname !~ '^Inv') "

                  "and (relname !~ '^pg_') ").arg(type);

    }

    t.exec(query);

    while (t.next()) {

        QString schema = t.value(1).toString();

        if (schema.isEmpty() || schema == QLatin1String("public"))

            tl.append(t.value(0).toString());

        else

            tl.append(t.value(0).toString().prepend(QLatin1Char('.')).prepend(schema));

    }

}

class QPSQLResultPrivate

{

public:

    QPSQLResultPrivate(QPSQLResult *qq): q(qq), driver(0), result(0), currentSize(-1), preparedQueriesEnabled(false) {}

    QPSQLResult *q;

    const QPSQLDriverPrivate *driver;

    PGresult *result;

    int currentSize;

    bool preparedQueriesEnabled;

    QString preparedStmtId;

    bool processResults();

};

static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,

                            const QPSQLDriverPrivate *p)

{

    const char *s = PQerrorMessage(p->connection);

    QString msg = p->isUtf8 ? QString::fromUtf8(s) : QString::fromLocal8Bit(s);

    return QSqlError(QLatin1String("QPSQL: ") + err, msg, type);

}

bool QPSQLResultPrivate::processResults()

{

    if (!result)

        return false;

    int status = PQresultStatus(result);

    if (status == PGRES_TUPLES_OK) {

        q->setSelect(true);

        q->setActive(true);

        currentSize = PQntuples(result);

        return true;

    } else if (status == PGRES_COMMAND_OK) {

        q->setSelect(false);

        q->setActive(true);

        currentSize = -1;

        return true;

    }

    q->setLastError(qMakeError(QCoreApplication::translate("QPSQLResult",

                    "Unable to create query"), QSqlError::StatementError, driver));

    return false;

}

static QVariant::Type qDecodePSQLType(int t)

{

    QVariant::Type type = QVariant::Invalid;

    switch (t) {

    case QBOOLOID:

        type = QVariant::Bool;

        break;

    case QINT8OID:

        type = QVariant::LongLong;

        break;

    case QINT2OID:

    case QINT4OID:

    case QOIDOID:

    case QREGPROCOID:

    case QXIDOID:

    case QCIDOID:

        type = QVariant::Int;

        break;

    case QNUMERICOID:

    case QFLOAT4OID:

    case QFLOAT8OID:

        type = QVariant::Double;

        break;

    case QABSTIMEOID:

    case QRELTIMEOID:

    case QDATEOID:

        type = QVariant::Date;

        break;

    case QTIMEOID:

    case QTIMETZOID:

        type = QVariant::Time;

        break;

    case QTIMESTAMPOID:

    case QTIMESTAMPTZOID:

        type = QVariant::DateTime;

        break;

    case QBYTEAOID:

        type = QVariant::ByteArray;

        break;

    default:

        type = QVariant::String;

        break;

    }

    return type;

}

static void qDeallocatePreparedStmt(QPSQLResultPrivate *d)

{

    const QString stmt = QLatin1String("DEALLOCATE ") + d->preparedStmtId;

    PGresult *result = PQexec(d->driver->connection,

                              d->driver->isUtf8 ? stmt.toUtf8().constData()

                                                : stmt.toLocal8Bit().constData());

    if (PQresultStatus(result) != PGRES_COMMAND_OK)

        qWarning("Unable to free statement: %s", PQerrorMessage(d->driver->connection));

    PQclear(result);

    d->preparedStmtId.clear();

}

QPSQLResult::QPSQLResult(const QPSQLDriver* db, const QPSQLDriverPrivate* p)

    : QSqlResult(db)

{

    d = new QPSQLResultPrivate(this);

    d->driver = p;

    d->preparedQueriesEnabled = db->hasFeature(QSqlDriver::PreparedQueries);

}

QPSQLResult::~QPSQLResult()

{

    cleanup();

    if (d->preparedQueriesEnabled && !d->preparedStmtId.isNull())

        qDeallocatePreparedStmt(d);

    delete d;

}

QVariant QPSQLResult::handle() const

{

    return qVariantFromValue(d->result);

}

void QPSQLResult::cleanup()

{

    if (d->result)

        PQclear(d->result);

    d->result = 0;

    setAt(QSql::BeforeFirstRow);

    d->currentSize = -1;

    setActive(false);

}

bool QPSQLResult::fetch(int i)

{

    if (!isActive())

        return false;

    if (i < 0)

        return false;

    if (i >= d->currentSize)

        return false;

    if (at() == i)

        return true;

    setAt(i);

    return true;

}

bool QPSQLResult::fetchFirst()

{

    return fetch(0);

}

bool QPSQLResult::fetchLast()

{

    return fetch(PQntuples(d->result) - 1);

}

QVariant QPSQLResult::data(int i)

{

    if (i >= PQnfields(d->result)) {

        qWarning("QPSQLResult::data: column %d out of range", i);

        return QVariant();

    }

    int ptype = PQftype(d->result, i);

    QVariant::Type type = qDecodePSQLType(ptype);

    const char *val = PQgetvalue(d->result, at(), i);

    if (PQgetisnull(d->result, at(), i))

        return QVariant(type);

    switch (type) {

    case QVariant::Bool:

        return QVariant((bool)(val[0] == 't'));

    case QVariant::String:

        return d->driver->isUtf8 ? QString::fromUtf8(val) : QString::fromAscii(val);

    case QVariant::LongLong:

        if (val[0] == '-')

            return QString::fromLatin1(val).toLongLong();

        else

            return QString::fromLatin1(val).toULongLong();

    case QVariant::Int:

        return atoi(val);

    case QVariant::Double:

        if (ptype == QNUMERICOID) {

            if (numericalPrecisionPolicy() != QSql::HighPrecision) {

                QVariant retval;

                bool convert;

                double dbl=QString::fromAscii(val).toDouble(&convert);

                if (numericalPrecisionPolicy() == QSql::LowPrecisionInt64)

                    retval = (qlonglong)dbl;

                else if (numericalPrecisionPolicy() == QSql::LowPrecisionInt32)

                    retval = (int)dbl;

                else if (numericalPrecisionPolicy() == QSql::LowPrecisionDouble)

                    retval = dbl;

                if (!convert)

                    return QVariant();

                return retval;

            }

            return QString::fromAscii(val);

        }

        return QString::fromAscii(val).toDouble();

    case QVariant::Date:

        if (val[0] == '\0') {

            return QVariant(QDate());

        } else {

#ifndef QT_NO_DATESTRING

            return QVariant(QDate::fromString(QString::fromLatin1(val), Qt::ISODate));

#else

            return QVariant(QString::fromLatin1(val));

#endif

        }

    case QVariant::Time: {

        const QString str = QString::fromLatin1(val);

#ifndef QT_NO_DATESTRING

        if (str.isEmpty())

            return QVariant(QTime());

        if (str.at(str.length() - 3) == QLatin1Char('+') || str.at(str.length() - 3) == QLatin1Char('-'))

            // strip the timezone

            // TODO: fix this when timestamp support comes into QDateTime

            return QVariant(QTime::fromString(str.left(str.length() - 3), Qt::ISODate));

        return QVariant(QTime::fromString(str, Qt::ISODate));

#else

        return QVariant(str);

#endif

    }

    case QVariant::DateTime: {

        QString dtval = QString::fromLatin1(val);

#ifndef QT_NO_DATESTRING

        if (dtval.length() < 10)

            return QVariant(QDateTime());

        // remove the timezone

        // TODO: fix this when timestamp support comes into QDateTime

        if (dtval.at(dtval.length() - 3) == QLatin1Char('+') || dtval.at(dtval.length() - 3) == QLatin1Char('-'))

            dtval.chop(3);

        // milliseconds are sometimes returned with 2 digits only

        if (dtval.at(dtval.length() - 3).isPunct())

            dtval += QLatin1Char('0');

        if (dtval.isEmpty())

            return QVariant(QDateTime());

        else

            return QVariant(QDateTime::fromString(dtval, Qt::ISODate));

#else

        return QVariant(dtval);

#endif

    }

    case QVariant::ByteArray: {

        size_t len;

        unsigned char *data = PQunescapeBytea((unsigned char*)val, &len);

        QByteArray ba((const char*)data, len);

        qPQfreemem(data);

        return QVariant(ba);

    }

    default:

    case QVariant::Invalid:

        qWarning("QPSQLResult::data: unknown data type");

    }

    return QVariant();

}

bool QPSQLResult::isNull(int field)

{

    PQgetvalue(d->result, at(), field);

    return PQgetisnull(d->result, at(), field);

}

bool QPSQLResult::reset (const QString& query)

{

    cleanup();

    if (!driver())

        return false;

    if (!driver()->isOpen() || driver()->isOpenError())

        return false;

    d->result = PQexec(d->driver->connection,

                       d->driver->isUtf8 ? query.toUtf8().constData()

                                         : query.toLocal8Bit().constData());

    return d->processResults();

}

int QPSQLResult::size()

{

    return d->currentSize;

}

int QPSQLResult::numRowsAffected()

{

    return QString::fromLatin1(PQcmdTuples(d->result)).toInt();

}

QVariant QPSQLResult::lastInsertId() const

{

    if (isActive()) {

        Oid id = PQoidValue(d->result);

        if (id != InvalidOid)

            return QVariant(id);

    }

    return QVariant();

}

QSqlRecord QPSQLResult::record() const

{

    QSqlRecord info;

    if (!isActive() || !isSelect())

        return info;

    int count = PQnfields(d->result);

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

        QSqlField f;

        if (d->driver->isUtf8)

            f.setName(QString::fromUtf8(PQfname(d->result, i)));

        else

            f.setName(QString::fromLocal8Bit(PQfname(d->result, i)));

        f.setType(qDecodePSQLType(PQftype(d->result, i)));

        int len = PQfsize(d->result, i);

        int precision = PQfmod(d->result, i);

        // swap length and precision if length == -1

        if (len == -1 && precision > -1) {

            len = precision - 4;

            precision = -1;

        }

        f.setLength(len);

        f.setPrecision(precision);

        f.setSqlType(PQftype(d->result, i));

        info.append(f);

    }

    return info;

}

void QPSQLResult::virtual_hook(int id, void *data)

{

    Q_ASSERT(data);

    switch (id) {

    default:

        QSqlResult::virtual_hook(id, data);

    }

}

static QString qReplacePlaceholderMarkers(const QString &query)

{

    const int originalLength = query.length();

    bool inQuote = false;

    int markerIdx = 0;

    QString result;

    result.reserve(originalLength + 23);

    for (int i = 0; i < originalLength; ++i) {

        const QChar ch = query.at(i);

        if (ch == QLatin1Char('?') && !inQuote) {

            result += QLatin1Char('$');

            result += QString::number(++markerIdx);

        } else {

            if (ch == QLatin1Char('\''))

                inQuote = !inQuote;

            result += ch;

        }

    }

    result.squeeze();

    return result;

}

static QString qCreateParamString(const QVector<QVariant> boundValues, const QSqlDriver *driver)

{

    if (boundValues.isEmpty())

        return QString();

    QString params;

    QSqlField f;

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

        const QVariant &val = boundValues.at(i);