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

#include <OciParam.h>

Inheritance diagram for OciParam:
SQL::Param OciData SQL::Field Object

Public Member Functions

OciQuery * query () const
ub2 _dataType () const
 OciParam ()
virtual ~OciParam ()
bool init (SQL::Query *_query, ub4 _position)
bool doBind ()
bool onAfterExecute ()
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
Public Member Functions inherited from OciData
bool onAfterFetch ()

Protected Member Functions

virtual bool __setDataType (SQL::DataType _dataType)
virtual bool isNull () const
virtual const wchar_t * serverDataTypeName () const
virtual bool __getDataSize (size_t *_size, bool _maxSize)
virtual bool __getData (void *_pv, size_t *_size, SQL::DataType _dataType)
virtual void setNull ()
virtual bool __setData (_CONST void *_pv, size_t _size, SQL::DataType _dataType, SQL::DataType _assignType)
bool setTimeStamp (const SQL::TimeStamp *_pv, size_t _size, SQL::DataType _assignType)
bool setInterval (const SQL::Interval *_pv, size_t _size, SQL::DataType _assignType)
sb4 onCallbackInBind (OCIBind *pBind, ub4 nIterator, ub4 _index, dvoid **ppvBuffer, ub4 *pnActualLength, ub1 *pnPiece, dvoid **ppvIndicator)
sb4 onCallbackOutBind (OCIBind *pBind, ub4 nIterator, ub4 _index, dvoid **ppvBuffer, ub4 **ppnActualLength, ub1 *pnPiece, dvoid **ppvIndicator, ub2 **ppnReturnCode)
Protected Member Functions inherited from SQL::Param
 Param (Query *_queryHandle)
virtual ~Param ()
Protected Member Functions inherited from SQL::Field
 Field (Query *_queryHandle)
virtual ~Field ()
Protected Member Functions inherited from Object
virtual ~Object ()
 Object ()
Protected Member Functions inherited from OciData
OciConnection * conn () const
 OciData ()
 ~OciData ()
bool isInteger () const
bool getDataSize (size_t *_size, bool _maxSize)
bool getData (void *_pv, size_t *_size, SQL::DataType _dataType)
bool getInteger (void *_pv, size_t *_size, SQL::DataType _dataType)
bool getFloat (void *_pv, size_t *_size)
bool getNumericText (char *_pv, size_t *_size)
bool getTimeStamp (SQL::TimeStamp *_pv, size_t *_size)
bool getInterval (SQL::Interval *_pv, size_t *_size)
bool getBytes (byte_t *_pv, size_t *_size)
bool writeTo (OutputStream *_pv, size_t *_size)
bool getBytesFromLob (byte_t *_pv, size_t *_size)
bool writeToFromLob (OutputStream *_pv, size_t *_size)

Static Protected Member Functions

static sb4 CallbackInBind (dvoid *ictxp, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 *alenp, ub1 *piecep, dvoid **indpp)
static sb4 CallbackOutBind (dvoid *octxp, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcodepp)
Static Protected Member Functions inherited from OciData
static const wchar_t * dataTypeName (ub2 _dataType)

Additional Inherited Members

Protected Attributes inherited from SQL::Field
Query * __queryHandle
String __name
DataType __dataType
short __precision
short __scale
Protected Attributes inherited from OciData
OciQuery * __queryHandle
ub4 __position
ub4 __descType
ub4 __dynamicMode
ub2 __dataType
void * __value
sb4 __valueSize
sb2 __indicator
ub2 __actualLength
ub4 __callbackActualLength
ub2 __returnCode
BytesOutputStream * __bytesOutput
size_t __dataSize
size_t __maxDataSize

Detailed Description

Definition at line 10 of file OciParam.h.

Constructor & Destructor Documentation

◆ OciParam()

OciParam::OciParam ( )

◆ ~OciParam()

OciParam::~OciParam ( )
virtual

Definition at line 61 of file OciParam.cpp.

62{
63 if (OciData::__descType) {
64 __DCL_ASSERT(__data.desc != NULL);
65 __DCL_VERIFY(
66 conn()->OCIDescriptorFree(
67 __data.desc,
68 OciData::__descType
69 ) == OCI_SUCCESS);
70 OciData::__descType = 0;
71 }
72
73 if (__buffer) {
74 free(__buffer);
75 __buffer = NULL;
76 }
77}
NULL
#define NULL
Definition Config.h:340
__DCL_VERIFY
#define __DCL_VERIFY(expr)
Definition Object.h:373
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
OciData::conn
OciConnection * conn() const
Definition OciData.h:62
OciData::__descType
ub4 __descType
Definition OciData.h:18

Member Function Documentation

◆ __getData()

bool OciParam::__getData ( void * _pv,
size_t * _size,
SQL::DataType _dataType )
protectedvirtual

Reimplemented from SQL::Param.

Definition at line 272 of file OciParam.cpp.

277{
278 return OciData::getData(_pv, _size, _dataType);
279}
OciData::getData
bool getData(void *_pv, size_t *_size, SQL::DataType _dataType)
Definition OciData.cpp:202
OciParam::_dataType
ub2 _dataType() const
Definition OciParam.h:29

◆ __getDataSize()

bool OciParam::__getDataSize ( size_t * _size,
bool _maxSize )
protectedvirtual

Reimplemented from SQL::Param.

Definition at line 264 of file OciParam.cpp.

268{
269 return OciData::getDataSize(_size, _maxSize);
270}
OciData::getDataSize
bool getDataSize(size_t *_size, bool _maxSize)
Definition OciData.cpp:172

◆ __setData()

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

Implements SQL::Param.

Definition at line 292 of file OciParam.cpp.

298{
299 switch(_assignType) {
300 case SQL::typeInteger :
301 case SQL::typeUInteger :
302 case SQL::typeFloat :
303 _assignType = SQL::typeNumeric;
304 break;
305 case SQL::typeDate :
306 _assignType = SQL::typeTimeStamp;
307 default :
308 ;
309 }
310
311 if (Param::__dataType != SQL::typeUnknown) {
312 if (Param::__dataType != _assignType) {
313 __SET_ERROR(SQL::eInvalidDataType, 0, NULL);
314 return false;
315 }
316 }
317
318 OCIError* pError = conn()->errorHandle();
319 sword status = OCI_SUCCESS;
320
321 switch(_dataType) {
322 case SQL::typeInteger :
323 case SQL::typeUInteger: {
324 if (_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
325 uword sign = OCI_NUMBER_SIGNED;
326 if (_dataType == SQL::typeUInteger)
327 sign = OCI_NUMBER_UNSIGNED;
328
329 status = ::OCINumberFromInt(
330 pError, // OCIError *err,
331 (CONST dvoid*)_pv, // CONST dvoid *inum,
332 _size, // uword inum_length,
333 sign, // uword inum_s_flag,
334 &__data.num // OCINumber *number
335 );
336 if (status != OCI_SUCCESS) {
337 __SET_ERROR(SQL::eServerError, status, pError);
338 return false;
339 }
340 }
341 #if 0 // 2025-02-03 월
342 else if (_size == sizeof(int64_t)) {
343 ByteString str;
344 if (_dataType == SQL::typeInteger)
345 str = Int64::toByteString(*(int64_t*)_pv, 10);
346 else
347 str = UInt64::toByteString(*(uint64_t*)_pv, 10);
348
349 status = ::OCINumberFromText(
350 pError, // OCIError *err,
351 (CONST OraText*)str.data(), // CONST OraText *str,
352 str.length(), // ub4 str_length,
353 NULL, // CONST OraText *fmt,
354 0, // ub4 fmt_length,
355 NULL, // CONST OraText *nls_params,
356 0, // ub4 nls_p_length,
357 &__data.num // OCINumber *number
358 );
359 if (status != OCI_SUCCESS) {
360 __SET_ERROR(SQL::eServerError, status, pError);
361 return false;
362 }
363 }
364 #endif
365 else {
366 __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
367 return false;
368 }
369 OciData::__value = &__data;
370 OciData::__valueSize = sizeof(OCINumber);
371 OciData::__dataType = SQLT_VNU;
372 OciData::__maxDataSize = 132;
373 break;
374 }
375 case SQL::typeFloat: {
376 if (_size <= sizeof(double)) {
377 status = ::OCINumberFromReal(
378 pError, // OCIError *err,
379 (CONST dvoid*)_pv, // CONST dvoid *rnum,
380 _size, // uword rnum_length,
381 &__data.num // OCINumber *number
382 );
383 if (status != OCI_SUCCESS) {
384 __SET_ERROR(SQL::eServerError, status, pError);
385 return false;
386 }
387 }
388 else {
389 __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
390 return false;
391 }
392 OciData::__value = &__data;
393 OciData::__valueSize = sizeof(OCINumber);
394 OciData::__dataType = SQLT_VNU;
395 OciData::__maxDataSize = 132;
396 break;
397 }
398 case SQL::typeDate: {
399 if (_size == sizeof(SQL::Date)) {
400 const SQL::Date* p = (const SQL::Date*)_pv;
401 SQL::TimeStamp ts;
402 ts.nYear = p->nYear;
403 ts.nMonth = p->nMonth;
404 ts.nDay = p->nDay;
405 ts.nHour = ts.nMin = ts.nSec = 0;
406 ts.nFrac = 0;
407 ts.nTzMin = 0;
408 if (!setTimeStamp(&ts, sizeof(SQL::TimeStamp), SQL::typeTimeStamp))
409 return false;
410 }
411 else {
412 __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
413 return false;
414 }
415 break;
416 }
417 case SQL::typeTime: {
418 // Oracle에서 DATE, TIMESTAMP 모두 시간만 저장할 수 없다.
419 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
420 return false;
421 }
422 case SQL::typeTimeStamp :
423 case SQL::typeTimeStampTz: {
424 if (_size == sizeof(SQL::TimeStamp)) {
425 if (!setTimeStamp((const SQL::TimeStamp*)_pv, _size, _assignType))
426 return false;
427 }
428 else {
429 __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
430 return false;
431 }
432 break;
433 }
434 case SQL::typeInterval:
435 case SQL::typeIntervalYm:
436 case SQL::typeIntervalDs: {
437 if (_size == sizeof(SQL::Interval)) {
438 if (!setInterval((const SQL::Interval*)_pv, _size, _assignType))
439 return false;
440 }
441 else {
442 __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
443 return false;
444 }
445 break;
446 }
447 case SQL::typeText: {
448 if (_assignType == SQL::typeNumeric) {
449 status = ::OCINumberFromText(
450 pError, // OCIError *err,
451 (CONST OraText*)_pv, // CONST OraText *str,
452 _size, // ub4 str_length,
453 NULL, // CONST OraText *fmt,
454 0, // ub4 fmt_length,
455 NULL, // CONST OraText *nls_params,
456 0, // ub4 nls_p_length,
457 &__data.num // OCINumber *number
458 );
459 if (status != OCI_SUCCESS) {
460 __SET_ERROR(SQL::eServerError, status, pError);
461 return false;
462 }
463 OciData::__value = &__data;
464 OciData::__valueSize = sizeof(OCINumber);
465 OciData::__dataType = SQLT_VNU;
466 OciData::__maxDataSize = 132;
467 break;
468 }
469 }
470 case SQL::typeLongText :
471 case SQL::typeBinary :
472 case SQL::typeLongBinary: {
473 switch (_assignType) {
474 case SQL::typeText: {
475 OciData::__dataType = SQLT_CHR;
476 OciData::__maxDataSize = 4000;
477 break;
478 }
479 case SQL::typeBinary: {
480 OciData::__dataType = SQLT_BIN;
481 OciData::__maxDataSize = 2000;
482 break;
483 }
484 case SQL::typeLongText: {
485 OciData::__dataType = SQLT_LNG;
486 OciData::__maxDataSize = INT32_MAX;
487 break;
488 }
489 case SQL::typeLongBinary: {
490 OciData::__dataType = SQLT_LBI;
491 OciData::__maxDataSize = INT32_MAX;
492 break;
493 }
494 default: {
495 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
496 return false;
497 }
498 }
499 OciData::__value = _pv;
500 OciData::__valueSize = _size;
501 break;
502 }
503 case SQL::typeInputStream: {
504 switch (_assignType) {
505 case SQL::typeText: {
506 OciData::__dataType = SQLT_CHR;
507 OciData::__maxDataSize = 4000;
508 break;
509 }
510 case SQL::typeBinary: {
511 OciData::__dataType = SQLT_BIN;
512 OciData::__maxDataSize = 2000;
513 break;
514 }
515 case SQL::typeLongText: {
516 OciData::__dataType = SQLT_LNG;
517 OciData::__maxDataSize = INT32_MAX;
518 break;
519 }
520 case SQL::typeLongBinary: {
521 OciData::__dataType = SQLT_LBI;
522 OciData::__maxDataSize = INT32_MAX;
523 break;
524 }
525 default: {
526 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
527 return false;
528 }
529 }
530 OciData::__value = NULL;
531 if (_size > INT32_MAX)
532 OciData::__valueSize = INT32_MAX;
533 else
534 OciData::__valueSize = _size;
535 __inputStream = (InputStream*)_pv;
536 break;
537 }
538 default: {
539 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
540 return false;
541 }
542 }
543
544 Param::__dataType = _assignType;
545 __inputIndicator = 0;
546
547 return true;
548}
INT32_MAX
#define INT32_MAX
Definition Config.h:318
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:150
Int64::toByteString
static ByteString toByteString(int64_t _n, unsigned _base=10)
Definition Numeric.cpp:581
OciConnection::errorHandle
OCIError * errorHandle() const
Definition OciConnection.h:52
OciData::__dataType
ub2 __dataType
Definition OciData.h:21
OciData::__valueSize
sb4 __valueSize
Definition OciData.h:23
OciData::__maxDataSize
size_t __maxDataSize
Definition OciData.h:31
OciData::__value
void * __value
Definition OciData.h:22
OciParam::setTimeStamp
bool setTimeStamp(const SQL::TimeStamp *_pv, size_t _size, SQL::DataType _assignType)
Definition OciParam.cpp:555
OciParam::setInterval
bool setInterval(const SQL::Interval *_pv, size_t _size, SQL::DataType _assignType)
Definition OciParam.cpp:630
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::typeUnknown
@ typeUnknown
Definition SQLCore.h:63
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:70
SQL::typeInputStream
@ typeInputStream
Definition SQLCore.h:83
SQL::typeTimeStampTz
@ typeTimeStampTz
Definition SQLCore.h:71
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::eNotSupportDataType
@ eNotSupportDataType
Definition SQLCore.h:48
SQL::eServerError
@ eServerError
Definition SQLCore.h:21
SQL::eInvalidDataSize
@ eInvalidDataSize
Definition SQLCore.h:57
SQL::eInvalidDataType
@ eInvalidDataType
Definition SQLCore.h:49
UInt64::toByteString
static ByteString toByteString(uint64_t _u, unsigned _base=10)
Definition Numeric.cpp:680
SQL::Date::nMonth
uint8_t nMonth
Definition SQLCore.h:97
SQL::Date::nYear
int16_t nYear
Definition SQLCore.h:96
SQL::Date::nDay
uint8_t nDay
Definition SQLCore.h:98
SQL::TimeStamp::nYear
int16_t nYear
Definition SQLCore.h:111
SQL::TimeStamp::nDay
uint8_t nDay
Definition SQLCore.h:113
SQL::TimeStamp::nHour
uint8_t nHour
Definition SQLCore.h:114
SQL::TimeStamp::nTzMin
int16_t nTzMin
Definition SQLCore.h:118
SQL::TimeStamp::nSec
uint8_t nSec
Definition SQLCore.h:116
SQL::TimeStamp::nMonth
uint8_t nMonth
Definition SQLCore.h:112
SQL::TimeStamp::nMin
uint8_t nMin
Definition SQLCore.h:115
SQL::TimeStamp::nFrac
uint32_t nFrac
Definition SQLCore.h:117

◆ __setDataType()

bool OciParam::__setDataType ( SQL::DataType _dataType)
protectedvirtual

Reimplemented from SQL::Param.

Definition at line 100 of file OciParam.cpp.

103{
104 switch(_dataType) {
105 case SQL::typeInteger :
106 case SQL::typeUInteger :
107 case SQL::typeFloat :
108 _dataType = SQL::typeNumeric;
109 break;
110 case SQL::typeDate :
111 _dataType = SQL::typeTimeStamp;
112 default :
113 ;
114 }
115
116 if (Param::__dataType != SQL::typeUnknown) {
117 if (Param::__dataType != _dataType) {
118 __SET_ERROR(SQL::eInvalidDataType, 0, NULL);
119 return false;
120 }
121 return true;
122 }
123
124 OciConnection* pConnection = conn();
125 sword status = OCI_SUCCESS;
126
127 switch(_dataType) {
128 //case SQL::typeInteger :
129 //case SQL::typeUInteger :
130 //case SQL::typeFloat :
131 case SQL::typeNumeric: {
132 OciData::__valueSize = sizeof(OCINumber);
133 OciData::__dataType = SQLT_VNU;
134 OciData::__maxDataSize = 132;
135 break;
136 }
137 case SQL::typeTime: {
138 // Oracle에서 DATE, TIMESTAMP은 모두 TIME만 저장할 수 없다.
139 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
140 break;
141 }
142 //case SQL::typeDate :
143 case SQL::typeTimeStamp :
144 case SQL::typeTimeStampTz: {
145 ub2 dataType = SQLT_TIMESTAMP;
146 ub4 nDescType = OCI_DTYPE_TIMESTAMP;
147 if (_dataType == SQL::typeTimeStampTz) {
148 dataType = SQLT_TIMESTAMP_TZ;
149 nDescType = OCI_DTYPE_TIMESTAMP_TZ;
150 }
151
152 status = pConnection->OCIDescriptorAlloc(
153 &(__data.desc),
154 nDescType
155 );
156 if (status != OCI_SUCCESS) {
157 __SET_ERROR(SQL::eServerError, status, NULL);
158 return false;
159 }
160 OciData::__descType = nDescType;
161 OciData::__valueSize = sizeof(OCIDateTime*);
162 OciData::__dataType = dataType;
163 OciData::__maxDataSize = sizeof(SQL::TimeStamp);
164 break;
165 }
166 case SQL::typeInterval :
167 case SQL::typeIntervalYm :
168 case SQL::typeIntervalDs: {
169 ub2 dataType = SQLT_INTERVAL_DS;
170 ub4 nDescType = OCI_DTYPE_INTERVAL_DS;
171 if (_dataType == SQL::typeIntervalYm) {
172 dataType = SQLT_INTERVAL_YM;
173 nDescType = OCI_DTYPE_INTERVAL_YM;
174 }
175
176 status = pConnection->OCIDescriptorAlloc(
177 &(__data.desc),
178 OCI_DTYPE_INTERVAL_DS
179 );
180 if (status != OCI_SUCCESS) {
181 __SET_ERROR(SQL::eServerError, status, NULL);
182 return false;
183 }
184 OciData::__descType = nDescType;
185 OciData::__valueSize = sizeof(OCIInterval*);
186 OciData::__dataType = dataType;
187 OciData::__maxDataSize = sizeof(SQL::Interval);
188 break;
189 }
190 case SQL::typeText: {
191 OciData::__valueSize = 4000;
192 OciData::__dataType = SQLT_CHR;
193 OciData::__maxDataSize = 4000; // AFC ==> 2000
194 break;
195 }
196 case SQL::typeBinary: {
197 OciData::__valueSize = 4000;
198 OciData::__dataType = SQLT_BIN;
199 OciData::__maxDataSize = 2000;
200 break;
201 }
202 case SQL::typeLongText: {
203 OciData::__valueSize = INT32_MAX;
204 OciData::__dataType = SQLT_LNG;
205 OciData::__maxDataSize = INT32_MAX;
206 break;
207 }
208 case SQL::typeLongBinary: {
209 OciData::__valueSize = INT32_MAX;
210 OciData::__dataType = SQLT_LBI;
211 OciData::__maxDataSize = INT32_MAX;
212 break;
213 }
214 case SQL::typeClob: {
215 status = pConnection->OCIDescriptorAlloc(
216 &(__data.desc),
217 OCI_DTYPE_LOB
218 );
219 if (status != OCI_SUCCESS) {
220 __SET_ERROR(SQL::eServerError, status, NULL);
221 return false;
222 }
223 OciData::__descType = OCI_DTYPE_LOB;
224 OciData::__valueSize = sizeof(OCILobLocator*);
225 OciData::__dataType = SQLT_CLOB;
226 OciData::__maxDataSize = UINT32_MAX;
227 break;
228 }
229 case SQL::typeBlob: {
230 status = pConnection->OCIDescriptorAlloc(
231 &(__data.desc),
232 OCI_DTYPE_LOB
233 );
234 if (status != OCI_SUCCESS) {
235 __SET_ERROR(SQL::eServerError, status, NULL);
236 return false;
237 }
238 OciData::__descType = OCI_DTYPE_LOB;
239 OciData::__valueSize = sizeof(OCILobLocator*);
240 OciData::__dataType = SQLT_BLOB;
241 OciData::__maxDataSize = UINT32_MAX;
242 break;
243 }
244 default: {
245 __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
246 return false;
247 }
248 }
249
250 Param::__dataType = _dataType;
251 return true;
252}
UINT32_MAX
#define UINT32_MAX
Definition Config.h:323
OciConnection::OCIDescriptorAlloc
sword OCIDescriptorAlloc(void **ppDescriptorHandle, ub4 nDescriptorType, size_t xtramem_sz=0, void **ppvUserMem=NULL)
Definition OciConnection.h:117
SQL::typeClob
@ typeClob
Definition SQLCore.h:79
SQL::typeBlob
@ typeBlob
Definition SQLCore.h:80

◆ _dataType()

ub2 OciParam::_dataType ( ) const
inline

Definition at line 29 of file OciParam.h.

29{ return OciData::__dataType; }

◆ CallbackInBind()

sb4 OciParam::CallbackInBind ( dvoid * ictxp,
OCIBind * bindp,
ub4 iter,
ub4 index,
dvoid ** bufpp,
ub4 * alenp,
ub1 * piecep,
dvoid ** indpp )
staticprotected

Definition at line 784 of file OciParam.cpp.

794{
795 return ((OciParam*)ictxp)->onCallbackInBind(
796 bindp,
797 iter,
798 index,
799 bufpp,
800 alenp,
801 piecep,
802 indpp
803 );
804}

◆ CallbackOutBind()

sb4 OciParam::CallbackOutBind ( dvoid * octxp,
OCIBind * bindp,
ub4 iter,
ub4 index,
dvoid ** bufpp,
ub4 ** alenpp,
ub1 * piecep,
dvoid ** indpp,
ub2 ** rcodepp )
staticprotected

Definition at line 806 of file OciParam.cpp.

817{
818 return ((OciParam*)octxp)->onCallbackOutBind(
819 bindp,
820 iter,
821 index,
822 bufpp,
823 alenpp,
824 piecep,
825 indpp,
826 rcodepp
827 );
828}

◆ doBind()

bool OciParam::doBind ( )

Definition at line 728 of file OciParam.cpp.

729{
730 sword status = OCI_SUCCESS;
731 OciConnection* pConnection = conn();
732 OCIError* pError = pConnection->errorHandle();
733 OCIStmt* pStmt = query()->stmtHandle();
734
735 if (OciData::__dataType == 0) {
736 // then out bind only param
737 __DCL_ASSERT(OciData::__value == NULL);
738 __DCL_ASSERT(OciData::__descType == 0);
739 __DCL_ASSERT(__buffer == NULL);
740 }
741
742 // __DCL_TRACE3_N("%s, %d, %p\n", Param::__name.data(),
743 // OciData::__valueSize, OciData::__value);
744 status = ::OCIBindByPos(
745 pStmt, // OCIStmt *stmtp,
746 &__bind, // OCIBind **bindp,
747 pError, // OCIError *errhp,
748 OciData::__position, // ub4 position,
749 NULL, // dvoid *valuep,
750 OciData::__valueSize, // sb4 value_sz,
751 OciData::__dataType, // ub2 dty,
752 &__inputIndicator, // dvoid *indp,
753 NULL, // ub2 *alenp,
754 &(OciData::__returnCode), // ub2 *rcodep,
755 0, // ub4 maxarr_len,
756 NULL, // ub4 *curelep,
757 OciData::__dynamicMode // ub4 mode
758 );
759 if (status != OCI_SUCCESS) {
760 __SET_ERROR(SQL::eServerError, status, pError);
761 conn()->setErrorEx(ByteString::format("position[%d]", OciData::__position));
762 return false;
763 }
764 __DCL_ASSERT(__bind != NULL); // bindDynamic은 bindByPos 이후에
765 if (OciData::__dynamicMode == OCI_DATA_AT_EXEC) {
766 status = ::OCIBindDynamic(
767 __bind, // OCIBind *bindp,
768 pError, // OCIError *errhp,
769 this, // dvoid *ictxp,
770 OciParam::CallbackInBind,
771 this, // dvoid *octxp
772 OciParam::CallbackOutBind
773 );
774 if (status != OCI_SUCCESS) {
775 __SET_ERROR(SQL::eServerError, status, pError);
776 conn()->setErrorEx(ByteString::format("position[%d]", OciData::__position));
777 return false;
778 }
779 }
780
781 return true;
782}
OciConnection::setErrorEx
void setErrorEx(const ByteString &_message)
Definition OciConnection.h:91
OciData::__dynamicMode
ub4 __dynamicMode
Definition OciData.h:19
OciData::__position
ub4 __position
Definition OciData.h:17
OciData::__returnCode
ub2 __returnCode
Definition OciData.h:27
OciParam::CallbackInBind
static sb4 CallbackInBind(dvoid *ictxp, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 *alenp, ub1 *piecep, dvoid **indpp)
Definition OciParam.cpp:784
OciParam::query
OciQuery * query() const
Definition OciParam.h:27
OciParam::CallbackOutBind
static sb4 CallbackOutBind(dvoid *octxp, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcodepp)
Definition OciParam.cpp:806

◆ init()

bool OciParam::init ( SQL::Query * _query,
ub4 _position )

Definition at line 79 of file OciParam.cpp.

80{
81 Param::__queryHandle = _queryHandle;
82
83 OciData::__queryHandle = (OciQuery*)_queryHandle;
84 OciData::__position = _position;
85 OciData::__dynamicMode = OCI_DATA_AT_EXEC;
86
87 return true;
88}
OciData::__queryHandle
OciQuery * __queryHandle
Definition OciData.h:16

◆ isNull()

bool OciParam::isNull ( ) const
protectedvirtual

Reimplemented from SQL::Param.

Definition at line 254 of file OciParam.cpp.

255{
256 return OciData::__indicator == -1;
257}
OciData::__indicator
sb2 __indicator
Definition OciData.h:24

◆ onAfterExecute()

bool OciParam::onAfterExecute ( )

Definition at line 90 of file OciParam.cpp.

91{
92 __inputIndicator = -1;
93 __inputStream = NULL;
94
95 // calc output datasize
96 return OciData::onAfterFetch();
97}
OciData::onAfterFetch
bool onAfterFetch()
Definition OciData.cpp:83

◆ onCallbackInBind()

sb4 OciParam::onCallbackInBind ( OCIBind * pBind,
ub4 nIterator,
ub4 _index,
dvoid ** ppvBuffer,
ub4 * pnActualLength,
ub1 * pnPiece,
dvoid ** ppvIndicator )
protected

Definition at line 835 of file OciParam.cpp.

844{
845
846//#ifdef __DCL_DEBUG
847// switch(*pnPiece)
848// {
849// case OCI_ONE_PIECE :
850// __DCL_TRACE1_N(L"OCI_ONE_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
851// break;
852// case OCI_FIRST_PIECE :
853// __DCL_TRACE1_N(L"OCI_FIRST_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
854// break;
855// case OCI_NEXT_PIECE :
856// __DCL_TRACE1_N(L"OCI_NEXT_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
857// break;
858// case OCI_LAST_PIECE :
859// __DCL_TRACE1_N(L"OCI_LAST_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
860// }
861//#endif
862
863 if (__inputIndicator == -1) {
864 *ppvBuffer = NULL;
865 *pnActualLength = 0;
866 *pnPiece = OCI_ONE_PIECE;
867 *ppvIndicator = &__inputIndicator;
868 return OCI_CONTINUE;
869 }
870
871 if (__inputStream) {
872 __DCL_ASSERT(OciData::__dataType == SQLT_CHR
873 || OciData::__dataType == SQLT_BIN
874 || OciData::__dataType == SQLT_LNG
875 || OciData::__dataType == SQLT_LBI);
876
877 if (!__buffer) {
878 __buffer = malloc(DYNAMIC_BUFFER_SIZE);
879 if (!__buffer) {
880 __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
881 return OCI_ERROR;
882 }
883 }
884
885 __DCL_ASSERT(__buffer != NULL);
886
887 size_t nRead = __MIN((size_t)OciData::__valueSize, DYNAMIC_BUFFER_SIZE);
888
889 if (nRead) {
890 try {
891 nRead = __inputStream->read(__buffer, nRead);
892 }
893 catch(IOException* e) {
894 conn()->setErrorEx(UTF8Encoder::encode(e->toStringAll()));
895 e->destroy();
896 return OCI_ERROR;
897 }
898 }
899
900 if (*pnPiece == OCI_FIRST_PIECE) {
901 if (nRead == (size_t)OciData::__valueSize)
902 *pnPiece = OCI_ONE_PIECE;
903 }
904 else {
905 // OCI_NEXT_PIECE
906 if (nRead == 0 || nRead == (size_t)OciData::__valueSize)
907 *pnPiece = OCI_LAST_PIECE;
908 }
909
910 OciData::__valueSize -= nRead;
911
912 *ppvBuffer = __buffer;
913 *pnActualLength = nRead;
914 *ppvIndicator = NULL;
915 }
916 else {
917 if (OciData::__descType) {
918 // 입력이 TIMESTAMP와 같은 디스크립터일 경우 버퍼에 이들의 값을
919 // 넣어 준다.
920 *ppvBuffer = __data.desc;
921 }
922 else {
923 // 나머지 경우 OciData::m_pValue는
924 // 외부에서 받은 char*, byte_t* 그리고 &OciParam::__data 이다.
925 *ppvBuffer = OciData::__value;
926 }
927 *pnActualLength = OciData::__valueSize;
928 *pnPiece = OCI_ONE_PIECE;
929 *ppvIndicator = &__inputIndicator;
930 }
931
932 return OCI_CONTINUE;
933}
DYNAMIC_BUFFER_SIZE
#define DYNAMIC_BUFFER_SIZE
Definition OciData.h:11
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
__MIN
size_t __MIN(size_t x, size_t y)
Definition size_t.h:27

◆ onCallbackOutBind()

sb4 OciParam::onCallbackOutBind ( OCIBind * pBind,
ub4 nIterator,
ub4 _index,
dvoid ** ppvBuffer,
ub4 ** ppnActualLength,
ub1 * pnPiece,
dvoid ** ppvIndicator,
ub2 ** ppnReturnCode )
protected

Definition at line 935 of file OciParam.cpp.

945{
946 __DCL_ASSERT(OciData::__dynamicMode == OCI_DATA_AT_EXEC);
947 /*
948 if (_index == 0) {
949 ub4 nRows = 0;
950 ub4 _size = 0;
951
952 sword status = ::OCIAttrGet(
953 __bind,
954 OCI_HTYPE_BIND,
955 &nRows,
956 &_size,
957 OCI_ATTR_ROWS_RETURNED,
958 query()->connection()->errorHandle());
959 if (status != OCI_SUCCESS) {
960 return OCI_ERROR;
961 }
962 }
963 */
964/*
965#ifdef __DCL_DEBUG
966 switch(*pnPiece) {
967 case OCI_ONE_PIECE :
968 __DCL_TRACE1_N("OCI_ONE_PIECE: %s\n", Param::__name.data());
969 break;
970 case OCI_FIRST_PIECE :
971 __DCL_TRACE1_N("OCI_FIRST_PIECE: %s\n", Param::__name.data());
972 break;
973 case OCI_NEXT_PIECE :
974 __DCL_TRACE1_N("OCI_NEXT_PIECE: %s\n", Param::__name.data());
975 break;
976 case OCI_LAST_PIECE :
977 __DCL_TRACE1_N("OCI_LAST_PIECE: %s\n", Param::__name.data());
978 }
979#endif
980*/
981 if (OciData::__dataType == SQLT_CHR
982 || OciData::__dataType == SQLT_BIN
983 || OciData::__dataType == SQLT_LNG
984 || OciData::__dataType == SQLT_LBI) {
985 if (*pnPiece == OCI_ONE_PIECE)
986 *pnPiece = OCI_FIRST_PIECE;
987
988 if (*pnPiece == OCI_FIRST_PIECE) {
989 if (!__buffer) {
990 __buffer = malloc(DYNAMIC_BUFFER_SIZE);
991 if (!__buffer) {
992 __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
993 return OCI_ERROR;
994 }
995 }
996
997 OciData::__value = __buffer;
998 if (OciData::__bytesOutput)
999 __bytesOutput->reset();
1000 }
1001 else {
1002 // 두번째 PIECE 부터는 이전 데이터를 내부 스트림에 보관한다.
1003 if (!OciData::__bytesOutput) {
1004 OciData::__bytesOutput = new BytesOutputStream();
1005 if (!OciData::__bytesOutput) {
1006 __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
1007 return OCI_ERROR;
1008 }
1009 }
1010
1011 __DCL_ASSERT(OciData::__bytesOutput != NULL);
1012 try {
1013 OciData::__bytesOutput->write(
1014 OciData::__value,
1015 OciData::__callbackActualLength
1016 );
1017 }
1018 catch(IOException* e) {
1019 conn()->setErrorEx(
1020 UTF8Encoder::encode(e->toStringAll())
1021 );
1022 e->destroy();
1023 return OCI_ERROR;
1024 }
1025 }
1026
1027 OciData::__callbackActualLength = DYNAMIC_BUFFER_SIZE;
1028 OciData::__indicator = -1;
1029
1030 *ppvBuffer = OciData::__value;
1031 *ppnActualLength = &(OciData::__callbackActualLength);
1032 *ppvIndicator = &(OciData::__indicator);
1033 *ppnReturnCode = &(OciData::__returnCode);
1034 }
1035 else {
1036 // 버퍼가 OCIDateTime*, OCILogLocator*, OCIRowid* 와 같은
1037 // void*의 디스크립터 일 경우 ppvBuffer에는 이들 디스크립터의
1038 // 값을 넣어 주어야 한다.
1039 // 그러나, OciData::getData에서는 OciData::m_pValue를 사용하여
1040 // 값을 얻기 때문에 이들의 주소를 할당해야 한다.
1041 // OCIDateTime의 경우 *(OCIDateTime**)OciData::__value 와 같이 사용된다.
1042 //
1043 // OCINumber, OCIDate와 같은 경우 이들의 포인터를 할당한다.
1044 if (OciData::__descType) {
1045 OciData::__value = &__data.desc;
1046 OciData::__callbackActualLength = sizeof(void*);
1047 *ppvBuffer = __data.desc;
1048 }
1049 else {
1050 OciData::__value = &__data;
1051 OciData::__callbackActualLength = OciData::__valueSize;
1052 *ppvBuffer = &__data;
1053 }
1054 OciData::__indicator = -1;
1055
1056 *pnPiece = OCI_ONE_PIECE;
1057 *ppnActualLength = &(OciData::__callbackActualLength);//NULL;
1058 *ppvIndicator = &(OciData::__indicator);
1059 *ppnReturnCode = &(OciData::__returnCode);
1060 }
1061
1062 return OCI_CONTINUE;
1063}
OciData::__callbackActualLength
ub4 __callbackActualLength
Definition OciData.h:26
OciData::__bytesOutput
BytesOutputStream * __bytesOutput
Definition OciData.h:29

◆ query()

OciQuery * OciParam::query ( ) const
inline

Definition at line 27 of file OciParam.h.

27{ return (OciQuery*)Param::__queryHandle; }

◆ serverDataTypeName()

const wchar_t * OciParam::serverDataTypeName ( ) const
protectedvirtual

Implements SQL::Field.

Definition at line 259 of file OciParam.cpp.

260{
261 return OciData::dataTypeName(OciData::__dataType);
262}
OciData::dataTypeName
static const wchar_t * dataTypeName(ub2 _dataType)
Definition OciData.cpp:844

◆ setInterval()

bool OciParam::setInterval ( const SQL::Interval * _pv,
size_t _size,
SQL::DataType _assignType )
protected

Definition at line 630 of file OciParam.cpp.

635{
636 OciConnection* _conn = conn();
637 sword status = OCI_SUCCESS;
638
639 if (OciData::__descType == 0) {
640 __DCL_ASSERT(OciData::__descType == 0);
641
642 ub2 dataType = SQLT_INTERVAL_DS;
643 ub4 nDescType = OCI_DTYPE_INTERVAL_DS;
644 if (_assignType == SQL::typeIntervalYm) {
645 dataType = SQLT_INTERVAL_YM;
646 nDescType = OCI_DTYPE_INTERVAL_YM;
647 }
648
649 status = _conn->OCIDescriptorAlloc(
650 &(__data.desc),
651 nDescType
652 );
653 if (status != OCI_SUCCESS) {
654 __SET_ERROR(SQL::eServerError, status, NULL);
655 return false;
656 }
657
658 OciData::__descType = nDescType;
659 OciData::__dataType = dataType;
660 OciData::__maxDataSize = sizeof(SQL::Interval);
661 }
662
663 OCISession* pSession = _conn->sessionHandle();
664 OCIError* pError = _conn->errorHandle();
665
666 if (OciData::__dataType == SQLT_INTERVAL_YM) {
667 // set zero
668 // 이부분이 빠지면 Query::execute에서
669 status = ::OCIIntervalFromText(
670 pSession, // dvoid *hndl,
671 pError, // OCIError *err,
672 (CONST OraText*)"0-0", // CONST OraText *inpstring,
673 3, // size_t str_len,
674 (OCIInterval*)__data.desc // OCIInterval *result
675 );
676 if (status == OCI_SUCCESS)
677 status = ::OCIIntervalSetYearMonth(
678 pSession, // dvoid *hndl,
679 pError, // OCIError *err,
680 _pv->nYears, // sb4 yr,
681 _pv->nMonths, // sb4 mnth,
682 (OCIInterval*)__data.desc // OCIInterval *result
683 );
684 }
685 else {
686 status = ::OCIIntervalFromText(
687 pSession, // dvoid *hndl,
688 pError, // OCIError *err,
689 (CONST OraText*)"0 00:00:00", // CONST OraText *inpstring,
690 10, // size_t str_len,
691 (OCIInterval*)__data.desc // OCIInterval *result
692 );
693 if (status == OCI_SUCCESS)
694 status = ::OCIIntervalSetDaySecond(
695 pSession, // dvoid *hndl,
696 pError, // OCIError *err,
697 _pv->nDays, // sb4 dy,
698 _pv->nHours, // sb4 hr,
699 _pv->nMins, // sb4 mm,
700 _pv->nSecs, // sb4 ss,
701 _pv->nFracs, // sb4 fsec,
702 (OCIInterval*)__data.desc // OCIInterval *result
703 );
704 }
705#if defined(__DCL_DEBUG) && 1
706 if (status == OCI_SUCCESS) {
707 ub4 valid = 0;
708 status = ::OCIIntervalCheck(
709 pSession, // dvoid *hndl,
710 pError, // OCIError *err,
711 (CONST OCIInterval*)__data.desc, // CONST OCIInterval *interval,
712 &valid // ub4 *valid
713 );
714 }
715#endif
716
717 if (status != OCI_SUCCESS) {
718 __SET_ERROR(SQL::eServerError, status, NULL);
719 return false;
720 }
721
722 OciData::__value = &__data;
723 OciData::__valueSize = sizeof(OCIInterval*);
724
725 return true;
726}
OciConnection::sessionHandle
OCISession * sessionHandle() const
Definition OciConnection.h:56
SQL::Interval::nHours
int8_t nHours
Definition SQLCore.h:128
SQL::Interval::nFracs
int32_t nFracs
Definition SQLCore.h:131
SQL::Interval::nSecs
int8_t nSecs
Definition SQLCore.h:130
SQL::Interval::nMins
int8_t nMins
Definition SQLCore.h:129
SQL::Interval::nYears
int32_t nYears
Definition SQLCore.h:125
SQL::Interval::nMonths
int8_t nMonths
Definition SQLCore.h:126
SQL::Interval::nDays
int32_t nDays
Definition SQLCore.h:127

◆ setNull()

void OciParam::setNull ( )
protectedvirtual

Implements SQL::Param.

Definition at line 281 of file OciParam.cpp.

282{
283 // FIX 2025-02-10 See 753 OCIBindByPos
284 Param::__dataType = SQL::typeUnknown;
285 OciData::__dataType = SQLT_CHR;
286 OciData::__value = NULL;
287 OciData::__valueSize = 0;
288 OciData::__maxDataSize = 0;
289 __inputIndicator = -1;
290}

◆ setTimeStamp()

bool OciParam::setTimeStamp ( const SQL::TimeStamp * _pv,
size_t _size,
SQL::DataType _assignType )
protected

Definition at line 555 of file OciParam.cpp.

560{
561 OciConnection* _conn = conn();
562 sword status = OCI_SUCCESS;
563
564 if (OciData::__descType == 0) {
565 __DCL_ASSERT(OciData::__descType == 0);
566
567 ub2 dataType = SQLT_TIMESTAMP;
568 ub4 nDescType = OCI_DTYPE_TIMESTAMP;
569 if (_assignType == SQL::typeTimeStampTz) {
570 dataType = SQLT_TIMESTAMP_TZ;
571 nDescType = OCI_DTYPE_TIMESTAMP_TZ;
572 }
573
574 status = _conn->OCIDescriptorAlloc(
575 &(__data.desc),
576 nDescType
577 );
578 if (status != OCI_SUCCESS) {
579 __SET_ERROR(SQL::eServerError, status, NULL);
580 return false;
581 }
582
583 OciData::__descType = nDescType;
584 OciData::__dataType = dataType;
585 OciData::__maxDataSize = sizeof(SQL::TimeStamp);
586 }
587
588 ByteString strTz;
589 OraText* pTz = NULL;
590 size_t nTzLen = 0;
591 if (_assignType == SQL::typeTimeStampTz) {
592 strTz = ByteString::format(
593 // 6,
594 "%02d:%02d",
595 _pv->nTzMin / 60,
596 __ABS(_pv->nTzMin % 60)
597 );
598 pTz = (OraText*)strTz.data();
599 nTzLen = strTz.length();
600 }
601
602 OCISession* pSession = _conn->sessionHandle();
603 OCIError* pError = _conn->errorHandle();
604
605 status = ::OCIDateTimeConstruct(
606 pSession, // dvoid *hndl,
607 pError, // OCIError *err,
608 (OCIDateTime*)__data.desc, // OCIDateTime *datetime,
609 _pv->nYear, // sb2 year,
610 _pv->nMonth, // ub1 month,
611 _pv->nDay, // ub1 day,
612 _pv->nHour, // ub1 hour,
613 _pv->nMin, // ub1 min,
614 _pv->nSec, // ub1 sec,
615 _pv->nFrac, // ub4 fsec,
616 pTz, // OraText *timezone,
617 nTzLen // size_t timezone_length
618 );
619 if (status != OCI_SUCCESS) {
620 __SET_ERROR(SQL::eServerError, status, NULL);
621 return false;
622 }
623
624 OciData::__value = &__data;
625 OciData::__valueSize = sizeof(OCIDateTime*);
626
627 return true;
628}
__ABS
#define __ABS(n)
Definition MyParam.cpp:143

Member Data Documentation

◆ desc

void* OciParam::desc

Definition at line 18 of file OciParam.h.

◆ num

OCINumber OciParam::num

Definition at line 17 of file OciParam.h.

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