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

#include <OciData.h>

Inheritance diagram for OciData:
OciField OciParam

Public Member Functions

bool onAfterFetch ()

Protected Member Functions

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 const wchar_t * dataTypeName (ub2 _dataType)

Protected Attributes

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 13 of file OciData.h.

Constructor & Destructor Documentation

◆ OciData()

OciData::OciData ( )
protected

Definition at line 47 of file OciData.cpp.

48{
49 __queryHandle = NULL;
50 __position = 0;
51 __descType = 0;
52 __dynamicMode = OCI_DEFAULT;
53
54 __dataType = SQLT_CHR;
55 __value = NULL;
56 __valueSize = 0;
57 __indicator = -1; // null
58 __actualLength = 0;
59 __callbackActualLength = 0;
60 __returnCode = 0;
61
62 __bytesOutput = NULL;
63 __dataSize = 0;
64 __maxDataSize = 0;
65}
NULL
#define NULL
Definition Config.h:340
OciData::__indicator
sb2 __indicator
Definition OciData.h:24
OciData::__dataType
ub2 __dataType
Definition OciData.h:21
OciData::__valueSize
sb4 __valueSize
Definition OciData.h:23
OciData::__actualLength
ub2 __actualLength
Definition OciData.h:25
OciData::__queryHandle
OciQuery * __queryHandle
Definition OciData.h:16
OciData::__dynamicMode
ub4 __dynamicMode
Definition OciData.h:19
OciData::__dataSize
size_t __dataSize
Definition OciData.h:30
OciData::__position
ub4 __position
Definition OciData.h:17
OciData::__returnCode
ub2 __returnCode
Definition OciData.h:27
OciData::__callbackActualLength
ub4 __callbackActualLength
Definition OciData.h:26
OciData::__maxDataSize
size_t __maxDataSize
Definition OciData.h:31
OciData::__descType
ub4 __descType
Definition OciData.h:18
OciData::__value
void * __value
Definition OciData.h:22
OciData::__bytesOutput
BytesOutputStream * __bytesOutput
Definition OciData.h:29

◆ ~OciData()

OciData::~OciData ( )
protected

Definition at line 67 of file OciData.cpp.

68{
69 if (OciData::__bytesOutput) {
70 delete OciData::__bytesOutput;
71 // OciData::__bytesOutput = NULL;
72 }
73}

Member Function Documentation

◆ conn()

OciConnection * OciData::conn ( ) const
inlineprotected

Definition at line 62 of file OciData.h.

63{
64 return __queryHandle->conn();
65}

◆ dataTypeName()

const wchar_t * OciData::dataTypeName ( ub2 _dataType)
staticprotected

Definition at line 844 of file OciData.cpp.

845{
846 switch(_dataType) {
847 SQLTYPE_NAME(SQLT_NUM, "NUMBER");
848 SQLTYPE_NAME(SQLT_VNU, "NUMBER"); // for OciParam
849 SQLTYPE_NAME(SQLT_DAT, "DATE");
850 SQLTYPE_NAME(SQLT_ODT, "DATE"); // for OciParam
851 SQLTYPE_NAME(SQLT_TIMESTAMP, "TIMESTAMP");
852 SQLTYPE_NAME(SQLT_TIMESTAMP_TZ, "TIMESTAMP WITH TIME ZONE");
853 SQLTYPE_NAME(SQLT_TIMESTAMP_LTZ, "TIMESTAMP WITH LOCAL TIME ZONE");
854 SQLTYPE_NAME(SQLT_INTERVAL_YM, "INTERVAL YEAR TO MONTH");
855 SQLTYPE_NAME(SQLT_INTERVAL_DS, "INTERVAL DAY TO SECOND");
856 SQLTYPE_NAME(SQLT_CHR, "VARCHAR2");
857 SQLTYPE_NAME(SQLT_AFC, "CHAR");
858 SQLTYPE_NAME(SQLT_BIN, "RAW");
859 SQLTYPE_NAME(SQLT_LNG, "LONG");
860 SQLTYPE_NAME(SQLT_LBI, "LONG RAW");
861 SQLTYPE_NAME(SQLT_CLOB, "CLOB");
862 SQLTYPE_NAME(SQLT_BLOB, "BLOB");
863 SQLTYPE_NAME(SQLT_BFILE, "BFILE");
864 SQLTYPE_NAME(SQLT_CFILE, "CFILE");
865 SQLTYPE_NAME(SQLT_RDD, "ROWID");
866 }
867 return L"Unknown Type: Driver is not Support";
868}
SQLTYPE_NAME
#define SQLTYPE_NAME(_dataType, name)
Definition IFXField.cpp:288

