qsql_odbc.cpp File Reference

#include "qsql_odbc.h"
#include <qsqlrecord.h>
#include <qcoreapplication.h>
#include <qvariant.h>
#include <qdatetime.h>
#include <qsqlerror.h>
#include <qsqlfield.h>
#include <qsqlindex.h>
#include <qstringlist.h>
#include <qvarlengtharray.h>
#include <qvector.h>
#include <qmath.h>
#include <QDebug>
#include <QSqlQuery>

Go to the source code of this file.

Classes
class	QODBCDriverPrivate
class	QODBCPrivate

Macros
#define	ODBC_CHECK_DRIVER

Functions
static QString	fromSQLTCHAR (const QVarLengthArray< SQLTCHAR > &input, int size=-1)
template<class T >
static QVariant::Type	qDecodeODBCType (SQLSMALLINT sqltype, const T *p, bool isSigned=true)
static QVariant	qGetBigIntData (SQLHANDLE hStmt, int column, bool isSigned=true)
static QVariant	qGetBinaryData (SQLHANDLE hStmt, int column)
static QVariant	qGetDoubleData (SQLHANDLE hStmt, int column)
static QVariant	qGetIntData (SQLHANDLE hStmt, int column, bool isSigned=true)
static int	qGetODBCVersion (const QString &connOpts)
static QString	qGetStringData (SQLHANDLE hStmt, int column, int colSize, bool unicode=false)
static QSqlError	qMakeError (const QString &err, QSqlError::ErrorType type, const QODBCPrivate *p)
static QSqlError	qMakeError (const QString &err, QSqlError::ErrorType type, const QODBCDriverPrivate *p)
static QSqlField	qMakeFieldInfo (const SQLHANDLE hStmt, const QODBCDriverPrivate *p)
static QSqlField	qMakeFieldInfo (const QODBCPrivate *p, int i)
static QString	qODBCWarn (const QODBCPrivate *odbc, int *nativeCode=0)
static QString	qODBCWarn (const QODBCDriverPrivate *odbc, int *nativeCode=0)
static void	qSqlWarning (const QString &message, const QODBCPrivate *odbc)
static void	qSqlWarning (const QString &message, const QODBCDriverPrivate *odbc)
static QString	qWarnODBCHandle (int handleType, SQLHANDLE handle, int *nativeCode=0)
static QVarLengthArray< SQLTCHAR >	toSQLTCHAR (const QString &input)

Variables
static const int	COLNAMESIZE = 256
static const SQLSMALLINT	qParamType [4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT }

Macro Definition Documentation

ODBC_CHECK_DRIVER

#define ODBC_CHECK_DRIVER

Definition at line 64 of file qsql_odbc.cpp.

Function Documentation

fromSQLTCHAR()

static QString fromSQLTCHAR ( const QVarLengthArray< SQLTCHAR > &  input, int  size = -1  )

inlinestatic

Definition at line 70 of file qsql_odbc.cpp.

Referenced by QODBCDriver::cleanup(), QODBCResult::exec(), qGetStringData(), qMakeFieldInfo(), and qWarnODBCHandle().

{
    QString result;

    int realsize = qMin(size, input.size());
    if(realsize > 0 && input[realsize-1] == 0)
        realsize--;
    switch(sizeof(SQLTCHAR)) {
        case 1:
            result=QString::fromUtf8((const char *)input.constData(), realsize);
            break;
        case 2:
            result=QString::fromUtf16((const ushort *)input.constData(), realsize);
            break;
        case 4:
            result=QString::fromUcs4((const uint *)input.constData(), realsize);
            break;
        default:
            qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";
    }
    return result;
}

qDecodeODBCType()

template<class T >

static QVariant::Type qDecodeODBCType ( SQLSMALLINT  sqltype, const T *  p, bool  isSigned = true  )

static

Definition at line 293 of file qsql_odbc.cpp.

Referenced by qMakeFieldInfo().

