SqField Class Reference

#include <SqField.h>

Inheritance diagram for SqField:

Public Member Functions
	SqField ()
virtual	~SqField ()
bool	init (SQL::Query *_query, int _index)
virtual const wchar_t *	serverDataTypeName () const
virtual bool	__getDataSize (size_t *_size, bool _maxsize)
virtual bool	__getData (void *_buf, size_t *_size, SQL::DataType _bufType)
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
SqQuery *	query () const
SqConnection *	conn () const
bool	getInteger (void *_buf, size_t *_size)
bool	getUInteger (void *_buf, size_t *_size)
bool	getFloat (void *_buf, size_t *_size)
bool	getDate (SQL::Date *_buf, size_t *_size)
bool	getTime (SQL::Time *_buf, size_t *_size)
bool	getTimeStamp (SQL::TimeStamp *_buf, size_t *_size)
bool	getInterval (SQL::Interval *_buf, size_t *_size)
bool	getNumeric (char *_buf, size_t *_size)
bool	getBytes (char *_buf, size_t *_size)
bool	writeTo (OutputStream *_output, size_t *_size)
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 8 of file SqField.h.

Constructor & Destructor Documentation

SqField()

SqField::SqField

(

)

~SqField()

SqField::~SqField ( )

virtual

Definition at line 61 of file SqField.cpp.

{
//  __DCL_TRACE1("~SqField: %ls", Field::__name.data());
}

Member Function Documentation

__getData()

bool SqField::__getData ( void * _buf, size_t * _size, SQL::DataType _bufType )

virtual

Implements SQL::Field.

Definition at line 210 of file SqField.cpp.

{
    switch(_bufType) {
        case SQL::typeInteger:
            return getInteger(_buf, _size);
        case SQL::typeUInteger:
            return getUInteger(_buf, _size);
        case SQL::typeFloat:
            return getFloat(_buf, _size);
        case SQL::typeDate:
            return getDate((SQL::Date*)_buf, _size);
        case SQL::typeTime:
            return getTime((SQL::Time*)_buf, _size);
        case SQL::typeTimeStamp:
            return getTimeStamp((SQL::TimeStamp*)_buf, _size);
        case SQL::typeInterval:
            return getInterval((SQL::Interval*)_buf, _size);
        case SQL::typeText:
            if (Field::__dataType == SQL::typeNumeric) {
                return getNumeric((char*)_buf, _size);
            }
        case SQL::typeBinary:
            return getBytes((char*)_buf, _size);
        case SQL::typeOutputStream:
            return writeTo((OutputStream*)_buf, _size);
        default:
            __DCL_ASSERT(false);        // SQL::Field::getData bug
    }
    return true;
}

__getDataSize()

bool SqField::__getDataSize ( size_t * _size, bool _maxsize )

virtual

Implements SQL::Field.

Definition at line 181 of file SqField.cpp.

{
    if (_maxsize) {
        *_size = __maxsize;
    }
    else {
        int type = sqlite3_column_type(query()->stmt(), __index);
        switch (type) {
            case SQLITE_INTEGER:
                *_size = sizeof(int64_t);
                break;
            case SQLITE_FLOAT:
                *_size = sizeof(double);
                break;
            case SQLITE_TEXT:
            case SQLITE_BLOB: {
                *_size = sqlite3_column_bytes(query()->stmt(), __index);
                break;
            }
            case SQLITE_NULL:
            default: {
                *_size = (size_t)-1;
            }
        }
    }
 
    return true;
}

conn()

SqConnection * SqField::conn ( ) const

inlineprotected

Definition at line 55 of file SqField.h.

{
    return query()->conn();
}

getBytes()

bool SqField::getBytes ( char * _buf, size_t * _size )

protected

Definition at line 686 of file SqField.cpp.

{
    ByteString str;
    const char* value;
    size_t length;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            str = ByteString::valueOf(sqlite3_column_int64(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_FLOAT: {
            str = ByteString::valueOf(sqlite3_column_double(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_TEXT: {
            value = (const char*)sqlite3_column_text(query()->stmt(), __index);
            length = sqlite3_column_bytes(query()->stmt(), __index);
            break;
        }
        case SQLITE_BLOB: {
            value = (const char*)sqlite3_column_blob(query()->stmt(), __index);
            length = sqlite3_column_bytes(query()->stmt(), __index);
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    if (length < *_size) {
        *(_buf + length) = '\0';
        *_size = length;
    }
    memcpy(_buf, value, *_size);
 
    return true;
}

getDate()

bool SqField::getDate ( SQL::Date * _buf, size_t * _size )

protected

Definition at line 467 of file SqField.cpp.

{
    if (*_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    SQL::TimeStamp ts;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            if (!__decode_timestamp_unixepoch(
                sqlite3_column_int64(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_FLOAT: {
            if (!__decode_timestamp_julianday(
                sqlite3_column_double(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_TEXT: {
            if (!__decode_timestamp_iso(
                (const char*) sqlite3_column_text(query()->stmt(), __index),
                NULL, ts)) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    _buf->year = ts.year;
    _buf->month = ts.month;
    _buf->day = ts.day;
 
    return true;
}

getFloat()

bool SqField::getFloat ( void * _buf, size_t * _size )

protected

Definition at line 404 of file SqField.cpp.

{
    double d;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            d = (double) sqlite3_column_int64(query()->stmt(), __index);
            break;
        }
        case SQLITE_FLOAT: {
            d = (double)sqlite3_column_double(query()->stmt(), __index);
            break;
        }
        case SQLITE_TEXT: {
            const char* value = (const char*)sqlite3_column_text(query()->stmt(), __index);
            errno = 0;
            char* endptr;
            d = strtod(value, &endptr);
            if (errno == ERANGE) {
                __DCL_ASSERT(
                    +HUGE_VAL == d || -HUGE_VAL == d    // overflow
                    || !(DBL_MIN < d)                   // underflow
                );
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
    #if __UNNEED__
            else if (errno == EINVAL) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
    #endif
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    switch (*_size) {
        case sizeof(float) : {
            if (d < -FLT_MAX || FLT_MAX < d) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(float*)_buf = (float)d;
            break;
        }
        case sizeof(double) : {
            *(double*)_buf = (double)d;
            break;
        }
        default: {
            *_size = sizeof(double);
            __SET_ERROR(SQL::eInvalidBufferSize);
            return false;
        }
    }
 
    return true;
}

getInteger()

bool SqField::getInteger ( void * _buf, size_t * _size )

protected

Definition at line 245 of file SqField.cpp.

{
    int64_t n;
 
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            n = sqlite3_column_int64(query()->stmt(), __index);
            break;
        }
        case SQLITE_FLOAT: {
            n = (int64_t)sqlite3_column_double(query()->stmt(), __index);
            break;
        }
        case SQLITE_TEXT: {
            const char* value = (const char*) sqlite3_column_text(query()->stmt(), __index);
            errno = 0;
            char* endptr;
            n = strtoll(value, &endptr, 10);
            if (errno == ERANGE) {
                __DCL_ASSERT(
                    n == LLONG_MAX || n == LLONG_MIN    // overflow
                );
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
    #define __UNNEED__ 0
    #if __UNNEED__
            else if (errno == EINVAL) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
    #endif
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    switch (*_size) {
        case sizeof(int8_t) : {
            if (n < INT8_MIN || INT8_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(int8_t*)_buf = (int8_t)n;
            break;
        }
        case sizeof(int16_t) : {
            if (n < INT16_MIN || INT16_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(int16_t*)_buf = (int16_t)n;
            break;
        }
        case sizeof(int32_t) : {
            if (n < INT32_MIN || INT32_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(int32_t*)_buf = (int32_t)n;
            break;
        }
        case sizeof(int64_t) : {
            *(int64_t*)_buf = (int64_t)n;
            break;
        }
        default: {
            *_size = sizeof(int64_t);
            __SET_ERROR(SQL::eInvalidBufferSize);
            return false;
        }
    }
 
    return true;
}

getInterval()

bool SqField::getInterval ( SQL::Interval * _buf, size_t * _size )

protected

Definition at line 624 of file SqField.cpp.

{
    if (*_size != sizeof(SQL::Interval)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    if (sqlite3_column_type(query()->stmt(), __index) == SQLITE_TEXT) {
        if (!__decode_interval_iso(
            (const char*)sqlite3_column_text(query()->stmt(), __index), 
            NULL, *_buf)) {
            __SET_ERROR(SQL::eInvalidData);
            return false;
        }
    }
    else {
        __SET_ERROR(SQL::eInvalidDataType);
        return false;
    }
 
    return true;
}

getNumeric()

bool SqField::getNumeric ( char * _buf, size_t * _size )

protected

Definition at line 647 of file SqField.cpp.

{
    ByteString str;
    const char* value;
    size_t length;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            str = ByteString::valueOf(sqlite3_column_int64(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_FLOAT: {
            str = ByteString::valueOf(sqlite3_column_double(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_TEXT: {
            value = (const char*)sqlite3_column_text(query()->stmt(), __index);
            length = sqlite3_column_bytes(query()->stmt(), __index);
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    if (length < *_size) {
        *(_buf + length) = '\0';
        *_size = length;
    }
    memcpy(_buf, value, *_size);
 
    return true;
}

getTime()

bool SqField::getTime ( SQL::Time * _buf, size_t * _size )

protected

Definition at line 520 of file SqField.cpp.

{
    if (*_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    SQL::TimeStamp ts;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            if (!__decode_timestamp_unixepoch(
                sqlite3_column_int64(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_FLOAT: {
            if (!__decode_timestamp_julianday(
                sqlite3_column_double(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_TEXT: {
            if (!__decode_timestamp_iso(
                (const char*)sqlite3_column_text(query()->stmt(), __index),
                NULL, ts)) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    _buf->hour = ts.hour;
    _buf->min = ts.min;
    _buf->sec = ts.sec;
    _buf->frac = ts.frac;
    _buf->tzoff = ts.tzoff;
 
    return true;
}

getTimeStamp()

bool SqField::getTimeStamp ( SQL::TimeStamp * _buf, size_t * _size )

protected

Definition at line 575 of file SqField.cpp.

{
    if (*_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    SQL::TimeStamp& ts = *_buf;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            if (!__decode_timestamp_unixepoch(
                sqlite3_column_int64(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_FLOAT: {
            if (!__decode_timestamp_julianday(
                sqlite3_column_double(query()->stmt(), __index),
                ts
            )) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_TEXT: {
            if (!__decode_timestamp_iso(
                (const char*)sqlite3_column_text(query()->stmt(), __index),
                NULL, ts)) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

getUInteger()

bool SqField::getUInteger ( void * _buf, size_t * _size )

protected

Definition at line 325 of file SqField.cpp.

{
    sqlite3_uint64 u;
 
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            u = (sqlite3_uint64) sqlite3_column_int64(query()->stmt(), __index);
            break;
        }
        case SQLITE_FLOAT: {
            u = (sqlite3_uint64) sqlite3_column_double(query()->stmt(), __index);
            break;
        }
        case SQLITE_TEXT: {
            const char* value = (const char*)sqlite3_column_text(query()->stmt(), __index);
            errno = 0;
            char* endptr;
            u = strtoull(value, &endptr, 10);
            if (errno == ERANGE) {
                __DCL_ASSERT(
                    u == ULLONG_MAX // overflow
                );
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
    #if __UNNEED__
            else if (errno == EINVAL) {
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
    #endif
            break;
        }
        case SQLITE_BLOB:
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    switch (*_size) {
        case sizeof(uint8_t) : {
            if (UINT8_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(uint8_t*)_buf = (uint8_t)u;
            break;
        }
        case sizeof(uint16_t) : {
            if (UINT16_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(uint16_t*)_buf = (uint16_t)u;
            break;
        }
        case sizeof(uint32_t) : {
            if (UINT32_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            *(uint32_t*)_buf = (uint32_t)u;
            break;
        }
        case sizeof(uint64_t) : {
            *(uint64_t*)_buf = (uint64_t)u;
            break;
        }
        default: {
            *_size = sizeof(uint64_t);
            __SET_ERROR(SQL::eInvalidBufferSize);
            return false;
        }
    }
 
    return true;
}

init()

bool SqField::init	(	SQL::Query *	_query,
		int	_index )

Definition at line 66 of file SqField.cpp.

{
    __DCL_ASSERT(Field::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL);
 
    Field::__queryHandle = _queryHandle;
    __index = _index;
 
    try {
        Field::__name = UTF8Decoder::decode(
            sqlite3_column_name(query()->stmt(), _index)
        ).toUpperCase();
 
        const char* column_decltype = sqlite3_column_decltype(query()->stmt(), _index);
        if (!column_decltype) {
            column_decltype = "ANY";
        }
        __declType = UTF8Decoder::decode(column_decltype).toUpperCase();
    }
    catch (CharsetConvertException* _e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
        _e->destroy();
        return false;
    }
 
    __DCL_TRACE3_N(L"Field [%2d] decltype%10ls] [%ls]\n",
        __index, __declType.data(), Field::__name.data());
 
    if (__declType.contains(L"RV")) {           // INTERVAL
        Field::__dataType = SQL::typeInterval;
    }
    else if (__declType.contains(L"BIN")        // BINARY
        || __declType.contains(L"BLO")          // BLOB
        || __declType.contains(L"BY")) {        // BYTE
        Field::__dataType = SQL::typeBinary;
    }
    else if (__declType.contains(L"XT")         // TEXT
        || __declType.contains(L"CH")           // CHAR
        || __declType.contains(L"CL")           // CLOB
        || __declType.contains(L"NG")){         // LONG
        Field::__dataType = SQL::typeText;
    }
    else if (__declType.contains(L"DE")         // DECIMAL
        || __declType.contains(L"NU")           // NUMBER, NUMERIC
        || __declType.contains(L"MO")) {        // MONEY
        Field::__dataType = SQL::typeNumeric;
    }
    else if (__declType.contains(L"BO")         // BOOL
        || __declType.contains(L"TIN")          // TINYINT
        || __declType.contains(L"SM")) {        // SMALLINT
        Field::__dataType = SQL::typeInteger;
    }
    else if (__declType.contains(L"BIG")) {     // BIGINT
        Field::__dataType = SQL::typeInteger;
    }
    else if (__declType.contains(L"INT")        // INTEGER
        || __declType.contains(L"SE")) {        // SERIAL
        Field::__dataType = SQL::typeInteger;
    }
    else if (__declType.contains(L"RE")         // REAL
        || __declType.contains(L"FL")           // FLOAT
        || __declType.contains(L"DO")) {        // DOUBLE
        Field::__dataType = SQL::typeFloat;
    }
    else if (__declType.contains(L"ET")         // DATETIME
        || __declType.contains(L"ST")) {        // TIMESTAMP
        Field::__dataType = SQL::typeTimeStamp;
    }
    else if (__declType.contains(L"DA")) {      // DATE
        Field::__dataType = SQL::typeDate;
    }
    else if (__declType.contains(L"ME")) {      // TIME
        Field::__dataType = SQL::typeTime;
    }
    else {
        Field::__dataType = SQL::typeText;     // ANY
    }
 
    switch (Field::__dataType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
            __maxsize = sizeof(int64_t);
            break;
        case SQL::typeFloat:
            __maxsize = sizeof(double);
            break;
        case SQL::typeNumeric:
            __maxsize = 133;
            break;
        case SQL::typeDate:
            __maxsize = sizeof(SQL::Date);
            break;
        case SQL::typeTime:
        case SQL::typeTimeTz:
            __maxsize = sizeof(SQL::Time);
            break;
        case SQL::typeTimeStamp:
        case SQL::typeTimeStampTz:
            __maxsize = sizeof(SQL::TimeStamp);
            break;
        case SQL::typeInterval:
            __maxsize = sizeof(SQL::Interval);
            break;
        default:
            __maxsize = INT32_MAX;
    }
 
    return true;
}

query()

SqQuery * SqField::query ( ) const

inlineprotected

Definition at line 50 of file SqField.h.

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

serverDataTypeName()

const wchar_t * SqField::serverDataTypeName ( ) const

virtual

Implements SQL::Field.

Definition at line 176 of file SqField.cpp.

{
    return __declType.data();
}

writeTo()

bool SqField::writeTo ( OutputStream * _output, size_t * _size )

protected

Definition at line 729 of file SqField.cpp.

{
    ByteString str;
    const char* value;
    size_t length;
    switch (sqlite3_column_type(query()->stmt(), __index)) {
        case SQLITE_INTEGER: {
            str = ByteString::valueOf(sqlite3_column_int64(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_FLOAT: {
            str = ByteString::valueOf(sqlite3_column_double(query()->stmt(), __index));
            value = str;
            length = str.length();
            break;
        }
        case SQLITE_TEXT: {
            value = (const char*)sqlite3_column_text(query()->stmt(), __index);
            length = sqlite3_column_bytes(query()->stmt(), __index);
            break;
        }
        case SQLITE_BLOB: {
            value = (const char*)sqlite3_column_blob(query()->stmt(), __index);
            length = sqlite3_column_bytes(query()->stmt(), __index);
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    if (length < *_size) {
        *_size = length;
    }
    try {
        _output->write(value, *_size);
    }
    catch (IOException* e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
        e->destroy();
        return false;
    }
 
    return true;
}

---

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

• SqField.h
• SqField.cpp