SqTypes.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <errno.h>      // errno
#include <stdlib.h>     // strol
#include <string.h>     // memset
 
#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/SQLCore.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
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/SqTypes.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
static int32_t __fraction_normalize(long _n)
{
    if (_n > 999999999) {
        // fraction이 999,999,999 보다 크면 오류값이다.
        _n = 0;
    }
    int divider = 10;
    for (; ; ) {
        if (!(_n / divider))
            break;
        divider *= 10;
    }
    return _n * (1000000000 / divider);
}
 
bool __decode_timestamp_iso(
    const char* _s, const char** _endptr,
    SQL::TimeStamp& _r
)
{
    __DCL_ASSERT(_s);
#ifndef __DCL_DEBUG
    if (!_s) {
        if (_endptr) {
            *_endptr = _s;
        }
        return false;
    }
#endif
 
#define __START 0
#define __yyyy  1
#define __MM    2
#define __dd    3
#define __HH    4
#define __mm    5
#define __ss    6
#define __SSS   7
#define __ZH    8
#define __Zm    9
#define __Zs    10
#define __BC    11
#define __DONE  12
 
    int state = __START; // yyyy-MM-dd'T'HH:mm:ss.SSSZ
    memset(&_r, 0, sizeof(_r));
    _r.tzoff = INT16_MIN;
 
    bool r = true;
    char* endptr = (char*)_s;
    for (; ; ) {
        errno = 0;
        const char* nptr = endptr;
        long n = strtol(nptr, &endptr, 10);
        if (errno == ERANGE) {
            // invalid string
            r = false;
            break;
        }
        if (state == __START) {
            if (*endptr == '-') {
                state = __yyyy;
            }
            else if (*endptr == ':') {
                state = __HH;
            }
            else {
                // invalid string
                r = false;
                break;
            }
        }
        else if (*endptr == 'B') {
            state = __BC;
        }
        else {
            // '\0' == *endptr || strchr("- T:.+", *endptr)
            state++;
        }
 
        __DCL_TRACE4_N(L"state[%2d] n[%10d] [%p][%hc]\n",
            state, n, endptr, *endptr ? *endptr : '$');
        switch (state) {
            case __yyyy:
                _r.year = (int16_t)n;
                break;
            case __MM:
                _r.month = (uint8_t)n;
                break;
            case __dd:
                _r.day = (uint8_t)n;
                break;
            case __HH:
                _r.hour = (uint8_t)n;
                break;
            case __mm:
                _r.min = (uint8_t)n;
                break;
            case __ss:
                _r.sec = (uint8_t)n;
                break;
            case __SSS:
                _r.frac = __fraction_normalize(n);
                break;
            case __ZH:
                _r.tzoff = (int16_t)(n * 60);
                break;
            case __Zm:
                _r.tzoff += (int16_t)n;
                break;
            case __Zs:
                // +08:27:52 BC PostgreSQL Bug!! ignore
                break;
            case __BC: {
                __DCL_ASSERT(*(endptr + 1) == 'C');
                _r.year *= -1;
                state = __DONE;
                break;
            }
            default: {
                __DCL_ASSERT(false);
            }
        }
 
        if (*endptr == '\0' || state == __DONE) {
            break;
        }
        else {
            __DCL_TRACE1_N(L"[%hs]\n", (*endptr ? endptr : "(nil)"));
            if ((state == __ss || state == __SSS)
                && (*endptr == '+' || *endptr == '-')
            ) {
                state = __SSS;
                // 부호와 함께 strtol 후 __ZH 상태가 된다.
            }
            else {
                endptr++;
            }
        }
    }
 
    if (_endptr) {
        *_endptr = endptr;
    }
    return r;
}
 
bool __decode_interval_iso(
    const char* _s, const char** _endptr,
    SQL::Interval& _r
)
{
    __DCL_ASSERT(_s);
#ifndef __DCL_DEBUG
    if (!_s) {
        if (_endptr) {
            *_endptr = _s;
        }
        return false;
    }
#endif
 
    if (*_s != 'P') {
        // invalid string
        if (_endptr) {
            *_endptr = _s;
        }
        return false;
    }
    _s++;
 
#define __P0    0
#define __PT    1
#define __PTDOT 2
#define __PDONE 3
 
    bool r = true;
    int state = __P0;   // P3Y6M4DT12H30M5S
    memset(&_r, 0, sizeof(_r));
 
    char dotsign = '+'; // '.'에서 부호를 보관해야 SSS 사용할 수 있다.
    char* endptr = (char*)_s;
    for (; ; ) {
        errno = 0;
        const char* nptr = endptr;
        long n = strtol(nptr, &endptr, 10);
        if (errno == ERANGE) {
            // invalid string
            r = false;
            break;
        }
        __DCL_TRACE4_N(L"state[%d] [%p][%hc] [%d]\n",
            state, endptr, (*endptr ? *endptr : '$'), n);
        switch (*endptr) {
            case 'Y':
                _r.years = (int32_t)n;
                break;
            case 'M':
                if (state == __PT) {
                    _r.mins = (int8_t)n;
                }
                else {
                    _r.months = (int8_t)n;
                }
                break;
            case 'D':
                _r.days = (int32_t)n;
                break;
            case 'T':
                state = __PT;
                break;
            case 'H':
                _r.hours = (int8_t)n;
                break;
            case '.':
                state = __PTDOT;
                dotsign = *nptr;
                _r.secs = (int8_t)n;
                break;
            case 'S': {
                if (state == __PTDOT) {
                    _r.fracs = __fraction_normalize(n)
                        * (dotsign == '-' ? -1 : 1);
                }
                else {
                    _r.secs = (int8_t)n;
                }
                state = __PDONE;
                break;
            }
            case '\0': {
                state = __PDONE;
                break;
            }
            default: {
                // invalid string
                r = false;
                state = __PDONE;
            }
        }
 
        if (state == __PDONE) {
            break;
        }
        else {
            endptr++;
        }
    }
 
    if (_endptr) {
        *_endptr = endptr;
    }
    return r;
}
 
