SqTypes.h File Reference

Go to the source code of this file.

Macros
#define	__DCL_SQ_TYPES_H__   20260117

Functions
__DCL_BEGIN_NAMESPACE bool	__decode_timestamp_iso (const char *_s, const char **_endptr, SQL::TimeStamp &_r)
bool	__decode_interval_iso (const char *_s, const char **_endptr, SQL::Interval &_r)
const wchar_t *	__dataTypeName (int _type)
bool	__decode_timestamp_julianday (double _julianday, SQL::TimeStamp &_r)
bool	__decode_timestamp_unixepoch (int64_t _unixepoch, SQL::TimeStamp &_r)

Macro Definition Documentation

__DCL_SQ_TYPES_H__

#define __DCL_SQ_TYPES_H__   20260117

Definition at line 2 of file SqTypes.h.

Function Documentation

__dataTypeName()

const wchar_t * __dataTypeName

(

int

_type

)

Definition at line 297 of file SqTypes.cpp.

{
    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)";
    }
}

__decode_interval_iso()

bool __decode_interval_iso	(	const char *	_s,
		const char **	_endptr,
		SQL::Interval &	_r )

Definition at line 308 of file PqTypes.cpp.

{
    __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;
}

__decode_timestamp_iso()

__DCL_BEGIN_NAMESPACE bool __decode_timestamp_iso	(	const char *	_s,
		const char **	_endptr,
		SQL::TimeStamp &	_r )

Definition at line 176 of file PqTypes.cpp.

{
    __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;
}

__decode_timestamp_julianday()

bool __decode_timestamp_julianday	(	double	_julianday,
		SQL::TimeStamp &	_r )

Definition at line 354 of file SqTypes.cpp.

{
    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;
}

__decode_timestamp_unixepoch()

bool __decode_timestamp_unixepoch	(	int64_t	_unixepoch,
		SQL::TimeStamp &	_r )

Definition at line 380 of file SqTypes.cpp.

{
    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;
}