IFXTypes.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <sqlhdr.h>
#include <sqliapi.h>
 
#include <stdio.h>
#include <string.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 "IFXTypes_.h"
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/IFXTypes.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
size_t __get_dec_strlen(const dec_t* _p)
{
    // assert(_p->dec_pos != -1);
    // assert(_p->dec_ndgts >= 0);
    __DCL_ASSERT(_p->dec_pos != -1);
    __DCL_ASSERT(_p->dec_ndgts >= 0);
 
    if (_p->dec_ndgts == 0)
        return 1;   // "0"
 
    size_t n = _p->dec_pos == 0 ? 1 : 0;
    int __n = _p->dec_exp - _p->dec_ndgts;
    if (__n < 0) {
        // 소숫점 아래 포함
        if (_p->dec_exp > 0) {
            // 소숫점 위 포함
            // 소숫점 아래와 소숫점 위 모두 포함
 
            n += _p->dec_ndgts * 2;
 
            // 첫번째가 10보다 작으면
            if (_p->dec_dgts[0] < 10)
                n--;
 
            // 소숫점아래 마지막이 0이면
            if ((_p->dec_dgts[_p->dec_ndgts - 1] % 10) == 0)
                n--;
 
            n++;    // 소숫점
        }
        else {
            // 소숫점 아래만 있음
            n += 2; // "0."
            n += (-__n) * 2;
 
            // 소숫점아래 마지막이 0이면
            if ((_p->dec_dgts[_p->dec_ndgts - 1] % 10) == 0)
                n--;
        }
    }
    else {
        // 소숫점을 포함하지 않음
 
        if (__n > 0)
            n += (_p->dec_ndgts + __n) * 2;
        else
            n += _p->dec_ndgts * 2;
 
        // 첫번째가 10보다 작으면
        if (_p->dec_dgts[0] < 10)
            n--;
 
        // dectoasc 에서 소숫점 없는 수는 ".0"을 추가함
        n += 2;
    }
 
    return n;
}
 
// __GET_UNIT_VALUE
// 첫번째이면 첫번째 길이만큼, 나머지는 1바이트(0~99) 값
#define __GET_UNIT_VALUE(TU_VAR, TU_NAME, TU_EXP) \
    if (_s->in_dec.dec_exp >= TU_EXP) { \
        if (TU_START(_s->in_qual) == TU_NAME) { \
            int n = _s->in_dec.dec_exp - (TU_EXP - 1); \
            while(n-- > 0) { \
                TU_VAR *= 100; \
                if (ndgts > 0) { \
                    TU_VAR += *p++; \
                    ndgts--; \
                } \
            } \
        } \
        else { \
            TU_VAR += *p++; \
            ndgts--; \
        } \
    } \
    if (TU_END(_s->in_qual) == TU_NAME || ndgts == 0) \
        break;
 
