MyField Class Reference

#include <MyField.h>

Inheritance diagram for MyField:

Public Member Functions
	MyField ()
virtual	~MyField ()
bool	init (SQL::Query *_query, unsigned int _index, MYSQL_FIELD *_field, MYSQL_BIND *_bind)
virtual bool	isNull () const
virtual const wchar_t *	serverDataTypeName () const
virtual bool	__getDataSize (size_t *_psize, bool _maxsize)
virtual bool	__getData (void *_pv, size_t *_psize, SQL::DataType _dataType)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
void	setErrorStatus (SQL::Error _error, const wchar_t *_filename, int _line)
void	setErrorStatus (const ByteString &_message, const wchar_t *_filename, int _line)
MyQuery *	query () const
bool	getInteger (void *_pv, size_t *_psize)
bool	getUInteger (void *_pv, size_t *_psize)
bool	getFloat (void *_pv, size_t *_psize)
bool	getDate (SQL::Date *_pv, size_t *_psize)
bool	getTimeStamp (SQL::TimeStamp *_pv, size_t *_psize)
bool	getTime (SQL::Time *_pv, size_t *_psize)
bool	getInterval (SQL::Interval *_pv, size_t *_psize)
Protected Member Functions inherited from SQL::Field
	Field (Query *_queryHandle)
virtual	~Field ()
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Additional Inherited Members
Protected Attributes inherited from SQL::Field
Query *	__queryHandle
String	__name
DataType	__dataType
short	__precision
short	__scale

Detailed Description

Definition at line 6 of file MyField.h.

Constructor & Destructor Documentation

MyField()

MyField::MyField

(

)

~MyField()

MyField::~MyField ( )

virtual

Definition at line 54 of file MyField.cpp.

{
    __DCL_TRACE1_N(L"~MyField [%ls]\n", Field::__name.data());
}

Member Function Documentation

__getData()

bool MyField::__getData ( void * _pv, size_t * _psize, SQL::DataType _dataType )

virtual

Implements SQL::Field.

Definition at line 339 of file MyField.cpp.

