DCL 4.1
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 getDate (SQL::Date *_pv, size_t *_size)
bool getTime (SQL::Time *_pv, size_t *_size)
bool getTimeStamp (SQL::TimeStamp *_pv)
bool getInterval (SQL::Interval *_pv)
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 64 of file OciData.h.

65{
66 return __queryHandle->conn();
67}

◆ dataTypeName()

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

Definition at line 872 of file OciData.cpp.

873{
874 switch(_dataType) {
875 SQLTYPE_NAME(SQLT_NUM, "NUMBER");
876 SQLTYPE_NAME(SQLT_VNU, "NUMBER"); // for OciParam
877 SQLTYPE_NAME(SQLT_DAT, "DATE");
878 SQLTYPE_NAME(SQLT_ODT, "DATE"); // for OciParam
879 SQLTYPE_NAME(SQLT_TIMESTAMP, "TIMESTAMP");
880 SQLTYPE_NAME(SQLT_TIMESTAMP_TZ, "TIMESTAMP WITH TIME ZONE");
881 SQLTYPE_NAME(SQLT_TIMESTAMP_LTZ, "TIMESTAMP WITH LOCAL TIME ZONE");
882 SQLTYPE_NAME(SQLT_INTERVAL_YM, "INTERVAL YEAR TO MONTH");
883 SQLTYPE_NAME(SQLT_INTERVAL_DS, "INTERVAL DAY TO SECOND");
884 SQLTYPE_NAME(SQLT_CHR, "VARCHAR2");
885 SQLTYPE_NAME(SQLT_AFC, "CHAR");
886 SQLTYPE_NAME(SQLT_BIN, "RAW");
887 SQLTYPE_NAME(SQLT_LNG, "LONG");
888 SQLTYPE_NAME(SQLT_LBI, "LONG RAW");
889 SQLTYPE_NAME(SQLT_CLOB, "CLOB");
890 SQLTYPE_NAME(SQLT_BLOB, "BLOB");
891 SQLTYPE_NAME(SQLT_BFILE, "BFILE");
892 SQLTYPE_NAME(SQLT_CFILE, "CFILE");
893 SQLTYPE_NAME(SQLT_RDD, "ROWID");
894 }
895 return L"Unknown Type: Driver is not Support";
896}
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 569 of file OciData.cpp.

570{
571 switch(__dataType) {
572 case SQLT_RDD: {
573 if (*_size < __dataSize) {
574 *_size = __dataSize;
575 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
576 return false;
577 }
578 }
579 case SQLT_CHR :
580 case SQLT_AFC :
581 case SQLT_BIN :
582 case SQLT_LNG :
583 case SQLT_LBI: {
584 size_t nTotalSize = __MIN(__dataSize, *_size);
585 size_t nTotalCopy = 0;
586 if (nTotalSize) {
587 size_t nCopy = 0;
588 if (__bytesOutput) {
589 nCopy = __MIN(nTotalSize - nTotalCopy, __bytesOutput->size());
590 if (nCopy) {
591 memcpy(_pv, __bytesOutput->data(), nCopy);
592 nTotalCopy = nCopy;
593 }
594 }
595
596 nCopy = __MIN(nTotalSize - nTotalCopy, __callbackActualLength);
597 if (nCopy) {
598 memcpy(_pv + nTotalCopy, __value, nCopy);
599 nTotalCopy += nCopy;
600 }
601
602 if (nTotalCopy < *_size)
603 *(_pv + nTotalCopy) = '\0';
604 }
605 *_size = nTotalCopy;
606 break;
607 }
608 case SQLT_CLOB:
609 case SQLT_BLOB:
610 case SQLT_CFILE:
611 case SQLT_BFILE: {
612 if (*_size && __dataSize)
613 return getBytesFromLob(_pv, _size);
614 else
615 *_size = 0;
616 break;
617 }
618 default: {
619 __DCL_ASSERT(false); // OciField::init bug
620 }
621 }
622
623 return true;
624}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:153
OciData::getBytesFromLob
bool getBytesFromLob(byte_t *_pv, size_t *_size)
Definition OciData.cpp:681
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 681 of file OciData.cpp.