{
    Q_UNUSED(p);
    QVariant::Type type = QVariant::Invalid;
    switch (sqltype) {
    case SQL_DECIMAL:
    case SQL_NUMERIC:
    case SQL_REAL:
    case SQL_FLOAT:
    case SQL_DOUBLE:
        type = QVariant::Double;
        break;
    case SQL_SMALLINT:
    case SQL_INTEGER:
    case SQL_BIT:
        type = isSigned ? QVariant::Int : QVariant::UInt;
        break;
    case SQL_TINYINT:
        type = QVariant::UInt;
        break;
    case SQL_BIGINT:
        type = isSigned ? QVariant::LongLong : QVariant::ULongLong;
        break;
    case SQL_BINARY:
    case SQL_VARBINARY:
    case SQL_LONGVARBINARY:
        type = QVariant::ByteArray;
        break;
    case SQL_DATE:
    case SQL_TYPE_DATE:
        type = QVariant::Date;
        break;
    case SQL_TIME:
    case SQL_TYPE_TIME:
        type = QVariant::Time;
        break;
    case SQL_TIMESTAMP:
    case SQL_TYPE_TIMESTAMP:
        type = QVariant::DateTime;
        break;
    case SQL_WCHAR:
    case SQL_WVARCHAR:
    case SQL_WLONGVARCHAR:
        type = QVariant::String;
        break;
    case SQL_CHAR:
    case SQL_VARCHAR:
#if (ODBCVER >= 0x0350)
    case SQL_GUID:
#endif
    case SQL_LONGVARCHAR:
        type = QVariant::String;
        break;
    default:
        type = QVariant::ByteArray;
        break;
    }
    return type;
}

qGetBigIntData()

static QVariant qGetBigIntData ( SQLHANDLE  hStmt, int  column, bool  isSigned = true  )

static

Definition at line 551 of file qsql_odbc.cpp.

Referenced by QODBCResult::data().

{
    SQLBIGINT lngbuf = 0;
    SQLLEN lengthIndicator = 0;
    SQLRETURN r = SQLGetData(hStmt,
                              column+1,
                              isSigned ? SQL_C_SBIGINT : SQL_C_UBIGINT,
                              (SQLPOINTER) &lngbuf,
                              sizeof(lngbuf),
                              &lengthIndicator);
    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
        return QVariant(QVariant::Invalid);
    if (lengthIndicator == SQL_NULL_DATA)
        return QVariant(QVariant::LongLong);

    if (isSigned)
        return qint64(lngbuf);
    else
        return quint64(lngbuf);
}

qGetBinaryData()

static QVariant qGetBinaryData ( SQLHANDLE  hStmt, int  column  )

static

Definition at line 454 of file qsql_odbc.cpp.

Referenced by QODBCResult::data().

{
    QByteArray fieldVal;
    SQLSMALLINT colNameLen;
    SQLSMALLINT colType;
    SQLULEN colSize;
    SQLSMALLINT colScale;
    SQLSMALLINT nullable;
    SQLLEN lengthIndicator = 0;
    SQLRETURN r = SQL_ERROR;

    QVarLengthArray<SQLTCHAR> colName(COLNAMESIZE);

    r = SQLDescribeCol(hStmt,
                       column + 1,
                       colName.data(),
                       COLNAMESIZE,
                       &colNameLen,
                       &colType,
                       &colSize,
                       &colScale,
                       &nullable);
    if (r != SQL_SUCCESS)
        qWarning() << "qGetBinaryData: Unable to describe column" << column;
    // SQLDescribeCol may return 0 if size cannot be determined
    if (!colSize)
        colSize = 255;
    else if (colSize > 65536) // read the field in 64 KB chunks
        colSize = 65536;
    fieldVal.resize(colSize);
    ulong read = 0;
    while (true) {
        r = SQLGetData(hStmt,
                        column+1,
                        SQL_C_BINARY,
                        (SQLPOINTER)(fieldVal.constData() + read),
                        colSize,
                        &lengthIndicator);
        if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
            break;
        if (lengthIndicator == SQL_NULL_DATA)
            return QVariant(QVariant::ByteArray);
        if (lengthIndicator > SQLLEN(colSize) || lengthIndicator == SQL_NO_TOTAL) {
            read += colSize;
            colSize = 65536;
        } else {
            read += lengthIndicator;
        }
        if (r == SQL_SUCCESS) { // the whole field was read in one chunk
            fieldVal.resize(read);
            break;
        }
        fieldVal.resize(fieldVal.size() + colSize);
    }
    return fieldVal;
}

