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 wchar_t __THIS_FILE__[] = __T("dcl/sql/IBParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
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* _pv,
        size_t _size,
        SQL::DataType _dataType,
        SQL::DataType _assignType
        )
{
    if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
        if (!cancelBlob())
            return false;
    }
 
    bool r = false;
    switch(_dataType) {
        case SQL::typeInteger: {
            r = setInteger(_pv, _size);
            break;
        }
        case SQL::typeUInteger: {
            r = setUInteger(_pv, _size);
            break;
        }
        case SQL::typeFloat: {
            r = setFloat(_pv, _size);
            break;
        }
        case SQL::typeDate: {
            r = setDate((const SQL::Date*)_pv, _size);
            break;
        }
        case SQL::typeTime: {
            r = setTime((const SQL::Time*)_pv, _size);
            break;
        }
        case SQL::typeTimeStamp: {
            r = setTimeStamp((const SQL::TimeStamp*)_pv, _size);
            break;
        }
        case SQL::typeText :
        case SQL::typeBinary :
        case SQL::typeLongText :
        case SQL::typeLongBinary: {
            if (__SQLTYPE_IS(SQL_BLOB))
                r = setBytesToBlob((const byte_t*)_pv, _size);
            else {
                __sqlvar->sqldata = (char*)_pv;
                __sqlvar->sqllen = _size;
                __sqlvar->sqltype = SQL_TEXT + 1;
                r = true;
            }
            break;
        }
        case SQL::typeInputStream: {
            if (__SQLTYPE_IS(SQL_BLOB))
                r = setInputStreamToBlob((_CONST InputStream*)_pv, _size);
            else {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
            break;
        }
    //  case SQL::typeTimeStampTz :
    //  case SQL::typeInterva
    //  case SQL::typeIntervalYm :
    //  case SQL::typeIntervalDs :
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        __indicator = 0;
        Param::__dataType = _dataType;
    }
 
    return r;
}
 
bool IBParam::setInteger(const void* _pv, size_t _size)
{
    switch(_size) {
        case sizeof(int16_t): {
            __data.i16 = *(int16_t*)_pv;
            __sqlvar->sqllen = sizeof(int16_t);
            __sqlvar->sqltype = SQL_SHORT + 1;
            break;
        }
        case sizeof(int32_t): {
            __data.i32 = *(int32_t*)_pv;
            __sqlvar->sqllen = sizeof(int32_t);
            __sqlvar->sqltype = SQL_LONG + 1;
            break;
        }
        case sizeof(int64_t): {
            __data.i64 = *(int64_t*)_pv;
            __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* _pv, size_t _size)
{
    switch(_size) {
        case sizeof(uint16_t): {
            __data.i16 = (int16_t) * (uint16_t*)_pv;
            __sqlvar->sqllen = sizeof(int16_t);
            __sqlvar->sqltype = SQL_SHORT + 1;
            break;
        }
        case sizeof(uint32_t): {
            __data.i32 = (int32_t) * (uint32_t*)_pv;
            __sqlvar->sqllen = sizeof(int32_t);
            __sqlvar->sqltype = SQL_LONG + 1;
            break;
        }
        case sizeof(uint64_t) : {
            __data.i64 = (int64_t) * (uint64_t*)_pv;
            __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* _pv, size_t _size)
{
    switch(_size) {
        case sizeof(float) : {
            __data.f32 = *(float*)_pv;
            __sqlvar->sqllen = sizeof(float);
            __sqlvar->sqltype = SQL_FLOAT + 1;
            break;
        }
        case sizeof(double) : {
            __data.f64 = *(double*)_pv;
            __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* p, size_t _size)
{
    if (_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_year = p->nYear - 1900;
    tm.tm_mon = p->nMonth - 1;
    tm.tm_mday = p->nDay;
 
    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* p, size_t _size)
{
    if (_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_hour = p->nHour;
    tm.tm_min = p->nMin;
    tm.tm_sec = p->nSec;
 
    isc_encode_sql_time(&tm, &__data.time);
    __data.time += p->nFrac / 100000;
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqllen = sizeof(ISC_TIME);
    __sqlvar->sqltype = SQL_TYPE_TIME + 1;
    return true;
}
 
bool IBParam::setTimeStamp(const SQL::TimeStamp* p, size_t _size)
{
    if (_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    struct tm tm;
    tm.tm_year = p->nYear - 1900;
    tm.tm_mon = p->nMonth - 1;
    tm.tm_mday = p->nDay;
    tm.tm_hour = p->nHour;
    tm.tm_min = p->nMin;
    tm.tm_sec = p->nSec;
 
    isc_encode_timestamp(&tm, &__data.ts);
    __data.ts.timestamp_time += p->nFrac / 100000;
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqllen = sizeof(ISC_TIMESTAMP);
    __sqlvar->sqltype = SQL_TIMESTAMP + 1;
    return true;
}
 
inline size_t __MIN(size_t x, size_t y)
{
    return x < y ? x : y;
}
 
bool IBParam::setBytesToBlob(const byte_t* p, size_t _size)
{
    IBConnection* connHandle = (IBConnection*)Param::connection();
    ISC_STATUS* statusVector = connHandle->statusVector();
    isc_blob_handle hBlob = NULL;
 
    if(isc_create_blob2(
            statusVector,
            connHandle->dbHandlePtr(),
            connHandle->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(
                statusVector,
                &hBlob,
                nBytes,
                (char*)p
                )) {
            __SET_ERROR(SQL::eServerError);
            ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
            isc_close_blob(statusVector, &hBlob);
            return false;
        }
 
        nTotal += nBytes;
        p += nBytes;
    }
    
    if (isc_close_blob(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* pInput, size_t _size)
{
    IBConnection* connHandle = (IBConnection*)Param::connection();
    ISC_STATUS* statusVector = connHandle->statusVector();
    isc_blob_handle hBlob = NULL;
 
    if(isc_create_blob2(
            statusVector,
            connHandle->dbHandlePtr(),
            connHandle->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 statusVector[ISC_STATUS_VECTOR_LENGTH];
        isc_close_blob(statusVector, &hBlob);
        return false;
    }
    
    try {
        size_t nTotal = 0;
        size_t nBytes = 0;
        for (; ; ) {
            nBytes = __MIN(_size - nTotal, USHRT_MAX);
            if (nBytes && (nBytes = pInput->read(_pbuf, nBytes))) {
                if (isc_put_segment(
                        statusVector,
                        &hBlob,
                        nBytes,
                        _pbuf
                        )) {
                    __SET_ERROR(SQL::eServerError);
                    free(_pbuf);
                    ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
                    isc_close_blob(statusVector, &hBlob);
                    return false;
                }
 
                nTotal += nBytes;
            }
            else {
                // done
                break;
            }
        }
    }
    catch (IOException* e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
        e->destroy();
        free(_pbuf);
        ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
        isc_close_blob(statusVector, &hBlob);
        return false;
    }
 
    free(_pbuf);
 
    if (isc_close_blob(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));
 
    IBConnection* connHandle = (IBConnection*)Param::connection();
    ISC_STATUS* statusVector = connHandle->statusVector();
    isc_blob_handle hBlob = NULL;
 
    if(isc_open_blob2(
            statusVector,
            connHandle->dbHandlePtr(),
            connHandle->trHandlePtr(),
            &hBlob,
            &__data.blob_id,
            0,
            NULL)) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
    
    if (isc_cancel_blob(
            statusVector,
            &hBlob
            )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    return true;
}
 
__DCL_END_NAMESPACE