DCL 4.0
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 : 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}
417
418bool PgField::getInteger(void* _pv, size_t* _size)
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}
592
593bool PgField::getUInteger(void* _pv, size_t* _size)
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}
772
773bool PgField::getFloat(void* _pv, size_t* _size)
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}
858
859__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:150
n
void CharsetConvertException *size_t n
Definition SQLField.cpp:253
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:418
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:593
PgField::getFloat
bool getFloat(void *_pv, size_t *_size)
Definition PgField.cpp:773
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:76
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:67
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