qGetDoubleData()

static QVariant qGetDoubleData ( SQLHANDLE  hStmt, int  column  )

static

Definition at line 531 of file qsql_odbc.cpp.

Referenced by QODBCResult::data().

{
    SQLDOUBLE dblbuf;
    SQLLEN lengthIndicator = 0;
    SQLRETURN r = SQLGetData(hStmt,
                              column+1,
                              SQL_C_DOUBLE,
                              (SQLPOINTER) &dblbuf,
                              0,
                              &lengthIndicator);
    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
        return QVariant(QVariant::Invalid);
    }
    if(lengthIndicator == SQL_NULL_DATA)
        return QVariant(QVariant::Double);

    return (double) dblbuf;
}

qGetIntData()

static QVariant qGetIntData ( SQLHANDLE  hStmt, int  column, bool  isSigned = true  )

static

Definition at line 511 of file qsql_odbc.cpp.

Referenced by QODBCResult::data(), and qMakeFieldInfo().

{
    SQLINTEGER intbuf = 0;
    SQLLEN lengthIndicator = 0;
    SQLRETURN r = SQLGetData(hStmt,
                              column+1,
                              isSigned ? SQL_C_SLONG : SQL_C_ULONG,
                              (SQLPOINTER)&intbuf,
                              sizeof(intbuf),
                              &lengthIndicator);
    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
        return QVariant(QVariant::Invalid);
    if (lengthIndicator == SQL_NULL_DATA)
        return QVariant(QVariant::Int);
    if (isSigned)
        return int(intbuf);
    else
        return uint(intbuf);
}

qGetODBCVersion()

static int qGetODBCVersion ( const QString &  connOpts )

static

Definition at line 655 of file qsql_odbc.cpp.

Referenced by QODBCDriver::open().

{
    if (connOpts.contains(QLatin1String("SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC3"), Qt::CaseInsensitive))
        return SQL_OV_ODBC3;
    return SQL_OV_ODBC2;
}

qGetStringData()

static QString qGetStringData ( SQLHANDLE  hStmt, int  column, int  colSize, bool  unicode = false  )

static

Definition at line 353 of file qsql_odbc.cpp.

Referenced by QODBCResult::data(), QODBCDriver::primaryIndex(), qMakeFieldInfo(), and QODBCDriver::tables().

