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"
 
#ifdef __DCL_DEBUG
#undef __THIS_FILE__
static const wchar_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->nYears = nYears;
        _r->nMonths = nMonths;
        _r->nDays = nDays;
        _r->nHours = nHours;
        _r->nMins = nMins;
        _r->nSecs = nSecs;
        _r->nFracs = nFSecs * 1000;
    }
    else
    {
        _r->nYears = -nYears;
        _r->nMonths = -nMonths;
        _r->nDays = -nDays;
        _r->nHours = -nHours;
        _r->nMins = -nMins;
        _r->nSecs = -nSecs;
        _r->nFracs = -(nFSecs * 1000);
    }
}
 
void __decode_dtime(const dtime_t* _s, SQL::TimeStamp* _r)
{
    // assert(0 <= _s->dt_dec.dec_exp && _s->dt_dec.dec_exp <= 7)
    // assert(_s->dt_dec.dec_ndgts > 0)
    __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->nYear = nYear;
    _r->nMonth = nMonth;
    _r->nDay = nDay;
    _r->nHour = nHour;
    _r->nMin = nMin;
    _r->nSec = nSec;
    _r->nFrac = nFSec * 1000;
    _r->nTzMin = 0;
}
 
void __decode_dtime(const dtime_t* _s, SQL::Date* _r)
{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->nYear = t.nYear;
    _r->nMonth = t.nMonth;
    _r->nDay = t.nDay;
}
 
void __decode_dtime(const dtime_t* _s, SQL::Time* _r)
{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->nHour = t.nHour;
    _r->nMin = t.nMin;
    _r->nSec = t.nSec;
    _r->nFrac = t.nFrac;
}
 
#if __DCL_WINDOWS
#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->nYear, _s->nMonth, _s->nDay,
                _s->nHour, _s->nMin, _s->nSec, _s->nFrac / 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->nYear, _s->nMonth, _s->nDay
                );
    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->nHour, _s->nMin, _s->nSec, _s->nFrac / 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 _dataType,
            intrvl_t* _r
            )
{
    if (_dataType == SQL::typeIntervalYm)
    {
        int fn = 1;
        int d = 10;
        for( ; _s->nYears / d; fn++)
            d *= 10;
 
        const char* fmt = "%d-%d";
        if (_s->nYears < 0 || _s->nMonths < 0)
            fmt = "-%d-%d";
 
        char sz[30];    // YYYYYYYYY-MM
        int n = snprintf(
                    sz,
                    sizeof(sz),
                    fmt,
                    __ABS(_s->nYears),
                    __ABS(_s->nMonths)
                    );
        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(_dataType == SQL::typeIntervalDs);
 
        int fn = 1; // FIRST LENGTH
        int d = 10;
        for( ; _s->nDays / d; fn++)
            d *= 10;
 
        const char* fmt = "%d %02d:%02d:%02d.%05d";
        if (_s->nDays < 0 || _s->nHours < 0 || _s->nMins < 0
            || _s->nSecs < 0 || _s->nFracs < 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->nDays),
                    __ABS(_s->nHours),
                    __ABS(_s->nMins),
                    __ABS(_s->nSecs),
                    __ABS(_s->nFracs / 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