MyParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <string.h>     // memset
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/SQLCore.h>
#include <dcl/Numeric.h>
#include <dcl/InputStream.h>
#include <dcl/Charset.h>
 
#include "MyConnection.h"
#include "MyQuery.h"
#include "MyParam.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
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/MyParam.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(MyParam, SQL::Param)
 
MyParam::MyParam() : Param(NULL)
{
    __index = 0;
    __bind = NULL;
    __input = NULL;
}
 
MyParam::~MyParam()
{
 
}
 
bool MyParam::init(SQL::Query* _query, unsigned int _index, MYSQL_BIND* _bind)
{
    __DCL_ASSERT(Param::__queryHandle == NULL);
    Param::__queryHandle = _query;
    __index = _index;
    __bind = _bind;
 
    return true;
}
 
bool MyParam::onBeforeExecute()
{
    if (__input) {
        try {
            char buf[4096];
            size_t total = 0;
            for (; ; ) {
                size_t n = __MIN(__size - total, sizeof(buf));
                if (n && (n = __input->read(buf, n))) {
                    __DCL_TRACE1_N(L"mysql_stmt_send_long_data [%u]\n", n);
                    if (mysql_stmt_send_long_data(query()->stmt(),
                        __index, buf, (unsigned int) n)) {
                        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                            mysql_stmt_errno(query()->stmt()),
                            mysql_stmt_error(query()->stmt())));
                        return false;
                    }
                }
                else {
                    break;
                }
            }
        }
        catch (IOException* e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
            e->destroy();
            return false;
        }
    }
    return true;
}
 
void MyParam::onAfterExecute()
{
    Param::__dataType = SQL::typeUnknown;
    __bind->buffer_length = 0;
    __bind->buffer = NULL;
    __bind->length_value = 0;
    __bind->is_null_value = 1;
    __input = NULL;
    __size = 0;
}
 
// in MyField.cpp
const wchar_t* __dataTypeName(enum_field_types _type, unsigned int _flags);
 
const wchar_t* MyParam::serverDataTypeName() const
{
    unsigned int flags = 0;
    switch (SQL::Param::__dataType) {
    case SQL::typeUInteger :
        flags = UNSIGNED_FLAG;
        break;
    case SQL::typeBinary :
    case SQL::typeLongBinary :
    case SQL::typeBlob :
        flags = BINARY_FLAG;
        break;
    default:
        ;
    }
 
    return __dataTypeName(__bind->buffer_type, flags);
}
 
void MyParam::setNull()
{
    Param::__dataType = SQL::typeUnknown;
    __bind->buffer_length = 0;
    __bind->buffer = NULL;
    __bind->length_value = 0;
    __bind->is_null_value = 1;
    __input = NULL;
    __size = 0;
}
 
#define __ABS(n) (n < 0) ? -n : n
 
