SqParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <sqlite3.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/DateTime.h>
#include <dcl/InputStream.h>
#include <dcl/Files.h>
#include <dcl/SQLCore.h>
 
#include "SqConnection.h"
#include "SqQuery.h"
#include "SqParam.h"
#include "SqTypes.h"
 
#define __TRACE_THIS    0
#if __TRACE_THIS
#define __DCL_TRACE0_N  __DCL_TRACE0
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#define __DCL_TRACE4_N  __DCL_TRACE4
#else
#define __DCL_TRACE0_N(fmt)
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/SqParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    connection()->setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_message) \
    conn()->setErrorMessage(_message, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SqParam, SQL::Param)
 
SqParam::SqParam() : Param(NULL)
{
    __number = -1;
    __type = SQLITE_NULL;
}
 
SqParam::~SqParam()
{
}
 
bool SqParam::init(SQL::Query* _queryHandle, int _number, const char* _name)
{
    __DCL_ASSERT(Param::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL);
 
    Param::__queryHandle = _queryHandle;
 
    __number = _number;
    __name.assign(_name);
 
    return true;
}
 
bool SqParam::onBeforeExecute()
{
    int rc = SQLITE_OK;
    switch (__type) {
        case SQLITE_INTEGER: {
            rc = sqlite3_bind_int64(query()->stmt(), __number, __data.n);
            break;
        }
        case SQLITE_FLOAT: {
            rc = sqlite3_bind_double(query()->stmt(), __number, __data.d);
            break;
        }
        case SQLITE_TEXT: {
            rc = sqlite3_bind_text64(query()->stmt(), __number,    (const char*)__data.p,
                __size, NULL, SQLITE_UTF8);
            break;
        }
        case SQLITE_BLOB: {
            rc = sqlite3_bind_blob(query()->stmt(), __number, __data.p, (int)__size, NULL);
            break;
        }
        case SQLITE_NULL:
        default: {
            rc = sqlite3_bind_null(query()->stmt(), __number);
        }
    }
 
    if (rc != SQLITE_OK) {
        ByteStringBuilder sb = sqlite3_errmsg(conn()->connHandle());
        sb.append(' ').append(__name);
        __SET_ERROR_MSG(sb.toByteString());
        return false;
    }
 
    return true;
}
bool SqParam::onAfterExecute()
{
    setNull();
    return true;
}
 
const wchar_t* SqParam::serverDataTypeName() const
{
    return __dataTypeName(__type);
}
 
void SqParam::setNull()
{
    Param::__dataType = SQL::typeUnknown;
    __type = SQLITE_NULL;
 
}
 
static inline int __ABS(int _n)
{
    return _n < 0 ? -_n : _n;
}
 
bool SqParam::__setData(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    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::typeInterval:
            r = setInterval((const SQL::Interval*)_val, _size);
            break;
        case SQL::typeText:
        case SQL::typeBinary:
        case SQL::typeInputStream:
            r = setBytes(_val, _size, _valType, _sqlType);
            break;
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        Param::__dataType = _sqlType;
    }
    return r;
}
 
bool SqParam::setInteger(const void* _val, size_t _size)
{
    switch (_size) {
        case sizeof(int8_t) : {
            __data.n =  *(int8_t*)_val;
            break;
        }
        case sizeof(int16_t) : {
            __data.n =  *(int16_t*)_val;
            break;
        }
        case sizeof(int32_t) : {
            __data.n =  *(int32_t*)_val;
            break;
        }
        case sizeof(int64_t) : {
            __data.n = *(int64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_INTEGER;
    return true;
}
 
bool SqParam::setUInteger(const void* _val, size_t _size)
{
    switch (_size) {
        case sizeof(uint8_t) : {
            __data.n =  *(uint8_t*)_val;
            break;
        }
        case sizeof(uint16_t) : {
            __data.n =  *(uint16_t*)_val;
            break;
        }
        case sizeof(uint32_t) : {
            __data.n =  *(uint32_t*)_val;
            break;
        }
        case sizeof(uint64_t) : {
            __data.n = *(uint64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_INTEGER;
    return true;
}
 
bool SqParam::setFloat(const void* _val, size_t _size)
{
    switch (_size) {
        case sizeof(float) : {
            __data.d =  *(float*)_val;
            break;
        }
        case sizeof(double) : {
            __data.d =  *(double*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_FLOAT;
    return true;
}
 
bool SqParam::setDate(const SQL::Date* _val, size_t _size)
{
    if (_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Date* val = (const SQL::Date*)_val;
    ByteStringBuilder sb;
    sb.format(
        "%04d-%02d-%02d",
        __ABS(val->year),
        val->month,
        val->day
    );
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    __data.p = (void*) __bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}
 
bool SqParam::setTime(const SQL::Time* _val, size_t _size)
{
    if (_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Time* val = (const SQL::Time*)_val;
    if (val->tzoff == INT16_MIN) {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d %+03d:%02d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}
 
bool SqParam::setTimeStamp(const SQL::TimeStamp* _val, size_t _size)
{
    if (_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::TimeStamp* val = (const SQL::TimeStamp*)_val;
    ByteStringBuilder sb;
    if (val->tzoff == INT16_MIN) {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d %+03d:%02d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}
 
bool SqParam::setInterval(const SQL::Interval* _val, size_t _size)
{
    if (_size != sizeof(SQL::Interval)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Interval* val = (const SQL::Interval*)_val;
    if (val->secs || val->fracs >= 0) {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%d.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            val->secs,
            __ABS(val->fracs)
        );
    }
    else {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%-0.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            __ABS(val->fracs)
        );
    }
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}
 
bool SqParam::setBytes(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    const char* val = (const char*)_val;
    size_t size = _size;
    SQL::DataType valType = _valType;
    if (_valType == SQL::typeInputStream) {
        try {
            __bytes = Files::readBytes(*(InputStream*)_val, _size);
            val = __bytes;
            size = __bytes.length();
        }
        catch (IOException* _e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
            _e->destroy();
            return false;
        }
        if (_sqlType == SQL::typeText
            || _sqlType == SQL::typeLongText
            || _sqlType == SQL::typeClob) {
            valType = SQL::typeText;
        }
        else {
            valType = SQL::typeBinary;
        }
    }
 
    __data.p = (const void*)val;
    __size = size;
 
    __type = valType == SQL::typeText ? SQLITE_TEXT : SQLITE_BLOB;
    return true;
}
 
__DCL_END_NAMESPACE