IFXTypes.cpp File Reference

#include <dcl/Config.h>
#include <sqlhdr.h>
#include <sqliapi.h>
#include <stdio.h>
#include <string.h>
#include <dcl/Object.h>
#include <dcl/SQLCore.h>
#include "IFXTypes_.h"

Go to the source code of this file.

Macros
#define	__GET_UNIT_VALUE(TU_VAR, TU_NAME, TU_EXP)
#define	MIN_PER_DAY   1440
#define	SEC_PER_DAY   86400
#define	SEC_PER_HOUR   3600

Functions
__DCL_BEGIN_NAMESPACE size_t	__get_dec_strlen (const dec_t *p)
void	__decode_intrvl (const intrvl_t *_s, SQL::Interval *_r)
void	__decode_dtime (const dtime_t *_s, SQL::TimeStamp *_r)
void	__decode_dtime (const dtime_t *_s, SQL::Date *_r)
void	__decode_dtime (const dtime_t *_s, SQL::Time *_r)
int	__encode_dtime (const SQL::TimeStamp *_s, dtime_t *_r)
int	__encode_dtime (const SQL::Date *_s, dtime_t *_r)
int	__encode_dtime (const SQL::Time *_s, dtime_t *_r)
int	__ABS (int n)
int	__encode_intrvl (const SQL::Interval *_s, SQL::DataType _dataType, intrvl_t *_r)

Macro Definition Documentation

__GET_UNIT_VALUE

#define __GET_UNIT_VALUE	(		TU_VAR,
			TU_NAME,
			TU_EXP )

Value:

    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;

Definition at line 93 of file IFXTypes.cpp.

#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;

MIN_PER_DAY

#define MIN_PER_DAY   1440

SEC_PER_DAY

#define SEC_PER_DAY   86400

SEC_PER_HOUR

#define SEC_PER_HOUR   3600

Function Documentation

__ABS()

int __ABS ( int n )

inline

Definition at line 394 of file IFXTypes.cpp.

{
    return n < 0 ? -n : n;
}

__decode_dtime() [1/3]

void __decode_dtime	(	const dtime_t *	_s,
		SQL::Date *	_r )

Definition at line 313 of file IFXTypes.cpp.

{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->nYear = t.nYear;
    _r->nMonth = t.nMonth;
    _r->nDay = t.nDay;
}

__decode_dtime() [2/3]

void __decode_dtime	(	const dtime_t *	_s,
		SQL::Time *	_r )

Definition at line 322 of file IFXTypes.cpp.

{
    SQL::TimeStamp t;
    __decode_dtime(_s, &t);
    _r->nHour = t.nHour;
    _r->nMin = t.nMin;
    _r->nSec = t.nSec;
    _r->nFrac = t.nFrac;
}

__decode_dtime() [3/3]

void __decode_dtime	(	const dtime_t *	_s,
		SQL::TimeStamp *	_r )

Definition at line 221 of file IFXTypes.cpp.

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

__decode_intrvl()

void __decode_intrvl	(	const intrvl_t *	_s,
		SQL::Interval *	_r )

Definition at line 118 of file IFXTypes.cpp.

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

__encode_dtime() [1/3]

int __encode_dtime	(	const SQL::Date *	_s,
		dtime_t *	_r )

Definition at line 358 of file IFXTypes.cpp.

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

__encode_dtime() [2/3]

int __encode_dtime	(	const SQL::Time *	_s,
		dtime_t *	_r )

Definition at line 376 of file IFXTypes.cpp.

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

__encode_dtime() [3/3]

int __encode_dtime	(	const SQL::TimeStamp *	_s,
		dtime_t *	_r )

Definition at line 336 of file IFXTypes.cpp.

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

__encode_intrvl()

int __encode_intrvl	(	const SQL::Interval *	_s,
		SQL::DataType	_dataType,
		intrvl_t *	_r )

Definition at line 399 of file IFXTypes.cpp.

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

__get_dec_strlen()

__DCL_BEGIN_NAMESPACE size_t __get_dec_strlen

(

const dec_t *

p

)

Definition at line 26 of file IFXTypes.cpp.

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