bool MyParam::__setData(
            _CONST void* _pv,
            size_t _size,
            SQL::DataType _dataType,
            SQL::DataType _assignType
            )
{
    switch(_dataType) {
        case SQL::typeInteger: {
            switch (_size) {
                case sizeof(int8_t) : {
                    __data.i32 = (int32_t) * (int8_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(int32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(int16_t) : {
                    __data.i32 = (int32_t) * (int16_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(int32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(int32_t) : {
                    __data.i32 = (int32_t) * (int32_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(int32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(int64_t) : {
                    __data.i64 = (int64_t) * (int64_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONGLONG;
                    __bind->buffer_length = sizeof(int64_t);
                    __bind->buffer = &__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            __bind->is_unsigned = 0;
            break;
        }
        case SQL::typeUInteger : {
            switch (_size) {
                case sizeof(uint8_t) : {
                    __data.u32 = (uint32_t) * (uint8_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(uint32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(uint16_t) : {
                    __data.u32 = (uint32_t) * (uint16_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(uint32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(uint32_t) : {
                    __data.u32 = (uint32_t) * (uint32_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONG;
                    __bind->buffer_length = sizeof(uint32_t);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(uint64_t) : {
                    __data.u64 = (uint64_t) * (uint64_t*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_LONGLONG;
                    __bind->buffer_length = sizeof(uint64_t);
                    __bind->buffer = &__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            __bind->is_unsigned = 1;
            break;
        }
        case SQL::typeFloat: {
            switch (_size) {
                case sizeof(float) : {
                    __data.f32 = *(float*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_FLOAT;
                    __bind->buffer_length = sizeof(float);
                    __bind->buffer = &__data;
                    break;
                }
                case sizeof(double) : {
                    __data.f64 = *(double*)_pv;
                    __bind->buffer_type = MYSQL_TYPE_DOUBLE;
                    __bind->buffer_length = sizeof(double);
                    __bind->buffer = &__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        case SQL::typeDate: {
            if (_size == sizeof(SQL::Date)) {
                const SQL::Date* p = (const SQL::Date*)_pv;
                memset(&__data.time, 0, sizeof(MYSQL_TIME));
                __data.time.year = __ABS(p->nYear);
                __data.time.month = p->nMonth;
                __data.time.day = p->nDay;
                __data.time.neg = p->nYear < 0 ? 1 : 0;
                __data.time.time_type = MYSQL_TIMESTAMP_DATE;
                __bind->buffer_type = MYSQL_TYPE_DATE;
                __bind->buffer_length = sizeof(MYSQL_TIME);
                __bind->buffer = &__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTime: {
            if (_size == sizeof(SQL::Time)) {
                const SQL::Time* p = (const SQL::Time*)_pv;
                memset(&__data.time, 0, sizeof(MYSQL_TIME));
                __data.time.hour = p->nHour;
                __data.time.minute = p->nMin;
                __data.time.second = p->nSec;
                __data.time.second_part = p->nFrac / 1000;
                __data.time.neg = 0;
                __data.time.time_type = MYSQL_TIMESTAMP_TIME;
                __bind->buffer_type = MYSQL_TYPE_TIME;
                __bind->buffer_length = sizeof(MYSQL_TIME);
                __bind->buffer = &__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTimeStamp: {
            if (_size == sizeof(SQL::TimeStamp)) {
                const SQL::TimeStamp* p = (const SQL::TimeStamp*)_pv;
                //if (p->nTzMin != INT16_MIN) {
                //  __SET_ERROR(SQL::eInvalidData);
                //  return false;
                //}
                __data.time.year = __ABS(p->nYear);
                __data.time.month = p->nMonth;
                __data.time.day = p->nDay;
                __data.time.hour = p->nHour;
                __data.time.minute = p->nMin;
                __data.time.second = p->nSec;
                __data.time.second_part = p->nFrac / 1000;
                __data.time.neg = p->nYear < 0 ? 1 : 0;
                __data.time.time_type = MYSQL_TIMESTAMP_DATETIME;
                __bind->buffer_type = MYSQL_TYPE_DATETIME;
                __bind->buffer_length = sizeof(MYSQL_TIME);
                __bind->buffer = &__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeInterval:
        case SQL::typeIntervalYm:
        case SQL::typeIntervalDs: {
            if (_size == sizeof(SQL::Interval)) {
                const SQL::Interval* p = (const SQL::Interval*)_pv;
                __data.time.year = 0;
                __data.time.month = 0;
                __data.time.day = __ABS(p->nYears * 365 + p->nMonths * 30 + p->nDays);
                __data.time.hour = __ABS(p->nHours);
                __data.time.minute = __ABS(p->nMins);
                __data.time.second = __ABS(p->nSecs);
                __data.time.second_part = __ABS(p->nFracs) / 1000;
                __data.time.neg = p->nYears < 0 || p->nMonths < 0 || p->nDays
                    || p->nHours < 0 || p->nMins || p->nSecs || p->nFracs < 0 ? 1 : 0;
                __data.time.time_type = MYSQL_TIMESTAMP_TIME;
                __bind->buffer_type = MYSQL_TYPE_TIME;
                __bind->buffer_length = sizeof(MYSQL_TIME);
                __bind->buffer = &__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeText :
        case SQL::typeBinary: {
            if (_size > UINT32_MAX) {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            __bind->buffer_type = MYSQL_TYPE_STRING;
            __bind->buffer_length = (unsigned int) _size;
            __bind->buffer = _pv;
            break;
        }
        case SQL::typeInputStream : {
            if (_size != (size_t)-1 && _size > UINT32_MAX) {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            __bind->buffer_type = MYSQL_TYPE_STRING;
            __bind->buffer_length = 0;
            __bind->buffer = NULL;
            __input = (InputStream*)_pv;
            __size = _size;
            break;
        }
        default:
        case SQL::typeTimeStampTz: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    __bind->is_null_value = 0;
    Param::__dataType = _assignType;
    return true;
}
 
__DCL_END_NAMESPACE