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

#include <IBParam.h>

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

Public Member Functions

bool init (SQL::Query *_query, XSQLVAR *_sqlvar)
void onAfterExecute ()
 IBParam ()
virtual ~IBParam ()
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, const wchar_t *_filename, int _line)
void setErrorStatus (const ByteString &_message, const wchar_t *_filename, int _line)
IBQuery * query () const
virtual const wchar_t * serverDataTypeName () const
virtual void setNull ()
virtual bool __setData (_CONST void *_value, size_t _size, SQL::DataType _dataType, SQL::DataType _assignType)
bool setInteger (const void *_value, size_t _size)
bool setUInteger (const void *_value, size_t _size)
bool setFloat (const void *_value, size_t _size)
bool setDate (const SQL::Date *_value, size_t _size)
bool setTime (const SQL::Time *_value, size_t _size)
bool setTimeStamp (const SQL::TimeStamp *_value, size_t _size)
bool setBytesToBlob (const byte_t *_value, size_t _size)
bool setInputStreamToBlob (_CONST InputStream *_input, size_t _size)
bool cancelBlob ()
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 8 of file IBParam.h.

Constructor & Destructor Documentation

◆ IBParam()

IBParam::IBParam ( )

◆ ~IBParam()

IBParam::~IBParam ( )
virtual

Definition at line 38 of file IBParam.cpp.

39{
40 if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
41 __DCL_VERIFY(cancelBlob());
42 }
43}
__SQLTYPE_IS
#define __SQLTYPE_IS(_sqltype)
Definition IFXField.cpp:61
__DCL_VERIFY
#define __DCL_VERIFY(expr)
Definition Object.h:373
IBParam::cancelBlob
bool cancelBlob()
Definition IBParam.cpp:456

Member Function Documentation

◆ __setData()

bool IBParam::__setData ( _CONST void * _value,
size_t _size,
SQL::DataType _dataType,
SQL::DataType _assignType )
protectedvirtual

Implements SQL::Param.

Definition at line 88 of file IBParam.cpp.

94{
95 if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
96 if (!cancelBlob())
97 return false;
98 }
99
100 bool r = false;
101 switch(_dataType) {
102 case SQL::typeInteger: {
103 r = setInteger(_value, _size);
104 break;
105 }
106 case SQL::typeUInteger: {
107 r = setUInteger(_value, _size);
108 break;
109 }
110 case SQL::typeFloat: {
111 r = setFloat(_value, _size);
112 break;
113 }
114 case SQL::typeDate: {
115 r = setDate((const SQL::Date*)_value, _size);
116 break;
117 }
118 case SQL::typeTime: {
119 r = setTime((const SQL::Time*)_value, _size);
120 break;
121 }
122 case SQL::typeTimeStamp: {
123 r = setTimeStamp((const SQL::TimeStamp*)_value, _size);
124 break;
125 }
126 case SQL::typeText:
127 case SQL::typeBinary: {
128 if (__SQLTYPE_IS(SQL_BLOB))
129 r = setBytesToBlob((const byte_t*)_value, _size);
130 else {
131 __sqlvar->sqldata = (char*)_value;
132 __sqlvar->sqllen = _size;
133 __sqlvar->sqltype = SQL_TEXT + 1;
134 r = true;
135 }
136 break;
137 }
138 case SQL::typeInputStream: {
139 if (__SQLTYPE_IS(SQL_BLOB))
140 r = setInputStreamToBlob((_CONST InputStream*)_value, _size);
141 else {
142 __SET_ERROR(SQL::eInvalidDataType);
143 return false;
144 }
145 break;
146 }
147 // case SQL::typeInterval:
148 default: {
149 __SET_ERROR(SQL::eNotSupportDataType);
150 return false;
151 }
152 }
153
154 if (r) {
155 __indicator = 0;
156 Param::__dataType = _dataType;
157 }
158
159 return r;
160}
byte_t
unsigned char byte_t
Definition Config.h:274
_CONST
#define _CONST
Definition Config.h:353
r
ByteString r
Definition SQLConnection.cpp:182
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:153
IBParam::setInputStreamToBlob
bool setInputStreamToBlob(_CONST InputStream *_input, size_t _size)
Definition IBParam.cpp:381
IBParam::setTime
bool setTime(const SQL::Time *_value, size_t _size)
Definition IBParam.cpp:266
IBParam::setDate
bool setDate(const SQL::Date *_value, size_t _size)
Definition IBParam.cpp:246
IBParam::setUInteger
bool setUInteger(const void *_value, size_t _size)
Definition IBParam.cpp:192
IBParam::setInteger
bool setInteger(const void *_value, size_t _size)
Definition IBParam.cpp:162
IBParam::setTimeStamp
bool setTimeStamp(const SQL::TimeStamp *_value, size_t _size)
Definition IBParam.cpp:295
IBParam::setBytesToBlob
bool setBytesToBlob(const byte_t *_value, size_t _size)
Definition IBParam.cpp:332
IBParam::setFloat
bool setFloat(const void *_value, size_t _size)
Definition IBParam.cpp:222
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:77
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::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::eInvalidDataType
@ eInvalidDataType
Definition SQLCore.h:49

◆ cancelBlob()

bool IBParam::cancelBlob ( )
protected

Definition at line 456 of file IBParam.cpp.

457{
458// __DCL_ASSERT(__indicator == 0 && __SQLTYPE_IS(SQL_BLOB));
459
460 IBConnection* connHandle = (IBConnection*)Param::connection();
461 ISC_STATUS* statusVector = connHandle->statusVector();
462 isc_blob_handle hBlob = NULL;
463
464 if(isc_open_blob2(
465 statusVector,
466 connHandle->dbHandlePtr(),
467 connHandle->trHandlePtr(),
468 &hBlob,
469 &__data.blob_id,
470 0,
471 NULL)) {
472 __SET_ERROR(SQL::eServerError);
473 return false;
474 }
475
476 if (isc_cancel_blob(
477 statusVector,
478 &hBlob
479 )) {
480 __SET_ERROR(SQL::eServerError);
481 return false;
482 }
483
484 return true;
485}
NULL
#define NULL
Definition Config.h:340
IBConnection::trHandlePtr
isc_tr_handle * trHandlePtr()
Definition IBConnection.h:31
IBConnection::statusVector
ISC_STATUS * statusVector()
Definition IBConnection.h:33
IBConnection::dbHandlePtr
isc_db_handle * dbHandlePtr()
Definition IBConnection.h:30
SQL::eServerError
@ eServerError
Definition SQLCore.h:21

◆ init()

bool IBParam::init ( SQL::Query * _query,
XSQLVAR * _sqlvar )

Definition at line 45 of file IBParam.cpp.

46{
47 __DCL_ASSERT(__sqlvar == NULL);
48
49 Param::__queryHandle = _queryHandle;
50
51 __indicator = -1;
52 __sqltype = _sqlvar->sqltype;
53
54 __sqlvar = _sqlvar;
55 __sqlvar->sqldata = NULL;
56 __sqlvar->sqlind = &__indicator;
57 __sqlvar->sqlscale = 0;
58
59 return true;
60}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371

◆ onAfterExecute()

void IBParam::onAfterExecute ( )

Definition at line 62 of file IBParam.cpp.

63{
64 Param::__dataType = SQL::typeUnknown;
65 __indicator = -1; // set null
66 __sqlvar->sqldata = NULL;
67}
SQL::typeUnknown
@ typeUnknown
Definition SQLCore.h:63

◆ query()

IBQuery * IBParam::query ( ) const
inlineprotected

Definition at line 85 of file IBParam.h.

86{
87 return (IBQuery*)Param::__queryHandle;
88}

◆ serverDataTypeName()

const wchar_t * IBParam::serverDataTypeName ( ) const
protectedvirtual

Implements SQL::Field.

Definition at line 72 of file IBParam.cpp.

73{
74 return __dataTypeName(__sqlvar);
75}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setBytesToBlob()

bool IBParam::setBytesToBlob ( const byte_t * _value,
size_t _size )
protected

Definition at line 332 of file IBParam.cpp.

333{
334 IBConnection* connHandle = (IBConnection*)Param::connection();
335 ISC_STATUS* statusVector = connHandle->statusVector();
336 isc_blob_handle hBlob = NULL;
337
338 if(isc_create_blob2(
339 statusVector,
340 connHandle->dbHandlePtr(),
341 connHandle->trHandlePtr(),
342 &hBlob,
343 &__data.blob_id,
344 0,
345 NULL)) {
346 __SET_ERROR(SQL::eServerError);
347 return false;
348 }
349
350 size_t nTotal = 0;
351 size_t nBytes = 0;
352 while(nTotal < _size) {
353 nBytes = __MIN(_size - nTotal, USHRT_MAX);
354 if (isc_put_segment(
355 statusVector,
356 &hBlob,
357 nBytes,
358 (char*)_value
359 )) {
360 __SET_ERROR(SQL::eServerError);
361 ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
362 isc_close_blob(statusVector, &hBlob);
363 return false;
364 }
365
366 nTotal += nBytes;
367 _value += nBytes;
368 }
369
370 if (isc_close_blob(statusVector, &hBlob)) {
371 __SET_ERROR(SQL::eServerError);
372 return false;
373 }
374
375 __sqlvar->sqldata = (char*)&__data.blob_id;
376 __sqlvar->sqllen = sizeof(ISC_QUAD);
377 __sqlvar->sqltype = SQL_BLOB + 1;
378 return true;
379}
ISC_STATUS_VECTOR_LENGTH
#define ISC_STATUS_VECTOR_LENGTH
Definition IBConnection.h:6
__MIN
size_t __MIN(size_t x, size_t y)
Definition size_t.h:27

◆ setDate()

bool IBParam::setDate ( const SQL::Date * _value,
size_t _size )
protected

Definition at line 246 of file IBParam.cpp.

247{
248 if (_size != sizeof(SQL::Date)) {
249 __SET_ERROR(SQL::eInvalidDataSize);
250 return false;
251 }
252
253 struct tm tm;
254 tm.tm_year = _value->year - 1900;
255 tm.tm_mon = _value->month - 1;
256 tm.tm_mday = _value->day;
257
258 isc_encode_sql_date(&tm, &__data.date);
259
260 __sqlvar->sqldata = (char*)&__data;
261 __sqlvar->sqllen = sizeof(ISC_DATE);
262 __sqlvar->sqltype = SQL_TYPE_DATE + 1;
263 return true;
264}
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

◆ setErrorStatus() [1/2]

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

Definition at line 78 of file IBParam.h.

80{
81 ((IBConnection*)Param::connection())
82 ->setErrorStatus(_message, _filename, _line);
83}

◆ setErrorStatus() [2/2]

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

Definition at line 71 of file IBParam.h.

73{
74 ((IBConnection*)Param::connection())
75 ->setErrorStatus(_error, _filename, _line);
76}

◆ setFloat()

bool IBParam::setFloat ( const void * _value,
size_t _size )
protected

Definition at line 222 of file IBParam.cpp.

223{
224 switch(_size) {
225 case sizeof(float) : {
226 __data.f32 = *(float*)_value;
227 __sqlvar->sqllen = sizeof(float);
228 __sqlvar->sqltype = SQL_FLOAT + 1;
229 break;
230 }
231 case sizeof(double) : {
232 __data.f64 = *(double*)_value;
233 __sqlvar->sqllen = sizeof(double);
234 __sqlvar->sqltype = SQL_DOUBLE + 1;
235 break;
236 }
237 default: {
238 __SET_ERROR(SQL::eInvalidDataSize);
239 return false;
240 }
241 }
242 __sqlvar->sqldata = (char*)&__data;
243 return true;
244}

◆ setInputStreamToBlob()

bool IBParam::setInputStreamToBlob ( _CONST InputStream * _input,
size_t _size )
protected

Definition at line 381 of file IBParam.cpp.

382{
383 IBConnection* connHandle = (IBConnection*)Param::connection();
384 ISC_STATUS* statusVector = connHandle->statusVector();
385 isc_blob_handle hBlob = NULL;
386
387 if(isc_create_blob2(
388 statusVector,
389 connHandle->dbHandlePtr(),
390 connHandle->trHandlePtr(),
391 &hBlob,
392 &__data.blob_id,
393 0,
394 NULL)) {
395 __SET_ERROR(SQL::eServerError);
396 return false;
397 }
398
399 char* _pbuf = (char*)malloc(USHRT_MAX);
400 if (!_pbuf) {
401 __SET_ERROR(SQL::eOutOfMemory);
402 ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
403 isc_close_blob(statusVector, &hBlob);
404 return false;
405 }
406
407 try {
408 size_t nTotal = 0;
409 size_t nBytes = 0;
410 for (; ; ) {
411 nBytes = __MIN(_size - nTotal, USHRT_MAX);
412 if (nBytes && (nBytes = _input->read(_pbuf, nBytes))) {
413 if (isc_put_segment(
414 statusVector,
415 &hBlob,
416 nBytes,
417 _pbuf
418 )) {
419 __SET_ERROR(SQL::eServerError);
420 free(_pbuf);
421 ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
422 isc_close_blob(statusVector, &hBlob);
423 return false;
424 }
425
426 nTotal += nBytes;
427 }
428 else {
429 // done
430 break;
431 }
432 }
433 }
434 catch (IOException* e) {
435 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
436 e->destroy();
437 free(_pbuf);
438 ISC_STATUS statusVector[ISC_STATUS_VECTOR_LENGTH];
439 isc_close_blob(statusVector, &hBlob);
440 return false;
441 }
442
443 free(_pbuf);
444
445 if (isc_close_blob(statusVector, &hBlob)) {
446 __SET_ERROR(SQL::eServerError);
447 return false;
448 }
449
450 __sqlvar->sqldata = (char*)&__data.blob_id;
451 __sqlvar->sqllen = sizeof(ISC_QUAD);
452 __sqlvar->sqltype = SQL_BLOB + 1;
453 return true;
454}
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.h:57
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
SQL::eOutOfMemory
@ eOutOfMemory
Definition SQLCore.h:24

◆ setInteger()

bool IBParam::setInteger ( const void * _value,
size_t _size )
protected

Definition at line 162 of file IBParam.cpp.

163{
164 switch(_size) {
165 case sizeof(int16_t): {
166 __data.i16 = *(int16_t*)_value;
167 __sqlvar->sqllen = sizeof(int16_t);
168 __sqlvar->sqltype = SQL_SHORT + 1;
169 break;
170 }
171 case sizeof(int32_t): {
172 __data.i32 = *(int32_t*)_value;
173 __sqlvar->sqllen = sizeof(int32_t);
174 __sqlvar->sqltype = SQL_LONG + 1;
175 break;
176 }
177 case sizeof(int64_t): {
178 __data.i64 = *(int64_t*)_value;
179 __sqlvar->sqllen = sizeof(int64_t);
180 __sqlvar->sqltype = SQL_INT64 + 1;
181 break;
182 }
183 default: {
184 __SET_ERROR(SQL::eInvalidDataSize);
185 return false;
186 }
187 }
188 __sqlvar->sqldata = (char*)&__data;
189 return true;
190}

◆ setNull()

void IBParam::setNull ( )
protectedvirtual

Implements SQL::Param.

Definition at line 77 of file IBParam.cpp.

78{
79 if (__indicator == 0 && __SQLTYPE_IS(SQL_BLOB)) {
80 __DCL_VERIFY(cancelBlob());
81 }
82
83 Param::__dataType = SQL::typeUnknown;
84 __indicator = -1; // set null
85 __sqlvar->sqldata = NULL;
86}

◆ setTime()

bool IBParam::setTime ( const SQL::Time * _value,
size_t _size )
protected

Definition at line 266 of file IBParam.cpp.

267{
268 if (_size != sizeof(SQL::Time)) {
269 __SET_ERROR(SQL::eInvalidDataSize);
270 return false;
271 }
272
273 struct tm tm;
274 tm.tm_hour = _value->hour;
275 tm.tm_min = _value->min;
276 tm.tm_sec = _value->sec;
277
278 isc_encode_sql_time(&tm, &__data.time);
279 __data.time += _value->frac / 100000;
280
281 __sqlvar->sqldata = (char*)&__data;
282 __sqlvar->sqllen = sizeof(ISC_TIME);
283 __sqlvar->sqltype = SQL_TYPE_TIME + 1;
284#if defined(FIREBIRD_IBASE_H) && FB_API_VER >= 40
285 if (_value->tzoff != INT16_MIN) {
286 __data.time_tz.time_zone = 0;
287 __data.time_tz.ext_offset = _value->tzoff;
288 __sqlvar->sqllen = sizeof(ISC_TIME_TZ_EX);
289 __sqlvar->sqltype = SQL_TIME_TZ_EX + 1;
290 }
291#endif
292 return true;
293}
INT16_MIN
#define INT16_MIN
Definition Config.h:312
SQL::Time::hour
uint8_t hour
Definition SQLCore.h:104
SQL::Time::sec
uint8_t sec
Definition SQLCore.h:106
SQL::Time::frac
uint32_t frac
Definition SQLCore.h:107
SQL::Time::min
uint8_t min
Definition SQLCore.h:105
SQL::Time::tzoff
int16_t tzoff
Definition SQLCore.h:108

◆ setTimeStamp()

bool IBParam::setTimeStamp ( const SQL::TimeStamp * _value,
size_t _size )
protected

Definition at line 295 of file IBParam.cpp.

296{
297 if (_size != sizeof(SQL::TimeStamp)) {
298 __SET_ERROR(SQL::eInvalidDataSize);
299 return false;
300 }
301
302 struct tm tm;
303 tm.tm_year = _value->year - 1900;
304 tm.tm_mon = _value->month - 1;
305 tm.tm_mday = _value->day;
306 tm.tm_hour = _value->hour;
307 tm.tm_min = _value->min;
308 tm.tm_sec = _value->sec;
309
310 isc_encode_timestamp(&tm, &__data.ts);
311 __data.ts.timestamp_time += _value->frac / 100000;
312
313 __sqlvar->sqldata = (char*)&__data;
314 __sqlvar->sqllen = sizeof(ISC_TIMESTAMP);
315 __sqlvar->sqltype = SQL_TIMESTAMP + 1;
316#if defined(FIREBIRD_IBASE_H) && FB_API_VER >= 40
317 if (_value->tzoff != INT16_MIN) {
318 __data.ts_tz.time_zone = 0;
319 __data.ts_tz.ext_offset = _value->tzoff;
320 __sqlvar->sqllen = sizeof(ISC_TIMESTAMP_TZ_EX);
321 __sqlvar->sqltype = SQL_TIMESTAMP_TZ_EX + 1;
322 }
323#endif
324 return true;
325}
SQL::TimeStamp::frac
uint32_t frac
Definition SQLCore.h:119
SQL::TimeStamp::tzoff
int16_t tzoff
Definition SQLCore.h:120
SQL::TimeStamp::min
uint8_t min
Definition SQLCore.h:117
SQL::TimeStamp::sec
uint8_t sec
Definition SQLCore.h:118
SQL::TimeStamp::hour
uint8_t hour
Definition SQLCore.h:116
SQL::TimeStamp::day
uint8_t day
Definition SQLCore.h:115
SQL::TimeStamp::year
int16_t year
Definition SQLCore.h:113
SQL::TimeStamp::month
uint8_t month
Definition SQLCore.h:114

◆ setUInteger()

bool IBParam::setUInteger ( const void * _value,
size_t _size )
protected

Definition at line 192 of file IBParam.cpp.

193{
194 switch(_size) {
195 case sizeof(uint16_t): {
196 __data.i16 = (int16_t) * (uint16_t*)_value;
197 __sqlvar->sqllen = sizeof(int16_t);
198 __sqlvar->sqltype = SQL_SHORT + 1;
199 break;
200 }
201 case sizeof(uint32_t): {
202 __data.i32 = (int32_t) * (uint32_t*)_value;
203 __sqlvar->sqllen = sizeof(int32_t);
204 __sqlvar->sqltype = SQL_LONG + 1;
205 break;
206 }
207 case sizeof(uint64_t) : {
208 __data.i64 = (int64_t) * (uint64_t*)_value;
209 __sqlvar->sqllen = sizeof(int64_t);
210 __sqlvar->sqltype = SQL_INT64 + 1;
211 break;
212 }
213 default: {
214 __SET_ERROR(SQL::eInvalidDataSize);
215 return false;
216 }
217 }
218 __sqlvar->sqldata = (char*)&__data;
219 return true;
220}

Member Data Documentation

◆ blob_id

ISC_QUAD IBParam::blob_id

Definition at line 28 of file IBParam.h.

◆ date

ISC_DATE IBParam::date

Definition at line 21 of file IBParam.h.

◆ f32

float IBParam::f32

Definition at line 19 of file IBParam.h.

◆ f64

double IBParam::f64

Definition at line 20 of file IBParam.h.

◆ i16

int16_t IBParam::i16

Definition at line 16 of file IBParam.h.

◆ i32

int32_t IBParam::i32

Definition at line 17 of file IBParam.h.

◆ i64

int64_t IBParam::i64

Definition at line 18 of file IBParam.h.

◆ time

ISC_TIME IBParam::time

Definition at line 22 of file IBParam.h.

◆ ts

ISC_TIMESTAMP IBParam::ts

Definition at line 23 of file IBParam.h.

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