DCL 4.1
Loading...
Searching...
No Matches
PgField.cpp
Go to the documentation of this file.
1#include <dcl/Config.h>
2
3#include <stdlib.h> // strtoll, strtoull
4#include <string.h> // memcpy
5#include <float.h> // FLT_MIN, FLT_MAX
6
7#include <pg_config.h>
8#include <ecpgtype.h>
9#include <sqlda.h>
10#include <pgtypes_numeric.h>
11#include <pgtypes_date.h>
12#include <pgtypes_timestamp.h>
13#include <pgtypes_interval.h>
14
15#include <dcl/Object.h>
16#if __DCL_HAVE_ALLOC_DEBUG
17#undef __DCL_ALLOC_LEVEL
18#define __DCL_ALLOC_LEVEL __DCL_ALLOC_INTERNAL
19#endif
20
21#include <dcl/OutputStream.h>
22#include <dcl/Charset.h>
23#include <dcl/SQLCore.h>
24
25#include "PgConnection.h"
26#include "PgQuery.h"
27#include "PgField.h"
28#include "PgTypes_.h"
29
30#undef __THIS_FILE__
31static const wchar_t __THIS_FILE__[] = __T("dcl/sql/PgField.cpp");
32
33__DCL_BEGIN_NAMESPACE
34
35IMPLEMENT_CLASSINFO(PgField, SQL::Field)
36
37PgField::PgField()
38 : Field(NULL)
39{
40 __sqlvar = NULL;
41 __maxDataSize = 0;
42}
43
44PgField::~PgField()
45{
46// __DCL_TRACE1("~PgField: %s", Field::__name.data());
47}
48
49bool PgField::init(SQL::Query* _queryHandle, sqlvar_t* _sqlvar)
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}
174
175bool PgField::onAfterFetch(sqlvar_t* _sqlvar)
176{
177 __sqlvar = _sqlvar;
178 return true;
179}
180
181#define SQLTYPE_NAME(_dataType, name) case _dataType : return L ## name
182
183const wchar_t* __dataTypeName(const sqlvar_t* _sqlvar)
184{
185 switch(_sqlvar->sqltype) {
186 SQLTYPE_NAME(ECPGt_char, "char" );
187 SQLTYPE_NAME(ECPGt_unsigned_char, "unsigned char" );
188 SQLTYPE_NAME(ECPGt_short, "short" );
189 SQLTYPE_NAME(ECPGt_unsigned_short, "unsigned short");
190 SQLTYPE_NAME(ECPGt_int, "int" );
191 SQLTYPE_NAME(ECPGt_unsigned_int, "unsigned int" );
192 SQLTYPE_NAME(ECPGt_long, "long" );
193 SQLTYPE_NAME(ECPGt_unsigned_long, "unsigned long" );
194 SQLTYPE_NAME(ECPGt_long_long, "long long" );
195 SQLTYPE_NAME(ECPGt_unsigned_long_long, "unsigned long long" );
196 SQLTYPE_NAME(ECPGt_bool, "bool" );
197 SQLTYPE_NAME(ECPGt_float, "float" );
198 SQLTYPE_NAME(ECPGt_double, "double" );
199 SQLTYPE_NAME(ECPGt_varchar, "varchar" );
200 SQLTYPE_NAME(ECPGt_varchar2, "varchar2" );
201 SQLTYPE_NAME(ECPGt_numeric, "numeric" );
202 SQLTYPE_NAME(ECPGt_decimal, "decimal" );
203 SQLTYPE_NAME(ECPGt_date, "date" );
204 SQLTYPE_NAME(ECPGt_timestamp, "timestamp" );
205 SQLTYPE_NAME(ECPGt_interval, "interval" );
206 SQLTYPE_NAME(ECPGt_array, "array" );
207 SQLTYPE_NAME(ECPGt_struct, "struct" );
208 SQLTYPE_NAME(ECPGt_union, "union" );
209 SQLTYPE_NAME(ECPGt_descriptor, "descriptor" );
210 SQLTYPE_NAME(ECPGt_char_variable, "char variable" );
211 SQLTYPE_NAME(ECPGt_const, "const" );
212 SQLTYPE_NAME(ECPGt_EOIT, "EOIT" );
213 SQLTYPE_NAME(ECPGt_EORT, "EORT" );
214 SQLTYPE_NAME(ECPGt_NO_INDICATOR, "NO_INDICATOR" );
215 SQLTYPE_NAME(ECPGt_string, "string" );
216 SQLTYPE_NAME(ECPGt_sqlda, "sqlda" );
217 SQLTYPE_NAME(ECPGt_bytea, "bytea" );
218 }
219 return L"Unknown Type: Driver is not Support";
220}
221
222const wchar_t* PgField::serverDataTypeName() const
223{
224 return __dataTypeName(__sqlvar);
225}
226
227bool PgField::isNull() const
228{
229 if (!query()->inState(SQL::Query::stFetched)) {
230 return true;
231 }
232 return !(__sqlvar && __sqlvar->sqlind
233 && *(__sqlvar->sqlind) == 0);
234}
235
236bool PgField::__getDataSize(size_t* _size, bool _maxSize)
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}
269
270bool PgField::__getData(
271 void* _pv,
272 size_t* _size,
273 SQL::DataType _dataType
274 )
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}
416
417bool PgField::getInteger(void* _pv, size_t* _size)
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}
591
592bool PgField::getUInteger(void* _pv, size_t* _size)
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}
771
772bool PgField::getFloat(void* _pv, size_t* _size)
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}
857
858__DCL_END_NAMESPACE
__THIS_FILE__
#define __THIS_FILE__
Definition _trace.h:14
NULL
#define NULL
Definition Config.h:340
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
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.h:57
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
__DCL_TRACE4
#define __DCL_TRACE4(fmt, arg1, arg2, arg3, arg4)
Definition Object.h:379
IMPLEMENT_CLASSINFO
#define IMPLEMENT_CLASSINFO(class_name, base_class_name)
Definition Object.h:228
__T
#define __T(str)
Definition Object.h:44
__DCL_TRACE2
#define __DCL_TRACE2(fmt, arg1, arg2)
Definition Object.h:377
__dataTypeName
const wchar_t * __dataTypeName(const sqlvar_t *_sqlvar)
Definition PgField.cpp:183
SQLTYPE_NAME
#define SQLTYPE_NAME(_dataType, name)
Definition PgField.cpp:181
__decode
__DCL_BEGIN_NAMESPACE void __decode(const date *_s, SQL::Date *_r)
Definition PgTypes.cpp:27
PgTypes_.h
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:153
n
void CharsetConvertException *size_t n
Definition SQLField.cpp:254
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
PgField::onAfterFetch
bool onAfterFetch(sqlvar_t *_sqlvar)
Definition PgField.cpp:175
PgField::getInteger
bool getInteger(void *_pv, size_t *_size)
Definition PgField.cpp:417
PgField::__getDataSize
virtual bool __getDataSize(size_t *_size, bool _maxSize)
Definition PgField.cpp:236
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::init
bool init(SQL::Query *_query, sqlvar_t *_sqlvar)
Definition PgField.cpp:49
PgField::__getData
virtual bool __getData(void *_pv, size_t *_size, SQL::DataType _dataType)
Definition PgField.cpp:270
PgField::serverDataTypeName
virtual const wchar_t * serverDataTypeName() const
Definition PgField.cpp:222
PgField::~PgField
virtual ~PgField()
Definition PgField.cpp:44
PgField::query
PgQuery * query() const
Definition PgField.h:63
PgField::isNull
virtual bool isNull() const
Definition PgField.cpp:227
SQL::DataType
DataType
Definition SQLCore.h:62
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:77
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:67
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