#define SQLTYPE_NAME(_type, _name) case _type : return L ## _name
 
const wchar_t* __dataTypeName(int _type)
{
    switch (_type) {
        SQLTYPE_NAME(SQLITE_INTEGER,    "INTEGER"); // 1
        SQLTYPE_NAME(SQLITE_FLOAT,      "FLOAT");   // 2
        SQLTYPE_NAME(SQLITE_TEXT,       "TEXT");    // 3
        SQLTYPE_NAME(SQLITE_BLOB,       "BLOB");    // 4
        SQLTYPE_NAME(SQLITE_NULL,       "NULL");    // 5
        default: return L"Unknown Type (Binary Mapped)";
    }
}
 
typedef sqlite_int64 i64;
 
struct DateTime {
    sqlite3_int64 iJD;  /* The julian day number times 86400000 */
    int Y, M, D;        /* Year, month, and day */
    int h, m;           /* Hour and minutes */
    int tz;             /* Timezone offset in minutes */
    double s;           /* Seconds */
    int ms;
};
 
#define INT_464269060799999  ((((i64)0x1a640)<<32)|0x1072fdff)
 
static int validJulianDay(sqlite3_int64 iJD) {
    return iJD >= 0 && iJD <= INT_464269060799999;
}
 
static void computeYMD_HMS(DateTime* p)
{
    int Z, alpha, A, B, C, D, E, X1;
    Z = (int)((p->iJD + 43200000) / 86400000);
    alpha = (int)((Z + 32044.75) / 36524.25) - 52;
    A = Z + 1 + alpha - ((alpha + 100) / 4) + 25;
    B = A + 1524;
    C = (int)((B - 122.1) / 365.25);
    D = (36525 * (C & 32767)) / 100;
    E = (int)((B - D) / 30.6001);
    X1 = (int)(30.6001 * E);
    p->D = B - D - X1;
    p->M = E < 14 ? E - 1 : E - 13;
    p->Y = p->M > 2 ? C - 4716 : C - 4715;
 
    int day_ms, day_min;
    day_ms = (int)((p->iJD + 43200000) % 86400000);
    p->s = (day_ms % 60000) / 1000.0;
    day_min = day_ms / 60000;
    p->m = day_min % 60;
    p->h = day_min / 60;
 
    p->ms = day_ms % 1000;
}
 
// See. sqlite3.c: juliandayFunc
// x.iJD/86400000.0
 
bool __decode_timestamp_julianday(double _julianday, SQL::TimeStamp& _r)
{
    DateTime dt;
    // setRawDateNumber
    dt.iJD = (sqlite3_int64)(_julianday * 86400000.0 + 0.5);
    if (!validJulianDay(dt.iJD)) {
        return false;
    }
    computeYMD_HMS(&dt);
 
    _r.year = dt.Y;
    _r.month = dt.M;
    _r.day = dt.D;
 
    _r.hour = dt.h;
    _r.min = dt.m;
    _r.sec = (uint8_t) dt.s;
    _r.frac = dt.ms * 1000000;
    _r.tzoff = INT16_MIN;
 
    return true;
}
 
// See. sqlite3.c: unixepochFunc, datetimeFunc
// x.iJD/1000 - 21086676*(i64)10000
 
bool __decode_timestamp_unixepoch(int64_t _unixepoch, SQL::TimeStamp& _r)
{
    DateTime dt;
    dt.iJD = (_unixepoch + 21086676 * (i64)10000) * 1000;
    __DCL_TRACE2_N(L"[%lld] [%lld]\n", _unixepoch, dt.iJD);
    if (!validJulianDay(dt.iJD)) {
        return false;
    }
    computeYMD_HMS(&dt);
 
    _r.year = dt.Y;
    _r.month = dt.M;
    _r.day = dt.D;
 
    _r.hour = dt.h;
    _r.min = dt.m;
    _r.sec = (uint8_t)dt.s;
    _r.frac = dt.ms * 1000000;
    _r.tzoff = INT16_MIN;
 
    return true;
}
 
__DCL_END_NAMESPACE