DCL 3.7.4
Loading...
Searching...
No Matches
PeField Class Reference

#include <PeField.h>

Inheritance diagram for PeField:
SQL::Field Object

Public Member Functions

 PeField ()
virtual ~PeField ()
bool init (SQL::Query *_query, sqlvar_t *_sqlvar)
bool onAfterFetch (sqlvar_t *_sqlvar)
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

PeQuery * query () const
PeConnection * 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 PeField.h.

Constructor & Destructor Documentation

◆ PeField()

PeField::PeField ( )

◆ ~PeField()

PeField::~PeField ( )
virtual

Definition at line 51 of file PeField.cpp.

52{
53// __DCL_TRACE1("~PeField: %ls", Field::__name.data());
54}

Member Function Documentation

◆ __getData()

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

Implements SQL::Field.

Definition at line 263 of file PeField.cpp.

268{
269 switch(_bufType) {
270 case SQL::typeInteger:
271 return getInteger(_buf, _size);
272 case SQL::typeUInteger:
273 return getUInteger(_buf, _size);
274 case SQL::typeFloat:
275 return getFloat(_buf, _size);
276 case SQL::typeDate: {
277 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_date);
278 __decode((date*)(__sqlvar->sqldata), (SQL::Date*)_buf);
279 break;
280 }
281 case SQL::typeTime: {
282 // SQL time에 해당하는 ECPGt 이 없다
283 // ECPGt_char이 사용된다.
284 __DCL_ASSERT(false);
285 break;
286 }
287 case SQL::typeTimeStamp: {
288 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_timestamp);
289 __decode(
290 (const timestamp*)(__sqlvar->sqldata),
291 (SQL::TimeStamp*)_buf
292 );
293 break;
294 }
295 case SQL::typeInterval: {
296 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_interval);
297 __decode(
298 (const interval*)(__sqlvar->sqldata),
299 (SQL::Interval*)_buf
300 );
301 break;
302 }
303 case SQL::typeText:{
304 numeric nu;
305 numeric* p = NULL;
306 if (__sqlvar->sqltype == ECPGt_decimal) {
307 if (PGTYPESnumeric_from_decimal(
308 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
309 __SET_ERROR(SQL::eOutOfRange);
310 return false;
311 }
312 p = &nu;
313 }
314 else if (__sqlvar->sqltype == ECPGt_numeric) {
315 p = (numeric*)(__sqlvar->sqldata);
316 }
317
318 if (p) {
319#if 0
320 __DCL_TRACE4(L"ndigits[%d] weight[%d] rscale[%d] dscale[%d]\n",
321 p->ndigits, p->weight, p->rscale, p->dscale);
322 __DCL_TRACE2(L"sign[%d], digits[%ls]\n", p->sign,
323 String::tryString((const char*)(p->digits), p->ndigits).data()
324 );
325#endif
326 char* s = PGTYPESnumeric_to_asc(p, p->dscale);
327 size_t l = ByteString::length(s);
328#if 0
329 __DCL_TRACE2(L"[%hs] [%zd]\n", s, l);
330#endif
331 if (l <= *_size) {
332 memcpy(_buf, s, l);
333 *_size = l;
334 PGTYPESchar_free(s);
335 }
336 else {
337 PGTYPESchar_free(s);
338 __SET_ERROR(SQL::eInvalidBufferSize);
339 return false;
340 }
341 break;
342 }
343 }
344 case SQL::typeBinary: {
345 switch (__sqlvar->sqltype) {
346 case ECPGt_char:
347 case ECPGt_unsigned_char:
348 case ECPGt_varchar:
349 case ECPGt_varchar2:
350 case ECPGt_bytea: {
351 if (__sqlvar->sqllen > 0 && *_size > 0) {
352 size_t nCopy = *_size;
353 if ((size_t)(__sqlvar->sqllen) < nCopy)
354 nCopy = (size_t)(__sqlvar->sqllen);
355
356 memcpy(_buf, __sqlvar->sqldata, nCopy);
357 if (nCopy < *_size) {
358 *((char*)_buf + nCopy) = '\0';
359 *_size = nCopy;
360 }
361 }
362 else
363 *_size = 0;
364 break;
365 }
366 default:
367 __DCL_ASSERT(false);
368 }
369 break;
370 }
371 case SQL::typeOutputStream: {
372 switch (__sqlvar->sqltype) {
373 case ECPGt_char:
374 case ECPGt_unsigned_char:
375 case ECPGt_varchar:
376 case ECPGt_varchar2:
377 case ECPGt_bytea: {
378 if ((size_t)(__sqlvar->sqllen) < *_size) {
379 *_size = (size_t)(__sqlvar->sqllen);
380 }
381 try {
382 ((OutputStream*)_buf)->write(
383 __sqlvar->sqldata,
384 *_size
385 );
386 }
387 catch (IOException* e) {
388 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
389 e->destroy();
390 return false;
391 }
392 break;
393 }
394 default:
395 __DCL_ASSERT(false);
396 }
397 break;
398 }
399 default:
400 __DCL_ASSERT(false); // SQL::Field::getData bug
401 }
402 return true;
403}
NULL
#define NULL
Definition Config.h:312
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.cpp:50
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:394
__DCL_TRACE4
#define __DCL_TRACE4(fmt, arg1, arg2, arg3, arg4)
Definition Object.h:402
__DCL_TRACE2
#define __DCL_TRACE2(fmt, arg1, arg2)
Definition Object.h:400
__decode
__DCL_BEGIN_NAMESPACE void __decode(const date *_s, SQL::Date *_r)
Definition PeTypes.cpp:27
__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
PeField::getFloat
bool getFloat(void *_buf, size_t *_size)
Definition PeField.cpp:760
PeField::getInteger
bool getInteger(void *_buf, size_t *_size)
Definition PeField.cpp:405
PeField::getUInteger
bool getUInteger(void *_buf, size_t *_size)
Definition PeField.cpp:580
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:74
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::eOutOfRange
@ eOutOfRange
Definition SQLCore.h:52
SQL::eInvalidBufferSize
@ eInvalidBufferSize
Definition SQLCore.h:50

◆ __getDataSize()

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

Implements SQL::Field.

Definition at line 234 of file PeField.cpp.

235{
236 if (_maxsize) {
237 *_size = __maxDataSize;
238 return true;
239 }
240
241 if (!(__sqlvar && __sqlvar->sqlind && *(__sqlvar->sqlind) == 0)) {
242 *_size = (size_t)-1;
243 }
244 else {
245 switch (__sqlvar->sqltype) {
246 case ECPGt_char:
247 case ECPGt_unsigned_char:
248 case ECPGt_varchar:
249 case ECPGt_varchar2:
250 case ECPGt_bytea: {
251 *_size = __sqlvar->sqllen;
252 break;
253 }
254 default: {
255 *_size = __maxDataSize;
256 }
257 }
258 }
259
260 return true;
261}

◆ conn()

PeConnection * PeField::conn ( ) const
inlineprotected

Definition at line 46 of file PeField.h.

47{
48 return query()->conn();
49}
PeField::query
PeQuery * query() const
Definition PeField.h:41

◆ getFloat()

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

Definition at line 760 of file PeField.cpp.

761{
762 switch (__sqlvar->sqltype) {
763 case ECPGt_float: {
764 switch (*_size) {
765 case sizeof(float) : {
766 *(float*)_buf = *(float*)(__sqlvar->sqldata);
767 break;
768 }
769 case sizeof(double) : {
770 *(double*)_buf = *(float*)(__sqlvar->sqldata);
771 break;
772 }
773 default: {
774 *_size = sizeof(float);
775 __SET_ERROR(SQL::eInvalidBufferSize);
776 return false;
777 }
778 }
779 break;
780 }
781 case ECPGt_double: {
782 switch (*_size) {
783 case sizeof(double) : {
784 *(double*)_buf = *(double*)(__sqlvar->sqldata);
785 break;
786 }
787 default: {
788 *_size = sizeof(double);
789 __SET_ERROR(SQL::eInvalidBufferSize);
790 return false;
791 }
792 }
793 break;
794 }
795 case ECPGt_numeric:
796 case ECPGt_decimal: {
797 double d;
798 if (__sqlvar->sqltype == ECPGt_numeric) {
799 if (PGTYPESnumeric_to_double(
800 (numeric*)(__sqlvar->sqldata), &d) != 0) {
801 __SET_ERROR(SQL::eOutOfRange);
802 return false;
803 }
804 }
805 else {
806 numeric nu;
807 if (PGTYPESnumeric_from_decimal(
808 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
809 __SET_ERROR(SQL::eOutOfRange);
810 return false;
811 }
812 if (PGTYPESnumeric_to_double(&nu, &d) != 0) {
813 __SET_ERROR(SQL::eOutOfRange);
814 return false;
815 }
816 }
817
818 switch (*_size) {
819 case sizeof(float) : {
820 if (d < -FLT_MAX || FLT_MAX < d) {
821 __SET_ERROR(SQL::eOutOfRange);
822 return false;
823 }
824 *(float*)_buf = (float)d;
825 break;
826 }
827 case sizeof(double) : {
828 *(double*)_buf = (double)d;
829 break;
830 }
831 default: {
832 *_size = sizeof(double);
833 __SET_ERROR(SQL::eInvalidBufferSize);
834 return false;
835 }
836 }
837 break;
838 }
839 default :
840 __DCL_ASSERT(false);
841 }
842
843 return true;
844}

◆ getInteger()

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

Definition at line 405 of file PeField.cpp.

406{
407 switch (__sqlvar->sqltype) {
408 case ECPGt_short: {
409 switch (*_size) {
410 case sizeof(int16_t) : {
411 *(int16_t*)_buf = *(int16_t*)(__sqlvar->sqldata);
412 break;
413 }
414 case sizeof(int32_t) : {
415 *(int32_t*)_buf = (int32_t) * (int16_t*)(__sqlvar->sqldata);
416 break;
417 }
418 case sizeof(int64_t) : {
419 *(int64_t*)_buf = (int64_t) * (int16_t*)(__sqlvar->sqldata);
420 break;
421 }
422 default: {
423 *_size = sizeof(int16_t);
424 __SET_ERROR(SQL::eInvalidBufferSize);
425 return false;
426 }
427 }
428 break;
429 }
430#if ALIGNOF_LONG == 4
431 case ECPGt_long:
432#endif
433 case ECPGt_int: {
434 switch (*_size) {
435 case sizeof(int32_t) : {
436 *(int32_t*)_buf = *(int32_t*)(__sqlvar->sqldata);
437 break;
438 }
439 case sizeof(int64_t) : {
440 *(int64_t*)_buf = (int64_t) * (int32_t*)(__sqlvar->sqldata);
441 break;
442 }
443 default: {
444 *_size = sizeof(int32_t);
445 __SET_ERROR(SQL::eInvalidBufferSize);
446 return false;
447 }
448 }
449 break;
450 }
451#if ALIGNOF_LONG == 8
452 case ECPGt_long:
453#endif
454 case ECPGt_long_long: {
455 if (*_size == sizeof(int64_t)) {
456 *(int64_t*)_buf = (int64_t) * (int64_t*)(__sqlvar->sqldata);
457 }
458 else {
459 *_size = sizeof(int64_t);
460 __SET_ERROR(SQL::eInvalidBufferSize);
461 return false;
462 }
463 break;
464 }
465 case ECPGt_unsigned_long_long: {
466 if (*_size == sizeof(int64_t)) {
467 *(int64_t*)_buf = (int64_t) * (uint64_t*)(__sqlvar->sqldata);
468 }
469 else {
470 *_size = sizeof(int64_t);
471 __SET_ERROR(SQL::eInvalidBufferSize);
472 return false;
473 }
474 break;
475 }
476 case ECPGt_numeric:
477 case ECPGt_decimal: {
478#if ALIGNOF_LONG == 4
479 if (*_size <= sizeof(int32_t)) {
480#endif
481 long n;
482 if (__sqlvar->sqltype == ECPGt_numeric) {
483 if (PGTYPESnumeric_to_long(
484 (numeric*)(__sqlvar->sqldata), &n) != 0) {
485 __SET_ERROR(SQL::eOutOfRange);
486 return false;
487 }
488 }
489 else {
490 numeric nu;
491 if (PGTYPESnumeric_from_decimal(
492 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
493 __SET_ERROR(SQL::eOutOfRange);
494 return false;
495 }
496 if (PGTYPESnumeric_to_long(&nu, &n) != 0) {
497 __SET_ERROR(SQL::eOutOfRange);
498 return false;
499 }
500 }
501
502 switch (*_size) {
503 case sizeof(int8_t) : {
504 if (n < INT8_MIN || INT8_MAX < n) {
505 __SET_ERROR(SQL::eOutOfRange);
506 return false;
507 }
508 *(int8_t*)_buf = (int8_t)n;
509 break;
510 }
511 case sizeof(int16_t) : {
512 if (n < INT16_MIN || INT16_MAX < n) {
513 __SET_ERROR(SQL::eOutOfRange);
514 return false;
515 }
516 *(int16_t*)_buf = (int16_t)n;
517 break;
518 }
519 case sizeof(int32_t) : {
520#if ALIGNOF_LONG == 8
521 if (n < INT32_MIN || INT32_MAX < n) {
522 __SET_ERROR(SQL::eOutOfRange);
523 return false;
524 }
525#endif
526 *(int32_t*)_buf = (int32_t)n;
527 break;
528 }
529 case sizeof(int64_t) : {
530 *(int64_t*)_buf = (int64_t)n;
531 break;
532 }
533 default: {
534#if ALIGNOF_LONG == 4
535 *_size = sizeof(int32_t);
536#elif ALIGNOF_LONG == 8
537 *_size = sizeof(int64_t);
538#endif
539 __SET_ERROR(SQL::eInvalidBufferSize);
540 return false;
541 }
542 }
543#if ALIGNOF_LONG == 4
544 }
545 else if (*_size == sizeof(int64_t)) {
546 numeric* p = (numeric*)(__sqlvar->sqldata);
547 numeric nu;
548 if (__sqlvar->sqltype == ECPGt_decimal) {
549 if (PGTYPESnumeric_from_decimal(
550 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
551 __SET_ERROR(SQL::eOutOfRange);
552 return false;
553 }
554 p = &nu;
555 }
556 char* s = PGTYPESnumeric_to_asc(p, 0);
557 char* endptr;
558 long long n = strtoll(s, &endptr, 10);
559 PGTYPESchar_free(s);
560 if (n == LLONG_MAX || n == LLONG_MIN) {
561 __SET_ERROR(SQL::eOutOfRange);
562 return false;
563 }
564 *(int64_t*)_buf = n;
565 }
566 else {
567 *_size = sizeof(int64_t);
568 __SET_ERROR(SQL::eInvalidBufferSize);
569 return false;
570 }
571#endif
572 break;
573 }
574 default :
575 __DCL_ASSERT(false);
576 }
577 return true;
578}
INT32_MAX
#define INT32_MAX
Definition Config.h:290
INT32_MIN
#define INT32_MIN
Definition Config.h:285
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 PeField::getUInteger ( void * _buf,
size_t * _size )
protected

Definition at line 580 of file PeField.cpp.

581{
582 switch(__sqlvar->sqltype) {
583 case ECPGt_bool: {
584 switch (*_size) {
585 case sizeof(uint8_t) : {
586 *(uint8_t*)_buf = (uint8_t) * (uint8_t*)(__sqlvar->sqldata);
587 break;
588 }
589 case sizeof(uint16_t) : {
590 *(uint16_t*)_buf = (uint16_t) * (uint8_t*)(__sqlvar->sqldata);
591 break;
592 }
593 case sizeof(uint32_t) : {
594 *(uint32_t*)_buf = (uint32_t) * (uint8_t*)(__sqlvar->sqldata);
595 break;
596 }
597 case sizeof(uint64_t) : {
598 *(uint64_t*)_buf = (uint64_t) * (uint8_t*)(__sqlvar->sqldata);
599 break;
600 }
601 default: {
602 *_size = sizeof(uint8_t);
603 __SET_ERROR(SQL::eInvalidBufferSize);
604 return false;
605 }
606 }
607 break;
608 }
609 case ECPGt_short: {
610 switch (*_size) {
611 case sizeof(uint16_t) : {
612 *(uint16_t*)_buf = (uint16_t) * (int16_t*)(__sqlvar->sqldata);
613 break;
614 }
615 case sizeof(uint32_t) : {
616 *(uint32_t*)_buf = (uint32_t) * (int16_t*)(__sqlvar->sqldata);
617 break;
618 }
619 case sizeof(uint64_t) : {
620 *(uint64_t*)_buf = (uint64_t) * (int16_t*)(__sqlvar->sqldata);
621 break;
622 }
623 default: {
624 *_size = sizeof(uint16_t);
625 __SET_ERROR(SQL::eInvalidBufferSize);
626 return false;
627 }
628 }
629 break;
630 }
631 case ECPGt_int:
632 case ECPGt_long: {
633 switch (*_size) {
634 case sizeof(uint32_t) : {
635 *(uint32_t*)_buf = (uint32_t) * (int32_t*)(__sqlvar->sqldata);
636 break;
637 }
638 case sizeof(int64_t) : {
639 *(uint64_t*)_buf = (uint64_t) * (int32_t*)(__sqlvar->sqldata);
640 break;
641 }
642 default: {
643 *_size = sizeof(int32_t);
644 __SET_ERROR(SQL::eInvalidBufferSize);
645 return false;
646 }
647 }
648 break;
649 }
650 case ECPGt_long_long: {
651 if (*_size == sizeof(int64_t)) {
652 *(uint64_t*)_buf = (uint64_t) * (int64_t*)(__sqlvar->sqldata);
653 }
654 else {
655 *_size = sizeof(int64_t);
656 __SET_ERROR(SQL::eInvalidBufferSize);
657 return false;
658 }
659 break;
660 }
661 case ECPGt_unsigned_long_long: {
662 if (*_size == sizeof(int64_t)) {
663 *(uint64_t*)_buf = (uint64_t) * (uint64_t*)(__sqlvar->sqldata);
664 }
665 else {
666 *_size = sizeof(int64_t);
667 __SET_ERROR(SQL::eInvalidBufferSize);
668 return false;
669 }
670 break;
671 }
672 case ECPGt_numeric:
673 case ECPGt_decimal: {
674 if (*_size <= sizeof(uint32_t)) {
675 long n;
676 if (__sqlvar->sqltype == ECPGt_numeric) {
677 if (PGTYPESnumeric_to_long(
678 (numeric*)(__sqlvar->sqldata), &n) != 0) {
679 __SET_ERROR(SQL::eOutOfRange);
680 return false;
681 }
682 }
683 else {
684 numeric nu;
685 if (PGTYPESnumeric_from_decimal(
686 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
687 __SET_ERROR(SQL::eOutOfRange);
688 return false;
689 }
690 if (PGTYPESnumeric_to_long(&nu, &n) != 0) {
691 __SET_ERROR(SQL::eOutOfRange);
692 return false;
693 }
694 }
695
696 switch (*_size) {
697 case sizeof(uint8_t) : {
698 if (n < INT8_MIN || INT8_MAX < n)
699 {
700 __SET_ERROR(SQL::eOutOfRange);
701 return false;
702 }
703 *(uint8_t*)_buf = (uint8_t)n;
704 break;
705 }
706 case sizeof(uint16_t) : {
707 if (n < INT16_MIN || INT16_MAX < n)
708 {
709 __SET_ERROR(SQL::eOutOfRange);
710 return false;
711 }
712 *(uint16_t*)_buf = (uint16_t)n;
713 break;
714 }
715 case sizeof(uint32_t) : {
716 *(uint32_t*)_buf = (uint32_t)n;
717 break;
718 }
719 default: {
720 *_size = sizeof(uint32_t);
721 __SET_ERROR(SQL::eInvalidBufferSize);
722 return false;
723 }
724 }
725 }
726 else if (*_size == sizeof(uint64_t)) {
727 numeric* p = (numeric*)(__sqlvar->sqldata);
728 numeric nu;
729 if (__sqlvar->sqltype == ECPGt_decimal) {
730 if (PGTYPESnumeric_from_decimal(
731 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
732 __SET_ERROR(SQL::eOutOfRange);
733 return false;
734 }
735 p = &nu;
736 }
737 char* s = PGTYPESnumeric_to_asc(p, 0);
738 char* endptr;
739 unsigned long long n = strtoull(s, &endptr, 10);
740 PGTYPESchar_free(s);
741 if (n == ULLONG_MAX) {
742 __SET_ERROR(SQL::eOutOfRange);
743 return false;
744 }
745 *(uint64_t*)_buf = n;
746 }
747 else {
748 *_size = sizeof(int64_t);
749 __SET_ERROR(SQL::eInvalidBufferSize);
750 return false;
751 }
752 break;
753 }
754 default :
755 __DCL_ASSERT(false); // PeField::init bug
756 }
757 return true;
758}

◆ init()

bool PeField::init ( SQL::Query * _query,
sqlvar_t * _sqlvar )

Definition at line 56 of file PeField.cpp.

57{
58 __DCL_ASSERT((Field::__queryHandle == NULL) && (__sqlvar == NULL));
59 __DCL_ASSERT((_sqlvar != NULL));// && (_sqlvar->sqldata != NULL));
60
61 Field::__queryHandle = _queryHandle;
62 __sqlvar = _sqlvar;
63
64 try {
65 Field::__name = UTF8Decoder::decode(__sqlvar->sqlname.data,
66 __sqlvar->sqlname.length).toUpperCase();
67 }
68 catch (CharsetConvertException* _e) {
69 __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
70 _e->destroy();
71 return false;
72 }
73
74 switch (__sqlvar->sqltype) {
75 case ECPGt_short: {
76 Field::__dataType = SQL::typeInteger;
77 __maxDataSize = sizeof(int16_t);
78 break;
79 }
80 case ECPGt_unsigned_short: {
81 Field::__dataType = SQL::typeUInteger;
82 __maxDataSize = sizeof(int16_t);
83 break;
84 }
85 case ECPGt_int: {
86 Field::__dataType = SQL::typeInteger;
87 __maxDataSize = sizeof(int32_t);
88 break;
89 }
90 case ECPGt_unsigned_int: {
91 Field::__dataType = SQL::typeUInteger;
92 __maxDataSize = sizeof(int32_t);
93 break;
94 }
95 case ECPGt_long: {
96 Field::__dataType = SQL::typeInteger;
97#if ALIGNOF_LONG == 8
98 __maxDataSize = sizeof(int64_t);
99#else
100 __maxDataSize = sizeof(int32_t);
101#endif
102 break;
103 }
104 case ECPGt_unsigned_long: {
105 Field::__dataType = SQL::typeUInteger;
106#if ALIGNOF_LONG == 8
107 __maxDataSize = sizeof(int64_t);
108#else
109 __maxDataSize = sizeof(int32_t);
110#endif
111 break;
112 }
113 case ECPGt_long_long: {
114 Field::__dataType = SQL::typeInteger;
115 __maxDataSize = sizeof(int64_t);
116 break;
117 }
118 case ECPGt_unsigned_long_long: {
119 Field::__dataType = SQL::typeUInteger;
120 __maxDataSize = sizeof(int64_t);
121 break;
122 }
123 case ECPGt_bool: {
124 Field::__dataType = SQL::typeUInteger;
125 __maxDataSize = sizeof(bool);
126 break;
127 }
128 case ECPGt_float: {
129 Field::__dataType = SQL::typeFloat;
130 __maxDataSize = sizeof(float);
131 break;
132 }
133 case ECPGt_double: {
134 Field::__dataType = SQL::typeFloat;
135 __maxDataSize = sizeof(double);
136 break;
137 }
138 case ECPGt_numeric:
139 case ECPGt_decimal: {
140 Field::__dataType = SQL::typeNumeric;
141 // float decimal
142 // max : 10^124 ==> 124, min : // 10^-130 : 130 + "-0." ESQL/C manual
143 // 10^(64 * 2) + "-0." 128 + 3 = 131 incl/esql/decimal.h
144 __maxDataSize = 133;
145 break;
146 }
147 case ECPGt_date: {
148 Field::__dataType = SQL::typeDate;
149 __maxDataSize = sizeof(SQL::Date);
150 break;
151 }
152 case ECPGt_timestamp: {
153 Field::__dataType = SQL::typeTimeStamp;
154 __maxDataSize = sizeof(SQL::TimeStamp);
155 break;
156 }
157 case ECPGt_interval: {
158 Field::__dataType = SQL::typeInterval;
159 __maxDataSize = sizeof(SQL::Interval);
160 break;
161 }
162 case ECPGt_char:
163 case ECPGt_unsigned_char:
164 case ECPGt_varchar:
165 case ECPGt_varchar2: {
166 Field::__dataType = SQL::typeText;
167 __maxDataSize = INT16_MAX;
168 break;
169 }
170 case ECPGt_bytea: {
171 Field::__dataType = SQL::typeBinary;
172 __maxDataSize = INT16_MAX;
173 break;
174 }
175 default: {
176 __DCL_ASSERT(false);
177 }
178 }
179 return true;
180}
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:64

◆ onAfterFetch()

bool PeField::onAfterFetch ( sqlvar_t * _sqlvar)

Definition at line 182 of file PeField.cpp.

183{
184 __sqlvar = _sqlvar;
185 return true;
186}

◆ query()

PeQuery * PeField::query ( ) const
inlineprotected

Definition at line 41 of file PeField.h.

42{
43 return (PeQuery*)Field::__queryHandle;
44}

◆ serverDataTypeName()

const wchar_t * PeField::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 229 of file PeField.cpp.

230{
231 return __dataTypeName(__sqlvar);
232}
__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: