qsql_ibase.cpp File Reference

#include "qsql_ibase.h"
#include <qcoreapplication.h>
#include <qdatetime.h>
#include <qvariant.h>
#include <qsqlerror.h>
#include <qsqlfield.h>
#include <qsqlindex.h>
#include <qsqlquery.h>
#include <qlist.h>
#include <qvector.h>
#include <qtextcodec.h>
#include <qmutex.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <qdebug.h>
#include <QVarLengthArray>

Go to the source code of this file.

Classes
class	QIBaseDriverPrivate
struct	QIBaseEventBuffer
class	QIBaseResultPrivate

Macros
#define	FBVERSION   SQL_DIALECT_V6
#define	SQLDA_CURRENT_VERSION   SQLDA_VERSION1

Typedefs
typedef QMap< void *, QIBaseDriver * >	QIBaseBufferDriverMap

Enumerations
enum	{ QIBaseChunkSize = SHRT_MAX / 2 }

Functions
static char *	createArrayBuffer (char *buffer, const QList< QVariant > &list, QVariant::Type type, short curDim, ISC_ARRAY_DESC *arrayDesc, QString &error, QTextCodec *tc)
static void	createDA (XSQLDA *&sqlda)
static void	delDA (XSQLDA *&sqlda)
static QByteArray	encodeString (QTextCodec *tc, const QString &str)
static void	enlargeDA (XSQLDA *&sqlda, int n)
template<typename T >
static char *	fillList (char *buffer, const QList< QVariant > &list, T *=0)
template<>
char *	fillList< float > (char *buffer, const QList< QVariant > &list, float *)
static QDate	fromDate (char *buffer)
static QTime	fromTime (char *buffer)
static QDateTime	fromTimeStamp (char *buffer)
static bool	getIBaseError (QString &msg, ISC_STATUS *status, ISC_LONG &sqlcode, QTextCodec *tc)
static void	initDA (XSQLDA *sqlda)
	Q_GLOBAL_STATIC (QMutex, qMutex)
static isc_callback	qEventCallback (char *result, short length, char *updated)
static char *	qFillBufferWithString (char *buffer, const QString &string, short buflen, bool varying, bool array, QTextCodec *tc)
static void	qFreeEventBuffer (QIBaseEventBuffer *eBuffer)
static QVariant::Type	qIBaseTypeName (int iType, bool hasScale)
static QVariant::Type	qIBaseTypeName2 (int iType, bool hasScale)
static char *	readArrayBuffer (QList< QVariant > &list, char *buffer, short curDim, short *numElements, ISC_ARRAY_DESC *arrayDesc, QTextCodec *tc)
static ISC_DATE	toDate (const QDate &t)
template<typename T >
static QList< QVariant >	toList (char **buf, int count, T *=0)
template<>
QList< QVariant >	toList< long > (char **buf, int count, long *)
static ISC_TIME	toTime (const QTime &t)
static ISC_TIMESTAMP	toTimeStamp (const QDateTime &dt)

Macro Definition Documentation

FBVERSION

#define FBVERSION   SQL_DIALECT_V6

Definition at line 62 of file qsql_ibase.cpp.

Referenced by QIBaseResult::exec(), QIBaseResult::gotoNext(), and QIBaseResult::prepare().

SQLDA_CURRENT_VERSION

#define SQLDA_CURRENT_VERSION   SQLDA_VERSION1

Definition at line 65 of file qsql_ibase.cpp.

Referenced by createDA(), and enlargeDA().

Typedef Documentation

QIBaseBufferDriverMap

typedef QMap<void *, QIBaseDriver *> QIBaseBufferDriverMap

Definition at line 337 of file qsql_ibase.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
QIBaseChunkSize

Definition at line 68 of file qsql_ibase.cpp.

{ QIBaseChunkSize = SHRT_MAX / 2 };

Function Documentation

createArrayBuffer()

static char* createArrayBuffer ( char *  buffer, const QList< QVariant > &  list, QVariant::Type  type, short  curDim, ISC_ARRAY_DESC *  arrayDesc, QString &  error, QTextCodec *  tc  )

static

Definition at line 675 of file qsql_ibase.cpp.

Referenced by QIBaseResultPrivate::writeArray().