682{
683 __DCL_ASSERT(__dataType == SQLT_CLOB
684 || __dataType == SQLT_BLOB
685 || __dataType == SQLT_BFILE
686 || __dataType == SQLT_CFILE
687 );
688
689 OCISvcCtx* pSvcCtx = conn()->svcctxHandle();
690 OCIError* pError = conn()->errorHandle();
691 sword status = OCI_SUCCESS;
692 if (__descType == OCI_DTYPE_FILE) {
693 status = ::OCILobFileOpen(
694 pSvcCtx,
695 pError,
696 *(OCILobLocator**)__value,
697 OCI_FILE_READONLY
698 );
699 if (status != OCI_SUCCESS) {
700 __SET_ERROR(SQL::eServerError, status, pError);
701 return false;
702 }
703 }
704
705 bool bResult = true;
706 size_t nTotalRead = 0;
707 ub4 nRead = 0;
708 while(nTotalRead < *_size) {
709 nRead = *_size - nTotalRead;
710 status = ::OCILobRead(
711 pSvcCtx,
712 pError,
713 *((OCILobLocator**)__value),
714 &nRead,
715 1 + nTotalRead, // offset
716 _pbuf, // bufp,
717 nRead, // bufl,
718 NULL, // ctxp
719 (OCICallbackLobRead)NULL,
720 0,
721 SQLCS_IMPLICIT);
722 if (status == OCI_ERROR) {
723 __SET_ERROR(SQL::eServerError, status, pError);
724 bResult = false;
725 break;
726 }
727
728 // OCI_SUCCESS, OCI_NEED_DATA
729 if (nRead) {
730 nTotalRead += nRead;
731 _pbuf += nRead;
732 }
733 else
734 break; // done
735
736// if (status != OCI_NEED_DATA)
737// break;
738 }
739
740 if (__descType == OCI_DTYPE_FILE) {
741 if (bResult) {
742 status = ::OCILobFileClose(
743 pSvcCtx,
744 pError,
745 *(OCILobLocator**)__value);
746 if (status != OCI_SUCCESS) {
747 __SET_ERROR(SQL::eServerError, status, pError);
748 return false;
749 }
750 }
751 else {
752 // 이전에 에러가 발생했다. Close 만 시킨다.
753 status = ::OCILobFileClose(
754 pSvcCtx,
755 conn()->errorHandle2(),
756 *(OCILobLocator**)__value);
757 if (status != OCI_SUCCESS) {
758 __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
759 }
760 }
761 }
762
763 if (*_size > nTotalRead)
764 *(_pbuf + nTotalRead) = '\0';
765
766 *_size = nTotalRead;
767
768 return bResult;
769}
__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:64
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::typeDate: {
231 if (*_size != sizeof(SQL::Date)) {
232 *_size = sizeof(SQL::Date);
233 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
234 return false;
235 }
236 SQL::TimeStamp ts;
237 size_t size = sizeof(ts);
238 bool r = getTimeStamp(&ts);
239 if (r) {
240 SQL::Date* p = (SQL::Date*)_pv;
241 p->year = ts.year;
242 p->month = ts.month;
243 p->day = ts.day;
244 }
245 return r;
246 }
247 case SQL::typeTime: {
248 if (*_size != sizeof(SQL::typeTime)) {
249 *_size = sizeof(SQL::typeTime);
250 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
251 return false;
252 }
253 SQL::TimeStamp ts;
254 size_t size = sizeof(ts);
255 bool r = getTimeStamp(&ts);
256 if (r) {
257 SQL::Time* p = (SQL::Time*)_pv;
258 p->hour = ts.hour;
259 p->min = ts.min;
260 p->sec = ts.sec;
261 p->frac = ts.frac;
262 p->tzoff = ts.tzoff;
263 }
264 return r;
265 }
266 case SQL::typeTimeStamp: {
267 if (*_size != sizeof(SQL::TimeStamp)) {
268 *_size = sizeof(SQL::TimeStamp);
269 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
270 return false;
271 }
272 return getTimeStamp((SQL::TimeStamp*)_pv);
273 }
274 case SQL::typeInterval: {
275 if (*_size != sizeof(SQL::Interval)) {
276 *_size = sizeof(SQL::Interval);
277 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
278 return false;
279 }
280 return getInterval((SQL::Interval*)_pv);
281 }
282 case SQL::typeText: {
283 if (__dataType == SQLT_VNU)
284 return getNumericText((char*)_pv, _size);
285 }
286 case SQL::typeBinary: {
287 return getBytes((byte_t*)_pv, _size);
288 }
289 case SQL::typeOutputStream: {
290 return writeTo((OutputStream*)_pv, _size);
291 }
292 // case SQL::typeDate :
293 // case SQL::typeTime :
294 default: {
295 __DCL_ASSERT(false); // SQL::Field::getData bug
296 }
297 }
298
299 return true;
300}
byte_t
unsigned char byte_t
Definition Config.h:274
r
ByteString r
Definition SQLConnection.cpp:182
OciData::getInterval
bool getInterval(SQL::Interval *_pv)
Definition OciData.cpp:509
OciData::getTimeStamp
bool getTimeStamp(SQL::TimeStamp *_pv)
Definition OciData.cpp:418
OciData::getInteger
bool getInteger(void *_pv, size_t *_size, SQL::DataType _dataType)
Definition OciData.cpp:302
OciData::getNumericText
bool getNumericText(char *_pv, size_t *_size)
Definition OciData.cpp:360
OciData::getBytes
bool getBytes(byte_t *_pv, size_t *_size)
Definition OciData.cpp:569
OciData::getFloat
bool getFloat(void *_pv, size_t *_size)
Definition OciData.cpp:331
OciData::writeTo
bool writeTo(OutputStream *_pv, size_t *_size)
Definition OciData.cpp:626
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::typeInterval
@ typeInterval
Definition SQLCore.h:73
SQL::typeDate
@ typeDate
Definition SQLCore.h:68
SQL::typeOutputStream
@ typeOutputStream
Definition SQLCore.h:85
SQL::typeText
@ typeText
Definition SQLCore.h:76
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:66
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:64
SQL::eNotExecuted
@ eNotExecuted
Definition SQLCore.h:42
SQL::eNotFetched
@ eNotFetched
Definition SQLCore.h:43
SQL::eValueIsNull
@ eValueIsNull
Definition SQLCore.h:47
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
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
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

