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

#include <IFXField.h>

Inheritance diagram for IFXField:
SQL::Field Object

Public Member Functions

 IFXField ()
virtual ~IFXField ()
bool init (SQL::Query *_query, ifx_sqlvar_t *_sqlvar)
bool onAfterFetch ()
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)
Public Member Functions inherited from Object
virtual String toString () const
virtual void destroy ()
String className () const
bool isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info & typeInfo () const

Protected Member Functions

void setErrorStatus (SQL::Error _error, long _SQLCODE, const wchar_t *_filename, int _line)
void setErrorStatus (const ByteString &_message, const wchar_t *_filename, int _line)
IFXQuery * query () const
bool getInteger (void *_pv, size_t *_size)
bool getUInteger (void *_pv, size_t *_size)
bool getFloat (void *_pv, size_t *_size)
Protected Member Functions inherited from SQL::Field
 Field (Query *_queryHandle)
virtual ~Field ()
Protected Member Functions inherited from Object
virtual ~Object ()
 Object ()

Additional Inherited Members

Protected Attributes inherited from SQL::Field
Query * __queryHandle
String __name
DataType __dataType
short __precision
short __scale

Detailed Description

Definition at line 8 of file IFXField.h.

Constructor & Destructor Documentation

◆ IFXField()

IFXField::IFXField ( )

◆ ~IFXField()

IFXField::~IFXField ( )
virtual

Definition at line 63 of file IFXField.cpp.

64{
65 if (__sqlvar) {
66 if (__SQLTYPE_IS(SQLTEXT) || __SQLTYPE_IS(SQLBYTES)) {
67 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
68 if (loc->loc_buffer)
69 ndebug_free(loc->loc_buffer);
70 }
71#if __USE_IFX_VAR
72 if (__SQLTYPE_IS(SQLLVARCHAR)) {
73 mint r = ifx_var_dealloc((void**)(__sqlvar->sqldata));
74 __DCL_TRACE1_N(L"ifx_var_dealloc[%d]\n", r);
75 }
76#endif
77 }
78// __DCL_TRACE1("~IFXField: %s", Field::__name.data());
79}
__DCL_TRACE1_N
#define __DCL_TRACE1_N(fmt, arg)
Definition HttpCollection.cpp:35
__SQLTYPE_IS
#define __SQLTYPE_IS(_sqltype)
Definition IFXField.cpp:61
mint
int mint
Definition IFXParam.cpp:11
ndebug_free
#define ndebug_free(_p)
Definition IFXUtils.h:23
r
ByteString r
Definition SQLConnection.cpp:182

Member Function Documentation

◆ __getData()

bool IFXField::__getData ( void * _pv,
size_t * _size,
SQL::DataType _dataType )
virtual

Implements SQL::Field.

Definition at line 384 of file IFXField.cpp.

