DCL 4.1
Loading...
Searching...
No Matches
PgField Class Reference

#include <PgField.h>

Inheritance diagram for PgField:
SQL::Field Object

Public Member Functions

 PgField ()
virtual ~PgField ()
bool init (SQL::Query *_query, sqlvar_t *_sqlvar)
bool onAfterFetch (sqlvar_t *_sqlvar)
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)
PgQuery * 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 6 of file PgField.h.

Constructor & Destructor Documentation

◆ PgField()

PgField::PgField ( )

◆ ~PgField()

PgField::~PgField ( )
virtual

Definition at line 44 of file PgField.cpp.

45{
46// __DCL_TRACE1("~PgField: %s", Field::__name.data());
47}

Member Function Documentation

◆ __getData()

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

Implements SQL::Field.

Definition at line 270 of file PgField.cpp.

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

◆ __getDataSize()

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

Implements SQL::Field.

Definition at line 236 of file PgField.cpp.

237{
238 if (_maxSize) {
239 *_size = __maxDataSize;
240 return true;
241 }
242
243 if (!query()->inState(SQL::Query::stFetched)) {
244 __SET_ERROR(SQL::eNotFetched);
245 return false;
246 }
247
248 if (!isNull()) {
249 // not null
250 switch (__sqlvar->sqltype) {
251 case ECPGt_char:
252 case ECPGt_unsigned_char:
253 case ECPGt_varchar:
254 case ECPGt_varchar2:
255 case ECPGt_bytea:
256 *_size = __sqlvar->sqllen;
257 break;
258 default:
259 *_size = __maxDataSize;
260 }
261 }
262 else {
263 *_size = 0;
264
265 }
266
267 return true;
268}
PgField::isNull
virtual bool isNull() const
Definition PgField.cpp:227

◆ getFloat()

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

Definition at line 772 of file PgField.cpp.

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

◆ getInteger()

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

Definition at line 417 of file PgField.cpp.

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

◆ getUInteger()

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

Definition at line 592 of file PgField.cpp.

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

◆ init()

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

Definition at line 49 of file PgField.cpp.

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

◆ isNull()

bool PgField::isNull ( ) const
virtual

Implements SQL::Field.

Definition at line 227 of file PgField.cpp.

228{
229 if (!query()->inState(SQL::Query::stFetched)) {
230 return true;
231 }
232 return !(__sqlvar && __sqlvar->sqlind
233 && *(__sqlvar->sqlind) == 0);
234}

◆ onAfterFetch()

bool PgField::onAfterFetch ( sqlvar_t * _sqlvar)

Definition at line 175 of file PgField.cpp.

176{
177 __sqlvar = _sqlvar;
178 return true;
179}

◆ query()

PgQuery * PgField::query ( ) const
inlineprotected

Definition at line 63 of file PgField.h.

64{
65 return (PgQuery*)Field::__queryHandle;
66}

◆ serverDataTypeName()

const wchar_t * PgField::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 222 of file PgField.cpp.

223{
224 return __dataTypeName(__sqlvar);
225}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setErrorStatus() [1/2]

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

Definition at line 53 of file PgField.h.

55{
56 ((PgConnection*)Field::connection())->setErrorStatus(
57 _message,
58 _filename,
59 _line
60 );
61}

◆ setErrorStatus() [2/2]

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

Definition at line 42 of file PgField.h.

44{
45 ((PgConnection*)Field::connection())->setErrorStatus(
46 _error,
47 _SQLCODE,
48 _filename,
49 _line
50 );
51}
The documentation for this class was generated from the following files: