IBParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
#include <time.h>       // struct tm
 
#include <ibase.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/SQLCore.h>
#include <dcl/BytesOutputStream.h>
#include <dcl/InputStream.h>
#include <dcl/Charset.h>
 
#include "IBConnection.h"
#include "IBQuery.h"
#include "IBParam.h"
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/IBParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    conn()->setErrorHandle(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(IBParam, SQL::Param)
 
#define __SQLTYPE_IS(_sqltype) ((__sqltype & ~1) == _sqltype)
 
IBParam::IBParam()
    : Param(NULL)
{
    __sqlvar = NULL;
}
 
IBParam::~IBParam()
{
    if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
        __DCL_VERIFY(cancelBlob());
    }
}
 
bool IBParam::init(SQL::Query* _queryHandle, XSQLVAR* _sqlvar)
{
    __DCL_ASSERT(__sqlvar == NULL);
 
    Param::__queryHandle = _queryHandle;
 
    __indicator = -1;
    __sqltype = _sqlvar->sqltype;
 
    __sqlvar = _sqlvar;
    __sqlvar->sqldata = NULL;
    __sqlvar->sqlind = &__indicator;
    __sqlvar->sqlscale = 0;
 
    return true;
}
 
void IBParam::onAfterExecute()
{
    Param::__dataType = SQL::typeUnknown;
    __indicator = -1;   // set null
    __sqlvar->sqldata = NULL;
}
 
// in IBField.cpp
const wchar_t* __dataTypeName(const XSQLVAR* _sqlvar);
 
const wchar_t* IBParam::serverDataTypeName() const
{
    return __dataTypeName(__sqlvar);
}
 
void IBParam::setNull()
{
    if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
        __DCL_VERIFY(cancelBlob());
    }
 
    Param::__dataType = SQL::typeUnknown;
    __indicator = -1;   // set null
    __sqlvar->sqldata = NULL;
}
 
bool IBParam::__setData(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
        if (!cancelBlob())
            return false;
    }
 
    bool r = false;
    switch(_valType) {
        case SQL::typeInteger: {
            r = setInteger(_val, _size);
            break;
        }
        case SQL::typeUInteger: {
            r = setUInteger(_val, _size);
            break;
        }
        case SQL::typeFloat: {
            r = setFloat(_val, _size);
            break;
        }
        case SQL::typeDate: {
            r = setDate((const SQL::Date*)_val, _size);
            break;
        }
        case SQL::typeTime: {
            r = setTime((const SQL::Time*)_val, _size);
            break;
        }
        case SQL::typeTimeStamp: {
            r = setTimeStamp((const SQL::TimeStamp*)_val, _size);
            break;
        }
        case SQL::typeText:
        case SQL::typeBinary: {
            if (__SQLTYPE_IS(SQL_BLOB))
                r = setBytesToBlob((const byte_t*)_val, _size);
            else {
                __sqlvar->sqldata = (char*)_val;
                __sqlvar->sqllen = _size;
                __sqlvar->sqltype = SQL_TEXT + 1;
                r = true;
            }
            break;
        }
        case SQL::typeInputStream: {
            if (__SQLTYPE_IS(SQL_BLOB))
                r = setInputStreamToBlob((_CONST InputStream*)_val, _size);
            else {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
            break;
        }
    //  case SQL::typeInterval:
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        __indicator = 0;
        Param::__dataType = _sqlType;
    }
 
    return r;
}
 