◆ 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}

◆ getDate()

bool OciData::getDate ( SQL::Date * _pv,
size_t * _size )
protected

◆ getFloat()

bool OciData::getFloat ( void * _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 if (*_size <= sizeof(long double)) {
337 // long double 의 storage size
338 // MSVC/WIN32 8
339 // GCC/Linux 12
340 sword status = ::OCINumberToReal(
341 pError, // OCIError *err,
342 (CONST OCINumber*)__value, // CONST OCINumber *number,
343 *_size, // uword rsl_length,
344 _pv // dvoid *rsl
345 );
346 if (status != OCI_SUCCESS) {
347 __SET_ERROR(SQL::eServerError, status, pError);
348 return false;
349 }
350 }
351 else {
352 *_size = sizeof(double);
353 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
354 return false;
355 }
356
357 return true;
358}

◆ getInteger()

bool OciData::getInteger ( void * _pv,
size_t * _size,
SQL::DataType _dataType )
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 sword status = OCI_SUCCESS;
308 if (*_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
309 status = ::OCINumberToInt(
310 pError, // OCIError *err,
311 (CONST OCINumber*)__value, // CONST OCINumber *number,
312 *_size, // uword rsl_length,
313 _dataType == SQL::typeInteger ? // uword rsl_flag,
314 OCI_NUMBER_SIGNED : OCI_NUMBER_UNSIGNED,
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(int64_t);
324 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
325 return false;
326 }
327
328 return true;
329}

◆ getInterval()

bool OciData::getInterval ( SQL::Interval * _pv)
protected

Definition at line 509 of file OciData.cpp.