{
    if (!query()->inState(SQL::Query::stFetched)) {
        __SET_ERROR(SQL::eNotFetched);
        return false;
    }
 
    switch(_dataType) {
        case SQL::typeInteger :
            return  getInteger(_pv, _psize);
        case SQL::typeUInteger :
            return getUInteger(_pv, _psize);
        case SQL::typeFloat :
            return getFloat(_pv, _psize);
        case SQL::typeDate :
            return getDate((SQL::Date*)_pv, _psize);
        case SQL::typeTimeStamp :
            return getTimeStamp((SQL::TimeStamp*)_pv, _psize);
        case SQL::typeTime:
            return getTime((SQL::Time*)_pv, _psize);
        case SQL::typeInterval:
            return getInterval((SQL::Interval*)_pv, _psize);
        case SQL::typeText:
        case SQL::typeBinary: {
            __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DECIMAL)
                || __TYPE_IS(MYSQL_TYPE_NEWDECIMAL)
                || __TYPE_IS(MYSQL_TYPE_BIT)
                || __TYPE_IS(MYSQL_TYPE_JSON)
                || __TYPE_IS(MYSQL_TYPE_ENUM)
                || __TYPE_IS(MYSQL_TYPE_SET)
                || __TYPE_IS(MYSQL_TYPE_VAR_STRING)
                || __TYPE_IS(MYSQL_TYPE_STRING)
                || __TYPE_IS(MYSQL_TYPE_GEOMETRY)
                || __TYPE_IS(MYSQL_TYPE_TINY_BLOB)
                || __TYPE_IS(MYSQL_TYPE_BLOB)
                || __TYPE_IS(MYSQL_TYPE_MEDIUM_BLOB)
                || __TYPE_IS(MYSQL_TYPE_LONG_BLOB)
                );
            if (*_psize < __bind->length_value) {
                __SET_ERROR(SQL::eInvalidBufferSize);
                return false;
            }
            if (__bind->buffer_length) {
                // 버퍼가 할당되어 있으면, 이것을 복사한다.
                memcpy(_pv, __bind->buffer, __bind->length_value);
            }
            else {
                __DCL_TRACE2_N(L"b[%u][%u]\n",
                    __bind->buffer_length, __bind->length_value);
                MYSQL_BIND bind;
                memset(&bind, 0, sizeof(bind));
                bind.buffer = _pv;
                bind.buffer_length = *_psize;
                if (mysql_stmt_fetch_column(query()->stmt(), &bind, __index, 0)) {
                    __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                        mysql_stmt_errno(query()->stmt()),
                        mysql_stmt_error(query()->stmt())));
                    return false;
                }
            }
            if (*_psize > __bind->length_value)
                *((char*)_pv + __bind->length_value) = '\0';
            *_psize = __bind->length_value;
            break;
        }
        case SQL::typeOutputStream: {
            __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DECIMAL)
                || __TYPE_IS(MYSQL_TYPE_NEWDECIMAL)
                || __TYPE_IS(MYSQL_TYPE_BIT)
                || __TYPE_IS(MYSQL_TYPE_JSON)
                || __TYPE_IS(MYSQL_TYPE_ENUM)
                || __TYPE_IS(MYSQL_TYPE_SET)
                || __TYPE_IS(MYSQL_TYPE_VAR_STRING)
                || __TYPE_IS(MYSQL_TYPE_STRING)
                || __TYPE_IS(MYSQL_TYPE_GEOMETRY)
                || __TYPE_IS(MYSQL_TYPE_TINY_BLOB)
                || __TYPE_IS(MYSQL_TYPE_BLOB)
                || __TYPE_IS(MYSQL_TYPE_MEDIUM_BLOB)
                || __TYPE_IS(MYSQL_TYPE_LONG_BLOB)
            );
            if (__bind->length_value < *_psize) {
                *_psize = __bind->length_value;
            }
            try {
                char buf[4096];
                MYSQL_BIND bind;
                memset(&bind, 0, sizeof(bind));
                bind.buffer = buf;
                bind.length = &bind.length_value;
                unsigned long total = 0;
                while (total < *_psize) {
                    bind.buffer_length = __MIN(sizeof(buf), *_psize - total);
                    if (mysql_stmt_fetch_column(query()->stmt(),
                        &bind, __index, total)) {
                        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                            mysql_stmt_errno(query()->stmt()),
                            mysql_stmt_error(query()->stmt())));
                        return false;
                    }
                    ((OutputStream*)_pv)->write(bind.buffer, bind.buffer_length);
                    total += bind.buffer_length;
                    __DCL_TRACE2_N(L"mysql_stmt_fetch_column [%u][%u]\n",
                        bind.buffer_length, bind.length_value);
                }               
            }
            catch (IOException* e) {
                __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
                e->destroy();
                return false;
            }
            break;
        }
        default :
            __DCL_ASSERT(false);        // SQL::Field::getData bug
    }
 
    return true;
}

__getDataSize()

bool MyField::__getDataSize ( size_t * _psize, bool _maxsize )

virtual

Implements SQL::Field.

Definition at line 305 of file MyField.cpp.

{
    if (_maxsize) {
        *_psize = __maxsize;
        return true;
    }
 
    if (!query()->inState(SQL::Query::stFetched)) {
        __SET_ERROR(SQL::eNotFetched);
        return false;
    }
 
    switch (Field::__dataType) {
    case SQL::typeInteger:
    case SQL::typeUInteger:
    case SQL::typeFloat:
    case SQL::typeDate:
    case SQL::typeTime:
    case SQL::typeTimeStamp:
    case SQL::typeTimeStampTz:
    case SQL::typeInterval:
    case SQL::typeIntervalYm:
    case SQL::typeIntervalDs:
        *_psize = __maxsize;
        break;
    default:
        *_psize = __bind->length_value;
    }
 
    return true;
}