◆ getBytes()

bool OciData::getBytes ( byte_t * _pv,
size_t * _size )
protected

Definition at line 541 of file OciData.cpp.

542{
543 switch(__dataType) {
544 case SQLT_RDD: {
545 if (*_size < __dataSize) {
546 *_size = __dataSize;
547 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
548 return false;
549 }
550 }
551 case SQLT_CHR :
552 case SQLT_AFC :
553 case SQLT_BIN :
554 case SQLT_LNG :
555 case SQLT_LBI: {
556 size_t nTotalSize = __MIN(__dataSize, *_size);
557 size_t nTotalCopy = 0;
558 if (nTotalSize) {
559 size_t nCopy = 0;
560 if (__bytesOutput) {
561 nCopy = __MIN(nTotalSize - nTotalCopy, __bytesOutput->size());
562 if (nCopy) {
563 memcpy(_pv, __bytesOutput->data(), nCopy);
564 nTotalCopy = nCopy;
565 }
566 }
567
568 nCopy = __MIN(nTotalSize - nTotalCopy, __callbackActualLength);
569 if (nCopy) {
570 memcpy(_pv + nTotalCopy, __value, nCopy);
571 nTotalCopy += nCopy;
572 }
573
574 if (nTotalCopy < *_size)
575 *(_pv + nTotalCopy) = '\0';
576 }
577 *_size = nTotalCopy;
578 break;
579 }
580 case SQLT_CLOB:
581 case SQLT_BLOB:
582 case SQLT_CFILE:
583 case SQLT_BFILE: {
584 if (*_size && __dataSize)
585 return getBytesFromLob(_pv, _size);
586 else
587 *_size = 0;
588 break;
589 }
590 default: {
591 __DCL_ASSERT(false); // OciField::init bug
592 }
593 }
594
595 return true;
596}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:150
OciData::getBytesFromLob
bool getBytesFromLob(byte_t *_pv, size_t *_size)
Definition OciData.cpp:653
SQL::eInvalidBufferSize
@ eInvalidBufferSize
Definition SQLCore.h:50
__MIN
size_t __MIN(size_t x, size_t y)
Definition size_t.h:27

◆ getBytesFromLob()

bool OciData::getBytesFromLob ( byte_t * _pv,
size_t * _size )
protected

Definition at line 653 of file OciData.cpp.