void __decode_intrvl(const intrvl_t* _s, SQL::Interval* _r)
{
    __DCL_ASSERT(_s->in_dec.dec_pos >= 0);
 
    int nYears, nMonths, nDays, nHours, nMins, nSecs, nFSecs;
    nYears =  nMonths = nDays = nHours = nMins = nSecs = nFSecs = 0;
 
    const char* p = _s->in_dec.dec_dgts;
    int ndgts = _s->in_dec.dec_ndgts;
 
    switch(TU_START(_s->in_qual)) {
        case TU_YEAR: {
            __GET_UNIT_VALUE(nYears, TU_YEAR, 6)
        }
        case TU_MONTH: {
            __GET_UNIT_VALUE(nMonths, TU_MONTH, 5)
        }
        case TU_DAY: {
            __GET_UNIT_VALUE(nDays, TU_DAY, 4)
        }
        case TU_HOUR: {
            __GET_UNIT_VALUE(nHours, TU_HOUR, 3)
        }
        case TU_MINUTE: {
            __GET_UNIT_VALUE(nMins, TU_MINUTE, 2)
        }
        case TU_SECOND: {
            __GET_UNIT_VALUE(nSecs, TU_SECOND, 1)
        }
        case TU_FRAC: {
            // TU_F1, TU_F2
            if (_s->in_dec.dec_exp >= 0) {
                nFSecs += *p++ * 10000;
                ndgts--;
            }
            if (ndgts == 0)
                break;
            // TU_F3, TU_F4
            if (_s->in_dec.dec_exp >= -1) {
                nFSecs += *p * 100;
                ndgts--;
            }
            if (ndgts == 0)
                break;
            // TU_F5
            if (_s->in_dec.dec_exp >= -2)
                nFSecs += *p;
        }
    }
 
#define MIN_PER_DAY     1440
#define SEC_PER_DAY     86400
#define SEC_PER_HOUR    3600
 
    switch(TU_START(_s->in_qual)) {
        case TU_YEAR: {
            break;
        }
        case TU_MONTH: {
            nYears = nMonths / 12;
            nMonths = nMonths % 12;
            break;
        }
        case TU_DAY: {
            break;
        }
        case TU_HOUR: {
            nDays = nHours / 24;
            nHours = nHours % 24;
            break;
        }
        case TU_MINUTE: {
            nDays = nMins / MIN_PER_DAY;
            nHours = (nMins % MIN_PER_DAY) / 60;
            nMins = nMins % 60;
            break;
        }
        case TU_SECOND: {
            nDays = nSecs / SEC_PER_DAY;
            nHours = (nSecs % SEC_PER_DAY) / SEC_PER_HOUR;
            nMins = (nSecs % SEC_PER_HOUR) / 60;
            nSecs = nSecs % 60;
            break;
        }
        case TU_FRAC: {
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    if (_s->in_dec.dec_pos == 1) {
        _r->years = nYears;
        _r->months = nMonths;
        _r->days = nDays;
        _r->hours = nHours;
        _r->mins = nMins;
        _r->secs = nSecs;
        _r->fracs = nFSecs * 1000;
    }
    else {
        _r->years = -nYears;
        _r->months = -nMonths;
        _r->days = -nDays;
        _r->hours = -nHours;
        _r->mins = -nMins;
        _r->secs = -nSecs;
        _r->fracs = -(nFSecs * 1000);
    }
}
 
void __decode_dtime(const dtime_t* _s, SQL::TimeStamp* _r)
{
    /*
    // 2025-12-10 dec_exp[-64] dec_ndgts[0] 인 경우가 발견되었다!
    if (!(0 <= _s->dt_dec.dec_exp && _s->dt_dec.dec_exp <= 7)
        || !(_s->dt_dec.dec_ndgts > 0)) {
        __DCL_TRACE2(L"dec_exp[%d] dec_ndgts[%d]\n", _s->dt_dec.dec_exp, _s->dt_dec.dec_ndgts);
    }
     __DCL_ASSERT(0 <= _s->dt_dec.dec_exp && _s->dt_dec.dec_exp <= 7);
     __DCL_ASSERT(_s->dt_dec.dec_ndgts > 0);
    */
 
    int nYear, nMonth, nDay, nHour, nMin, nSec, nFSec;
    nYear = nMonth = nDay = nHour = nMin = nSec = nFSec = 0;
 
    const char* p = _s->dt_dec.dec_dgts;
    int ndgts = _s->dt_dec.dec_ndgts;
    switch (TU_START(_s->dt_qual)) {
        case TU_YEAR: {
            if (_s->dt_dec.dec_exp >= 7) {
                nYear = (*p++) * 100;
                if (--ndgts == 0)
                    break;
            }
            if (_s->dt_dec.dec_exp >= 6) {
                nYear += (*p++);
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_MONTH: {
            if (_s->dt_dec.dec_exp >= 5) {
                nMonth = *p++;
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_DAY: {
            if (_s->dt_dec.dec_exp >= 4) {
                nDay = *p++;
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_HOUR: {
            if (_s->dt_dec.dec_exp >= 3) {
                nHour = *p++;
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_MINUTE: {
            if (_s->dt_dec.dec_exp >= 2) {
                nMin = *p++;
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_SECOND: {
            if (_s->dt_dec.dec_exp >= 1) {
                nSec = *p++;
                if (--ndgts == 0)
                    break;
            }
        }
        case TU_FRAC: {
            // TU_F1, TU_F2
            if (_s->dt_dec.dec_exp >= 0) {
                nFSec = *p++ * 10000;
                if (--ndgts == 0)
                    break;
            }
            // TU_F3, TU_F4
            if (_s->dt_dec.dec_exp >= -1) {
                nFSec += *p * 100;
                if (--ndgts == 0)
                    break;
            }
            // TU_F5
            if (_s->dt_dec.dec_exp >= -2)
                nFSec += *p;
        }
    }
 
    _r->year = nYear;
    _r->month = nMonth;
    _r->day = nDay;
    _r->hour = nHour;
    _r->min = nMin;
    _r->sec = nSec;
    _r->frac = nFSec * 1000;
    _r->tzoff = INT16_MIN;
}
 
void __decode_dtime(const dtime_t* _s, SQL::Date* _r)
{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->year = t.year;
    _r->month = t.month;
    _r->day = t.day;
}
 
void __decode_dtime(const dtime_t* _s, SQL::Time* _r)
{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->hour = t.hour;
    _r->min = t.min;
    _r->sec = t.sec;
    _r->frac = t.frac;
    _r->tzoff = INT16_MIN;
}
 
#ifdef __WINNT__
#define snprintf    _snprintf
#endif
 
int __encode_dtime(const SQL::TimeStamp* _s, dtime_t* _r)
{
    char sz[40];    // YYYY-MM-DD HH:MM:SS.FFF 23
    int n = snprintf(
        sz,
        sizeof(sz),
        "%04d-%02u-%02u %02u:%02u:%02u.%05u",
        _s->year, _s->month, _s->day,
        _s->hour, _s->min, _s->sec, _s->frac / 10000
    );
 
    // -1263 A field in a datetime or interval value
    // is out of range or incorrect.
    if (n < 0)
        return -1263;
    else
        sz[n] = '\0';
 
    _r->dt_qual = TU_DTENCODE(TU_YEAR, TU_F5);
    return dtcvasc(sz, _r);
}
 
int __encode_dtime(const SQL::Date* _s, dtime_t* _r)
{
    char sz[30];    // YYYY-MM-DD 10
    int n = snprintf(
        sz,
        sizeof(sz),
        "%04d-%02d-%02d",
        _s->year, _s->month, _s->day
    );
    if (n < 0)
        return -1263;   
    else
        sz[n] = '\0';
 
    _r->dt_qual = TU_DTENCODE(TU_YEAR, TU_DAY);
    return dtcvasc(sz, _r);
}
 
int __encode_dtime(const SQL::Time* _s, dtime_t* _r)
{
    char sz[30];    // HH:MM:SS.FFF 12
    int n = snprintf(
        sz,
        sizeof(sz),
        "%02u:%02u:%02u.%05u",
        _s->hour, _s->min, _s->sec, _s->frac / 10000
    );
    if (n < 0)
        return -1263;
    else
        sz[n] = '\0';
 
    _r->dt_qual = TU_DTENCODE(TU_HOUR, TU_F5);
    return dtcvasc(sz, _r);
}
 
inline int __ABS(int n)
{
    return n < 0 ? -n : n;
}
 
int __encode_intrvl(
    const SQL::Interval* _s,
    SQL::DataType _sqlType,
    intrvl_t* _r
)
{
    if (_sqlType == SQL::typeIntervalYm) {
        int fn = 1;
        int d = 10;
        for( ; _s->years / d; fn++)
            d *= 10;
 
        const char* fmt = "%d-%d";
        if (_s->years < 0 || _s->months < 0)
            fmt = "-%d-%d";
 
        char sz[30];    // YYYYYYYYY-MM
        int n = snprintf(
            sz,
            sizeof(sz),
            fmt,
            __ABS(_s->years),
            __ABS(_s->months)
        );
        if (n < 0)
            return -1263;
        else
            sz[n] = '\0';
 
        _r->in_qual = TU_IENCODE(fn, TU_YEAR, TU_MONTH);
        return incvasc(sz, _r);
    }
    else {
        __DCL_ASSERT(_sqlType == SQL::typeIntervalDs);
 
        int fn = 1; // FIRST LENGTH
        int d = 10;
        for( ; _s->days / d; fn++)
            d *= 10;
 
        const char* fmt = "%d %02d:%02d:%02d.%05d";
        if (_s->days < 0 || _s->hours < 0 || _s->mins < 0
            || _s->secs < 0 || _s->fracs < 0)
            fmt = "-%d %02d:%02d:%02d.%05d";
 
        char sz[40]; // DDDDDDDDDD HH:MM:SS.FFF + sign = 24
        int n = snprintf(
            sz,
            sizeof(sz),
            fmt,
            __ABS(_s->days),
            __ABS(_s->hours),
            __ABS(_s->mins),
            __ABS(_s->secs),
            __ABS(_s->fracs / 10000)
        );
        if (n < 0)
            return -1263;   
        else
            sz[n] = '\0';
 
        _r->in_qual = TU_IENCODE(fn, TU_DAY, TU_F5);
        return incvasc(sz, _r);
    }
}
 
__DCL_END_NAMESPACE