getDate()

bool MyField::getDate ( SQL::Date * _pv, size_t * _psize )

protected

Definition at line 858 of file MyField.cpp.

{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATE));
 
    if (*_psize != sizeof(SQL::Date)) {
        *_psize = sizeof(SQL::Date);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
    
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->year = s->year * (s->neg ? -1 : 1);
    _pv->month = s->month;
    _pv->day = s->day;
 
    return true;
}

getFloat()

bool MyField::getFloat ( void * _pv, size_t * _psize )

protected

Definition at line 780 of file MyField.cpp.

{
    switch (__field->type) {
        case MYSQL_TYPE_FLOAT: {
            switch (*_psize) {
                case sizeof(float): {
                    *(float*)_pv = *(float*)__bind->buffer;
                    break;
                }
                case sizeof(double): {
                    *(double*)_pv = *(float*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(float);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            switch (*_psize) {
                case sizeof(double) : {
                    *(double*)_pv = *(double*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            char* endptr;
            double d = strtod((char*)__bind->buffer, &endptr);
            if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eServerError);
                return false;
            }
 
            switch (*_psize) {
                case sizeof(float): {
                    if (d < FLT_MIN || FLT_MAX < d) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(float*)_pv = (float) d;
                    break;
                }
                case sizeof(double): {
                    if (d < DBL_MIN || DBL_MAX < d) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(double*)_pv = (double)d;
                    break;
                }
                default : {
                    *_psize = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default : {
            __DCL_ASSERT(false);    // MyField::init bug
        }
    }
 
    return true;
}

getInteger()

bool MyField::getInteger ( void * _pv, size_t * _psize )

protected

Definition at line 458 of file MyField.cpp.

{
    __DCL_ASSERT(!(__field->flags & UNSIGNED_FLAG));
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY: {
            switch (*_psize) {
                case sizeof(int8_t) : {
                    *(int8_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int16_t) : {
                    *(int16_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR : 
        case MYSQL_TYPE_SHORT : {
            switch (*_psize) {
                case sizeof(int16_t) : {
                    *(int16_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24 :
        case MYSQL_TYPE_LONG : {
            switch (*_psize) {
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int32_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG : {
            switch (*_psize) {
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            char* endptr;
            long long n;
            if ((Field::__precision - Field::__scale) < 20) {
                n = strtoll((char*)__bind->buffer, &endptr, 10);
                if (n == LLONG_MAX || n == LLONG_MIN) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
 
                double i;
                (void)modf(d, &i);  // 정수부분만, 반환값(소수)는 버림
                if (i < LLONG_MIN || LLONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                n = (long long)i;
            }
 
            switch (*_psize) {
                case sizeof(int8_t) : {
                    if (n < INT8_MIN || INT8_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int8_t*)_pv = (int8_t)n;
                    break;
                }
                case sizeof(int16_t) : {
                    if (n < INT16_MIN || INT16_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int16_t*)_pv = (int16_t)n;
                    break;
                }
                case sizeof(int32_t) : {
                    if (n < INT32_MIN || INT32_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int32_t*)_pv = (int32_t)n;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = (int64_t)n;
                    break;
                }
                default: {
                    *_psize = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}

getInterval()

bool MyField::getInterval ( SQL::Interval * _pv, size_t * _psize )

protected

Definition at line 919 of file MyField.cpp.

{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_psize != sizeof(SQL::Interval)) {
        *_psize = sizeof(SQL::Interval);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    int8_t sign = s->neg ? -1 : 1;
    _pv->years = 0;
    _pv->months = 0;
    _pv->days = s->hour / 24 * sign;
    _pv->hours = s->hour % 24 * sign;
    _pv->mins = s->minute * sign;
    _pv->secs = s->second * sign;
    _pv->fracs = s->second_part * 1000 * sign;
 
    return true;
}

getTime()

bool MyField::getTime ( SQL::Time * _pv, size_t * _psize )

protected

Definition at line 899 of file MyField.cpp.

{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_psize != sizeof(SQL::Time)) {
        *_psize = sizeof(SQL::Time);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->hour = s->hour;
    _pv->min = s->minute;
    _pv->sec = s->second;
    _pv->frac = s->second_part * 1000;
    _pv->tzoff = INT16_MIN;
 
    return true;
}

getTimeStamp()

bool MyField::getTimeStamp ( SQL::TimeStamp * _pv, size_t * _psize )

protected

Definition at line 876 of file MyField.cpp.

{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATETIME)
            || __TYPE_IS(MYSQL_TYPE_TIMESTAMP));
 
    if (*_psize != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->year = s->year * (s->neg ? -1 : 1);
    _pv->month = s->month;
    _pv->day = s->day;
    _pv->hour = s->hour;
    _pv->min = s->minute;
    _pv->sec = s->second;
    _pv->frac = s->second_part * 1000;
    _pv->tzoff = INT16_MIN;
 
    return true;
}

getUInteger()

bool MyField::getUInteger ( void * _pv, size_t * _psize )

protected

Definition at line 619 of file MyField.cpp.

{
    __DCL_ASSERT(__field->flags & UNSIGNED_FLAG);
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY : {
            switch (*_psize) {
                case sizeof(uint8_t) : {
                    *(uint8_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint16_t) : {
                    *(uint16_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR :
        case MYSQL_TYPE_SHORT: {
            switch (*_psize) {
                case sizeof(uint16_t) : {
                    *(uint16_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG: {
            switch (*_psize) {
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint32_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG: {
            switch (*_psize) {
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL :
        case MYSQL_TYPE_NEWDECIMAL : {
            char* endptr;
            unsigned long long u;
            if ((Field::__precision - Field::__scale) < 20) {
                u = strtoull((char*)__bind->buffer, &endptr, 10);
                if (u == ULONG_MAX) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
 
                double i;
                modf(d, &i);    // 정수부분만, 반환값(소수)는 버림
                if (i < 0 || ULONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                u = (unsigned long long)i;
            }
 
            switch (*_psize) {
                case sizeof(uint8_t): {
                    if (UINT8_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint8_t*)_pv = (uint8_t)u;
                    break;
                }
                case sizeof(uint16_t): {
                    if (UINT16_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint16_t*)_pv = (uint16_t)u;
                    break;
                }
                case sizeof(uint32_t): {
                    if (UINT32_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint32_t*)_pv = (uint32_t)u;
                    break;
                }
                case sizeof(uint64_t): {
                    *(uint64_t*)_pv = (uint64_t)u;
                    break;
                }
                default: {
                    *_psize = sizeof(uint64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}

init()

bool MyField::init	(	SQL::Query *	_query,
		unsigned int	_index,
		MYSQL_FIELD *	_field,
		MYSQL_BIND *	_bind )

Definition at line 59 of file MyField.cpp.

{
    __DCL_ASSERT((_queryHandle != NULL) && (_field != NULL));
 
    Field::__queryHandle = _queryHandle;
    __index = _index;
    __field = _field;
    __bind = _bind;
 
    try {
        Field::__name = UTF8Decoder::decode(_field->name).toUpperCase();
    }
    catch (CharsetConvertException* _e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
        _e->destroy();
        return false;
    }
 
    __DCL_TRACE2_N(L"[%ls] decimals[%u]\n", __name.data(), _field->decimals);
    Field::__scale = _field->decimals;
 
    enum enum_field_types _type = __field->type;
    unsigned int _flags = __field->flags;
 
    switch(_type) {
        case MYSQL_TYPE_TINY: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int8_t);
            break;
        }
        case MYSQL_TYPE_YEAR:
        case MYSQL_TYPE_SHORT: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int16_t);
            break;
        }
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int32_t);
            break;
        }
        case MYSQL_TYPE_LONGLONG: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int64_t);
            break;
        }
        case MYSQL_TYPE_FLOAT: {
            Field::__precision = _field->length - 1;
            Field::__dataType = SQL::typeFloat;
            __maxsize = sizeof(float);
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            Field::__precision = _field->length - 1;
            Field::__dataType = SQL::typeFloat;
            __maxsize = sizeof(double);
            break;
        }
        case MYSQL_TYPE_NULL: {
            Field::__dataType = SQL::typeUnknown;
            __maxsize = 0;
            break;
        }
        case MYSQL_TYPE_TIMESTAMP:
        case MYSQL_TYPE_DATETIME:
        case MYSQL_TYPE_TIMESTAMP2:
        case MYSQL_TYPE_DATETIME2: {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeTimeStamp;
            __maxsize = sizeof(SQL::TimeStamp);
            break;
        }
        case MYSQL_TYPE_DATE:
        case MYSQL_TYPE_NEWDATE : {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeDate;
            __maxsize = sizeof(SQL::Date);
            break;
        }
        case MYSQL_TYPE_TIME:
        case MYSQL_TYPE_TIME2: {
            Field::__precision = _field->length - 2;
            Field::__dataType = SQL::typeIntervalDs;
            __maxsize = sizeof(SQL::Interval);
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            Field::__precision = _field->length - (_field->decimals == 0 ? 1 : 2);
            Field::__dataType = SQL::typeNumeric;
            __maxsize = _field->length;
            break;
        }
        case MYSQL_TYPE_BIT: {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeBinary;
            __maxsize = sizeof(int64_t);
            break;
        }
        case MYSQL_TYPE_JSON:
        case MYSQL_TYPE_ENUM:
        case MYSQL_TYPE_SET:
        case MYSQL_TYPE_VAR_STRING:
        case MYSQL_TYPE_STRING:
        case MYSQL_TYPE_GEOMETRY: {
            Field::__dataType = _flags & BINARY_FLAG ?
                SQL::typeBinary : SQL::typeText;
            __maxsize = _field->length;
            break;
        }
        case MYSQL_TYPE_TINY_BLOB :
        case MYSQL_TYPE_BLOB :
        case MYSQL_TYPE_MEDIUM_BLOB :
        case MYSQL_TYPE_LONG_BLOB: {
            if (_flags & BINARY_FLAG) {
                Field::__dataType = _field->length <= ((uint16_t)-1 * 3) ?
                    SQL::typeBinary : SQL::typeLongBinary;
            }
            else {
                Field::__dataType = _field->length <= ((uint16_t)-1 * 3) ?
                    SQL::typeText : SQL::typeLongText;
            }
            __maxsize = _field->length;
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    return true;
}

isNull()

bool MyField::isNull ( ) const

virtual

Implements SQL::Field.

Definition at line 297 of file MyField.cpp.

{  
    if (!query()->inState(SQL::Query::stFetched)) {
        return true;
    }
    return __bind->is_null_value;
}

query()

MyQuery * MyField::query ( ) const

inlineprotected

Definition at line 67 of file MyField.h.

{ 
    return (MyQuery*)Field::__queryHandle; 
}

serverDataTypeName()

const wchar_t * MyField::serverDataTypeName ( ) const

virtual

Implements SQL::Field.

Definition at line 292 of file MyField.cpp.

{
    return __dataTypeName(__field->type, __field->flags);
}

setErrorStatus() [1/2]

void MyField::setErrorStatus ( const ByteString & _message, const wchar_t * _filename, int _line )

inlineprotected

Definition at line 57 of file MyField.h.

{
    ((MyConnection*)Field::connection())->setErrorStatus(
            _message,
            _filename,
            _line
            );
}

setErrorStatus() [2/2]

void MyField::setErrorStatus ( SQL::Error _error, const wchar_t * _filename, int _line )

inlineprotected

Definition at line 47 of file MyField.h.

{
    ((MyConnection*)Field::connection())->setErrorStatus(
            _error,
            _filename,
            _line
            );
}

---

The documentation for this class was generated from the following files:

• MyField.h
• MyField.cpp