654{
655 __DCL_ASSERT(__dataType == SQLT_CLOB
656 || __dataType == SQLT_BLOB
657 || __dataType == SQLT_BFILE
658 || __dataType == SQLT_CFILE
659 );
660
661 OCISvcCtx* pSvcCtx = conn()->svcctxHandle();
662 OCIError* pError = conn()->errorHandle();
663 sword status = OCI_SUCCESS;
664 if (__descType == OCI_DTYPE_FILE) {
665 status = ::OCILobFileOpen(
666 pSvcCtx,
667 pError,
668 *(OCILobLocator**)__value,
669 OCI_FILE_READONLY
670 );
671 if (status != OCI_SUCCESS) {
672 __SET_ERROR(SQL::eServerError, status, pError);
673 return false;
674 }
675 }
676
677 bool bResult = true;
678 size_t nTotalRead = 0;
679 ub4 nRead = 0;
680 while(nTotalRead < *_size) {
681 nRead = *_size - nTotalRead;
682 status = ::OCILobRead(
683 pSvcCtx,
684 pError,
685 *((OCILobLocator**)__value),
686 &nRead,
687 1 + nTotalRead, // offset
688 _pbuf, // bufp,
689 nRead, // bufl,
690 NULL, // ctxp
691 (OCICallbackLobRead)NULL,
692 0,
693 SQLCS_IMPLICIT);
694 if (status == OCI_ERROR) {
695 __SET_ERROR(SQL::eServerError, status, pError);
696 bResult = false;
697 break;
698 }
699
700 // OCI_SUCCESS, OCI_NEED_DATA
701 if (nRead) {
702 nTotalRead += nRead;
703 _pbuf += nRead;
704 }
705 else
706 break; // done
707
708// if (status != OCI_NEED_DATA)
709// break;
710 }
711
712 if (__descType == OCI_DTYPE_FILE) {
713 if (bResult) {
714 status = ::OCILobFileClose(
715 pSvcCtx,
716 pError,
717 *(OCILobLocator**)__value);
718 if (status != OCI_SUCCESS) {
719 __SET_ERROR(SQL::eServerError, status, pError);
720 return false;
721 }
722 }
723 else {
724 // 이전에 에러가 발생했다. Close 만 시킨다.
725 status = ::OCILobFileClose(
726 pSvcCtx,
727 conn()->errorHandle2(),
728 *(OCILobLocator**)__value);
729 if (status != OCI_SUCCESS) {
730 __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
731 }
732 }
733 }
734
735 if (*_size > nTotalRead)
736 *(_pbuf + nTotalRead) = '\0';
737
738 *_size = nTotalRead;
739
740 return bResult;
741}
__DCL_TRACE0
#define __DCL_TRACE0(psz)
Definition Object.h:375
__T
#define __T(str)
Definition Object.h:44
OciConnection::svcctxHandle
OCISvcCtx * svcctxHandle() const
Definition OciConnection.h:55
OciConnection::errorHandle
OCIError * errorHandle() const
Definition OciConnection.h:52
OciData::conn
OciConnection * conn() const
Definition OciData.h:62
SQL::eServerError
@ eServerError
Definition SQLCore.h:21

◆ getData()

bool OciData::getData ( void * _pv,
size_t * _size,
SQL::DataType _dataType )
protected

Definition at line 202 of file OciData.cpp.

203{
204 if (__queryHandle->stmtType() == OCI_STMT_SELECT) {
205 if (!__queryHandle->inState(SQL::Query::stFetched)) {
206 __SET_ERROR(SQL::eNotFetched, 0, NULL);
207 return false;
208 }
209 }
210 else {
211 if (!__queryHandle->inState(SQL::Query::stExecuted)) {
212 __SET_ERROR(SQL::eNotExecuted, 0, NULL);
213 return false;
214 }
215 }
216
217 if (__indicator == -1) {
218 __SET_ERROR(SQL::eValueIsNull, 0, NULL);
219 return false;
220 }
221
222 switch(_dataType) {
223 case SQL::typeInteger:
224 case SQL::typeUInteger: {
225 return getInteger(_pv, _size, _dataType);
226 }
227 case SQL::typeFloat: {
228 return getFloat(_pv, _size);
229 }
230 case SQL::typeTimeStamp:
231 case SQL::typeTimeStampTz: {
232 if (*_size == sizeof(SQL::TimeStamp))
233 return getTimeStamp((SQL::TimeStamp*)_pv, _size);
234 else {
235 *_size = sizeof(SQL::TimeStamp);
236 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
237 return false;
238 }
239 }
240 case SQL::typeInterval:
241 case SQL::typeIntervalYm:
242 case SQL::typeIntervalDs: {
243 if (*_size == sizeof(SQL::Interval))
244 return getInterval((SQL::Interval*)_pv, _size);
245 else {
246 *_size = sizeof(SQL::Interval);
247 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
248 return false;
249 }
250 }
251 case SQL::typeText: {
252 if (__dataType == SQLT_VNU)
253 return getNumericText((char*)_pv, _size);
254 }
255 case SQL::typeBinary:
256 case SQL::typeLongText:
257 case SQL::typeLongBinary: {
258 return getBytes((byte_t*)_pv, _size);
259 }
260 case SQL::typeOutputStream: {
261 return writeTo((OutputStream*)_pv, _size);
262 }
263 // case SQL::typeDate :
264 // case SQL::typeTime :
265 default: {
266 __DCL_ASSERT(false); // SQL::Field::getData bug
267 }
268 }
269
270 return true;
271}
byte_t
unsigned char byte_t
Definition Config.h:274
OciData::getInteger
bool getInteger(void *_pv, size_t *_size, SQL::DataType _dataType)
Definition OciData.cpp:273
OciData::getInterval
bool getInterval(SQL::Interval *_pv, size_t *_size)
Definition OciData.cpp:481
OciData::getNumericText
bool getNumericText(char *_pv, size_t *_size)
Definition OciData.cpp:331
OciData::getBytes
bool getBytes(byte_t *_pv, size_t *_size)
Definition OciData.cpp:541
OciData::getFloat
bool getFloat(void *_pv, size_t *_size)
Definition OciData.cpp:302
OciData::getTimeStamp
bool getTimeStamp(SQL::TimeStamp *_pv, size_t *_size)
Definition OciData.cpp:389
OciData::writeTo
bool writeTo(OutputStream *_pv, size_t *_size)
Definition OciData.cpp:598
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:76
SQL::typeLongBinary
@ typeLongBinary
Definition SQLCore.h:78
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:65
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:70
SQL::typeTimeStampTz
@ typeTimeStampTz
Definition SQLCore.h:71
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:72
SQL::typeIntervalDs
@ typeIntervalDs
Definition SQLCore.h:74
SQL::typeOutputStream
@ typeOutputStream
Definition SQLCore.h:84
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::eNotExecuted
@ eNotExecuted
Definition SQLCore.h:42
SQL::eNotFetched
@ eNotFetched
Definition SQLCore.h:43
SQL::eValueIsNull
@ eValueIsNull
Definition SQLCore.h:47

◆ getDataSize()

bool OciData::getDataSize ( size_t * _size,
bool _maxSize )
protected

Definition at line 172 of file OciData.cpp.

173{
174 if (_maxSize) {
175 *_size = OciData::__maxDataSize;
176 return true;
177 }
178 else {
179 if (__queryHandle->stmtType() == OCI_STMT_SELECT) {
180 if (!__queryHandle->inState(SQL::Query::stFetched)) {
181 __SET_ERROR(SQL::eNotFetched, 0, NULL);
182 return false;
183 }
184 }
185 else {
186 if (!__queryHandle->inState(SQL::Query::stExecuted)) {
187 __SET_ERROR(SQL::eNotExecuted, 0, NULL);
188 return false;
189 }
190 }
191
192 if (__indicator == -1) {
193 __SET_ERROR(SQL::eValueIsNull, 0, NULL);
194 return false;
195 }
196 *_size = OciData::__dataSize;
197 }
198
199 return true;
200}

◆ getFloat()

bool OciData::getFloat ( void * _pv,
size_t * _size )
protected

Definition at line 302 of file OciData.cpp.

303{
304 __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
305
306 OCIError* pError = conn()->errorHandle();
307 if (*_size <= sizeof(long double)) {
308 // long double 의 storage size
309 // MSVC/WIN32 8
310 // GCC/Linux 12
311 sword status = ::OCINumberToReal(
312 pError, // OCIError *err,
313 (CONST OCINumber*)__value, // CONST OCINumber *number,
314 *_size, // uword rsl_length,
315 _pv // dvoid *rsl
316 );
317 if (status != OCI_SUCCESS) {
318 __SET_ERROR(SQL::eServerError, status, pError);
319 return false;
320 }
321 }
322 else {
323 *_size = sizeof(double);
324 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
325 return false;
326 }
327
328 return true;
329}

◆ getInteger()

bool OciData::getInteger ( void * _pv,
size_t * _size,
SQL::DataType _dataType )
protected

Definition at line 273 of file OciData.cpp.

274{
275 __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
276
277 OCIError* pError = conn()->errorHandle();
278 sword status = OCI_SUCCESS;
279 if (*_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
280 status = ::OCINumberToInt(
281 pError, // OCIError *err,
282 (CONST OCINumber*)__value, // CONST OCINumber *number,
283 *_size, // uword rsl_length,
284 _dataType == SQL::typeInteger ? // uword rsl_flag,
285 OCI_NUMBER_SIGNED : OCI_NUMBER_UNSIGNED,
286 _pv // dvoid *rsl
287 );
288 if (status != OCI_SUCCESS) {
289 __SET_ERROR(SQL::eServerError, status, pError);
290 return false;
291 }
292 }
293 else {
294 *_size = sizeof(int64_t);
295 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
296 return false;
297 }
298
299 return true;
300}

◆ getInterval()

bool OciData::getInterval ( SQL::Interval * _pv,
size_t * _size )
protected

Definition at line 481 of file OciData.cpp.

482{
483 OCISession* pSession = conn()->sessionHandle();
484 OCIError* pError = conn()->errorHandle();
485
486 sb4 nYear = 0;
487 sb4 nMonth = 0;
488 sb4 nDay = 0;
489 sb4 nHour = 0;
490 sb4 nMin = 0;
491 sb4 nSec = 0;
492 sb4 nFSec = 0;
493 sword status = OCI_SUCCESS;
494
495 switch(__dataType) {
496 case SQLT_INTERVAL_YM :
497 status = OCIIntervalGetYearMonth(
498 pSession, // dvoid *hndl,
499 pError, // OCIError *err,
500 &nYear, // sb4 *yr,
501 &nMonth, // sb4 *mnth,
502 *(CONST OCIInterval**)__value // CONST OCIInterval *interval
503 );
504 break;
505 case SQLT_INTERVAL_DS :
506 status = OCIIntervalGetDaySecond(
507 pSession, // dvoid *hndl,
508 pError, // OCIError *err,
509 &nDay, // sb4 *dy,
510 &nHour, // sb4 *hr,
511 &nMin, // sb4 *mm,
512 &nSec, // sb4 *ss,
513 &nFSec, // sb4 *fsec,
514 *(CONST OCIInterval**)__value // CONST OCIInterval *interval
515 );
516 break;
517 default :
518 __DCL_ASSERT(false); // OciField::init bug
519 }
520
521 if (status != OCI_SUCCESS) {
522 __SET_ERROR(SQL::eServerError, status, pError);
523 return false;
524 }
525
526 _pv->nYears = nYear;
527 _pv->nMonths = nMonth;
528 _pv->nDays = nDay;
529 _pv->nHours = nHour;
530 _pv->nMins = nMin;
531 _pv->nSecs = nSec;
532 _pv->nFracs = nFSec;
533 return true;
534}
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

◆ getNumericText()

bool OciData::getNumericText ( char * _pv,
size_t * _size )
protected

Definition at line 331 of file OciData.cpp.

332{
333 __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
334
335 OCIError* pError = conn()->errorHandle();
336 ub4 n = 133;
337 ByteBuffer* buf = ByteBuffer::create_e(n);
338 sword status = ::OCINumberToText(
339 pError, // OCIError *err,
340 (CONST OCINumber*)__value, // CONST OCINumber *number,
341 (const OraText*)"TM", // CONST OraText *fmt,
342 2, // ub4 fmt_length,
343 NULL, // CONST OraText *nls_params,
344 0, // ub4 nls_p_length,
345 &n, // ub4 *buf_size,
346 (text*)buf->data() // text *buf
347 );
348 if (status != OCI_SUCCESS) {
349 if (buf->__allocLength < n) {
350 ByteBuffer::extend(buf, n);
351 }
352 status = ::OCINumberToText(
353 pError, // OCIError *err,
354 (CONST OCINumber*)__value, // CONST OCINumber *number,
355 (CONST OraText*)"TM", // CONST OraText *fmt,
356 2, // ub4 fmt_length,
357 NULL, // CONST OraText *nls_params,
358 0, // ub4 nls_p_length,
359 &n, // ub4 *buf_size,
360 (text*)buf->data() // text *buf
361 );
362 }
363 if (status != OCI_SUCCESS) {
364 buf->release();
365 __SET_ERROR(SQL::eServerError, status, pError);
366 return false;
367 }
368
369 buf->__dataLength = n;
370 ByteString s = buf;
371 buf->release();
372
373 if (*_size < (size_t)s.length()) {
374 *_size = (size_t)s.length();
375 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
376 return false;
377 }
378
379 strncpy(pBuf, s.data(), s.length());
380 if (*_size > (size_t)s.length()) {
381 *_size = (size_t)s.length();
382 pBuf[*_size] = '\0';
383 }
384
385 return true;
386}
buf
ByteBuffer * buf
Definition SQLConnection.cpp:176
n
void CharsetConvertException *size_t n
Definition SQLField.cpp:253

◆ getTimeStamp()

bool OciData::getTimeStamp ( SQL::TimeStamp * _pv,
size_t * _size )
protected

Definition at line 389 of file OciData.cpp.

390{
391 OCISession* pSession = conn()->sessionHandle();
392 OCIError* pError = conn()->errorHandle();
393
394 sb2 nYear = 0;
395 ub1 nMonth = 0;
396 ub1 nDay = 0;
397 ub1 nHour = 0;
398 ub1 nMin = 0;
399 ub1 nSec = 0;
400 ub4 nFSec = 0;
401
402 _pv->nTzMin = 0;
403
404 sword status = OCI_SUCCESS;
405
406 switch(__dataType) {
407 // case SQLT_DAT :
408 case SQLT_ODT: {
409 OCIDateGetDate((CONST OCIDate*)__value,
410 &nYear,
411 &nMonth,
412 &nDay
413 );
414 OCIDateGetTime(
415 (CONST OCIDate*)__value,
416 &nHour,
417 &nMin,
418 &nSec
419 );
420 break;
421 }
422 case SQLT_TIMESTAMP :
423 case SQLT_TIMESTAMP_TZ :
424 case SQLT_TIMESTAMP_LTZ: {
425 status = ::OCIDateTimeGetDate(
426 pSession, // dvoid *hndl,
427 pError, // OCIError *err,
428 *(CONST OCIDateTime**)__value, // CONST OCIDateTime *datetime,
429 &nYear, // sb2 *year,
430 &nMonth, // ub1 *month,
431 &nDay // ub1 *day
432 );
433 if (status == OCI_SUCCESS)
434 status = ::OCIDateTimeGetTime(
435 pSession, // dvoid *hndl,
436 pError, // OCIError *err,
437 *(OCIDateTime**)__value, // OCIDateTime *datetime,
438 &nHour, // ub1 *hour,
439 &nMin, // ub1 *min,
440 &nSec, // ub1 *sec,
441 &nFSec // ub4 *fsec
442 );
443 if (status == OCI_SUCCESS && __dataType != SQLT_TIMESTAMP) {
444 sb1 nTzHour = 0;
445 sb1 nTzMin = 0;
446
447 status = ::OCIDateTimeGetTimeZoneOffset(
448 pSession, // dvoid *hndl,
449 pError, // OCIError *err,
450 *(CONST OCIDateTime**)__value, // CONST OCIDateTime *datetime,
451 &nTzHour, // sb1 *hour,
452 &nTzMin // sb1 *min,
453 );
454 if (status != OCI_SUCCESS) {
455 __SET_ERROR(SQL::eServerError, status, pError);
456 return false;
457 }
458 // __DCL_TRACE2_N("TZ : %+03d:%02d\n", nTzHour, nTzMin);
459 _pv->nTzMin = nTzHour * 60 + nTzMin;
460 }
461
462 // __DCL_TRACE3_N("_pv: %d, s: %d, %d\n", m_nPrecision, m_nScale, nFSec);
463 break;
464 }
465 default: {
466 __DCL_ASSERT(false); // OciField::init bug
467 }
468 }
469
470 _pv->nYear = nYear;
471 _pv->nMonth = nMonth;
472 _pv->nDay = nDay;
473 _pv->nHour = nHour;
474 _pv->nMin = nMin;
475 _pv->nSec = nSec;
476 _pv->nFrac = nFSec;
477
478 return true;
479}
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

◆ isInteger()

bool OciData::isInteger ( ) const
protected

◆ onAfterFetch()

bool OciData::onAfterFetch ( )

Definition at line 83 of file OciData.cpp.

84{
85 // after fetch
86 // after execute in outbind
87
88 if (__indicator == -1)
89 return true;
90
91 OciConnection* pConnection = conn();
92 OCIError* pError = pConnection->errorHandle();
93 sword status = OCI_SUCCESS;
94
95 switch(__dataType) {
96 case SQLT_CHR :
97 case SQLT_AFC :
98 case SQLT_BIN :
99 case SQLT_LNG :
100 // case SQLT_RDD : SQLT_CHR로 OciField.cpp(213)
101 case SQLT_LBI: {
102 if (__dynamicMode == OCI_DEFAULT)
103 __callbackActualLength = __actualLength;
104
105 if (__bytesOutput)
106 __dataSize = __bytesOutput->size();
107 else
108 __dataSize = 0;
109 __dataSize += __callbackActualLength;
110 break;
111 }
112 case SQLT_CLOB :
113 case SQLT_BLOB :
114 case SQLT_CFILE :
115 case SQLT_BFILE: {
116 OCISvcCtx* pSvcCtx = pConnection->svcctxHandle();
117 ub8 nLength = 0;
118 if (__descType == OCI_DTYPE_FILE) {
119 status = ::OCILobFileOpen(
120 pSvcCtx,
121 pError,
122 *(OCILobLocator**)__value,
123 OCI_FILE_READONLY
124 );
125 if (status != OCI_SUCCESS) {
126 __SET_ERROR(SQL::eServerError, status, pError);
127 return false;
128 }
129 }
130
131 status = ::OCILobGetLength2(
132 pSvcCtx,
133 pError,
134 *(OCILobLocator**)__value,
135 &nLength
136 );
137 if (status != OCI_SUCCESS) {
138 __SET_ERROR(SQL::eServerError, status, pError);
139 return false;
140 }
141
142 if (__descType == OCI_DTYPE_FILE) {
143 status = ::OCILobFileClose(
144 pSvcCtx,
145 pError,
146 *(OCILobLocator**)__value
147 );
148 if (status != OCI_SUCCESS) {
149 __SET_ERROR(SQL::eServerError, status, pError);
150 return false;
151 }
152 }
153
154 switch (__dataType) {
155 case SQLT_CLOB:
156 case SQLT_CFILE:
157 __dataSize = nLength * 3; // UTF-8
158 break;
159 default:
160 __dataSize = nLength;
161 }
162 break;
163 }
164 default: {
165 __dataSize = OciData::__maxDataSize;
166 }
167 }
168
169 return true;
170}

◆ writeTo()

bool OciData::writeTo ( OutputStream * _pv,
size_t * _size )
protected

Definition at line 598 of file OciData.cpp.

599{
600 switch(__dataType) {
601 case SQLT_RDD :
602 case SQLT_CHR :
603 case SQLT_AFC :
604 case SQLT_BIN :
605 case SQLT_LNG :
606 case SQLT_LBI: {
607 try {
608 size_t nTotalSize = __MIN(__dataSize, *_size);
609 size_t nTotalWritten = 0;
610 if (nTotalSize) {
611 size_t nWrite = 0;
612 if (__bytesOutput) {
613 nWrite = __MIN(nTotalSize - nTotalWritten, __bytesOutput->size());
614 if (nWrite) {
615 pOutput->write(__bytesOutput->data(), nWrite);
616 nTotalWritten += nWrite;
617 }
618 }
619
620 nWrite = __MIN(nTotalSize - nTotalWritten, __callbackActualLength);
621 if (nWrite) {
622 pOutput->write(__value, nWrite);
623 nTotalWritten += nWrite;
624 }
625 }
626
627 *_size = nTotalWritten;
628 }
629 catch (IOException* e) {
630 e->destroy();
631 return false;
632 }
633 break;
634 }
635 case SQLT_CLOB :
636 case SQLT_BLOB :
637 case SQLT_CFILE :
638 case SQLT_BFILE: {
639 if (*_size && __dataSize)
640 return writeToFromLob(pOutput, _size);
641 else
642 *_size = 0;
643 break;
644 }
645 default: {
646 __DCL_ASSERT(false); // OciField::init bug
647 }
648 }
649
650 return true;
651}
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
OciData::writeToFromLob
bool writeToFromLob(OutputStream *_pv, size_t *_size)
Definition OciData.cpp:743

◆ writeToFromLob()

bool OciData::writeToFromLob ( OutputStream * _pv,
size_t * _size )
protected

Definition at line 743 of file OciData.cpp.

744{
745 __DCL_ASSERT(__dataType == SQLT_CLOB
746 || __dataType == SQLT_BLOB
747 || __dataType == SQLT_BFILE
748 || __dataType == SQLT_CFILE
749 );
750
751 OCISvcCtx* pSvcCtx = conn()->svcctxHandle();
752 OCIError* pError = conn()->errorHandle();
753 sword status = OCI_SUCCESS;
754 if (__descType == OCI_DTYPE_FILE) {
755 status = ::OCILobFileOpen(
756 pSvcCtx,
757 pError,
758 *(OCILobLocator**)__value,
759 OCI_FILE_READONLY
760 );
761 if (status != OCI_SUCCESS) {
762 __SET_ERROR(SQL::eServerError, status, pError);
763 return false;
764 }
765 }
766
767 bool bResult = true;
768 size_t nTotalRead = 0;
769 ub4 nRead = 0;
770 char buf[4096];
771 while(nTotalRead < *_size) {
772 nRead = __MIN(*_size - nTotalRead, sizeof(buf));
773 status = ::OCILobRead(
774 pSvcCtx,
775 pError,
776 *((OCILobLocator**)__value),
777 &nRead,
778 1 + nTotalRead, // offset
779 buf, // bufp
780 nRead, // bufl
781 NULL, // ctxp
782 (OCICallbackLobRead)NULL,
783 0,
784 SQLCS_IMPLICIT);
785 if (status == OCI_ERROR) {
786 __SET_ERROR(SQL::eServerError, status, pError);
787 bResult = false;
788 break;
789 }
790
791 if (nRead) {
792 try {
793 pOutput->write(buf, nRead);
794 }
795 catch(IOException* e) {
796 e->destroy();
797 bResult = false;
798 break;
799 }
800
801 nTotalRead += nRead;
802 }
803 else {
804 break; // done
805 }
806
807// if (status != OCI_NEED_DATA)
808// break;
809 }
810
811 if (__descType == OCI_DTYPE_FILE) {
812 if (bResult) {
813 status = ::OCILobFileClose(
814 pSvcCtx,
815 pError,
816 *(OCILobLocator**)__value);
817 if (status != OCI_SUCCESS) {
818 __SET_ERROR(SQL::eServerError, status, pError);
819 return false;
820 }
821 }
822 else {
823 // 이전에 에러가 발생했다. Close 만 시킨다.
824 status = ::OCILobFileClose(
825 pSvcCtx,
826 conn()->errorHandle2(),
827 *(OCILobLocator**)__value);
828 if (status != OCI_SUCCESS) {
829 __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
830 }
831 }
832 }
833
834 *_size = nTotalRead;
835 return bResult;
836}

Member Data Documentation

◆ __actualLength

ub2 OciData::__actualLength
protected

Definition at line 25 of file OciData.h.

◆ __bytesOutput

BytesOutputStream* OciData::__bytesOutput
protected

Definition at line 29 of file OciData.h.

◆ __callbackActualLength

ub4 OciData::__callbackActualLength
protected

Definition at line 26 of file OciData.h.

◆ __dataSize

size_t OciData::__dataSize
protected

Definition at line 30 of file OciData.h.

◆ __dataType

ub2 OciData::__dataType
protected

Definition at line 21 of file OciData.h.

◆ __descType

ub4 OciData::__descType
protected

Definition at line 18 of file OciData.h.

◆ __dynamicMode

ub4 OciData::__dynamicMode
protected

Definition at line 19 of file OciData.h.

◆ __indicator

sb2 OciData::__indicator
protected

Definition at line 24 of file OciData.h.

◆ __maxDataSize

size_t OciData::__maxDataSize
protected

Definition at line 31 of file OciData.h.

◆ __position

ub4 OciData::__position
protected

Definition at line 17 of file OciData.h.

◆ __queryHandle

OciQuery* OciData::__queryHandle
protected

Definition at line 16 of file OciData.h.

◆ __returnCode

ub2 OciData::__returnCode
protected

Definition at line 27 of file OciData.h.

◆ __value

void* OciData::__value
protected

Definition at line 22 of file OciData.h.

◆ __valueSize

sb4 OciData::__valueSize
protected

Definition at line 23 of file OciData.h.

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