389{
390 if (!query()->inState(SQL::Query::stFetched)) {
391 __SET_ERROR(SQL::eNotFetched);
392 return false;
393 }
394
395 switch(_dataType) {
396 case SQL::typeInteger: {
397 return getInteger(_pv, _size);
398 }
399 case SQL::typeUInteger: {
400 return getUInteger(_pv, _size);
401 }
402 case SQL::typeFloat: {
403 return getFloat(_pv, _size);
404 }
405 case SQL::typeDate: {
406 __DCL_ASSERT(__SQLTYPE_IS(SQLDATE));
407 short mdy[3];
408 __DCL_VERIFY(rjulmdy(*(long*)(__sqlvar->sqldata), mdy) == 0);
409 SQL::Date* p = (SQL::Date*)_pv;
410 p->nMonth = (uint8_t)mdy[0];
411 p->nDay = (uint8_t)mdy[1];
412 p->nYear = mdy[2];
413 break;
414 }
415 case SQL::typeTime: {
416 __DCL_ASSERT(__SQLTYPE_IS(SQLDTIME));
417 __decode_dtime(
418 (const dtime_t*)(__sqlvar->sqldata),
419 (SQL::Time*)_pv
420 );
421 break;
422 }
423 case SQL::typeTimeStamp: {
424 __DCL_ASSERT(__SQLTYPE_IS(SQLDTIME));
425 __decode_dtime(
426 (const dtime_t*)(__sqlvar->sqldata),
427 (SQL::TimeStamp*)_pv
428 );
429 break;
430 }
431 case SQL::typeInterval:
432 case SQL::typeIntervalYm:
433 case SQL::typeIntervalDs: {
434 __DCL_ASSERT(__SQLTYPE_IS(SQLINTERVAL));
435 __decode_intrvl(
436 (const intrvl_t*)(__sqlvar->sqldata),
437 (SQL::Interval*)_pv
438 );
439 break;
440 }
441 case SQL::typeText : {
442 if (Field::__dataType == SQL::typeNumeric) {
443 __DCL_ASSERT(__SQLTYPE_IS(SQLDECIMAL)
444 || __SQLTYPE_IS(SQLMONEY));
445
446 if (*_size < __dataSize) {
447 __SET_ERROR(SQL::eInvalidBufferSize);
448 return false;
449 }
450 else {
451 char* ps = (char*)_pv;
452 if (dectoasc(
453 (dec_t*)(__sqlvar->sqldata),
454 ps,
455 *_size,
456 -1
457 )) {
458 // invalid buffer size
459 // __get_dec_strlen 함수 버그
460 __DCL_ASSERT(false);
461 }
462
463 size_t uLen = 0;
464 for (; uLen < *_size; uLen++) {
465 if (ps[uLen] == ' ')
466 break;
467 }
468
469 if (uLen < *_size) {
470 *_size = uLen;
471 ps[uLen] = '\0';
472 }
473 }
474 break;
475 }
476 }
477 case SQL::typeBinary:
478 case SQL::typeLongText:
479 case SQL::typeLongBinary: {
480 switch (__sqlvar->sqltype & SQLTYPE) {
481 case SQLLVARCHAR: {
482#if __USE_IFX_VAR
483 int nLen = ifx_var_getlen((void**)(__sqlvar->sqldata));
484 if (nLen < 0) {
485 __SET_ERROR_SQLCODE(nLen);
486 return false;
487 }
488
489 void* pSrc = ifx_var_getdata((void**)(__sqlvar->sqldata));
490 if (nLen > 0 && *_size > 0 && pSrc != NULL) {
491 size_t nCopy = *_size;
492 if ((size_t)nLen < nCopy)
493 nCopy = (size_t)nLen;
494
495 memcpy(_pv, pSrc, nCopy);
496 if (nCopy < *_size) {
497 *((char*)_pv + nCopy) = '\0';
498 *_size = nCopy;
499 }
500 }
501 else {
502 *_size = 0;
503 }
504 break;
505#endif
506 }
507 case SQLCHAR:
508 case SQLNCHAR:
509 case SQLVCHAR:
510 case SQLNVCHAR: {
511 if (__sqlvar->sqllen > 0 && *_size > 0) {
512 size_t nCopy = *_size;
513 if ((size_t)(__sqlvar->sqllen) < nCopy)
514 nCopy = (size_t)(__sqlvar->sqllen);
515
516 memcpy(_pv, __sqlvar->sqldata, nCopy);
517
518 if (nCopy < *_size) {
519 *((char*)_pv + nCopy) = '\0';
520 *_size = nCopy;
521 }
522 }
523 else
524 *_size = 0;
525 break;
526 }
527 case SQLTEXT:
528 case SQLBYTES: {
529 if (((loc_t*)(__sqlvar->sqldata))->loc_size > 0
530 && *_size > 0) {
531 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
532 size_t nCopy = *_size;
533 if ((size_t)(loc->loc_size) < nCopy)
534 nCopy = (size_t)(loc->loc_size);
535
536 memcpy(_pv, loc->loc_buffer, nCopy);
537 if (nCopy < *_size) {
538 *((char*)_pv + nCopy) = '\0';
539 *_size = nCopy;
540 }
541 }
542 else {
543 *_size = 0;
544 }
545 break;
546 }
547 default: {
548 __DCL_ASSERT(false);
549 }
550 }
551 break;
552 }
553 case SQL::typeOutputStream: {
554 switch (__sqlvar->sqltype & SQLTYPE) {
555 case SQLCHAR:
556 case SQLNCHAR:
557 case SQLVCHAR:
558 case SQLNVCHAR: {
559 if (__sqlvar->sqllen > 0 && *_size > 0) {
560 if ((size_t)(__sqlvar->sqllen) < *_size)
561 *_size = (size_t)(__sqlvar->sqllen);
562
563 try {
564 ((OutputStream*)_pv)->write(
565 __sqlvar->sqldata, *_size);
566 }
567 catch (IOException* e) {
568 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
569 e->destroy();
570 return false;
571 }
572 }
573 else {
574 *_size = 0;
575 }
576 break;
577 }
578 case SQLLVARCHAR: {
579 int nLen = ifx_var_getlen((void**)(__sqlvar->sqldata));
580 if (nLen < 0) {
581 __SET_ERROR_SQLCODE(nLen);
582 return false;
583 }
584
585 void* pSrc = ifx_var_getdata((void**)(__sqlvar->sqldata));
586 if (nLen > 0 && *_size > 0 && pSrc != NULL) {
587 if ((size_t)nLen < *_size)
588 *_size = (size_t)nLen;
589
590 try {
591 ((OutputStream*)_pv)->write(
592 pSrc, *_size);
593 }
594 catch (IOException* e) {
595 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
596 e->destroy();
597 return false;
598 }
599 }
600 else {
601 *_size = 0;
602 }
603 break;
604 }
605 case SQLTEXT:
606 case SQLBYTES: {
607 if (((loc_t*)(__sqlvar->sqldata))->loc_size > 0) {
608 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
609
610 if ((size_t)(loc->loc_size) < *_size)
611 *_size = (size_t)(loc->loc_size);
612
613 if (*_size) {
614 try {
615 ((OutputStream*)_pv)->write(
616 loc->loc_buffer, *_size);
617 }
618 catch (IOException* e) {
619 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
620 e->destroy();
621 return false;
622 }
623 }
624 }
625 else {
626 *_size = 0;
627 }
628 break;
629 }
630 default: {
631 __DCL_ASSERT(false);
632 }
633 }
634 break;
635 }
636 default: {
637 __DCL_ASSERT(false); // SQL::Field::getData bug
638 }
639 }
640 return true;
641}
NULL
#define NULL
Definition Config.h:340
__SET_ERROR_SQLCODE
#define __SET_ERROR_SQLCODE(SQLCODE)
Definition IFXConnection.h:54
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.h:57
__decode_dtime
void __decode_dtime(const dtime_t *_s, SQL::TimeStamp *_r)
Definition IFXTypes.cpp:221
__decode_intrvl
void __decode_intrvl(const intrvl_t *_s, SQL::Interval *_r)
Definition IFXTypes.cpp:118
__DCL_VERIFY
#define __DCL_VERIFY(expr)
Definition Object.h:373
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:150
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
IFXField::query
IFXQuery * query() const
Definition IFXField.h:68
IFXField::getFloat
bool getFloat(void *_pv, size_t *_size)
Definition IFXField.cpp:925
IFXField::getUInteger
bool getUInteger(void *_pv, size_t *_size)
Definition IFXField.cpp:784
IFXField::getInteger
bool getInteger(void *_pv, size_t *_size)
Definition IFXField.cpp:643
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::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:70
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:72
SQL::typeIntervalDs
@ typeIntervalDs
Definition SQLCore.h:74
SQL::typeDate
@ typeDate
Definition SQLCore.h:68
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::eInvalidBufferSize
@ eInvalidBufferSize
Definition SQLCore.h:50
SQL::eNotFetched
@ eNotFetched
Definition SQLCore.h:43
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

