DCL 4.0
Loading...
Searching...
No Matches
PgParam Class Reference

#include <PgParam.h>

Inheritance diagram for PgParam:
SQL::Param SQL::Field Object

Public Member Functions

bool init (SQL::Query *_query, sqlvar_t *_sqlvar)
bool onAfterExecute ()
 PgParam ()
virtual ~PgParam ()
virtual const wchar_t * serverDataTypeName () const
virtual void setNull ()
virtual bool __setData (_CONST void *_pv, size_t _size, SQL::DataType _dataType, SQL::DataType _assignType)
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

void setErrorStatus (SQL::Error _error, long _SQLCODE, const wchar_t *_filename, int _line)
void setErrorStatus (const ByteString &_message, const wchar_t *_filename, int _line)
PgQuery * query () const
Protected Member Functions inherited from SQL::Param
 Param (Query *_queryHandle)
virtual ~Param ()
virtual bool isNull () const
virtual bool __setDataType (DataType _dataType)
virtual bool __getDataSize (size_t *_pn, bool _maxSize)
virtual bool __getData (void *_pv, size_t *_pn, DataType _dataType)
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 PgParam.h.

Constructor & Destructor Documentation

◆ PgParam()

PgParam::PgParam ( )

◆ ~PgParam()

PgParam::~PgParam ( )
virtual

Definition at line 38 of file PgParam.cpp.

39{
40}

Member Function Documentation

◆ __setData()

bool PgParam::__setData ( _CONST void * _pv,
size_t _size,
SQL::DataType _dataType,
SQL::DataType _assignType )
virtual

Implements SQL::Param.

Definition at line 91 of file PgParam.cpp.

97{
98 switch(_dataType) {
99 case SQL::typeInteger: {
100 switch (_size) {
101 case sizeof(int8_t) : {
102 __data.i32 = (int32_t) * (int8_t*)_pv;
103 __sqlvar->sqltype = ECPGt_int;
104 __sqlvar->sqllen = sizeof(int32_t);
105 __sqlvar->sqldata = (char*)&__data;
106 break;
107 }
108 case sizeof(int16_t) : {
109 __data.i32 = (int32_t) * (int16_t*)_pv;
110 __sqlvar->sqltype = ECPGt_int;
111 __sqlvar->sqllen = sizeof(int32_t);
112 __sqlvar->sqldata = (char*)&__data;
113 break;
114 }
115 case sizeof(int32_t) : {
116 __data.i32 = *(int32_t*)_pv;
117 __sqlvar->sqltype = ECPGt_int;
118 __sqlvar->sqllen = sizeof(int32_t);
119 __sqlvar->sqldata = (char*)&__data;
120 break;
121 }
122 case sizeof(int64_t) : {
123 __data.i64 = *(int64_t*)_pv;
124#if ALIGNOF_LONG == 8
125 __sqlvar->sqltype = ECPGt_long;
126#else
127 __sqlvar->sqltype = ECPGt_long_long;
128#endif
129 __sqlvar->sqllen = sizeof(int64_t);
130 __sqlvar->sqldata = (char*)&__data;
131 break;
132 }
133 default: {
134 __SET_ERROR(SQL::eInvalidDataSize);
135 return false;
136 }
137 }
138 break;
139 }
140 case SQL::typeUInteger: {
141 switch (_size) {
142 case sizeof(uint8_t) : {
143 __data.i32 = (int32_t) * (uint8_t*)_pv;
144 __sqlvar->sqltype = ECPGt_int;
145 __sqlvar->sqllen = sizeof(uint32_t);
146 __sqlvar->sqldata = (char*)&__data;
147 break;
148 }
149 case sizeof(uint16_t) : {
150 __data.i32 = (int32_t) * (uint16_t*)_pv;
151 __sqlvar->sqltype = ECPGt_int;
152 __sqlvar->sqllen = sizeof(uint32_t);
153 __sqlvar->sqldata = (char*)&__data;
154 break;
155 }
156 case sizeof(uint32_t) : {
157 __data.i32 = (int32_t) * (uint32_t*)_pv;
158 __sqlvar->sqltype = ECPGt_int;
159 __sqlvar->sqllen = sizeof(uint32_t);
160 __sqlvar->sqldata = (char*)&__data;
161 break;
162 }
163 case sizeof(uint64_t) : {
164 __data.i64 = (int64_t) * (uint64_t*)_pv;
165#if ALIGNOF_LONG == 8
166 __sqlvar->sqltype = ECPGt_long;
167#else
168 __sqlvar->sqltype = ECPGt_long_long;
169#endif
170 __sqlvar->sqllen = sizeof(int64_t);
171 __sqlvar->sqldata = (char*)&__data;
172 break;
173 }
174 default: {
175 __SET_ERROR(SQL::eInvalidDataSize);
176 return false;
177 }
178 }
179 break;
180 }
181 case SQL::typeFloat: {
182 switch (_size) {
183 case sizeof(float) : {
184 __data.f32 = *(float*)_pv;
185 __sqlvar->sqltype = ECPGt_float;
186 __sqlvar->sqllen = sizeof(float);
187 __sqlvar->sqldata = (char*)&__data;
188 break;
189 }
190 case sizeof(double) : {
191 __data.f64 = *(double*)_pv;
192 __sqlvar->sqltype = ECPGt_double;
193 __sqlvar->sqllen = sizeof(double);
194 __sqlvar->sqldata = (char*)&__data;
195 break;
196 }
197 default: {
198 __SET_ERROR(SQL::eInvalidDataSize);
199 return false;
200 }
201 }
202 break;
203 }
204 case SQL::typeDate: {
205 if (_size == sizeof(SQL::Date)) {
206 __encode((const SQL::Date*)_pv, &__data.dt);
207 __sqlvar->sqltype = ECPGt_date;
208 __sqlvar->sqllen = sizeof(date);
209 __sqlvar->sqldata = (char*)&__data;
210 }
211 else {
212 __SET_ERROR(SQL::eInvalidDataSize);
213 return false;
214 }
215 break;
216 }
217 case SQL::typeTime: {
218 if (_size == sizeof(SQL::Time)) {
219 __bytes = __encode((const SQL::Time*)_pv);
220 __sqlvar->sqltype = ECPGt_char;
221 __sqlvar->sqllen = (short)__bytes.length();
222 __sqlvar->sqldata = (char*)__bytes.data();
223 }
224 else {
225 __SET_ERROR(SQL::eInvalidDataSize);
226 return false;
227 }
228 break;
229 }
230 case SQL::typeTimeStamp: {
231 if (_size == sizeof(SQL::TimeStamp)) {
232 const SQL::TimeStamp* p = (const SQL::TimeStamp*)_pv;
233#if 0
234 if (p->nTzMin != INT16_MIN) {
235 __SET_ERROR(SQL::eInvalidData);
236 return false;
237 }
238#endif
239 __encode(p, &__data.ts);
240 __sqlvar->sqltype = ECPGt_timestamp;
241 __sqlvar->sqllen = sizeof(timestamp);
242 __sqlvar->sqldata = (char*)&__data;
243 }
244 else {
245 __SET_ERROR(SQL::eInvalidDataSize);
246 return false;
247 }
248 break;
249 }
250 case SQL::typeInterval :
251 case SQL::typeIntervalYm :
252 case SQL::typeIntervalDs: {
253 if (_size == sizeof(SQL::Interval)) {
254 __encode((const SQL::Interval*)_pv, &__data.ival);
255 __sqlvar->sqltype = ECPGt_interval;
256 __sqlvar->sqllen = sizeof(interval);
257 __sqlvar->sqldata = (char*)&__data;
258 }
259 else {
260 __SET_ERROR(SQL::eInvalidDataSize);
261 return false;
262 }
263 break;
264 }
265 case SQL::typeText: {
266 if (_assignType == SQL::typeNumeric) {
267 if (_size > 0) {
268 numeric* p = PGTYPESnumeric_from_asc((char*)_pv, NULL);
269 if (!p) {
270 __SET_ERROR(SQL::eInvalidData);
271 return false;
272 }
273 PGTYPESnumeric_copy(p, &__data.nu);
274 __sqlvar->sqltype = ECPGt_numeric;
275 __sqlvar->sqllen = sizeof(numeric);
276 __sqlvar->sqldata = (char*)&__data;
277 }
278 else {
279 __SET_ERROR(SQL::eInvalidDataSize);
280 return false;
281 }
282 break;
283 }
284 }
285 case SQL::typeBinary: {
286 switch (_assignType) {
287 case SQL::typeText: // CHAR, VARCHAR
288 case SQL::typeLongText: {
289 __sqlvar->sqltype = ECPGt_char;
290 __sqlvar->sqllen = (short) _size;
291 __sqlvar->sqldata = (char*) _pv;
292 break;
293 }
294 case SQL::typeBinary: // ECPGt_bytea 동작하지 않는다!
295 case SQL::typeLongBinary: {
296 __bytes = ByteString::toHexString(
297 (const char*)_pv, _size, (size_t)-1, true);
298 if (__bytes.length() > INT16_MAX) {
299 __SET_ERROR(SQL::eInvalidDataSize);
300 return false;
301 }
302 __sqlvar->sqltype = ECPGt_char;
303 __sqlvar->sqllen = (short)__bytes.length();
304 __sqlvar->sqldata = (char*)__bytes.data();
305 break;
306 }
307 default: {
308 __SET_ERROR(SQL::eNotSupportDataType);
309 return false;
310 }
311 }
312 break;
313 }
314 case SQL::typeInputStream: {
315 try {
316 __bytes = Files::readBytes(*(InputStream*)_pv, _size);
317 }
318 catch (IOException* e) {
319 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
320 e->destroy();
321 return false;
322 }
323 if (__bytes.length() > INT16_MAX) {
324 __SET_ERROR(SQL::eInvalidDataSize);
325 return false;
326 }
327 __bytes = ByteString::toHexString(__bytes, (size_t)-1, true);
328 if (__bytes.length() > INT16_MAX) {
329 __SET_ERROR(SQL::eInvalidDataSize);
330 return false;
331 }
332 __sqlvar->sqltype = ECPGt_char;
333 __sqlvar->sqllen = (short) __bytes.length();
334 __sqlvar->sqldata = (char*)__bytes.data();
335 break;
336 }
337 default: {
338 __SET_ERROR(SQL::eNotSupportDataType);
339 return false;
340 }
341 }
342
343 __indicator = 0;
344 Param::__dataType = _assignType;
345 return true;
346}
NULL
#define NULL
Definition Config.h:340
INT16_MAX
#define INT16_MAX
Definition Config.h:317
INT16_MIN
#define INT16_MIN
Definition Config.h:312
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.h:57
__encode
void __encode(const SQL::Date *_s, date *_r)
Definition PgTypes.cpp:37
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:150
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
Files::readBytes
static ByteString readBytes(InputStream &_input, size_t _n=(size_t) -1) __DCL_THROWS1(IOException *)
Definition Files.cpp:398
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:76
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:67
SQL::typeTime
@ typeTime
Definition SQLCore.h:69
SQL::typeLongBinary
@ typeLongBinary
Definition SQLCore.h:78
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:65
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:70
SQL::typeInputStream
@ typeInputStream
Definition SQLCore.h:83
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:72
SQL::typeIntervalDs
@ typeIntervalDs
Definition SQLCore.h:74
SQL::typeDate
@ typeDate
Definition SQLCore.h:68
SQL::typeText
@ typeText
Definition SQLCore.h:75
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:66
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:64
SQL::typeIntervalYm
@ typeIntervalYm
Definition SQLCore.h:73
SQL::typeLongText
@ typeLongText
Definition SQLCore.h:77
SQL::eInvalidData
@ eInvalidData
Definition SQLCore.h:55
SQL::eNotSupportDataType
@ eNotSupportDataType
Definition SQLCore.h:48
SQL::eInvalidDataSize
@ eInvalidDataSize
Definition SQLCore.h:57
SQL::TimeStamp::nTzMin
int16_t nTzMin
Definition SQLCore.h:118

◆ init()

bool PgParam::init ( SQL::Query * _query,
sqlvar_t * _sqlvar )

Definition at line 42 of file PgParam.cpp.

43{
44 __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
45
46 Param::__queryHandle = _queryHandle;
47
48 //__DCL_TRACE4(L"type[%d] len[%d] data[%p] ind[%p]\n",
49 // _sqlvar->sqltype, _sqlvar->sqllen,
50 // _sqlvar->sqldata, _sqlvar->sqlind);
51
52 __sqlvar = _sqlvar;
53 //__sqlvar->sqltype = 0;
54 //__sqlvar->sqllen = 0;
55 //__sqlvar->sqldata = NULL;
56 __sqlvar->sqlind = &__indicator;
57 __indicator = -1; // set null
58
59 return true;
60}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371

◆ onAfterExecute()

bool PgParam::onAfterExecute ( )

Definition at line 62 of file PgParam.cpp.

63{
64 Param::__dataType = SQL::typeUnknown;
65 __sqlvar->sqltype = 0;
66 __sqlvar->sqllen = 0;
67 __sqlvar->sqldata = NULL;
68 __indicator = -1; // set null
69 __bytes.clear();
70
71 return true;
72}
SQL::typeUnknown
@ typeUnknown
Definition SQLCore.h:63

◆ query()

PgQuery * PgParam::query ( ) const
inlineprotected

Definition at line 73 of file PgParam.h.

74{
75 return (PgQuery*)Param::__queryHandle;
76}

◆ serverDataTypeName()

const wchar_t * PgParam::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 77 of file PgParam.cpp.

78{
79 return __dataTypeName(__sqlvar);
80}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setErrorStatus() [1/2]

void PgParam::setErrorStatus ( const ByteString & _message,
const wchar_t * _filename,
int _line )
inlineprotected

Definition at line 63 of file PgParam.h.

65{
66 ((PgConnection*)Param::connection())->setErrorStatus(
67 _message,
68 _filename,
69 _line
70 );
71}

◆ setErrorStatus() [2/2]

void PgParam::setErrorStatus ( SQL::Error _error,
long _SQLCODE,
const wchar_t * _filename,
int _line )
inlineprotected

Definition at line 52 of file PgParam.h.

54{
55 ((PgConnection*)Param::connection())->setErrorStatus(
56 _error,
57 _SQLCODE,
58 _filename,
59 _line
60 );
61}

◆ setNull()

void PgParam::setNull ( )
virtual

Implements SQL::Param.

Definition at line 82 of file PgParam.cpp.

83{
84 Param::__dataType = SQL::typeUnknown;
85 __sqlvar->sqltype = 0;
86 __sqlvar->sqllen = 0;
87 __sqlvar->sqldata = NULL;
88 __indicator = -1; // set null
89}

Member Data Documentation

◆ dt

date PgParam::dt

Definition at line 20 of file PgParam.h.

◆ f32

float PgParam::f32

Definition at line 17 of file PgParam.h.

◆ f64

double PgParam::f64

Definition at line 18 of file PgParam.h.

◆ i32

int32_t PgParam::i32

Definition at line 13 of file PgParam.h.

◆ i64

int64_t PgParam::i64

Definition at line 14 of file PgParam.h.

◆ ival

interval PgParam::ival

Definition at line 22 of file PgParam.h.

◆ nu

numeric PgParam::nu

Definition at line 19 of file PgParam.h.

◆ ts

timestamp PgParam::ts

Definition at line 21 of file PgParam.h.

◆ u32

uint32_t PgParam::u32

Definition at line 15 of file PgParam.h.

◆ u64

uint64_t PgParam::u64

Definition at line 16 of file PgParam.h.

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