510{
511 OCISession* pSession = conn()->sessionHandle();
512 OCIError* pError = conn()->errorHandle();
513
514 sb4 nYear = 0;
515 sb4 nMonth = 0;
516 sb4 nDay = 0;
517 sb4 nHour = 0;
518 sb4 nMin = 0;
519 sb4 nSec = 0;
520 sb4 nFSec = 0;
521 sword status = OCI_SUCCESS;
522
523 switch(__dataType) {
524 case SQLT_INTERVAL_YM :
525 status = OCIIntervalGetYearMonth(
526 pSession, // dvoid *hndl,
527 pError, // OCIError *err,
528 &nYear, // sb4 *yr,
529 &nMonth, // sb4 *mnth,
530 *(CONST OCIInterval**)__value // CONST OCIInterval *interval
531 );
532 break;
533 case SQLT_INTERVAL_DS :
534 status = OCIIntervalGetDaySecond(
535 pSession, // dvoid *hndl,
536 pError, // OCIError *err,
537 &nDay, // sb4 *dy,
538 &nHour, // sb4 *hr,
539 &nMin, // sb4 *mm,
540 &nSec, // sb4 *ss,
541 &nFSec, // sb4 *fsec,
542 *(CONST OCIInterval**)__value // CONST OCIInterval *interval
543 );
544 break;
545 default :
546 __DCL_ASSERT(false); // OciField::init bug
547 }
548
549 if (status != OCI_SUCCESS) {
550 __SET_ERROR(SQL::eServerError, status, pError);
551 return false;
552 }
553
554 _pv->years = nYear;
555 _pv->months = nMonth;
556 _pv->days = nDay;
557 _pv->hours = nHour;
558 _pv->mins = nMin;
559 _pv->secs = nSec;
560 _pv->fracs = nFSec;
561 return true;
562}
OciConnection::sessionHandle
OCISession * sessionHandle() const
Definition OciConnection.h:56
SQL::Interval::years
int32_t years
Definition SQLCore.h:127
SQL::Interval::days
int32_t days
Definition SQLCore.h:129
SQL::Interval::hours
int8_t hours
Definition SQLCore.h:130
SQL::Interval::mins
int8_t mins
Definition SQLCore.h:131
SQL::Interval::fracs
int32_t fracs
Definition SQLCore.h:133
SQL::Interval::months
int8_t months
Definition SQLCore.h:128
SQL::Interval::secs
int8_t secs
Definition SQLCore.h:132

◆ getNumericText()

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

Definition at line 360 of file OciData.cpp.

361{
362 __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
363
364 OCIError* pError = conn()->errorHandle();
365 ub4 n = 133;
366 ByteBuffer* buf = ByteBuffer::create_e(n);
367 sword status = ::OCINumberToText(
368 pError, // OCIError *err,
369 (CONST OCINumber*)__value, // CONST OCINumber *number,
370 (const OraText*)"TM", // CONST OraText *fmt,
371 2, // ub4 fmt_length,
372 NULL, // CONST OraText *nls_params,
373 0, // ub4 nls_p_length,
374 &n, // ub4 *buf_size,
375 (text*)buf->data() // text *buf
376 );
377 if (status != OCI_SUCCESS) {
378 if (buf->__allocLength < n) {
379 ByteBuffer::extend(buf, n);
380 }
381 status = ::OCINumberToText(
382 pError, // OCIError *err,
383 (CONST OCINumber*)__value, // CONST OCINumber *number,
384 (CONST OraText*)"TM", // CONST OraText *fmt,
385 2, // ub4 fmt_length,
386 NULL, // CONST OraText *nls_params,
387 0, // ub4 nls_p_length,
388 &n, // ub4 *buf_size,
389 (text*)buf->data() // text *buf
390 );
391 }
392 if (status != OCI_SUCCESS) {
393 buf->release();
394 __SET_ERROR(SQL::eServerError, status, pError);
395 return false;
396 }
397
398 buf->__dataLength = n;
399 ByteString s = buf;
400 buf->release();
401
402 if (*_size < (size_t)s.length()) {
403 *_size = (size_t)s.length();
404 __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
405 return false;
406 }
407
408 strncpy(pBuf, s.data(), s.length());
409 if (*_size > (size_t)s.length()) {
410 *_size = (size_t)s.length();
411 pBuf[*_size] = '\0';
412 }
413
414 return true;
415}
buf
ByteBuffer * buf
Definition SQLConnection.cpp:176
n
void CharsetConvertException *size_t n
Definition SQLField.cpp:254

