SqField.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <errno.h>      // errno
#include <float.h>      // FLT_MAX
#include <math.h>       // modf, HUGE_VAL
#include <stdlib.h>     // strtoll, strtoull
#include <string.h>     // memset, memcpy
 
#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/size_t.h>
#include <dcl/SQLCore.h>
#include <dcl/OutputStream.h>
#include <dcl/Charset.h>
 
#include "SqConnection.h"
#include "SqQuery.h"
#include "SqField.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/SqField.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(SqField, SQL::Field)
 
SqField::SqField() 
    : Field(NULL)
{
    __index = -1;
    __maxsize = 0;
}
 
SqField::~SqField()
{
//  __DCL_TRACE1("~SqField: %ls", Field::__name.data());
}
 
bool SqField::init(SQL::Query* _queryHandle, int _index)
{
    __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;
}
 
const wchar_t* SqField::serverDataTypeName() const
{
    return __declType.data();
}
 
bool SqField::__getDataSize(size_t* _size, bool _maxsize)
{
    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;
}
 
bool SqField::__getData(
    void*           _buf,
    size_t*         _size,
    SQL::DataType  _bufType
)
{
    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;
}
 
bool SqField::getInteger(void* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getUInteger(void* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getFloat(void* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getDate(SQL::Date* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getTime(SQL::Time* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getTimeStamp(SQL::TimeStamp* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getInterval(SQL::Interval* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getNumeric(char* _buf, size_t* _size)
{
    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;
}
 
bool SqField::getBytes(char* _buf, size_t* _size)
{
    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;
}
 
bool SqField::writeTo(OutputStream* _output, size_t* _size)
{
    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;
}
 
__DCL_END_NAMESPACE