bool IBParam::setInteger(const void* _val, size_t _size)
{
    switch(_size) {
        case sizeof(int16_t): {
            __data.i16 = *(int16_t*)_val;
            __sqlvar->sqllen = sizeof(int16_t);
            __sqlvar->sqltype = SQL_SHORT + 1;
            break;
        }
        case sizeof(int32_t): {
            __data.i32 = *(int32_t*)_val;
            __sqlvar->sqllen = sizeof(int32_t);
            __sqlvar->sqltype = SQL_LONG + 1;
            break;
        }
        case sizeof(int64_t): {
            __data.i64 = *(int64_t*)_val;
            __sqlvar->sqllen = sizeof(int64_t);
            __sqlvar->sqltype = SQL_INT64 + 1;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
    __sqlvar->sqldata = (char*)&__data;
    return true;
}
 
bool IBParam::setUInteger(const void* _val, size_t _size)
{
    switch(_size) {
        case sizeof(uint16_t): {
            __data.i16 = (int16_t) * (uint16_t*)_val;
            __sqlvar->sqllen = sizeof(int16_t);
            __sqlvar->sqltype = SQL_SHORT + 1;
            break;
        }
        case sizeof(uint32_t): {
            __data.i32 = (int32_t) * (uint32_t*)_val;
            __sqlvar->sqllen = sizeof(int32_t);
            __sqlvar->sqltype = SQL_LONG + 1;
            break;
        }
        case sizeof(uint64_t) : {
            __data.i64 = (int64_t) * (uint64_t*)_val;
            __sqlvar->sqllen = sizeof(int64_t);
            __sqlvar->sqltype = SQL_INT64 + 1;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
    __sqlvar->sqldata = (char*)&__data;
    return true;
}
 
bool IBParam::setFloat(const void* _val, size_t _size)
{
    switch(_size) {
        case sizeof(float) : {
            __data.f32 = *(float*)_val;
            __sqlvar->sqllen = sizeof(float);
            __sqlvar->sqltype = SQL_FLOAT + 1;
            break;
        }
        case sizeof(double) : {
            __data.f64 = *(double*)_val;
            __sqlvar->sqllen = sizeof(double);
            __sqlvar->sqltype = SQL_DOUBLE + 1;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
    __sqlvar->sqldata = (char*)&__data;
    return true;
}
 
bool IBParam::setDate(const SQL::Date* _val, size_t _size)
{
    if (_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_year = _val->year - 1900;
    tm.tm_mon = _val->month - 1;
    tm.tm_mday = _val->day;
 
    isc_encode_sql_date(&tm, &__data.date);
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqllen = sizeof(ISC_DATE);
    __sqlvar->sqltype = SQL_TYPE_DATE + 1;
    return true;
}
 
bool IBParam::setTime(const SQL::Time* _val, size_t _size)
{
    if (_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_hour = _val->hour;
    tm.tm_min = _val->min;
    tm.tm_sec = _val->sec;
 
    isc_encode_sql_time(&tm, &__data.time);
    __data.time += _val->frac / 100000;
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqllen = sizeof(ISC_TIME);
    __sqlvar->sqltype = SQL_TYPE_TIME + 1;
#if defined(FIREBIRD_IBASE_H) && FB_API_VER >= 40
    if (_val->tzoff != INT16_MIN) {
        __data.time_tz.time_zone = 0;
        __data.time_tz.ext_offset = _val->tzoff;
        __sqlvar->sqllen = sizeof(ISC_TIME_TZ_EX);
        __sqlvar->sqltype = SQL_TIME_TZ_EX + 1;
    }
#endif
    return true;
}
 
bool IBParam::setTimeStamp(const SQL::TimeStamp* _val, size_t _size)
{
    if (_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_year = _val->year - 1900;
    tm.tm_mon = _val->month - 1;
    tm.tm_mday = _val->day;
    tm.tm_hour = _val->hour;
    tm.tm_min = _val->min;
    tm.tm_sec = _val->sec;
 
    isc_encode_timestamp(&tm, &__data.ts);
    __data.ts.timestamp_time += _val->frac / 100000;
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqllen = sizeof(ISC_TIMESTAMP);
    __sqlvar->sqltype = SQL_TIMESTAMP + 1;
#if defined(FIREBIRD_IBASE_H) && FB_API_VER >= 40
    if (_val->tzoff != INT16_MIN) {
        __data.ts_tz.time_zone = 0;
        __data.ts_tz.ext_offset = _val->tzoff;
        __sqlvar->sqllen = sizeof(ISC_TIMESTAMP_TZ_EX);
        __sqlvar->sqltype = SQL_TIMESTAMP_TZ_EX + 1;
    }
#endif
    return true;
}
 
inline size_t __MIN(size_t x, size_t y)
{
    return x < y ? x : y;
}
 
bool IBParam::setBytesToBlob(const byte_t* _val, size_t _size)
{
    isc_blob_handle hBlob = NULL_HANDLE;
    if(isc_create_blob2(
        conn()->statusVector(),
        conn()->dbHandlePtr(),
        conn()->trHandlePtr(),
        &hBlob,
        &__data.blob_id,
        0,
        NULL
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    size_t nTotal = 0;
    size_t nBytes = 0;
    while(nTotal < _size) {
        nBytes = __MIN(_size - nTotal, USHRT_MAX);     
        if (isc_put_segment(
            conn()->statusVector(),
            &hBlob,
            nBytes,
            (char*)_val
        )) {
            __SET_ERROR(SQL::eServerError);
            ISC_STATUS status2[ISC_STATUS_VECTOR_LENGTH];
            isc_close_blob(status2, &hBlob);
            return false;
        }
 
        nTotal += nBytes;
        _val += nBytes;
    }
 
    if (isc_close_blob(conn()->statusVector(), &hBlob)) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    __sqlvar->sqldata = (char*)&__data.blob_id;
    __sqlvar->sqllen = sizeof(ISC_QUAD);
    __sqlvar->sqltype = SQL_BLOB + 1;
    return true;
}
 
bool IBParam::setInputStreamToBlob(_CONST InputStream* _input, size_t _size)
{
    isc_blob_handle hBlob = NULL_HANDLE;
    if(isc_create_blob2(
        conn()->statusVector(),
        conn()->dbHandlePtr(),
        conn()->trHandlePtr(),
        &hBlob,
        &__data.blob_id,
        0,
        NULL
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    char* _pbuf = (char*)malloc(USHRT_MAX);
    if (!_pbuf) {
        __SET_ERROR(SQL::eOutOfMemory);
        ISC_STATUS status2[ISC_STATUS_VECTOR_LENGTH];
        isc_close_blob(status2, &hBlob);
        return false;
    }
 
    try {
        size_t nTotal = 0;
        size_t nBytes = 0;
        for (; ; ) {
            nBytes = __MIN(_size - nTotal, USHRT_MAX);
            if (nBytes && (nBytes = _input->read(_pbuf, nBytes))) {
                if (isc_put_segment(
                    conn()->statusVector(),
                    &hBlob,
                    nBytes,
                    _pbuf
                )) {
                    __SET_ERROR(SQL::eServerError);
                    free(_pbuf);
                    ISC_STATUS status2[ISC_STATUS_VECTOR_LENGTH];
                    isc_close_blob(status2, &hBlob);
                    return false;
                }
                nTotal += nBytes;
            }
            else {
                // done
                break;
            }
        }
    }
    catch (IOException* e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
        e->destroy();
        free(_pbuf);
        ISC_STATUS status2[ISC_STATUS_VECTOR_LENGTH];
        isc_close_blob(status2, &hBlob);
        return false;
    }
 
    free(_pbuf);
 
    if (isc_close_blob(conn()->statusVector(), &hBlob)) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    __sqlvar->sqldata = (char*)&__data.blob_id;
    __sqlvar->sqllen = sizeof(ISC_QUAD);
    __sqlvar->sqltype = SQL_BLOB + 1;
    return true;
}
 
bool IBParam::cancelBlob()
{
//  __DCL_ASSERT(__indicator == 0 && __SQLTYPE_IS(SQL_BLOB));
    isc_blob_handle hBlob = NULL_HANDLE;
 
    if(isc_open_blob2(
        conn()->statusVector(),
        conn()->dbHandlePtr(),
        conn()->trHandlePtr(),
        &hBlob,
        &__data.blob_id,
        0,
        NULL
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    if (isc_cancel_blob(
        conn()->statusVector(),
        &hBlob
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    return true;
}
 
__DCL_END_NAMESPACE