◆ __getDataSize()

bool IFXField::__getDataSize ( size_t * _size,
bool _maxSize )
virtual

Implements SQL::Field.

Definition at line 345 of file IFXField.cpp.

346{
347 if (_maxSize) {
348 *_size = __maxDataSize;
349 return true;
350 }
351
352 if (!query()->inState(SQL::Query::stFetched)) {
353 __SET_ERROR(SQL::eNotFetched);
354 return false;
355 }
356
357 if (!isNull()) {
358 // not null
359 switch(__sqlvar->sqltype & SQLTYPE) {
360 case SQLDECIMAL:
361 case SQLMONEY:
362 case SQLCHAR:
363 case SQLNCHAR:
364 case SQLVCHAR:
365 case SQLNVCHAR:
366 case SQLLVARCHAR:
367 case SQLTEXT:
368 case SQLBYTES: {
369 *_size = __dataSize;
370 break;
371 }
372 default: {
373 *_size = __maxDataSize;
374 }
375 }
376 }
377 else {
378 *_size = 0;
379
380 }
381 return true;
382}
IFXField::isNull
virtual bool isNull() const
Definition IFXField.cpp:337

◆ getFloat()

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

Definition at line 925 of file IFXField.cpp.

926{
927 switch(__sqlvar->sqltype & SQLTYPE) {
928 case SQLSMFLOAT: {
929 switch (*_size) {
930 case sizeof(float) : {
931 *(float*)_pv = *(float*)(__sqlvar->sqldata);
932 break;
933 }
934 case sizeof(double) : {
935 *(double*)_pv = *(float*)(__sqlvar->sqldata);
936 break;
937 }
938 default: {
939 *_size = sizeof(float);
940 __SET_ERROR(SQL::eInvalidBufferSize);
941 return false;
942 }
943 }
944 break;
945 }
946 case SQLFLOAT: {
947 switch (*_size) {
948 case sizeof(double) : {
949 *(double*)_pv = *(double*)(__sqlvar->sqldata);
950 break;
951 }
952 default: {
953 *_size = sizeof(double);
954 __SET_ERROR(SQL::eInvalidBufferSize);
955 return false;
956 }
957 }
958 break;
959 }
960 case SQLDECIMAL:
961 case SQLMONEY: {
962 double d;
963 if (dectodbl((dec_t*)__sqlvar->sqldata, &d)) {
964 __SET_ERROR(SQL::eOutOfRange);
965 return false;
966 }
967
968 switch (*_size) {
969 case sizeof(float) : {
970 if (d < FLT_MIN || FLT_MAX < d) {
971 __SET_ERROR(SQL::eOutOfRange);
972 return false;
973 }
974 *(float*)_pv = (float)d;
975 break;
976 }
977 case sizeof(double) : {
978 *(double*)_pv = d;
979 break;
980 }
981 default: {
982 *_size = sizeof(double);
983 __SET_ERROR(SQL::eInvalidBufferSize);
984 return false;
985 }
986 }
987 break;
988 }
989 default: {
990 __DCL_ASSERT(false);
991 }
992 }
993
994 return true;
995}
SQL::eOutOfRange
@ eOutOfRange
Definition SQLCore.h:52

◆ getInteger()

bool IFXField::getInteger ( void * _pv,
size_t * _size )
protected

Definition at line 643 of file IFXField.cpp.

644{
645 switch(__sqlvar->sqltype & SQLTYPE) {
646 case SQLSMINT: {
647 switch (*_size) {
648 case sizeof(int16_t) : {
649 *(int16_t*)_pv = *(int16_t*)(__sqlvar->sqldata);
650 break;
651 }
652 case sizeof(int32_t) : {
653 *(int32_t*)_pv = (int32_t) * (int16_t*)(__sqlvar->sqldata);
654 break;
655 }
656 case sizeof(int64_t) : {
657 *(int64_t*)_pv = (int64_t) * (int16_t*)(__sqlvar->sqldata);
658 break;
659 }
660 default: {
661 *_size = sizeof(int16_t);
662 __SET_ERROR(SQL::eInvalidBufferSize);
663 return false;
664 }
665 }
666 break;
667 }
668 case SQLINT:
669 case SQLSERIAL: {
670 switch (*_size) {
671 case sizeof(int32_t) : {
672 *(int32_t*)_pv = *(int32_t*)(__sqlvar->sqldata);
673 break;
674 }
675 case sizeof(int64_t) : {
676 *(int64_t*)_pv = (int64_t) * (int32_t*)(__sqlvar->sqldata);
677 break;
678 }
679 default: {
680 *_size = sizeof(int32_t);
681 __SET_ERROR(SQL::eInvalidBufferSize);
682 return false;
683 }
684 }
685 break;
686 }
687 case SQLINFXBIGINT:
688 case SQLBIGSERIAL: {
689 switch (*_size) {
690 case sizeof(int64_t) : {
691 *(int64_t*)_pv = (int64_t) * (int64_t*)(__sqlvar->sqldata);
692 break;
693 }
694 default: {
695 *_size = sizeof(int64_t);
696 __SET_ERROR(SQL::eInvalidBufferSize);
697 return false;
698 }
699 }
700 break;
701 }
702 case SQLINT8:
703 case SQLSERIAL8: {
704 if (*_size == sizeof(int64_t)) {
705 const ifx_int8_t* p = (const ifx_int8_t*)__sqlvar->sqldata;
706 __DCL_ASSERT(p->sign != 0); // assert(not null)
707 if (p->sign == 1)
708 *(int64_t*)_pv = (int64_t) * (uint64_t*)(p->data);
709 else // -1
710 *(int64_t*)_pv = -((int64_t) * (uint64_t*)(p->data));
711 }
712 else {
713 *_size = sizeof(int64_t);
714 __SET_ERROR(SQL::eInvalidBufferSize);
715 return false;
716 }
717 break;
718 }
719 case SQLDECIMAL :
720 case SQLMONEY: {
721 if (*_size <= sizeof(int32_t)) {
722 int4 n;
723 if (dectolong((dec_t*)__sqlvar->sqldata, &n)) {
724 // -1200
725 __SET_ERROR(SQL::eOutOfRange);
726 return false;
727 }
728
729 switch (*_size) {
730 case sizeof(int8_t) : {
731 if (n < INT8_MIN || INT8_MAX < n) {
732 __SET_ERROR(SQL::eOutOfRange);
733 return false;
734 }
735 *(int8_t*)_pv = (int8_t)n;
736 break;
737 }
738 case sizeof(int16_t) : {
739 if (n < INT16_MIN || INT16_MAX < n) {
740 __SET_ERROR(SQL::eOutOfRange);
741 return false;
742 }
743 *(int16_t*)_pv = (int16_t)n;
744 break;
745 }
746 case sizeof(int32_t) : {
747 *(int32_t*)_pv = (int32_t)n;
748 break;
749 }
750 default: {
751 *_size = sizeof(int32_t);
752 __SET_ERROR(SQL::eInvalidBufferSize);
753 return false;
754 }
755 }
756 }
757 else if (*_size == sizeof(int64_t)) {
758 ifx_int8_t n;
759 if (ifx_int8cvdec((dec_t*)__sqlvar->sqldata, &n)) {
760 __SET_ERROR(SQL::eOutOfRange);
761 return false;
762 }
763
764 __DCL_ASSERT(n.sign != 0); // assert(not null)
765 if (n.sign == 1)
766 *(int64_t*)_pv = (int64_t) * (uint64_t*)(n.data);
767 else // -1
768 *(int64_t*)_pv = -((int64_t) * (uint64_t*)(n.data));
769 }
770 else {
771 *_size = sizeof(int64_t);
772 __SET_ERROR(SQL::eInvalidBufferSize);
773 return false;
774 }
775 break;
776 }
777 default: {
778 __DCL_ASSERT(false);
779 }
780 }
781 return true;
782}
INT8_MIN
#define INT8_MIN
Definition Config.h:311
INT8_MAX
#define INT8_MAX
Definition Config.h:316
INT16_MAX
#define INT16_MAX
Definition Config.h:317
INT16_MIN
#define INT16_MIN
Definition Config.h:312
n
void CharsetConvertException *size_t n
Definition SQLField.cpp:253

◆ getUInteger()

bool IFXField::getUInteger ( void * _pv,
size_t * _size )
protected

Definition at line 784 of file IFXField.cpp.

785{
786 switch(__sqlvar->sqltype & SQLTYPE) {
787 case SQLSMINT :
788 switch(*_size) {
789 case sizeof(uint16_t) : {
790 *(uint16_t*)_pv = (uint16_t) * (int16_t*)(__sqlvar->sqldata);
791 break;
792 }
793 case sizeof(uint32_t) : {
794 *(uint32_t*)_pv = (uint32_t) * (int16_t*)(__sqlvar->sqldata);
795 break;
796 }
797 case sizeof(uint64_t) : {
798 *(uint64_t*)_pv = (uint64_t) * (int16_t*)(__sqlvar->sqldata);
799 break;
800 }
801 default: {
802 *_size = sizeof(uint16_t);
803 __SET_ERROR(SQL::eInvalidBufferSize);
804 return false;
805 }
806 }
807 break;
808 case SQLINT:
809 case SQLSERIAL: {
810 switch (*_size) {
811 case sizeof(uint32_t) : {
812 *(uint32_t*)_pv = (uint32_t) * (int32_t*)(__sqlvar->sqldata);
813 break;
814 }
815 case sizeof(int64_t) : {
816 *(uint64_t*)_pv = (uint64_t) * (int32_t*)(__sqlvar->sqldata);
817 break;
818 }
819 default: {
820 *_size = sizeof(int32_t);
821 __SET_ERROR(SQL::eInvalidBufferSize);
822 return false;
823 }
824 }
825 break;
826 }
827 case SQLINFXBIGINT:
828 case SQLBIGSERIAL: {
829 switch (*_size) {
830 case sizeof(int64_t) : {
831 *(uint64_t*)_pv = (uint64_t) * (int64_t*)(__sqlvar->sqldata);
832 break;
833 }
834 default: {
835 *_size = sizeof(uint64_t);
836 __SET_ERROR(SQL::eInvalidBufferSize);
837 return false;
838 }
839 }
840 break;
841 }
842 case SQLINT8:
843 case SQLSERIAL8: {
844 if (*_size == sizeof(int64_t)) {
845 const ifx_int8_t* p = (const ifx_int8_t*)__sqlvar->sqldata;
846 __DCL_ASSERT(p->sign != 0); // assert(not null)
847 if (p->sign == 1)
848 *(uint64_t*)_pv = *(uint64_t*)(p->data);
849 else // -1
850 *(uint64_t*)_pv = (uint64_t)(-((int64_t) * (uint64_t*)(p->data)));
851 }
852 else {
853 *_size = sizeof(int64_t);
854 __SET_ERROR(SQL::eInvalidBufferSize);
855 return false;
856 }
857 break;
858 }
859 case SQLDECIMAL :
860 case SQLMONEY: {
861 if (*_size <= sizeof(uint32_t)) {
862 int4 n;
863 if (dectolong((dec_t*)__sqlvar->sqldata, &n)) {
864 // -1200
865 __SET_ERROR(SQL::eOutOfRange);
866 return false;
867 }
868
869 switch (*_size) {
870 case sizeof(uint8_t) : {
871 if (n < INT8_MIN || INT8_MAX < n) {
872 __SET_ERROR(SQL::eOutOfRange);
873 return false;
874 }
875 *(uint8_t*)_pv = (uint8_t)n;
876 break;
877 }
878 case sizeof(uint16_t) : {
879 if (n < INT16_MIN || INT16_MAX < n) {
880 __SET_ERROR(SQL::eOutOfRange);
881 return false;
882 }
883 *(uint16_t*)_pv = (uint16_t)n;
884 break;
885 }
886 case sizeof(uint32_t) : {
887 *(uint32_t*)_pv = (uint32_t)n;
888 break;
889 }
890 default: {
891 *_size = sizeof(uint32_t);
892 __SET_ERROR(SQL::eInvalidBufferSize);
893 return false;
894 }
895 }
896 }
897 else if (*_size == sizeof(uint64_t)) {
898 ifx_int8_t n;
899 if (ifx_int8cvdec((dec_t*)__sqlvar->sqldata, &n)) {
900 __SET_ERROR(SQL::eOutOfRange);
901 return false;
902 }
903
904 __DCL_ASSERT(n.sign != 0); // assert(not null)
905 if (n.sign == 1)
906 *(uint64_t*)_pv = *(uint64_t*)(n.data);
907 else // -1
908 *(uint64_t*)_pv = (uint64_t)(-((int64_t) * (uint64_t*)(n.data)));
909 }
910 else {
911 *_size = sizeof(int64_t);
912 __SET_ERROR(SQL::eInvalidBufferSize);
913 return false;
914 }
915 break;
916 }
917 default: {
918 __DCL_ASSERT(false); // IFXField::init bug
919 }
920 }
921
922 return true;
923}

◆ init()

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

Definition at line 81 of file IFXField.cpp.

82{
83 __DCL_ASSERT((Field::__queryHandle == NULL) && (__sqlvar == NULL));
84 __DCL_ASSERT((_sqlvar != NULL) && (_sqlvar->sqldata != NULL));
85
86 Field::__queryHandle = _queryHandle;
87 __sqlvar = _sqlvar;
88 __sqlvar->sqlind = &__indicator;
89
90 /*
91 2005.12.29 ByteString::makeUpper을 toUpperCase로 변경
92 Field::__name.assign(__sqlvar->sqlname);
93 Field::__name.makeUpper();
94 */
95 try {
96 Field::__name = UTF8Decoder::decode(__sqlvar->sqlname).toUpperCase();
97 }
98 catch (CharsetConvertException* _e) {
99 __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
100 _e->destroy();
101 return false;
102 }
103
104 switch(__sqlvar->sqltype & SQLTYPE) {
105 case SQLSMINT: {
106 Field::__dataType = SQL::typeInteger;
107 __maxDataSize = sizeof(int16_t);
108 break;
109 }
110 case SQLINT:
111 case SQLSERIAL: {
112 Field::__dataType = SQL::typeInteger;
113 __maxDataSize = sizeof(int32_t);
114 break;
115 }
116 case SQLINT8:
117 case SQLSERIAL8:
118 case SQLINFXBIGINT:
119 case SQLBIGSERIAL: {
120 Field::__dataType = SQL::typeInteger;
121 __maxDataSize = sizeof(int64_t);
122 break;
123 }
124 case SQLSMFLOAT: {
125 Field::__dataType = SQL::typeFloat;
126 __maxDataSize = sizeof(float);
127 break;
128 }
129 case SQLFLOAT: {
130 Field::__dataType = SQL::typeFloat;
131 __maxDataSize = sizeof(double);
132 break;
133 }
134 case SQLDECIMAL:
135 case SQLMONEY: {
136 Field::__dataType = SQL::typeNumeric;
137 // float decimal
138 // max : 10^124 ==> 124, min : // 10^-130 : 130 + "-0." ESQL/C manual
139 // 10^(64 * 2) + "-0." 128 + 3 = 131 incl/esql/decimal.h
140 __maxDataSize = 133;
141 break;
142 }
143 case SQLDATE: {
144 Field::__dataType = SQL::typeDate;
145 __maxDataSize = sizeof(SQL::Date);
146 break;
147 }
148 case SQLDTIME: {
149 if (TU_START(__sqlvar->sqllen) >= TU_HOUR) {
150 Field::__dataType = SQL::typeTime;
151 __maxDataSize = sizeof(SQL::Time);
152 }
153 else {
154 Field::__dataType = SQL::typeTimeStamp;
155 __maxDataSize = sizeof(SQL::TimeStamp);
156 }
157 break;
158 }
159 case SQLINTERVAL: {
160 if (TU_START(__sqlvar->sqllen) >= TU_DAY)
161 Field::__dataType = SQL::typeIntervalDs;
162 else
163 Field::__dataType = SQL::typeIntervalYm;
164 __maxDataSize = sizeof(SQL::Interval);
165 break;
166 }
167 case SQLCHAR:
168 case SQLNCHAR: {
169 Field::__dataType = SQL::typeText;
170 __maxDataSize = 32767;
171 break;
172 }
173 case SQLVCHAR:
174 case SQLNVCHAR: {
175 Field::__dataType = SQL::typeText;
176 __maxDataSize = 255;
177 break;
178 }
179 case SQLLVARCHAR: {
180 Field::__dataType = SQL::typeText;
181 __maxDataSize = 32739;
182#if __USE_IFX_VAR
183 // automatic memory alloc
184 mint r = ifx_var_flag((void**)(__sqlvar->sqldata), 1);
185 __DCL_TRACE1_N(L"ifx_var_flag[%d]\n", r);
186 if (r) {
187 __SET_ERROR_SQLCODE(r);
188 return false;
189 }
190#endif
191 break;
192 }
193 case SQLTEXT: {
194 Field::__dataType = SQL::typeLongText;
195 __maxDataSize = INT32_MAX;
196 // init locator
197 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
198 loc->loc_loctype = LOCMEMORY;
199 loc->loc_buffer = NULL;
200 loc->loc_bufsize = -1;
201 loc->loc_size = -1;
202 loc->loc_mflags = 0;
203 loc->loc_oflags = 0;
204 loc->loc_indicator = 0;
205 break;
206 }
207 case SQLBYTES: {
208 Field::__dataType = SQL::typeLongBinary;
209 __maxDataSize = INT32_MAX;
210 // init locator
211 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
212 loc->loc_loctype = LOCMEMORY;
213 loc->loc_buffer = NULL;
214 loc->loc_bufsize = -1;
215 loc->loc_size = -1;
216 loc->loc_mflags = 0;
217 loc->loc_oflags = 0;
218 loc->loc_indicator = 0;
219 break;
220 }
221 default: {
222 __DCL_TRACE2_N(L"[%hs][%d]\n",
223 Field::__name.data(), __sqlvar->sqltype & SQLTYPE);
224 __DCL_ASSERT(false);
225 }
226 }
227 return true;
228}
INT32_MAX
#define INT32_MAX
Definition Config.h:318
__DCL_TRACE2_N
#define __DCL_TRACE2_N(fmt, arg1, arg2)
Definition HttpCollection.cpp:36

