DCL 4.1
Loading...
Searching...
No Matches
IFXParam Class Reference

#include <IFXParam.h>

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

Public Member Functions

bool init (SQL::Query *_query, ifx_sqlvar_t *_sqlvar)
bool onAfterExecute ()
 IFXParam ()
virtual ~IFXParam ()
virtual const wchar_t * serverDataTypeName () const
virtual void setNull ()
virtual bool __setData (_CONST void *_pv, size_t _size, SQL::DataType _dataType, SQL::DataType _assignType)
bool setInteger (const void *_pv, size_t _size)
bool setUInteger (const void *_pv, size_t _size)
bool setBytes (const void *_pv, size_t _size, SQL::DataType _assignType)
bool setInputStream (const void *_pv, size_t _size, 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)
IFXQuery * 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 IFXParam.h.

Constructor & Destructor Documentation

◆ IFXParam()

IFXParam::IFXParam ( )

◆ ~IFXParam()

IFXParam::~IFXParam ( )
virtual

Definition at line 55 of file IFXParam.cpp.

56{
57}

Member Function Documentation

◆ __setData()

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

Implements SQL::Param.

Definition at line 109 of file IFXParam.cpp.

115{
116 bool r = true;
117 switch(_dataType) {
118 case SQL::typeInteger : {
119 r = setInteger(_pv, _size);
120 break;
121 }
122 case SQL::typeUInteger: {
123 r = setUInteger(_pv, _size);
124 break;
125 }
126 case SQL::typeFloat: {
127 if (_size == sizeof(float)) {
128 __data.f32 = *(float*)_pv;
129 __sqlvar->sqldata = (char*)&__data;
130 __sqlvar->sqltype = CFLOATTYPE;
131 __sqlvar->sqllen = sizeof(float);
132 }
133 else if (_size == sizeof(double)) {
134 __data.f64 = *(double*)_pv;
135 __sqlvar->sqldata = (char*)&__data;
136 __sqlvar->sqltype = CDOUBLETYPE;
137 __sqlvar->sqllen = sizeof(double);
138 }
139 else {
140 __SET_ERROR(SQL::eInvalidDataSize);
141 return false;
142 }
143 break;
144 }
145 case SQL::typeDate: {
146 if (_size == sizeof(SQL::Date)) {
147 const SQL::Date* p = (const SQL::Date*)_pv;
148 short mdy[3];
149 mdy[0] = p->month;
150 mdy[1] = p->day;
151 mdy[2] = p->year;
152
153 int r = rmdyjul(mdy, &__data.date);
154 if (r) {
155 __SET_ERROR_SQLCODE(r);
156 return false;
157 }
158 __sqlvar->sqldata = (char*)&__data;
159 __sqlvar->sqltype = CDATETYPE;
160 __sqlvar->sqllen = sizeof(long);
161 }
162 else {
163 __SET_ERROR(SQL::eInvalidDataSize);
164 return false;
165 }
166 break;
167 }
168 case SQL::typeTime: {
169 if (_size == sizeof(SQL::Time)) {
170 const SQL::Time* p = (const SQL::Time*)_pv;
171 int r = __encode_dtime(p, &__data.dtime);
172 if (r) {
173 __SET_ERROR_SQLCODE(r);
174 return false;
175 }
176
177 __sqlvar->sqldata = (char*)&__data;
178 __sqlvar->sqltype = CDTIMETYPE;
179 __sqlvar->sqllen = sizeof(dtime_t);
180 }
181 else {
182 __SET_ERROR(SQL::eInvalidDataSize);
183 return false;
184 }
185 break;
186 }
187 case SQL::typeTimeStamp: {
188 if (_size == sizeof(SQL::TimeStamp)) {
189 const SQL::TimeStamp* p = (const SQL::TimeStamp*)_pv;
190 int r = __encode_dtime(p, &__data.dtime);
191 if (r) {
192 __SET_ERROR_SQLCODE(r);
193 return false;
194 }
195
196 __sqlvar->sqldata = (char*)&__data;
197 __sqlvar->sqltype = CDTIMETYPE;
198 __sqlvar->sqllen = sizeof(dtime_t);
199 }
200 else {
201 __SET_ERROR(SQL::eInvalidDataSize);
202 return false;
203 }
204 break;
205 }
206 case SQL::typeInterval: {
207 if (_size == sizeof(SQL::Interval)) {
208 int r = __encode_intrvl(
209 (const SQL::Interval*)_pv,
210 _dataType,
211 &__data.ival
212 );
213 if (r) {
214 __SET_ERROR_SQLCODE(r);
215 return false;
216 }
217
218 __sqlvar->sqldata = (char*)&__data;
219 __sqlvar->sqltype = CINVTYPE;
220 __sqlvar->sqllen = sizeof(intrvl_t);
221 }
222 else {
223 __SET_ERROR(SQL::eInvalidDataSize);
224 return false;
225 }
226 break;
227 }
228 case SQL::typeText : {
229 if (_assignType == SQL::typeNumeric) {
230 if (_size > 0) {
231 int r = deccvasc((char*)_pv, _size, &__data.dec);
232 if (r) {
233 __SET_ERROR_SQLCODE(r);
234 return false;
235 }
236 __sqlvar->sqldata = (char*)&__data;
237 __sqlvar->sqltype = CDECIMALTYPE;
238 __sqlvar->sqllen = sizeof(dec_t);
239 }
240 else {
241 __SET_ERROR(SQL::eInvalidDataSize);
242 return false;
243 }
244 break;
245 }
246 }
247 case SQL::typeBinary: {
248 r = setBytes(_pv, _size, _assignType);
249 break;
250 }
251 case SQL::typeInputStream: {
252 r = setInputStream(_pv, _size, _assignType);
253 break;
254 }
255 default: {
256 __SET_ERROR(SQL::eNotSupportDataType);
257 return false;
258 }
259 }
260
261 if (r) {
262 __indicator = 0;
263 Param::__dataType = _assignType;
264 }
265
266 return true;
267}
__SET_ERROR_SQLCODE
#define __SET_ERROR_SQLCODE(SQLCODE)
Definition IFXConnection.h:54
__encode_dtime
int __encode_dtime(const SQL::TimeStamp *_s, dtime_t *_r)
Definition IFXTypes.cpp:337
__encode_intrvl
int __encode_intrvl(const SQL::Interval *_s, SQL::DataType _dataType, intrvl_t *_r)
Definition IFXTypes.cpp:400
r
ByteString r
Definition SQLConnection.cpp:182
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:153
IFXParam::setBytes
bool setBytes(const void *_pv, size_t _size, SQL::DataType _assignType)
Definition IFXParam.cpp:389
IFXParam::setInteger
bool setInteger(const void *_pv, size_t _size)
Definition IFXParam.cpp:269
IFXParam::setUInteger
bool setUInteger(const void *_pv, size_t _size)
Definition IFXParam.cpp:305
IFXParam::setInputStream
bool setInputStream(const void *_pv, size_t _size, SQL::DataType _assignType)
Definition IFXParam.cpp:462
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:77
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:67
SQL::typeTime
@ typeTime
Definition SQLCore.h:69
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:65
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:71
SQL::typeInputStream
@ typeInputStream
Definition SQLCore.h:84
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:73
SQL::typeDate
@ typeDate
Definition SQLCore.h:68
SQL::typeText
@ typeText
Definition SQLCore.h:76
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:66
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:64
SQL::eNotSupportDataType
@ eNotSupportDataType
Definition SQLCore.h:48
SQL::eInvalidDataSize
@ eInvalidDataSize
Definition SQLCore.h:57
SQL::Date::year
int16_t year
Definition SQLCore.h:97
SQL::Date::month
uint8_t month
Definition SQLCore.h:98
SQL::Date::day
uint8_t day
Definition SQLCore.h:99

◆ init()

bool IFXParam::init ( SQL::Query * _query,
ifx_sqlvar_t * _sqlvar )

Definition at line 59 of file IFXParam.cpp.

60{
61 __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
62
63 Param::__queryHandle = _queryHandle;
64
65 __sqltype = _sqlvar->sqltype;
66 __sqllen = _sqlvar->sqllen;
67 __indicator = -1; // set null
68 __sqlvar = _sqlvar;
69 __sqlvar->sqldata = NULL;
70 __sqlvar->sqlind = &__indicator;
71
72 return true;
73}
NULL
#define NULL
Definition Config.h:340
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371

◆ onAfterExecute()

bool IFXParam::onAfterExecute ( )

Definition at line 75 of file IFXParam.cpp.

76{
77 bool r = true;
78 if (__sqlvar->sqltype == CLOCATORTYPE && __sqlvar->sqldata) {
79 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
80 if (loc->loc_status != 0) {
81 __SET_ERROR_SQLCODE(loc->loc_status);
82 r = false;;
83 }
84 }
85
86 Param::__dataType = SQL::typeUnknown;
87 __indicator = -1; // set null
88 __sqlvar->sqldata = NULL;
89
90 return r;
91}
IFXParam::loc
loc_t loc
Definition IFXParam.h:23
SQL::typeUnknown
@ typeUnknown
Definition SQLCore.h:63

◆ query()

IFXQuery * IFXParam::query ( ) const
inlineprotected

Definition at line 81 of file IFXParam.h.

82{
83 return (IFXQuery*)Param::__queryHandle;
84}

◆ serverDataTypeName()

const wchar_t * IFXParam::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 96 of file IFXParam.cpp.

97{
98 return __dataTypeName(__sqlvar);
99}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setBytes()

bool IFXParam::setBytes ( const void * _pv,
size_t _size,
SQL::DataType _assignType )

Definition at line 389 of file IFXParam.cpp.

391{
392 switch (__sqltype & SQLTYPE) {
393 case SQLTEXT:
394 case SQLBYTES: {
395 if (_size > INT32_MAX) {
396 __SET_ERROR(SQL::eInvalidDataSize);
397 return false;
398 }
399 switch (_assignType) {
400 case SQL::typeText:
401 case SQL::typeLongText:
402 case SQL::typeClob: {
403 __data.loc.loc_type = SQLTEXT;
404 break;
405 }
406 case SQL::typeBinary:
407 case SQL::typeLongBinary:
408 case SQL::typeBlob: {
409 __data.loc.loc_type = SQLBYTES;
410 break;
411 }
412 default: {
413 __SET_ERROR(SQL::eNotSupportDataType);
414 return false;
415 }
416 }
417 __data.loc.loc_loctype = LOCMEMORY;
418 __data.loc.loc_indicator = 0;
419 // __data.loc.loc_type = SQLTEXT or SQLBYTES;
420 __data.loc.loc_mflags = 0;
421 __data.loc.loc_oflags = LOC_WONLY;
422
423 __data.loc.loc_buffer = (char*)_pv;
424 __data.loc.loc_bufsize = _size;
425 __data.loc.loc_size = _size;
426
427 __sqlvar->sqltype = CLOCATORTYPE;
428 __sqlvar->sqllen = sizeof(loc_t);
429 __sqlvar->sqldata = (char*)&__data.loc;
430 break;
431 }
432 default: {
433 switch (_assignType) {
434 case SQL::typeText:
435 case SQL::typeLongText:
436 case SQL::typeClob: {
437 __sqlvar->sqltype = CFIXCHARTYPE;
438 break;
439 }
440 case SQL::typeBinary:
441 case SQL::typeLongBinary:
442 case SQL::typeBlob: {
443 __sqlvar->sqltype = CFIXBINTYPE;
444 break;
445 }
446 default: {
447 __SET_ERROR(SQL::eNotSupportDataType);
448 return false;
449 }
450 }
451 __sqlvar->sqldata = (char*)_pv;
452 __sqlvar->sqllen = _size;
453 }
454 }
455 return true;
456}
INT32_MAX
#define INT32_MAX
Definition Config.h:318
SQL::typeClob
@ typeClob
Definition SQLCore.h:80
SQL::typeLongBinary
@ typeLongBinary
Definition SQLCore.h:79
SQL::typeBlob
@ typeBlob
Definition SQLCore.h:81
SQL::typeLongText
@ typeLongText
Definition SQLCore.h:78

◆ setErrorStatus() [1/2]

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

Definition at line 71 of file IFXParam.h.

73{
74 ((IFXConnection*)Param::connection())->setErrorStatus(
75 _message,
76 _filename,
77 _line
78 );
79}

◆ setErrorStatus() [2/2]

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

Definition at line 60 of file IFXParam.h.

62{
63 ((IFXConnection*)Param::connection())->setErrorStatus(
64 _error,
65 _SQLCODE,
66 _filename,
67 _line
68 );
69}

◆ setInputStream()

bool IFXParam::setInputStream ( const void * _pv,
size_t _size,
SQL::DataType _assignType )

Definition at line 462 of file IFXParam.cpp.

464{
465 if (_size != (size_t)-1 && _size > INT32_MAX) {
466 __SET_ERROR(SQL::eInvalidDataSize);
467 return false;
468 }
469
470 switch (_assignType) {
471 case SQL::typeText:
472 case SQL::typeLongText:
473 case SQL::typeClob: {
474 __data.loc.loc_type = SQLTEXT;
475 break;
476 }
477 case SQL::typeBinary:
478 case SQL::typeLongBinary:
479 case SQL::typeBlob: {
480 __data.loc.loc_type = SQLBYTES;
481 break;
482 }
483 default: {
484 __SET_ERROR(SQL::eNotSupportDataType);
485 return false;
486 }
487 }
488
489 __data.loc.loc_open = on_loc_open;
490 __data.loc.loc_read = on_loc_read;
491 __data.loc.loc_close = on_loc_close;
492 __data.loc.loc_write = NULL;
493
494 __data.loc.loc_loctype = LOCUSER;
495 __data.loc.loc_indicator = 0;
496 // __data.loc.loc_type = SQLTEXT or SQLBYTES;
497 __data.loc.loc_mflags = 0;
498 __data.loc.loc_oflags = LOC_WONLY;
499
500 __data.loc.loc_user_env = (char*)_pv;
501 __data.loc.loc_size = _size;
502
503 __sqlvar->sqldata = (char*)&__data;
504 __sqlvar->sqltype = CLOCATORTYPE;
505 __sqlvar->sqllen = sizeof(loc_t);
506
507 return true;
508}

◆ setInteger()

bool IFXParam::setInteger ( const void * _pv,
size_t _size )

Definition at line 269 of file IFXParam.cpp.

270{
271 switch (_size) {
272 case sizeof(int8_t) : {
273 __data.i32 = (int32_t) * (int8_t*)_pv;
274 __sqlvar->sqltype = CLONGTYPE;
275 __sqlvar->sqllen = sizeof(int32_t);
276 break;
277 }
278 case sizeof(int16_t) : {
279 __data.i32 = (int32_t) * (int16_t*)_pv;
280 __sqlvar->sqltype = CLONGTYPE;
281 __sqlvar->sqllen = sizeof(int32_t);
282 break;
283 }
284 case sizeof(int32_t) : {
285 __data.i32 = *(int32_t*)_pv;
286 __sqlvar->sqltype = CLONGTYPE;
287 __sqlvar->sqllen = sizeof(int32_t);
288 break;
289 }
290 case sizeof(int64_t) : {
291 __data.i64 = *(int64_t*)_pv;
292 __sqlvar->sqltype = CBIGINTTYPE;
293 __sqlvar->sqllen = sizeof(bigint);
294 break;
295 }
296 default: {
297 __SET_ERROR(SQL::eInvalidDataSize);
298 return false;
299 }
300 }
301 __sqlvar->sqldata = (char*)&__data;
302 return true;
303}

◆ setNull()

void IFXParam::setNull ( )
virtual

Implements SQL::Param.

Definition at line 102 of file IFXParam.cpp.

103{
104 Param::__dataType = SQL::typeUnknown;
105 __indicator = -1; // set null
106 __sqlvar->sqldata = NULL;
107}

