PqParam Class Reference

#include <PqParam.h>

Inheritance diagram for PqParam:

Public Member Functions
bool	init (SQL::Query *_query, int _index, const PGresult *_res)
bool	onAfterExecute ()
	PqParam ()
virtual	~PqParam ()
virtual const wchar_t *	serverDataTypeName () const
virtual void	setNull ()
virtual bool	__setData (_CONST void *_val, size_t _size, SQL::DataType _valType, SQL::DataType _sqlType)
bool	setInteger (const void *_val, size_t _size)
bool	setUInteger (const void *_val, size_t _size)
bool	setFloat (const void *_val, size_t _size)
bool	setDate (const SQL::Date *_val, size_t _size)
bool	setTime (const SQL::Time *_val, size_t _size)
bool	setTimeStamp (const SQL::TimeStamp *_val, size_t _size)
bool	setInterval (const SQL::Interval *_val, size_t _size)
bool	setBytes (_CONST void *_val, size_t _size, SQL::DataType _valType, SQL::DataType _sqlType)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
PqQuery *	query () const
PqConnection *	conn () const
Protected Member Functions inherited from SQL::Param
	Param (Query *_queryHandle)
virtual	~Param ()
virtual bool	__setOutputType (DataType _sqlType)
virtual bool	__getDataSize (size_t *_size, bool _maxsize)
virtual bool	__getData (void *_buf, size_t *_size, DataType _bufType)
Protected Member Functions inherited from SQL::Field
	Field (Query *_queryHandle)
virtual	~Field ()
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Additional Inherited Members
Protected Attributes inherited from SQL::Field
Query *	__queryHandle
String	__name
DataType	__dataType
short	__precision
short	__scale

Detailed Description

Definition at line 6 of file PqParam.h.

Constructor & Destructor Documentation

PqParam()

PqParam::PqParam

(

)

~PqParam()

PqParam::~PqParam ( )

virtual

Definition at line 60 of file PqParam.cpp.

{
}

Member Function Documentation

__setData()

bool PqParam::__setData ( _CONST void * _val, size_t _size, SQL::DataType _valType, SQL::DataType _sqlType )

virtual

Implements SQL::Param.

Definition at line 100 of file PqParam.cpp.

{
    bool r = false;
    switch(_valType) {
        case SQL::typeInteger:
            r = setInteger(_val, _size);
            break;
        case SQL::typeUInteger:
            r = setUInteger(_val, _size);
            break;
        case SQL::typeFloat:
            r = setFloat(_val, _size);
            break;
        case SQL::typeDate: 
            r = setDate((const SQL::Date*)_val, _size);
            break;
        case SQL::typeTime:
            r = setTime((const SQL::Time*)_val, _size);
            break;
        case SQL::typeTimeStamp:
            r = setTimeStamp((const SQL::TimeStamp*)_val, _size);
            break;
        case SQL::typeInterval:
            r = setInterval((const SQL::Interval*)_val, _size);
            break;
        case SQL::typeText:
        case SQL::typeBinary:
        case SQL::typeInputStream:
            r = setBytes(_val, _size, _valType, _sqlType);
            break;
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        Param::__dataType = _sqlType;
    }
    return r;
}

conn()

PqConnection * PqParam::conn ( ) const

inlineprotected

Definition at line 65 of file PqParam.h.

{
    return query()->conn();
}

init()

bool PqParam::init	(	SQL::Query *	_query,
		int	_index,
		const PGresult *	_res )

Definition at line 64 of file PqParam.cpp.

{
    __DCL_ASSERT(Param::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL && _res != NULL);
 
    Param::__queryHandle = _queryHandle;
 
    __index = _index;
    __type = PQparamtype(_res, _index);
 
    return true;
}

onAfterExecute()

bool PqParam::onAfterExecute

(

)

Definition at line 77 of file PqParam.cpp.

{
    Param::__dataType = SQL::typeUnknown;
    __bytes.clear();
 
    return true;
}

query()

PqQuery * PqParam::query ( ) const

inlineprotected

Definition at line 60 of file PqParam.h.

{
    return (PqQuery*)Param::__queryHandle;
}

serverDataTypeName()

const wchar_t * PqParam::serverDataTypeName ( ) const

virtual

Implements SQL::Field.

Definition at line 85 of file PqParam.cpp.

{
    return __dataTypeName(__type);
}

setBytes()

bool PqParam::setBytes	(	_CONST void *	_val,
		size_t	_size,
		SQL::DataType	_valType,
		SQL::DataType	_sqlType )

Definition at line 620 of file PqParam.cpp.

{
    const char* val = (const char*)_val;
    size_t size = _size;
    SQL::DataType valType = _valType;
    if (_valType == SQL::typeInputStream) {
        try {
            __bytes = Files::readBytes(*(InputStream*)_val, _size);
            val = __bytes;
            size = __bytes.length();
        }
        catch (IOException* _e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
            _e->destroy();
            return false;
        }
        if (_sqlType == SQL::typeBinary
            || _sqlType == SQL::typeLongBinary
            || _sqlType == SQL::typeBlob) {
            valType = SQL::typeBinary;
        }
    }
 
    if (10 * 1024 * 1024 < size) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    if (valType == SQL::typeText) {
        switch (__type) {
            case BYTEAOID:
            case CHAROID:           
            case BPCHAROID:
            case VARCHAROID:
 
            case TEXTOID:
            case JSONOID:
            case XMLOID:
 
            case TSVECTOROID:
            case TSQUERYOID:
            case JSONBOID:
            case JSONPATHOID: {
                // 여기서 FORMAT_BINARY는 
                // 서버에서 변환하지 마라! 의미
                query()->setValue(__index, __type,
                    val, (unsigned)size, __FORMAT_BINARY
                );
                break;
            }
            case BOOLOID:
            case INT2OID:
            case INT4OID:
            case INT8OID:
            case FLOAT4OID:
            case FLOAT8OID:
            case MONEYOID:
            case NUMERICOID:
            case DATEOID:
            case TIMEOID:
            case TIMETZOID:
            case TIMESTAMPOID:
            case TIMESTAMPTZOID:
            case INTERVALOID:
            case BITOID:
            case VARBITOID:
 
            case MACADDROID:
            case INETOID:
            case CIDROID:
            case MACADDR8OID:
 
            case UUIDOID:
            default: {
                // 텍스트를 서버에서 적절히 변환해서 사용하라!
                query()->setValue(__index, __type,
                    val, (unsigned)size, __FORMAT_TEXT
                );
            }
#if 0
            default: {
                __SET_ERROR(SQL::eNotSupportDataType);
                return false;
            }
#endif
        }
    }
    else {
        // SQL::typeBinary는
        // 서버에서 변환하지 마라!
        query()->setValue(__index, __type,
            val, (unsigned)size, __FORMAT_BINARY
        );
    }
 
    return true;
}

setDate()

bool PqParam::setDate	(	const SQL::Date *	_val,
		size_t	_size )

Definition at line 415 of file PqParam.cpp.

{
    if (_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Date* val = (const SQL::Date*)_val;
    ByteStringBuilder sb;
    sb.format(
        "%04d-%02d-%02d",
        __ABS(val->year),
        val->month,
        val->day
    );
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    switch (__type) {
        case DATEOID:
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setFloat()

bool PqParam::setFloat	(	const void *	_val,
		size_t	_size )

Definition at line 331 of file PqParam.cpp.

{
    double d;
    switch (_size) {
        case sizeof(float) : {
            d = *(float*)_val;
            break;
        }
        case sizeof(double) : {
            d = *(double*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = d != 0 ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (d < INT16_MIN || INT16_MAX < d) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)(int16_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (d < INT32_MIN || INT32_MAX < d) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)(int32_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)(int64_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::format((_size == 4 ? "%.8g" : "%.16g"), d);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setInteger()

bool PqParam::setInteger	(	const void *	_val,
		size_t	_size )

Definition at line 147 of file PqParam.cpp.

{
    int64_t n;
    switch (_size) {
        case sizeof(int8_t) : {
            n = *(int8_t*)_val;
            break;
        }
        case sizeof(int16_t) : {
            n = *(int16_t*)_val;
            break;
        }
        case sizeof(int32_t) : {
            n = *(int32_t*)_val;
            break;
        }
        case sizeof(int64_t) : {
            n = *(int64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = n ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (n < INT16_MIN || INT16_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)(int16_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (n < INT32_MIN || INT32_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)(int32_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)(int64_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::valueOf(n);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setInterval()

bool PqParam::setInterval	(	const SQL::Interval *	_val,
		size_t	_size )

Definition at line 568 of file PqParam.cpp.

{
    if (_size != sizeof(SQL::Interval)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Interval* val = (const SQL::Interval*)_val;
    if (val->secs || val->fracs >= 0) {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%d.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            val->secs,
            __ABS(val->fracs)
        );
    }
    else {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%-0.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            __ABS(val->fracs)
        );
    }
 
    switch (__type) {
        case INTERVALOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setNull()

void PqParam::setNull ( )

virtual

Implements SQL::Param.

Definition at line 90 of file PqParam.cpp.

{
    Param::__dataType = SQL::typeUnknown;
}

setTime()

bool PqParam::setTime	(	const SQL::Time *	_val,
		size_t	_size )

Definition at line 457 of file PqParam.cpp.

{
    if (_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Time* val = (const SQL::Time*)_val;
    if (val->tzoff == INT16_MIN) {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d %+03d:%02d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
 
    switch (__type) {
        case TIMEOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setTimeStamp()

bool PqParam::setTimeStamp	(	const SQL::TimeStamp *	_val,
		size_t	_size )

Definition at line 506 of file PqParam.cpp.

{
    if (_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::TimeStamp* val = (const SQL::TimeStamp*)_val;
    ByteStringBuilder sb;
    if (val->tzoff == INT16_MIN) {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d %+03d:%02d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    switch (__type) {
        case DATEOID:
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

setUInteger()

bool PqParam::setUInteger	(	const void *	_val,
		size_t	_size )

Definition at line 239 of file PqParam.cpp.

{
    uint64_t u;
    switch (_size) {
        case sizeof(uint8_t) : {
            u = *(uint8_t*)_val;
            break;
        }
        case sizeof(uint16_t) : {
            u = *(uint16_t*)_val;
            break;
        }
        case sizeof(uint32_t) : {
            u = *(uint32_t*)_val;
            break;
        }
        case sizeof(uint64_t) : {
            u = *(uint64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = u ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (UINT16_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (UINT32_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::valueOf(u);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}

Member Data Documentation

u16

uint16_t PqParam::u16

Definition at line 15 of file PqParam.h.

u32

uint32_t PqParam::u32

Definition at line 16 of file PqParam.h.

u64

uint64_t PqParam::u64

Definition at line 17 of file PqParam.h.

u8

uint8_t PqParam::u8

Definition at line 14 of file PqParam.h.

---

The documentation for this class was generated from the following files:

• PqParam.h
• PqParam.cpp