◆ getTime()

bool OciData::getTime ( SQL::Time * _pv,
size_t * _size )
protected

◆ getTimeStamp()

bool OciData::getTimeStamp ( SQL::TimeStamp * _pv)
protected

Definition at line 418 of file OciData.cpp.

419{
420 OCISession* pSession = conn()->sessionHandle();
421 OCIError* pError = conn()->errorHandle();
422
423 sb2 nYear = 0;
424 ub1 nMonth = 0;
425 ub1 nDay = 0;
426 ub1 nHour = 0;
427 ub1 nMin = 0;
428 ub1 nSec = 0;
429 ub4 nFSec = 0;
430
431 _pv->tzoff = INT16_MIN;
432
433 sword status = OCI_SUCCESS;
434
435 switch(__dataType) {
436 // case SQLT_DAT :
437 case SQLT_ODT: {
438 OCIDateGetDate(
439 (CONST OCIDate*)__value,
440 &nYear,
441 &nMonth,
442 &nDay
443 );
444 OCIDateGetTime(
445 (CONST OCIDate*)__value,
446 &nHour,
447 &nMin,
448 &nSec
449 );
450 break;
451 }
452 case SQLT_TIMESTAMP :
453 case SQLT_TIMESTAMP_TZ :
454 case SQLT_TIMESTAMP_LTZ: {
455 status = ::OCIDateTimeGetDate(
456 pSession, // dvoid *hndl,
457 pError, // OCIError *err,
458 *(CONST OCIDateTime**)__value, // CONST OCIDateTime *datetime,
459 &nYear, // sb2 *year,
460 &nMonth, // ub1 *month,
461 &nDay // ub1 *day
462 );
463 if (status == OCI_SUCCESS)
464 status = ::OCIDateTimeGetTime(
465 pSession, // dvoid *hndl,
466 pError, // OCIError *err,
467 *(OCIDateTime**)__value, // OCIDateTime *datetime,
468 &nHour, // ub1 *hour,
469 &nMin, // ub1 *min,
470 &nSec, // ub1 *sec,
471 &nFSec // ub4 *fsec
472 );
473 if (status == OCI_SUCCESS && __dataType != SQLT_TIMESTAMP) {
474 sb1 tzHour = 0;
475 sb1 tzMin = 0;
476
477 status = ::OCIDateTimeGetTimeZoneOffset(
478 pSession, // dvoid *hndl,
479 pError, // OCIError *err,
480 *(CONST OCIDateTime**)__value, // CONST OCIDateTime *datetime,
481 &tzHour, // sb1 *hour,
482 &tzMin // sb1 *min,
483 );
484 if (status != OCI_SUCCESS) {
485 __SET_ERROR(SQL::eServerError, status, pError);
486 return false;
487 }
488 // __DCL_TRACE2_N("TZ : %+03d:%02d\n", hour, min);
489 _pv->tzoff = tzHour * 60 + tzMin;
490 }
491 break;
492 }
493 default: {
494 __DCL_ASSERT(false); // OciField::init bug
495 }
496 }
497
498 _pv->year = nYear;
499 _pv->month = nMonth;
500 _pv->day = nDay;
501 _pv->hour = nHour;
502 _pv->min = nMin;
503 _pv->sec = nSec;
504 _pv->frac = nFSec;
505
506 return true;
507}
INT16_MIN
#define INT16_MIN
Definition Config.h:312

◆ 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 626 of file OciData.cpp.

627{
628 switch(__dataType) {
629 case SQLT_RDD :
630 case SQLT_CHR :
631 case SQLT_AFC :
632 case SQLT_BIN :
633 case SQLT_LNG :
634 case SQLT_LBI: {
635 try {
636 size_t nTotalSize = __MIN(__dataSize, *_size);
637 size_t nTotalWritten = 0;
638 if (nTotalSize) {
639 size_t nWrite = 0;
640 if (__bytesOutput) {
641 nWrite = __MIN(nTotalSize - nTotalWritten, __bytesOutput->size());
642 if (nWrite) {
643 pOutput->write(__bytesOutput->data(), nWrite);
644 nTotalWritten += nWrite;
645 }
646 }
647
648 nWrite = __MIN(nTotalSize - nTotalWritten, __callbackActualLength);
649 if (nWrite) {
650 pOutput->write(__value, nWrite);
651 nTotalWritten += nWrite;
652 }
653 }
654
655 *_size = nTotalWritten;
656 }
657 catch (IOException* e) {
658 e->destroy();
659 return false;
660 }
661 break;
662 }
663 case SQLT_CLOB :
664 case SQLT_BLOB :
665 case SQLT_CFILE :
666 case SQLT_BFILE: {
667 if (*_size && __dataSize)
668 return writeToFromLob(pOutput, _size);
669 else
670 *_size = 0;
671 break;
672 }
673 default: {
674 __DCL_ASSERT(false); // OciField::init bug
675 }
676 }
677
678 return true;
679}
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
OciData::writeToFromLob
bool writeToFromLob(OutputStream *_pv, size_t *_size)
Definition OciData.cpp:771

◆ writeToFromLob()

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

Definition at line 771 of file OciData.cpp.

772{
773 __DCL_ASSERT(__dataType == SQLT_CLOB
774 || __dataType == SQLT_BLOB
775 || __dataType == SQLT_BFILE
776 || __dataType == SQLT_CFILE
777 );
778
779 OCISvcCtx* pSvcCtx = conn()->svcctxHandle();
780 OCIError* pError = conn()->errorHandle();
781 sword status = OCI_SUCCESS;
782 if (__descType == OCI_DTYPE_FILE) {
783 status = ::OCILobFileOpen(
784 pSvcCtx,
785 pError,
786 *(OCILobLocator**)__value,
787 OCI_FILE_READONLY
788 );
789 if (status != OCI_SUCCESS) {
790 __SET_ERROR(SQL::eServerError, status, pError);
791 return false;
792 }
793 }
794
795 bool bResult = true;
796 size_t nTotalRead = 0;
797 ub4 nRead = 0;
798 char buf[4096];
799 while(nTotalRead < *_size) {
800 nRead = __MIN(*_size - nTotalRead, sizeof(buf));
801 status = ::OCILobRead(
802 pSvcCtx,
803 pError,
804 *((OCILobLocator**)__value),
805 &nRead,
806 1 + nTotalRead, // offset
807 buf, // bufp
808 nRead, // bufl
809 NULL, // ctxp
810 (OCICallbackLobRead)NULL,
811 0,
812 SQLCS_IMPLICIT);
813 if (status == OCI_ERROR) {
814 __SET_ERROR(SQL::eServerError, status, pError);
815 bResult = false;
816 break;
817 }
818
819 if (nRead) {
820 try {
821 pOutput->write(buf, nRead);
822 }
823 catch(IOException* e) {
824 e->destroy();
825 bResult = false;
826 break;
827 }
828
829 nTotalRead += nRead;
830 }
831 else {
832 break; // done
833 }
834
835// if (status != OCI_NEED_DATA)
836// break;
837 }
838
839 if (__descType == OCI_DTYPE_FILE) {
840 if (bResult) {
841 status = ::OCILobFileClose(
842 pSvcCtx,
843 pError,
844 *(OCILobLocator**)__value);
845 if (status != OCI_SUCCESS) {
846 __SET_ERROR(SQL::eServerError, status, pError);
847 return false;
848 }
849 }
850 else {
851 // 이전에 에러가 발생했다. Close 만 시킨다.
852 status = ::OCILobFileClose(
853 pSvcCtx,
854 conn()->errorHandle2(),
855 *(OCILobLocator**)__value);
856 if (status != OCI_SUCCESS) {
857 __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
858 }
859 }
860 }
861
862 *_size = nTotalRead;
863 return bResult;
864}

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: