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

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

◆ getInteger()

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

Definition at line 418 of file PgField.cpp.

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

◆ getUInteger()

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

Definition at line 593 of file PgField.cpp.

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

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