◆ isNull()

bool IFXField::isNull ( ) const
virtual

Implements SQL::Field.

Definition at line 337 of file IFXField.cpp.

338{
339 if (!query()->inState(SQL::Query::stFetched)) {
340 return true;
341 }
342 return __indicator == -1;
343}

◆ onAfterFetch()

bool IFXField::onAfterFetch ( )

Definition at line 230 of file IFXField.cpp.

231{
232#if __TRACE_THIS && 1
233 __DCL_TRACE4_N(L"[%ls] sqllen[%d] indicator[%d][%p]\n",
234 __name.data(), __sqlvar->sqllen, __indicator, __sqlvar->sqldata);
235#endif
236 if (__indicator != -1) {
237 // not null
238 switch (__sqlvar->sqltype & SQLTYPE) {
239 case SQLDECIMAL:
240 case SQLMONEY: {
241 __dataSize = __get_dec_strlen((const dec_t*)(__sqlvar->sqldata));
242 break;
243 }
244 case SQLCHAR:
245 case SQLNCHAR: {
246 __dataSize = __sqlvar->sqllen - 1;
247 break;
248 }
249 case SQLVCHAR:
250 case SQLNVCHAR: {
251 __dataSize = ByteString::length(__sqlvar->sqldata, __sqlvar->sqllen);
252 break;
253 }
254 case SQLLVARCHAR: {
255#if __USE_IFX_VAR
256 int n = ifx_var_getlen((void**)(__sqlvar->sqldata));
257 __DCL_TRACE1_N(L"ifx_var_getlen[%d]\n", n);
258 if (n < 0) {
259 __SET_ERROR_SQLCODE(n);
260 return false;
261 }
262 __dataSize = n;
263#else
264 __dataSize = ByteString::length(__sqlvar->sqldata, __sqlvar->sqllen);
265#endif
266 break;
267 }
268 case SQLTEXT:
269 case SQLBYTES: {
270 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
271 if (loc->loc_status != 0) {
272 __SET_ERROR_SQLCODE(loc->loc_status);
273 return false;
274 }
275 loc->loc_mflags = LOC_ALLOC;
276
277 if (loc->loc_indicator == -1)
278 __dataSize = 0;
279 else
280 __dataSize = loc->loc_size;
281 break;
282 }
283 }
284 }
285 return true;
286}
__DCL_TRACE4_N
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
Definition IFXField.cpp:41
__get_dec_strlen
__DCL_BEGIN_NAMESPACE size_t __get_dec_strlen(const dec_t *p)
Definition IFXTypes.cpp:26
SQL::Field::__name
String __name
Definition SQLCore.h:183

◆ query()

IFXQuery * IFXField::query ( ) const
inlineprotected

Definition at line 68 of file IFXField.h.

69{
70 return (IFXQuery*)Field::__queryHandle;
71}

◆ serverDataTypeName()

const wchar_t * IFXField::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 332 of file IFXField.cpp.

333{
334 return __dataTypeName(__sqlvar);
335}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setErrorStatus() [1/2]

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

Definition at line 58 of file IFXField.h.

60{
61 ((IFXConnection*)Field::connection())->setErrorStatus(
62 _message,
63 _filename,
64 _line
65 );
66}

◆ setErrorStatus() [2/2]

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

Definition at line 47 of file IFXField.h.

49{
50 ((IFXConnection*)Field::connection())->setErrorStatus(
51 _error,
52 _SQLCODE,
53 _filename,
54 _line
55 );
56}
The documentation for this class was generated from the following files: