SqParam Class Reference

#include <SqParam.h>

Inheritance diagram for SqParam:

Public Member Functions
bool	init (SQL::Query *_query, int _number, const char *_name)
bool	onBeforeExecute ()
bool	onAfterExecute ()
	SqParam ()
virtual	~SqParam ()
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
SqQuery *	query () const
SqConnection *	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 SqParam.h.

Constructor & Destructor Documentation

SqParam()

SqParam::SqParam

(

)

~SqParam()

SqParam::~SqParam ( )

virtual

Definition at line 54 of file SqParam.cpp.

{
}

Member Function Documentation

__setData()

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

virtual

Implements SQL::Param.

Definition at line 130 of file SqParam.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()

SqConnection * SqParam::conn ( ) const

inlineprotected

Definition at line 67 of file SqParam.h.

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

init()

bool SqParam::init	(	SQL::Query *	_query,
		int	_number,
		const char *	_name )

Definition at line 58 of file SqParam.cpp.

{
    __DCL_ASSERT(Param::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL);
 
    Param::__queryHandle = _queryHandle;
 
    __number = _number;
    __name.assign(_name);
 
    return true;
}

onAfterExecute()

bool SqParam::onAfterExecute

(

)

Definition at line 107 of file SqParam.cpp.

{
    setNull();
    return true;
}

onBeforeExecute()

bool SqParam::onBeforeExecute

(

)

Definition at line 71 of file SqParam.cpp.

{
    int rc = SQLITE_OK;
    switch (__type) {
        case SQLITE_INTEGER: {
            rc = sqlite3_bind_int64(query()->stmt(), __number, __data.n);
            break;
        }
        case SQLITE_FLOAT: {
            rc = sqlite3_bind_double(query()->stmt(), __number, __data.d);
            break;
        }
        case SQLITE_TEXT: {
            rc = sqlite3_bind_text64(query()->stmt(), __number,    (const char*)__data.p,
                __size, NULL, SQLITE_UTF8);
            break;
        }
        case SQLITE_BLOB: {
            rc = sqlite3_bind_blob(query()->stmt(), __number, __data.p, (int)__size, NULL);
            break;
        }
        case SQLITE_NULL:
        default: {
            rc = sqlite3_bind_null(query()->stmt(), __number);
        }
    }
 
    if (rc != SQLITE_OK) {
        ByteStringBuilder sb = sqlite3_errmsg(conn()->connHandle());
        sb.append(' ').append(__name);
        __SET_ERROR_MSG(sb.toByteString());
        return false;
    }
 
    return true;
}

query()

SqQuery * SqParam::query ( ) const

inlineprotected

Definition at line 62 of file SqParam.h.

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

serverDataTypeName()

const wchar_t * SqParam::serverDataTypeName ( ) const

virtual

Implements SQL::Field.

Definition at line 113 of file SqParam.cpp.

{
    return __dataTypeName(__type);
}

setBytes()

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

Definition at line 405 of file SqParam.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::typeText
            || _sqlType == SQL::typeLongText
            || _sqlType == SQL::typeClob) {
            valType = SQL::typeText;
        }
        else {
            valType = SQL::typeBinary;
        }
    }
 
    __data.p = (const void*)val;
    __size = size;
 
    __type = valType == SQL::typeText ? SQLITE_TEXT : SQLITE_BLOB;
    return true;
}

setDate()

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

Definition at line 256 of file SqParam.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();
 
    __data.p = (void*) __bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}

setFloat()

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

Definition at line 235 of file SqParam.cpp.

{
    switch (_size) {
        case sizeof(float) : {
            __data.d =  *(float*)_val;
            break;
        }
        case sizeof(double) : {
            __data.d =  *(double*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_FLOAT;
    return true;
}

setInteger()

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

Definition at line 177 of file SqParam.cpp.

{
    switch (_size) {
        case sizeof(int8_t) : {
            __data.n =  *(int8_t*)_val;
            break;
        }
        case sizeof(int16_t) : {
            __data.n =  *(int16_t*)_val;
            break;
        }
        case sizeof(int32_t) : {
            __data.n =  *(int32_t*)_val;
            break;
        }
        case sizeof(int64_t) : {
            __data.n = *(int64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_INTEGER;
    return true;
}

setInterval()

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

Definition at line 366 of file SqParam.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)
        );
    }
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}

setNull()

void SqParam::setNull ( )

virtual

Implements SQL::Param.

Definition at line 118 of file SqParam.cpp.

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

setTime()

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

Definition at line 283 of file SqParam.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)
        );
    }
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}

setTimeStamp()

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

Definition at line 319 of file SqParam.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();
 
    __data.p = (void*)__bytes.data();
    __size = __bytes.length();
 
    __type = SQLITE_TEXT;
    return true;
}

setUInteger()

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

Definition at line 206 of file SqParam.cpp.

{
    switch (_size) {
        case sizeof(uint8_t) : {
            __data.n =  *(uint8_t*)_val;
            break;
        }
        case sizeof(uint16_t) : {
            __data.n =  *(uint16_t*)_val;
            break;
        }
        case sizeof(uint32_t) : {
            __data.n =  *(uint32_t*)_val;
            break;
        }
        case sizeof(uint64_t) : {
            __data.n = *(uint64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    __type = SQLITE_INTEGER;
    return true;
}

Member Data Documentation

d

double SqParam::d

Definition at line 16 of file SqParam.h.

n

int64_t SqParam::n

Definition at line 15 of file SqParam.h.

p

const void* SqParam::p

Definition at line 17 of file SqParam.h.

---

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

• SqParam.h
• SqParam.cpp