◆ setUInteger()

bool IFXParam::setUInteger ( const void * _pv,
size_t _size )

Definition at line 305 of file IFXParam.cpp.

306{
307 switch (__sqltype & SQLTYPE) {
308 case SQLSMINT:
309 case SQLINT:
310 case SQLSERIAL: {
311 switch (_size) {
312 case sizeof(uint8_t) : {
313 __data.i32 = (int32_t) * (uint8_t*)_pv;
314 __sqlvar->sqltype = CLONGTYPE;
315 __sqlvar->sqllen = sizeof(int32_t);
316 break;
317 }
318 case sizeof(uint16_t) : {
319 __data.i32 = (int32_t) * (uint16_t*)_pv;
320 __sqlvar->sqltype = CLONGTYPE;
321 __sqlvar->sqllen = sizeof(int32_t);
322 break;
323 }
324 case sizeof(uint32_t) : {
325 __data.i32 = (int32_t) * (uint32_t*)_pv;
326 __sqlvar->sqltype = CLONGTYPE;
327 __sqlvar->sqllen = sizeof(int32_t);
328 break;
329 }
330 case sizeof(uint64_t) : {
331 __data.i64 = (int64_t) * (uint32_t*)_pv;
332 __sqlvar->sqltype = CBIGINTTYPE;
333 __sqlvar->sqllen = sizeof(bigint);
334 break;
335 }
336 default: {
337 __SET_ERROR(SQL::eInvalidDataSize);
338 return false;
339 }
340 }
341 break;
342 }
343 case SQLINT8:
344 case SQLSERIAL8:
345 case SQLINFXBIGINT:
346 case SQLBIGSERIAL: {
347 switch (_size) {
348 case sizeof(uint8_t) : {
349 __data.i64 = (int64_t) * (uint8_t*)_pv;
350 __sqlvar->sqltype = CBIGINTTYPE;
351 __sqlvar->sqllen = sizeof(int32_t);
352 break;
353 }
354 case sizeof(uint16_t) : {
355 __data.i64 = (int64_t) * (uint16_t*)_pv;
356 __sqlvar->sqltype = CBIGINTTYPE;
357 __sqlvar->sqllen = sizeof(int32_t);
358 break;
359 }
360 case sizeof(uint32_t) : {
361 __data.i64 = (int64_t) * (uint32_t*)_pv;
362 __sqlvar->sqltype = CBIGINTTYPE;
363 __sqlvar->sqllen = sizeof(int32_t);
364 break;
365 }
366 case sizeof(uint64_t) : {
367 __data.i64 = (int64_t) * (uint32_t*)_pv;
368 __sqlvar->sqltype = CBIGINTTYPE;
369 __sqlvar->sqllen = sizeof(bigint);
370 break;
371 }
372 default: {
373 __SET_ERROR(SQL::eInvalidDataSize);
374 return false;
375 }
376 }
377 break;
378 }
379 default: {
380 __SET_ERROR(SQL::eInvalidDataType);
381 return false;
382 }
383 }
384
385 __sqlvar->sqldata = (char*)&__data;
386 return true;
387}
SQL::eInvalidDataType
@ eInvalidDataType
Definition SQLCore.h:49

Member Data Documentation

◆ date

int4 IFXParam::date

Definition at line 20 of file IFXParam.h.

◆ dec

dec_t IFXParam::dec

Definition at line 19 of file IFXParam.h.

◆ dtime

dtime_t IFXParam::dtime

Definition at line 21 of file IFXParam.h.

◆ f32

float IFXParam::f32

Definition at line 17 of file IFXParam.h.

◆ f64

double IFXParam::f64

Definition at line 18 of file IFXParam.h.

◆ i32

int32_t IFXParam::i32

Definition at line 15 of file IFXParam.h.

◆ i64

int64_t IFXParam::i64

Definition at line 16 of file IFXParam.h.

◆ ival

intrvl_t IFXParam::ival

Definition at line 22 of file IFXParam.h.

◆ loc

loc_t IFXParam::loc

Definition at line 23 of file IFXParam.h.

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