{
    QString fieldVal;
    SQLRETURN r = SQL_ERROR;
    SQLLEN lengthIndicator = 0;

    // NB! colSize must be a multiple of 2 for unicode enabled DBs
    if (colSize <= 0) {
        colSize = 256;
    } else if (colSize > 65536) { // limit buffer size to 64 KB
        colSize = 65536;
    } else {
        colSize++; // make sure there is room for more than the 0 termination
    }
    if(unicode) {
        r = SQLGetData(hStmt,
                        column+1,
                        SQL_C_TCHAR,
                        NULL,
                        0,
                        &lengthIndicator);
        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)
            colSize = lengthIndicator/sizeof(SQLTCHAR) + 1;
        QVarLengthArray<SQLTCHAR> buf(colSize);
        memset(buf.data(), 0, colSize*sizeof(SQLTCHAR));
        while (true) {
            r = SQLGetData(hStmt,
                            column+1,
                            SQL_C_TCHAR,
                            (SQLPOINTER)buf.data(),
                            colSize*sizeof(SQLTCHAR),
                            &lengthIndicator);
            if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {
                if (lengthIndicator == SQL_NULL_DATA || lengthIndicator == SQL_NO_TOTAL) {
                    fieldVal.clear();
                    break;
                }
                // if SQL_SUCCESS_WITH_INFO is returned, indicating that
                // more data can be fetched, the length indicator does NOT
                // contain the number of bytes returned - it contains the
                // total number of bytes that CAN be fetched
                // colSize-1: remove 0 termination when there is more data to fetch
                int rSize = (r == SQL_SUCCESS_WITH_INFO) ? colSize : lengthIndicator/sizeof(SQLTCHAR);
                    fieldVal += fromSQLTCHAR(buf, rSize);
                if (lengthIndicator < SQLLEN(colSize*sizeof(SQLTCHAR))) {
                    // workaround for Drivermanagers that don't return SQL_NO_DATA
                    break;
                }
            } else if (r == SQL_NO_DATA) {
                break;
            } else {
                qWarning() << "qGetStringData: Error while fetching data (" << qWarnODBCHandle(SQL_HANDLE_STMT, hStmt) << ')';
                fieldVal.clear();
                break;
            }
        }
    } else {
        r = SQLGetData(hStmt,
                        column+1,
                        SQL_C_CHAR,
                        NULL,
                        0,
                        &lengthIndicator);
        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)
            colSize = lengthIndicator + 1;
        QVarLengthArray<SQLCHAR> buf(colSize);
        while (true) {
            r = SQLGetData(hStmt,
                            column+1,
                            SQL_C_CHAR,
                            (SQLPOINTER)buf.data(),
                            colSize,
                            &lengthIndicator);
            if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {
                if (lengthIndicator == SQL_NULL_DATA || lengthIndicator == SQL_NO_TOTAL) {
                    fieldVal.clear();
                    break;
                }
                // if SQL_SUCCESS_WITH_INFO is returned, indicating that
                // more data can be fetched, the length indicator does NOT
                // contain the number of bytes returned - it contains the
                // total number of bytes that CAN be fetched
                // colSize-1: remove 0 termination when there is more data to fetch
                int rSize = (r == SQL_SUCCESS_WITH_INFO) ? colSize : lengthIndicator;
                    fieldVal += QString::fromUtf8((const char *)buf.constData(), rSize);
                if (lengthIndicator < SQLLEN(colSize)) {
                    // workaround for Drivermanagers that don't return SQL_NO_DATA
                    break;
                }
            } else if (r == SQL_NO_DATA) {
                break;
            } else {
                qWarning() << "qGetStringData: Error while fetching data (" << qWarnODBCHandle(SQL_HANDLE_STMT, hStmt) << ')';
                fieldVal.clear();
                break;
            }
        }
    }
    return fieldVal;
}

qMakeError() [1/2]

static QSqlError qMakeError ( const QString &  err, QSqlError::ErrorType  type, const QODBCPrivate *  p  )

static

Definition at line 277 of file qsql_odbc.cpp.

Referenced by QODBCDriver::beginTransaction(), QODBCDriver::commitTransaction(), QODBCDriver::endTrans(), QODBCResult::exec(), QODBCResult::fetch(), QODBCResult::fetchFirst(), QODBCResult::fetchLast(), QODBCResult::fetchNext(), QODBCResult::fetchPrevious(), QODBCResult::nextResult(), QODBCDriver::open(), QODBCResult::prepare(), QODBCResult::reset(), and QODBCDriver::rollbackTransaction().

{
    int nativeCode = -1;
    QString message = qODBCWarn(p, &nativeCode);
    return QSqlError(QLatin1String("QODBC3: ") + err, message, type, nativeCode);
}

qMakeError() [2/2]

static QSqlError qMakeError ( const QString &  err, QSqlError::ErrorType  type, const QODBCDriverPrivate *  p  )

static

Definition at line 284 of file qsql_odbc.cpp.

{
    int nativeCode = -1;
    QString message = qODBCWarn(p, &nativeCode);
    return QSqlError(QLatin1String("QODBC3: ") + err, qODBCWarn(p), type, nativeCode);
}

qMakeFieldInfo() [1/2]

static QSqlField qMakeFieldInfo ( const SQLHANDLE  hStmt, const QODBCDriverPrivate *  p  )

static

Definition at line 574 of file qsql_odbc.cpp.

Referenced by QODBCResult::exec(), QODBCResult::nextResult(), QODBCDriver::record(), and QODBCResult::reset().

{
    QString fname = qGetStringData(hStmt, 3, -1, p->unicode);
    int type = qGetIntData(hStmt, 4).toInt(); // column type
    QSqlField f(fname, qDecodeODBCType(type, p));
    int required = qGetIntData(hStmt, 10).toInt(); // nullable-flag
    // required can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN
    if (required == SQL_NO_NULLS)
        f.setRequired(true);
    else if (required == SQL_NULLABLE)
        f.setRequired(false);
    // else we don't know
    QVariant var = qGetIntData(hStmt, 6);
    f.setLength(var.isNull() ? -1 : var.toInt()); // column size
    var = qGetIntData(hStmt, 8).toInt();
    f.setPrecision(var.isNull() ? -1 : var.toInt()); // precision
    f.setSqlType(type);
    return f;
}

qMakeFieldInfo() [2/2]

static QSqlField qMakeFieldInfo ( const QODBCPrivate *  p, int  i  )

static

Definition at line 594 of file qsql_odbc.cpp.

{
    SQLSMALLINT colNameLen;
    SQLSMALLINT colType;
    SQLULEN colSize;
    SQLSMALLINT colScale;
    SQLSMALLINT nullable;
    SQLRETURN r = SQL_ERROR;
    QVarLengthArray<SQLTCHAR> colName(COLNAMESIZE);
    r = SQLDescribeCol(p->hStmt,
                        i+1,
                        colName.data(),
                        (SQLSMALLINT)COLNAMESIZE,
                        &colNameLen,
                        &colType,
                        &colSize,
                        &colScale,
                        &nullable);

    if (r != SQL_SUCCESS) {
        qSqlWarning(QString::fromLatin1("qMakeField: Unable to describe column %1").arg(i), p);
        return QSqlField();
    }

    SQLLEN unsignedFlag = SQL_FALSE;
    r = SQLColAttribute (p->hStmt,
                         i + 1,
                         SQL_DESC_UNSIGNED,
                         0,
                         0,
                         0,
                         &unsignedFlag);
    if (r != SQL_SUCCESS) {
        qSqlWarning(QString::fromLatin1("qMakeField: Unable to get column attributes for column %1").arg(i), p);
    }

#ifdef UNICODE
    QString qColName(fromSQLTCHAR(colName, colNameLen));
#else
    QString qColName = QString::fromUtf8((const char *)colName.constData());
#endif
    // nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN
    int required = -1;
    if (nullable == SQL_NO_NULLS) {
        required = 1;
    } else if (nullable == SQL_NULLABLE) {
        required = 0;
    }
    QVariant::Type type = qDecodeODBCType(colType, p, unsignedFlag == SQL_FALSE);
    QSqlField f(qColName, type);
    f.setSqlType(colType);
    f.setLength(colSize == 0 ? -1 : int(colSize));
    f.setPrecision(colScale == 0 ? -1 : int(colScale));
    if (nullable == SQL_NO_NULLS)
        f.setRequired(true);
    else if (nullable == SQL_NULLABLE)
        f.setRequired(false);
    // else we don't know
    return f;
}

qODBCWarn() [1/2]

static QString qODBCWarn ( const QODBCPrivate *  odbc, int *  nativeCode = 0  )

static

Definition at line 254 of file qsql_odbc.cpp.

Referenced by QODBCResult::exec(), QODBCResult::nextResult(), qMakeError(), and qSqlWarning().

{
    return QString(qWarnODBCHandle(SQL_HANDLE_ENV, odbc->dpEnv()) + QLatin1Char(' ')
             + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->dpDbc()) + QLatin1Char(' ')
             + qWarnODBCHandle(SQL_HANDLE_STMT, odbc->hStmt, nativeCode)).simplified();
}

qODBCWarn() [2/2]

static QString qODBCWarn ( const QODBCDriverPrivate *  odbc, int *  nativeCode = 0  )

static

Definition at line 261 of file qsql_odbc.cpp.

{
    return QString(qWarnODBCHandle(SQL_HANDLE_ENV, odbc->hEnv) + QLatin1Char(' ')
             + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->hDbc, nativeCode)).simplified();
}

qSqlWarning() [1/2]

static void qSqlWarning ( const QString &  message, const QODBCPrivate *  odbc  )

static

Definition at line 267 of file qsql_odbc.cpp.

Referenced by QODBCDriver::cleanup(), QODBCResult::exec(), QODBCResult::numRowsAffected(), QODBCDriver::open(), QODBCResult::prepare(), QODBCDriver::primaryIndex(), qGetODBCVersion(), qMakeFieldInfo(), QODBCDriver::record(), QODBCResult::reset(), QODBCDriver::tables(), and QODBCResult::~QODBCResult().

{
    qWarning() << message << "\tError:" << qODBCWarn(odbc);
}

qSqlWarning() [2/2]

static void qSqlWarning ( const QString &  message, const QODBCDriverPrivate *  odbc  )

static

Definition at line 272 of file qsql_odbc.cpp.

{
    qWarning() << message << "\tError:" << qODBCWarn(odbc);
}

qWarnODBCHandle()

static QString qWarnODBCHandle ( int  handleType, SQLHANDLE  handle, int *  nativeCode = 0  )

static

Definition at line 202 of file qsql_odbc.cpp.

Referenced by qGetStringData(), qODBCWarn(), and QODBCDriver::tables().

{
    SQLINTEGER nativeCode_ = 0;
    SQLSMALLINT msgLen = 0;
    SQLRETURN r = SQL_NO_DATA;
    SQLTCHAR state_[SQL_SQLSTATE_SIZE+1];
    QVarLengthArray<SQLTCHAR> description_(SQL_MAX_MESSAGE_LENGTH);
    QString result;
    int i = 1;

    description_[0] = 0;
    do {
        r = SQLGetDiagRec(handleType,
                          handle,
                          i,
                          state_,
                          &nativeCode_,
                          0,
                          0,
                          &msgLen);
        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && msgLen > 0)
            description_.resize(msgLen+1);
        r = SQLGetDiagRec(handleType,
                            handle,
                            i,
                            state_,
                            &nativeCode_,
                            description_.data(),
                            description_.size(),
                            &msgLen);
        if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {
            if (nativeCode)
                *nativeCode = nativeCode_;
            QString tmpstore;
#ifdef UNICODE
            tmpstore = fromSQLTCHAR(description_, msgLen);
#else
            tmpstore = QString::fromUtf8((const char*)description_.constData(), msgLen);
#endif
            if(result != tmpstore) {
                if(!result.isEmpty())
                    result += QLatin1Char(' ');
                result += tmpstore;
            }
        } else if (r == SQL_ERROR || r == SQL_INVALID_HANDLE) {
            return result;
        }
        ++i;
    } while (r != SQL_NO_DATA);
    return result;
}

toSQLTCHAR()

static QVarLengthArray<SQLTCHAR> toSQLTCHAR ( const QString &  input )

inlinestatic

Definition at line 93 of file qsql_odbc.cpp.

Referenced by QODBCDriver::cleanup(), QODBCResult::exec(), QODBCDriver::open(), QODBCResult::prepare(), QODBCDriver::primaryIndex(), qGetODBCVersion(), QODBCDriver::record(), QODBCResult::reset(), and QODBCDriver::tables().

{
    QVarLengthArray<SQLTCHAR> result;
    result.resize(input.size());
    switch(sizeof(SQLTCHAR)) {
        case 1:
            memcpy(result.data(), input.toUtf8().data(), input.size());
            break;
        case 2:
            memcpy(result.data(), input.unicode(), input.size() * 2);
            break;
        case 4:
            memcpy(result.data(), input.toUcs4().data(), input.size() * 4);
            break;
        default:
            qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";
    }
    result.append(0); // make sure it's null terminated, doesn't matter if it already is, it does if it isn't.
    return result;
}

Variable Documentation

COLNAMESIZE

const int COLNAMESIZE = 256

static

Definition at line 66 of file qsql_odbc.cpp.

Referenced by qGetBinaryData(), and qMakeFieldInfo().

qParamType

const SQLSMALLINT qParamType[4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT }

static

Definition at line 68 of file qsql_odbc.cpp.

Referenced by QODBCResult::exec().