{
    int i;
    ISC_ARRAY_BOUND *bounds = arrayDesc->array_desc_bounds;
    short dim = arrayDesc->array_desc_dimensions - 1;

    int elements = (bounds[curDim].array_bound_upper -
                    bounds[curDim].array_bound_lower + 1);

    if (list.size() != elements) { // size mismatch
        error = QLatin1String("Expected size: %1. Supplied size: %2");
        error = QLatin1String("Array size mismatch. Fieldname: %1 ")
                + error.arg(elements).arg(list.size());
        return 0;
    }

    if (curDim != dim) {
        for(i = 0; i < list.size(); ++i) {

          if (list.at(i).type() != QVariant::List) { // dimensions mismatch
              error = QLatin1String("Array dimensons mismatch. Fieldname: %1");
              return 0;
          }

          buffer = createArrayBuffer(buffer, list.at(i).toList(), type, curDim + 1,
                                     arrayDesc, error, tc);
          if (!buffer)
              return 0;
        }
    } else {
        switch(type) {
        case QVariant::Int:
        case QVariant::UInt:
            if (arrayDesc->array_desc_dtype == blr_short)
                buffer = fillList<short>(buffer, list);
            else
                buffer = fillList<int>(buffer, list);
            break;
        case QVariant::Double:
            if (arrayDesc->array_desc_dtype == blr_float)
                buffer = fillList<float>(buffer, list, static_cast<float *>(0));
            else
                buffer = fillList<double>(buffer, list);
            break;
        case QVariant::LongLong:
            buffer = fillList<qint64>(buffer, list);
            break;
        case QVariant::ULongLong:
            buffer = fillList<quint64>(buffer, list);
            break;
        case QVariant::String:
            for (i = 0; i < list.size(); ++i)
                buffer = qFillBufferWithString(buffer, list.at(i).toString(),
                                               arrayDesc->array_desc_length,
                                               arrayDesc->array_desc_dtype == blr_varying,
                                               true, tc);
            break;
        case QVariant::Date:
            for (i = 0; i < list.size(); ++i) {
                *((ISC_DATE*)buffer) = toDate(list.at(i).toDate());
                buffer += sizeof(ISC_DATE);
            }
            break;
        case QVariant::Time:
            for (i = 0; i < list.size(); ++i) {
                *((ISC_TIME*)buffer) = toTime(list.at(i).toTime());
                buffer += sizeof(ISC_TIME);
            }
            break;

        case QVariant::DateTime:
            for (i = 0; i < list.size(); ++i) {
                *((ISC_TIMESTAMP*)buffer) = toTimeStamp(list.at(i).toDateTime());
                buffer += sizeof(ISC_TIMESTAMP);
            }
            break;
        default:
            break;
        }
    }
    return buffer;
}

createDA()

static void createDA ( XSQLDA *&  sqlda )

static

Definition at line 97 of file qsql_ibase.cpp.

Referenced by QIBaseResult::prepare().

{
    sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(1));
    if (sqlda == (XSQLDA*)0) return;
    sqlda->sqln = 1;
    sqlda->sqld = 0;
    sqlda->version = SQLDA_CURRENT_VERSION;
    sqlda->sqlvar[0].sqlind = 0;
    sqlda->sqlvar[0].sqldata = 0;
}

delDA()

static void delDA ( XSQLDA *&  sqlda )

static

Definition at line 155 of file qsql_ibase.cpp.

Referenced by QIBaseResultPrivate::cleanup(), and QIBaseResult::exec().

{
    if (!sqlda)
        return;
    for (int i = 0; i < sqlda->sqld; ++i) {
        delete [] sqlda->sqlvar[i].sqlind;
        delete [] sqlda->sqlvar[i].sqldata;
    }
    free(sqlda);
    sqlda = 0;
}

encodeString()

static QByteArray encodeString ( QTextCodec *  tc, const QString &  str  )

static

Definition at line 289 of file qsql_ibase.cpp.

Referenced by QKeySequence::operator>=(), QIBaseResult::prepare(), and qFillBufferWithString().

{
    if (tc)
        return tc->fromUnicode(str);
    return str.toUtf8();
}

enlargeDA()

static void enlargeDA ( XSQLDA *&  sqlda, int  n  )

static

Definition at line 108 of file qsql_ibase.cpp.

Referenced by QIBaseResult::prepare().

{
    if (sqlda != (XSQLDA*)0)
        free(sqlda);
    sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(n));
    if (sqlda == (XSQLDA*)0) return;
    sqlda->sqln = n;
    sqlda->version = SQLDA_CURRENT_VERSION;
}

fillList()

template<typename T >

static char* fillList ( char *  buffer, const QList< QVariant > &  list, T *  = 0  )

static

Definition at line 625 of file qsql_ibase.cpp.

{
    for (int i = 0; i < list.size(); ++i) {
        T val;
        val = qvariant_cast<T>(list.at(i));
        memcpy(buffer, &val, sizeof(T));
        buffer += sizeof(T);
    }
    return buffer;
}

fillList< float >()

template<>

char* fillList< float >	(	char *	buffer,
		const QList< QVariant > &	list,
		float *
	)

Definition at line 637 of file qsql_ibase.cpp.

Referenced by createArrayBuffer().

{
    for (int i = 0; i < list.size(); ++i) {
        double val;
        float val2 = 0;
        val = qvariant_cast<double>(list.at(i));
        val2 = (float)val;
        memcpy(buffer, &val2, sizeof(float));
        buffer += sizeof(float);
    }
    return buffer;
}

fromDate()

static QDate fromDate ( char *  buffer )

static

Definition at line 277 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext(), and readArrayBuffer().

{
    static const QDate bd(1858, 11, 17);
    QDate d;

    // have to demangle the structure ourselves because isc_decode_time
    // strips the msecs
    d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));

    return d;
}

fromTime()

static QTime fromTime ( char *  buffer )

static

Definition at line 258 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext(), and readArrayBuffer().

{
    QTime t;
    // have to demangle the structure ourselves because isc_decode_time
    // strips the msecs
    t = t.addMSecs(int((*(ISC_TIME*)buffer) / 10));

    return t;
}

fromTimeStamp()

static QDateTime fromTimeStamp ( char *  buffer )

static

Definition at line 238 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext(), and readArrayBuffer().

{
    static const QDate bd(1858, 11, 17);
    QTime t;
    QDate d;

    // have to demangle the structure ourselves because isc_decode_time
    // strips the msecs
    t = t.addMSecs(int(((ISC_TIMESTAMP*)buffer)->timestamp_time / 10));
    d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));

    return QDateTime(d, t);
}

getIBaseError()

static bool getIBaseError ( QString &  msg, ISC_STATUS *  status, ISC_LONG &  sqlcode, QTextCodec *  tc  )

static

Definition at line 73 of file qsql_ibase.cpp.

Referenced by QIBaseDriverPrivate::isError(), and QIBaseResultPrivate::isError().

{
    if (status[0] != 1 || status[1] <= 0)
        return false;

    msg.clear();
    sqlcode = isc_sqlcode(status);
    char buf[512];
#if defined(FB_API_VER) && FB_API_VER >= 20
    while(fb_interpret(buf, 512, &status)) {
#else
    while(isc_interprete(buf, &status)) {
#endif
        if(!msg.isEmpty())
            msg += QLatin1String(" - ");
        if (tc)
            msg += tc->toUnicode(buf);
        else
            msg += QString::fromUtf8(buf);
    }
    return true;
}

initDA()

static void initDA ( XSQLDA *  sqlda )

static

Definition at line 118 of file qsql_ibase.cpp.

Referenced by QIBaseResult::prepare().

{
    for (int i = 0; i < sqlda->sqld; ++i) {
        switch (sqlda->sqlvar[i].sqltype & ~1) {
        case SQL_INT64:
        case SQL_LONG:
        case SQL_SHORT:
        case SQL_FLOAT:
        case SQL_DOUBLE:
        case SQL_TIMESTAMP:
        case SQL_TYPE_TIME:
        case SQL_TYPE_DATE:
        case SQL_TEXT:
        case SQL_BLOB:
            sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen];
            break;
        case SQL_ARRAY:
            sqlda->sqlvar[i].sqldata = new char[sizeof(ISC_QUAD)];
            memset(sqlda->sqlvar[i].sqldata, 0, sizeof(ISC_QUAD));
            break;
        case SQL_VARYING:
            sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen + sizeof(short)];
            break;
        default:
            // not supported - do not bind.
            sqlda->sqlvar[i].sqldata = 0;
            break;
        }
        if (sqlda->sqlvar[i].sqltype & 1) {
            sqlda->sqlvar[i].sqlind = new short[1];
            *(sqlda->sqlvar[i].sqlind) = 0;
        } else {
            sqlda->sqlvar[i].sqlind = 0;
        }
    }
}

Q_GLOBAL_STATIC()

Q_GLOBAL_STATIC	(	QMutex	,
		qMutex
	)

qEventCallback()

static isc_callback qEventCallback ( char *  result, short  length, char *  updated  )

static

Definition at line 1727 of file qsql_ibase.cpp.

Referenced by QIBaseDriver::handle(), QIBaseDriver::qHandleEventNotification(), and QIBaseDriver::subscribeToNotificationImplementation().

{
    if (!updated)
        return 0;


    memcpy(result, updated, length);
    qMutex()->lock();
    QIBaseDriver *driver = qBufferDriverMap()->value(result);
    qMutex()->unlock();

    // We use an asynchronous call (i.e., queued connection) because the event callback
    // is executed in a different thread than the one in which the driver lives.
    if (driver)
        QMetaObject::invokeMethod(driver, "qHandleEventNotification", Qt::QueuedConnection, Q_ARG(void *, reinterpret_cast<void *>(result)));

    return 0;
}

qFillBufferWithString()

static char* qFillBufferWithString ( char *  buffer, const QString &  string, short  buflen, bool  varying, bool  array, QTextCodec *  tc  )

static

Definition at line 650 of file qsql_ibase.cpp.

Referenced by createArrayBuffer(), and QIBaseResult::exec().

{
    QByteArray str = encodeString(tc, string); // keep a copy of the string alive in this scope
    if (varying) {
        short tmpBuflen = buflen;
        if (str.length() < buflen)
            buflen = str.length();
        if (array) { // interbase stores varying arrayelements different than normal varying elements
            memcpy(buffer, str.data(), buflen);
            memset(buffer + buflen, 0, tmpBuflen - buflen);
        } else {
            *(short*)buffer = buflen; // first two bytes is the length
            memcpy(buffer + sizeof(short), str.data(), buflen);
        }
        buffer += tmpBuflen;
    } else {
        str = str.leftJustified(buflen, ' ', true);
        memcpy(buffer, str.data(), buflen);
        buffer += buflen;
    }
    return buffer;
}

qFreeEventBuffer()

static void qFreeEventBuffer ( QIBaseEventBuffer *  eBuffer )

static

Definition at line 341 of file qsql_ibase.cpp.

Referenced by QIBaseDriver::close(), QIBaseDriver::subscribeToNotificationImplementation(), and QIBaseDriver::unsubscribeFromNotificationImplementation().

{
    qMutex()->lock();
    qBufferDriverMap()->remove(reinterpret_cast<void *>(eBuffer->resultBuffer));
    qMutex()->unlock();
    delete eBuffer;
}

qIBaseTypeName()

static QVariant::Type qIBaseTypeName ( int  iType, bool  hasScale  )

static

Definition at line 167 of file qsql_ibase.cpp.

Referenced by QIBaseDriver::primaryIndex(), QIBaseDriver::record(), and QIBaseResultPrivate::writeArray().

{
    switch (iType) {
    case blr_varying:
    case blr_varying2:
    case blr_text:
    case blr_cstring:
    case blr_cstring2:
        return QVariant::String;
    case blr_sql_time:
        return QVariant::Time;
    case blr_sql_date:
        return QVariant::Date;
    case blr_timestamp:
        return QVariant::DateTime;
    case blr_blob:
        return QVariant::ByteArray;
    case blr_quad:
    case blr_short:
    case blr_long:
        return (hasScale ? QVariant::Double : QVariant::Int);
    case blr_int64:
        return (hasScale ? QVariant::Double : QVariant::LongLong);
    case blr_float:
    case blr_d_float:
    case blr_double:
        return QVariant::Double;
    }
    qWarning("qIBaseTypeName: unknown datatype: %d", iType);
    return QVariant::Invalid;
}

qIBaseTypeName2()

static QVariant::Type qIBaseTypeName2 ( int  iType, bool  hasScale  )

static

Definition at line 199 of file qsql_ibase.cpp.

Referenced by QIBaseResult::gotoNext(), and QIBaseResult::record().

{
    switch(iType & ~1) {
    case SQL_VARYING:
    case SQL_TEXT:
        return QVariant::String;
    case SQL_LONG:
    case SQL_SHORT:
        return (hasScale ? QVariant::Double : QVariant::Int);
    case SQL_INT64:
        return (hasScale ? QVariant::Double : QVariant::LongLong);
    case SQL_FLOAT:
    case SQL_DOUBLE:
        return QVariant::Double;
    case SQL_TIMESTAMP:
        return QVariant::DateTime;
    case SQL_TYPE_TIME:
        return QVariant::Time;
    case SQL_TYPE_DATE:
        return QVariant::Date;
    case SQL_ARRAY:
        return QVariant::List;
    case SQL_BLOB:
        return QVariant::ByteArray;
    default:
        return QVariant::Invalid;
    }
}

readArrayBuffer()

static char* readArrayBuffer ( QList< QVariant > &  list, char *  buffer, short  curDim, short *  numElements, ISC_ARRAY_DESC *  arrayDesc, QTextCodec *  tc  )

static

Definition at line 496 of file qsql_ibase.cpp.

Referenced by QIBaseResultPrivate::fetchArray().

{
    const short dim = arrayDesc->array_desc_dimensions - 1;
    const unsigned char dataType = arrayDesc->array_desc_dtype;
    QList<QVariant> valList;
    unsigned short strLen = arrayDesc->array_desc_length;

    if (curDim != dim) {
        for(int i = 0; i < numElements[curDim]; ++i)
            buffer = readArrayBuffer(list, buffer, curDim + 1, numElements,
                                     arrayDesc, tc);
    } else {
        switch(dataType) {
            case blr_varying:
            case blr_varying2:
                 strLen += 2; // for the two terminating null values
            case blr_text:
            case blr_text2: {
                int o;
                for (int i = 0; i < numElements[dim]; ++i) {
                    for(o = 0; o < strLen && buffer[o]!=0; ++o )
                        ;

                    if (tc)
                        valList.append(tc->toUnicode(buffer, o));
                    else
                        valList.append(QString::fromUtf8(buffer, o));

                    buffer += strLen;
                }
                break; }
            case blr_long:
                valList = toList<long>(&buffer, numElements[dim], static_cast<long *>(0));
                break;
            case blr_short:
                valList = toList<short>(&buffer, numElements[dim]);
                break;
            case blr_int64:
                valList = toList<qint64>(&buffer, numElements[dim]);
                break;
            case blr_float:
                valList = toList<float>(&buffer, numElements[dim]);
                break;
            case blr_double:
                valList = toList<double>(&buffer, numElements[dim]);
                break;
            case blr_timestamp:
                for(int i = 0; i < numElements[dim]; ++i) {
                    valList.append(fromTimeStamp(buffer));
                    buffer += sizeof(ISC_TIMESTAMP);
                }
                break;
            case blr_sql_time:
                for(int i = 0; i < numElements[dim]; ++i) {
                    valList.append(fromTime(buffer));
                    buffer += sizeof(ISC_TIME);
                }
                break;
            case blr_sql_date:
                for(int i = 0; i < numElements[dim]; ++i) {
                    valList.append(fromDate(buffer));
                    buffer += sizeof(ISC_DATE);
                }
                break;
        }
    }
    if (dim > 0)
        list.append(valList);
    else
        list += valList;
    return buffer;
}

toDate()

static ISC_DATE toDate ( const QDate &  t )

static

Definition at line 268 of file qsql_ibase.cpp.

Referenced by createArrayBuffer(), QIBaseResult::exec(), and QVariant::swap().

{
    static const QDate basedate(1858, 11, 17);
    ISC_DATE date;

    date = basedate.daysTo(t);
    return date;
}

toList()

template<typename T >

static QList<QVariant> toList ( char **  buf, int  count, T *  = 0  )

static

Definition at line 472 of file qsql_ibase.cpp.

Referenced by Maemo::appendVariantToDBusMessage(), QEventDispatcherWin32::createInternalHwnd(), operator<<(), QVector< QPoint >::operator<<(), QTreeModel::sortItems(), and QVariant::swap().

{
    QList<QVariant> res;
    for (int i = 0; i < count; ++i) {
        res.append(*(T*)(*buf));
        *buf += sizeof(T);
    }
    return res;
}

toList< long >()

template<>

QList<QVariant> toList< long >	(	char **	buf,
		int	count,
		long *
	)

Definition at line 483 of file qsql_ibase.cpp.

Referenced by readArrayBuffer().

{
    QList<QVariant> res;
    for (int i = 0; i < count; ++i) {
        if (sizeof(int) == sizeof(long))
            res.append(int((*(long*)(*buf))));
        else
            res.append((qint64)(*(long*)(*buf)));
        *buf += sizeof(long);
    }
    return res;
}

toTime()

static ISC_TIME toTime ( const QTime &  t )

static

Definition at line 252 of file qsql_ibase.cpp.

Referenced by createArrayBuffer(), QIBaseResult::exec(), and QVariant::swap().

{
    static const QTime midnight(0, 0, 0, 0);
    return (ISC_TIME)midnight.msecsTo(t) * 10;
}

toTimeStamp()

static ISC_TIMESTAMP toTimeStamp ( const QDateTime &  dt )

static

Definition at line 228 of file qsql_ibase.cpp.

Referenced by createArrayBuffer(), and QIBaseResult::exec().

{
    static const QTime midnight(0, 0, 0, 0);
    static const QDate basedate(1858, 11, 17);
    ISC_TIMESTAMP ts;
    ts.timestamp_time = midnight.msecsTo(dt.time()) * 10;
    ts.timestamp_date = basedate.daysTo(dt.date());
    return ts;
}