DCL 3.7.4
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 const wchar_t * serverDataTypeName () const
virtual bool __getDataSize (size_t *_size, bool _maxsize)
virtual bool __getData (void *_buf, size_t *_size, SQL::DataType _bufType)
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

IFXQuery * query () const
IFXConnection * conn () const
bool getInteger (void *_buf, size_t *_size)
bool getUInteger (void *_buf, size_t *_size)
bool getFloat (void *_buf, 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 6 of file IFXField.h.

Constructor & Destructor Documentation

◆ IFXField()

IFXField::IFXField ( )

◆ ~IFXField()

IFXField::~IFXField ( )
virtual

Definition at line 70 of file IFXField.cpp.

71{
72 if (__sqlvar) {
73 if (__SQLTYPE_IS(SQLTEXT) || __SQLTYPE_IS(SQLBYTES)) {
74 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
75 if (loc->loc_buffer)
76 ndebug_free(loc->loc_buffer);
77 }
78#if __USE_IFX_VAR
79 if (__SQLTYPE_IS(SQLLVARCHAR)) {
80 mint r = ifx_var_dealloc((void**)(__sqlvar->sqldata));
81 __DCL_TRACE1_N(L"ifx_var_dealloc[%d]\n", r);
82 }
83#endif
84 }
85// __DCL_TRACE1("~IFXField: %ls", Field::__name.data());
86}
__DCL_TRACE1_N
#define __DCL_TRACE1_N(fmt, arg)
Definition HttpCollection.cpp:35
__SQLTYPE_IS
#define __SQLTYPE_IS(_sqltype)
Definition IFXField.cpp:68
mint
int mint
Definition IFXParam.cpp:11
ndebug_free
#define ndebug_free(_p)
Definition IFXUtils.h:23
r
IOException *size_t r
Definition MediaInfo.cpp:82

Member Function Documentation

◆ __getData()

bool IFXField::__getData ( void * _buf,
size_t * _size,
SQL::DataType _bufType )
virtual

Implements SQL::Field.

Definition at line 384 of file IFXField.cpp.

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

◆ __getDataSize()

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

Implements SQL::Field.

Definition at line 350 of file IFXField.cpp.

351{
352 if (_maxsize) {
353 *_size = __maxDataSize;
354 return true;
355 }
356
357 if (__indicator == -1) {
358 *_size = (size_t)-1;
359 }
360 else {
361 switch(__sqlvar->sqltype & SQLTYPE) {
362 case SQLDECIMAL:
363 case SQLMONEY:
364 case SQLCHAR:
365 case SQLNCHAR:
366 case SQLVCHAR:
367 case SQLNVCHAR:
368 case SQLLVARCHAR:
369 case SQLTEXT:
370 case SQLBYTES: {
371 *_size = __dataSize;
372 break;
373 }
374 default: {
375 *_size = __maxDataSize;
376 // *_size = rtypmsize(__sqlvar->sqltype, __sqlvar->sqllen);
377 }
378 }
379 }
380
381 return true;
382}

◆ conn()

IFXConnection * IFXField::conn ( ) const
inlineprotected

Definition at line 49 of file IFXField.h.

50{
51 return query()->conn();
52}

◆ getFloat()

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

Definition at line 969 of file IFXField.cpp.

970{
971 switch(__sqlvar->sqltype & SQLTYPE) {
972 case SQLSMFLOAT: {
973 switch (*_size) {
974 case sizeof(float) : {
975 *(float*)_buf = *(float*)(__sqlvar->sqldata);
976 break;
977 }
978 case sizeof(double) : {
979 *(double*)_buf = *(float*)(__sqlvar->sqldata);
980 break;
981 }
982 default: {
983 *_size = sizeof(float);
984 __SET_ERROR(SQL::eInvalidBufferSize);
985 return false;
986 }
987 }
988 break;
989 }
990 case SQLFLOAT: {
991 switch (*_size) {
992 case sizeof(double) : {
993 *(double*)_buf = *(double*)(__sqlvar->sqldata);
994 break;
995 }
996 default: {
997 *_size = sizeof(double);
998 __SET_ERROR(SQL::eInvalidBufferSize);
999 return false;
1000 }
1001 }
1002 break;
1003 }
1004 case SQLDECIMAL:
1005 case SQLMONEY: {
1006 double d;
1007 if (dectodbl((dec_t*)__sqlvar->sqldata, &d)) {
1008 __SET_ERROR(SQL::eOutOfRange);
1009 return false;
1010 }
1011
1012 switch (*_size) {
1013 case sizeof(float) : {
1014 if (d < -FLT_MAX || FLT_MAX < d) {
1015 __SET_ERROR(SQL::eOutOfRange);
1016 return false;
1017 }
1018 *(float*)_buf = (float)d;
1019 break;
1020 }
1021 case sizeof(double) : {
1022 *(double*)_buf = (double)d;
1023 break;
1024 }
1025 default: {
1026 *_size = sizeof(double);
1027 __SET_ERROR(SQL::eInvalidBufferSize);
1028 return false;
1029 }
1030 }
1031 break;
1032 }
1033 default: {
1034 __DCL_ASSERT(false);
1035 }
1036 }
1037
1038 return true;
1039}
SQL::eOutOfRange
@ eOutOfRange
Definition SQLCore.h:52

◆ getInteger()

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

Definition at line 635 of file IFXField.cpp.

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

◆ getUInteger()

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

Definition at line 802 of file IFXField.cpp.

803{
804 switch(__sqlvar->sqltype & SQLTYPE) {
805 case SQLBOOL: {
806 switch (*_size) {
807 case sizeof(uint8_t) : {
808 *(uint8_t*)_buf = *(uint8_t*)(__sqlvar->sqldata);
809 break;
810 }
811 case sizeof(uint16_t) : {
812 *(uint16_t*)_buf = *(uint8_t*)(__sqlvar->sqldata);
813 break;
814 }
815 case sizeof(uint32_t) : {
816 *(uint32_t*)_buf = *(uint8_t*)(__sqlvar->sqldata);
817 break;
818 }
819 case sizeof(uint64_t) : {
820 *(uint64_t*)_buf = *(uint8_t*)(__sqlvar->sqldata);
821 break;
822 }
823 default: {
824 *_size = sizeof(uint8_t);
825 __SET_ERROR(SQL::eInvalidBufferSize);
826 return false;
827 }
828 }
829 break;
830 }
831 case SQLSMINT :
832 switch(*_size) {
833 case sizeof(uint16_t) : {
834 *(uint16_t*)_buf = (uint16_t) * (int16_t*)(__sqlvar->sqldata);
835 break;
836 }
837 case sizeof(uint32_t) : {
838 *(uint32_t*)_buf = (uint32_t) * (int16_t*)(__sqlvar->sqldata);
839 break;
840 }
841 case sizeof(uint64_t) : {
842 *(uint64_t*)_buf = (uint64_t) * (int16_t*)(__sqlvar->sqldata);
843 break;
844 }
845 default: {
846 *_size = sizeof(uint16_t);
847 __SET_ERROR(SQL::eInvalidBufferSize);
848 return false;
849 }
850 }
851 break;
852 case SQLINT:
853 case SQLSERIAL: {
854 switch (*_size) {
855 case sizeof(uint32_t) : {
856 *(uint32_t*)_buf = (uint32_t) * (int32_t*)(__sqlvar->sqldata);
857 break;
858 }
859 case sizeof(int64_t) : {
860 *(uint64_t*)_buf = (uint64_t) * (int32_t*)(__sqlvar->sqldata);
861 break;
862 }
863 default: {
864 *_size = sizeof(int32_t);
865 __SET_ERROR(SQL::eInvalidBufferSize);
866 return false;
867 }
868 }
869 break;
870 }
871 case SQLINFXBIGINT:
872 case SQLBIGSERIAL: {
873 switch (*_size) {
874 case sizeof(int64_t) : {
875 *(uint64_t*)_buf = (uint64_t) * (int64_t*)(__sqlvar->sqldata);
876 break;
877 }
878 default: {
879 *_size = sizeof(uint64_t);
880 __SET_ERROR(SQL::eInvalidBufferSize);
881 return false;
882 }
883 }
884 break;
885 }
886 case SQLINT8:
887 case SQLSERIAL8: {
888 if (*_size == sizeof(int64_t)) {
889 const ifx_int8_t* p = (const ifx_int8_t*)__sqlvar->sqldata;
890 __DCL_ASSERT(p->sign != 0); // assert(not null)
891 if (p->sign == 1)
892 *(uint64_t*)_buf = *(uint64_t*)(p->data);
893 else // -1
894 *(uint64_t*)_buf = (uint64_t)(-((int64_t) * (uint64_t*)(p->data)));
895 }
896 else {
897 *_size = sizeof(int64_t);
898 __SET_ERROR(SQL::eInvalidBufferSize);
899 return false;
900 }
901 break;
902 }
903 case SQLDECIMAL :
904 case SQLMONEY: {
905 if (*_size <= sizeof(uint32_t)) {
906 int4 n;
907 if (dectolong((dec_t*)__sqlvar->sqldata, &n)) {
908 // -1200
909 __SET_ERROR(SQL::eOutOfRange);
910 return false;
911 }
912
913 switch (*_size) {
914 case sizeof(uint8_t) : {
915 if (n < INT8_MIN || INT8_MAX < n) {
916 __SET_ERROR(SQL::eOutOfRange);
917 return false;
918 }
919 *(uint8_t*)_buf = (uint8_t)n;
920 break;
921 }
922 case sizeof(uint16_t) : {
923 if (n < INT16_MIN || INT16_MAX < n) {
924 __SET_ERROR(SQL::eOutOfRange);
925 return false;
926 }
927 *(uint16_t*)_buf = (uint16_t)n;
928 break;
929 }
930 case sizeof(uint32_t) : {
931 *(uint32_t*)_buf = (uint32_t)n;
932 break;
933 }
934 default: {
935 *_size = sizeof(uint32_t);
936 __SET_ERROR(SQL::eInvalidBufferSize);
937 return false;
938 }
939 }
940 }
941 else if (*_size == sizeof(uint64_t)) {
942 ifx_int8_t n;
943 if (ifx_int8cvdec((dec_t*)__sqlvar->sqldata, &n)) {
944 __SET_ERROR(SQL::eOutOfRange);
945 return false;
946 }
947
948 __DCL_ASSERT(n.sign != 0); // assert(not null)
949 if (n.sign == 1)
950 *(uint64_t*)_buf = *(uint64_t*)(n.data);
951 else // -1
952 *(uint64_t*)_buf = (uint64_t)(-((int64_t) * (uint64_t*)(n.data)));
953 }
954 else {
955 *_size = sizeof(int64_t);
956 __SET_ERROR(SQL::eInvalidBufferSize);
957 return false;
958 }
959 break;
960 }
961 default: {
962 __DCL_ASSERT(false); // IFXField::init bug
963 }
964 }
965
966 return true;
967}

◆ init()

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

Definition at line 88 of file IFXField.cpp.

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

◆ onAfterFetch()

bool IFXField::onAfterFetch ( )

Definition at line 242 of file IFXField.cpp.

243{
244#if __TRACE_THIS && 1
245 __DCL_TRACE4_N(L"indicator[%2d] sqllen[%10d] rtypmsize[%10d][%ls]\n",
246 __indicator, __sqlvar->sqllen,
247 rtypmsize(__sqlvar->sqltype, __sqlvar->sqllen),
248 __name.data());
249#endif
250 if (__indicator != -1) {
251 // not null
252 switch (__sqlvar->sqltype & SQLTYPE) {
253 case SQLDECIMAL:
254 case SQLMONEY: {
255 __dataSize = __get_dec_strlen((const dec_t*)(__sqlvar->sqldata));
256 break;
257 }
258 case SQLCHAR:
259 case SQLNCHAR: {
260 __dataSize = __sqlvar->sqllen - 1;
261 break;
262 }
263 case SQLVCHAR:
264 case SQLNVCHAR: {
265 __dataSize = ByteString::length(__sqlvar->sqldata, __sqlvar->sqllen);
266 break;
267 }
268 case SQLLVARCHAR: {
269#if __USE_IFX_VAR
270 int n = ifx_var_getlen((void**)(__sqlvar->sqldata));
271 __DCL_TRACE1_N(L"ifx_var_getlen[%d]\n", n);
272 if (n < 0) {
273 __SET_ERROR_HANDLE(n);
274 return false;
275 }
276 __dataSize = n;
277#else
278 __dataSize = ByteString::length(__sqlvar->sqldata, __sqlvar->sqllen);
279#endif
280 break;
281 }
282 case SQLTEXT:
283 case SQLBYTES: {
284 loc_t* loc = (loc_t*)(__sqlvar->sqldata);
285 if (loc->loc_status != 0) {
286 __SET_ERROR_HANDLE(loc->loc_status);
287 return false;
288 }
289 loc->loc_mflags = LOC_ALLOC;
290
291 if (loc->loc_indicator == -1)
292 __dataSize = 0;
293 else
294 __dataSize = loc->loc_size;
295 break;
296 }
297 }
298 }
299 return true;
300}
__DCL_TRACE4_N
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
Definition IFXConnection.cpp:38
__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:187

◆ query()

IFXQuery * IFXField::query ( ) const
inlineprotected

Definition at line 44 of file IFXField.h.

45{
46 return (IFXQuery*)Field::__queryHandle;
47}

◆ serverDataTypeName()

const wchar_t * IFXField::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 345 of file IFXField.cpp.

346{
347 return __dataTypeName(__sqlvar);
348}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:304
The documentation for this class was generated from the following files: