DCL 3.7.4
Loading...
Searching...
No Matches
PeField.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_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 "PeConnection.h"
26#include "PeQuery.h"
27#include "PeField.h"
28#include "PeTypes.h"
29
30#undef __THIS_FILE__
31static const char_t __THIS_FILE__[] = __T("dcl/sql/PeField.cpp");
32
33__DCL_BEGIN_NAMESPACE
34
35#define __SET_ERROR(_error) \
36 conn()->setErrorHandle(_error, 0L, __THIS_FILE__, __LINE__)
37#define __SET_ERROR_HANDLE(_SQLCODE) \
38 conn()->setErrorHandle(SQL::eServerError, _SQLCODE, __THIS_FILE__, __LINE__)
39#define __SET_ERROR_MSG(_message) \
40 conn()->setErrorMessage(_message, __THIS_FILE__, __LINE__)
41
42IMPLEMENT_CLASSINFO(PeField, SQL::Field)
43
44PeField::PeField()
45 : Field(NULL)
46{
47 __sqlvar = NULL;
48 __maxDataSize = 0;
49}
50
51PeField::~PeField()
52{
53// __DCL_TRACE1("~PeField: %ls", Field::__name.data());
54}
55
56bool PeField::init(SQL::Query* _queryHandle, sqlvar_t* _sqlvar)
57{
58 __DCL_ASSERT((Field::__queryHandle == NULL) && (__sqlvar == NULL));
59 __DCL_ASSERT((_sqlvar != NULL));// && (_sqlvar->sqldata != NULL));
60
61 Field::__queryHandle = _queryHandle;
62 __sqlvar = _sqlvar;
63
64 try {
65 Field::__name = UTF8Decoder::decode(__sqlvar->sqlname.data,
66 __sqlvar->sqlname.length).toUpperCase();
67 }
68 catch (CharsetConvertException* _e) {
69 __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
70 _e->destroy();
71 return false;
72 }
73
74 switch (__sqlvar->sqltype) {
75 case ECPGt_short: {
76 Field::__dataType = SQL::typeInteger;
77 __maxDataSize = sizeof(int16_t);
78 break;
79 }
80 case ECPGt_unsigned_short: {
81 Field::__dataType = SQL::typeUInteger;
82 __maxDataSize = sizeof(int16_t);
83 break;
84 }
85 case ECPGt_int: {
86 Field::__dataType = SQL::typeInteger;
87 __maxDataSize = sizeof(int32_t);
88 break;
89 }
90 case ECPGt_unsigned_int: {
91 Field::__dataType = SQL::typeUInteger;
92 __maxDataSize = sizeof(int32_t);
93 break;
94 }
95 case ECPGt_long: {
96 Field::__dataType = SQL::typeInteger;
97#if ALIGNOF_LONG == 8
98 __maxDataSize = sizeof(int64_t);
99#else
100 __maxDataSize = sizeof(int32_t);
101#endif
102 break;
103 }
104 case ECPGt_unsigned_long: {
105 Field::__dataType = SQL::typeUInteger;
106#if ALIGNOF_LONG == 8
107 __maxDataSize = sizeof(int64_t);
108#else
109 __maxDataSize = sizeof(int32_t);
110#endif
111 break;
112 }
113 case ECPGt_long_long: {
114 Field::__dataType = SQL::typeInteger;
115 __maxDataSize = sizeof(int64_t);
116 break;
117 }
118 case ECPGt_unsigned_long_long: {
119 Field::__dataType = SQL::typeUInteger;
120 __maxDataSize = sizeof(int64_t);
121 break;
122 }
123 case ECPGt_bool: {
124 Field::__dataType = SQL::typeUInteger;
125 __maxDataSize = sizeof(bool);
126 break;
127 }
128 case ECPGt_float: {
129 Field::__dataType = SQL::typeFloat;
130 __maxDataSize = sizeof(float);
131 break;
132 }
133 case ECPGt_double: {
134 Field::__dataType = SQL::typeFloat;
135 __maxDataSize = sizeof(double);
136 break;
137 }
138 case ECPGt_numeric:
139 case ECPGt_decimal: {
140 Field::__dataType = SQL::typeNumeric;
141 // float decimal
142 // max : 10^124 ==> 124, min : // 10^-130 : 130 + "-0." ESQL/C manual
143 // 10^(64 * 2) + "-0." 128 + 3 = 131 incl/esql/decimal.h
144 __maxDataSize = 133;
145 break;
146 }
147 case ECPGt_date: {
148 Field::__dataType = SQL::typeDate;
149 __maxDataSize = sizeof(SQL::Date);
150 break;
151 }
152 case ECPGt_timestamp: {
153 Field::__dataType = SQL::typeTimeStamp;
154 __maxDataSize = sizeof(SQL::TimeStamp);
155 break;
156 }
157 case ECPGt_interval: {
158 Field::__dataType = SQL::typeInterval;
159 __maxDataSize = sizeof(SQL::Interval);
160 break;
161 }
162 case ECPGt_char:
163 case ECPGt_unsigned_char:
164 case ECPGt_varchar:
165 case ECPGt_varchar2: {
166 Field::__dataType = SQL::typeText;
167 __maxDataSize = INT16_MAX;
168 break;
169 }
170 case ECPGt_bytea: {
171 Field::__dataType = SQL::typeBinary;
172 __maxDataSize = INT16_MAX;
173 break;
174 }
175 default: {
176 __DCL_ASSERT(false);
177 }
178 }
179 return true;
180}
181
182bool PeField::onAfterFetch(sqlvar_t* _sqlvar)
183{
184 __sqlvar = _sqlvar;
185 return true;
186}
187
188#define SQLTYPE_NAME(_dataType, name) case _dataType : return L ## name
189
190const wchar_t* __dataTypeName(const sqlvar_t* _sqlvar)
191{
192 switch(_sqlvar->sqltype) {
193 SQLTYPE_NAME(ECPGt_char, "char" );
194 SQLTYPE_NAME(ECPGt_unsigned_char, "unsigned char" );
195 SQLTYPE_NAME(ECPGt_short, "short" );
196 SQLTYPE_NAME(ECPGt_unsigned_short, "unsigned short");
197 SQLTYPE_NAME(ECPGt_int, "int" );
198 SQLTYPE_NAME(ECPGt_unsigned_int, "unsigned int" );
199 SQLTYPE_NAME(ECPGt_long, "long" );
200 SQLTYPE_NAME(ECPGt_unsigned_long, "unsigned long" );
201 SQLTYPE_NAME(ECPGt_long_long, "long long" );
202 SQLTYPE_NAME(ECPGt_unsigned_long_long, "unsigned long long" );
203 SQLTYPE_NAME(ECPGt_bool, "bool" );
204 SQLTYPE_NAME(ECPGt_float, "float" );
205 SQLTYPE_NAME(ECPGt_double, "double" );
206 SQLTYPE_NAME(ECPGt_varchar, "varchar" );
207 SQLTYPE_NAME(ECPGt_varchar2, "varchar2" );
208 SQLTYPE_NAME(ECPGt_numeric, "numeric" );
209 SQLTYPE_NAME(ECPGt_decimal, "decimal" );
210 SQLTYPE_NAME(ECPGt_date, "date" );
211 SQLTYPE_NAME(ECPGt_timestamp, "timestamp" );
212 SQLTYPE_NAME(ECPGt_interval, "interval" );
213 SQLTYPE_NAME(ECPGt_array, "array" );
214 SQLTYPE_NAME(ECPGt_struct, "struct" );
215 SQLTYPE_NAME(ECPGt_union, "union" );
216 SQLTYPE_NAME(ECPGt_descriptor, "descriptor" );
217 SQLTYPE_NAME(ECPGt_char_variable, "char variable" );
218 SQLTYPE_NAME(ECPGt_const, "const" );
219 SQLTYPE_NAME(ECPGt_EOIT, "EOIT" );
220 SQLTYPE_NAME(ECPGt_EORT, "EORT" );
221 SQLTYPE_NAME(ECPGt_NO_INDICATOR, "NO_INDICATOR" );
222 SQLTYPE_NAME(ECPGt_string, "string" );
223 SQLTYPE_NAME(ECPGt_sqlda, "sqlda" );
224 SQLTYPE_NAME(ECPGt_bytea, "bytea" );
225 }
226 return L"Unknown Type: Driver is not Support";
227}
228
229const wchar_t* PeField::serverDataTypeName() const
230{
231 return __dataTypeName(__sqlvar);
232}
233
234bool PeField::__getDataSize(size_t* _size, bool _maxsize)
235{
236 if (_maxsize) {
237 *_size = __maxDataSize;
238 return true;
239 }
240
241 if (!(__sqlvar && __sqlvar->sqlind && *(__sqlvar->sqlind) == 0)) {
242 *_size = (size_t)-1;
243 }
244 else {
245 switch (__sqlvar->sqltype) {
246 case ECPGt_char:
247 case ECPGt_unsigned_char:
248 case ECPGt_varchar:
249 case ECPGt_varchar2:
250 case ECPGt_bytea: {
251 *_size = __sqlvar->sqllen;
252 break;
253 }
254 default: {
255 *_size = __maxDataSize;
256 }
257 }
258 }
259
260 return true;
261}
262
263bool PeField::__getData(
264 void* _buf,
265 size_t* _size,
266 SQL::DataType _bufType
267)
268{
269 switch(_bufType) {
270 case SQL::typeInteger:
271 return getInteger(_buf, _size);
272 case SQL::typeUInteger:
273 return getUInteger(_buf, _size);
274 case SQL::typeFloat:
275 return getFloat(_buf, _size);
276 case SQL::typeDate: {
277 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_date);
278 __decode((date*)(__sqlvar->sqldata), (SQL::Date*)_buf);
279 break;
280 }
281 case SQL::typeTime: {
282 // SQL time에 해당하는 ECPGt 이 없다
283 // ECPGt_char이 사용된다.
284 __DCL_ASSERT(false);
285 break;
286 }
287 case SQL::typeTimeStamp: {
288 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_timestamp);
289 __decode(
290 (const timestamp*)(__sqlvar->sqldata),
291 (SQL::TimeStamp*)_buf
292 );
293 break;
294 }
295 case SQL::typeInterval: {
296 __DCL_ASSERT(__sqlvar->sqltype == ECPGt_interval);
297 __decode(
298 (const interval*)(__sqlvar->sqldata),
299 (SQL::Interval*)_buf
300 );
301 break;
302 }
303 case SQL::typeText:{
304 numeric nu;
305 numeric* p = NULL;
306 if (__sqlvar->sqltype == ECPGt_decimal) {
307 if (PGTYPESnumeric_from_decimal(
308 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
309 __SET_ERROR(SQL::eOutOfRange);
310 return false;
311 }
312 p = &nu;
313 }
314 else if (__sqlvar->sqltype == ECPGt_numeric) {
315 p = (numeric*)(__sqlvar->sqldata);
316 }
317
318 if (p) {
319#if 0
320 __DCL_TRACE4(L"ndigits[%d] weight[%d] rscale[%d] dscale[%d]\n",
321 p->ndigits, p->weight, p->rscale, p->dscale);
322 __DCL_TRACE2(L"sign[%d], digits[%ls]\n", p->sign,
323 String::tryString((const char*)(p->digits), p->ndigits).data()
324 );
325#endif
326 char* s = PGTYPESnumeric_to_asc(p, p->dscale);
327 size_t l = ByteString::length(s);
328#if 0
329 __DCL_TRACE2(L"[%hs] [%zd]\n", s, l);
330#endif
331 if (l <= *_size) {
332 memcpy(_buf, s, l);
333 *_size = l;
334 PGTYPESchar_free(s);
335 }
336 else {
337 PGTYPESchar_free(s);
338 __SET_ERROR(SQL::eInvalidBufferSize);
339 return false;
340 }
341 break;
342 }
343 }
344 case SQL::typeBinary: {
345 switch (__sqlvar->sqltype) {
346 case ECPGt_char:
347 case ECPGt_unsigned_char:
348 case ECPGt_varchar:
349 case ECPGt_varchar2:
350 case ECPGt_bytea: {
351 if (__sqlvar->sqllen > 0 && *_size > 0) {
352 size_t nCopy = *_size;
353 if ((size_t)(__sqlvar->sqllen) < nCopy)
354 nCopy = (size_t)(__sqlvar->sqllen);
355
356 memcpy(_buf, __sqlvar->sqldata, nCopy);
357 if (nCopy < *_size) {
358 *((char*)_buf + nCopy) = '\0';
359 *_size = nCopy;
360 }
361 }
362 else
363 *_size = 0;
364 break;
365 }
366 default:
367 __DCL_ASSERT(false);
368 }
369 break;
370 }
371 case SQL::typeOutputStream: {
372 switch (__sqlvar->sqltype) {
373 case ECPGt_char:
374 case ECPGt_unsigned_char:
375 case ECPGt_varchar:
376 case ECPGt_varchar2:
377 case ECPGt_bytea: {
378 if ((size_t)(__sqlvar->sqllen) < *_size) {
379 *_size = (size_t)(__sqlvar->sqllen);
380 }
381 try {
382 ((OutputStream*)_buf)->write(
383 __sqlvar->sqldata,
384 *_size
385 );
386 }
387 catch (IOException* e) {
388 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
389 e->destroy();
390 return false;
391 }
392 break;
393 }
394 default:
395 __DCL_ASSERT(false);
396 }
397 break;
398 }
399 default:
400 __DCL_ASSERT(false); // SQL::Field::getData bug
401 }
402 return true;
403}
404
405bool PeField::getInteger(void* _buf, size_t* _size)
406{
407 switch (__sqlvar->sqltype) {
408 case ECPGt_short: {
409 switch (*_size) {
410 case sizeof(int16_t) : {
411 *(int16_t*)_buf = *(int16_t*)(__sqlvar->sqldata);
412 break;
413 }
414 case sizeof(int32_t) : {
415 *(int32_t*)_buf = (int32_t) * (int16_t*)(__sqlvar->sqldata);
416 break;
417 }
418 case sizeof(int64_t) : {
419 *(int64_t*)_buf = (int64_t) * (int16_t*)(__sqlvar->sqldata);
420 break;
421 }
422 default: {
423 *_size = sizeof(int16_t);
424 __SET_ERROR(SQL::eInvalidBufferSize);
425 return false;
426 }
427 }
428 break;
429 }
430#if ALIGNOF_LONG == 4
431 case ECPGt_long:
432#endif
433 case ECPGt_int: {
434 switch (*_size) {
435 case sizeof(int32_t) : {
436 *(int32_t*)_buf = *(int32_t*)(__sqlvar->sqldata);
437 break;
438 }
439 case sizeof(int64_t) : {
440 *(int64_t*)_buf = (int64_t) * (int32_t*)(__sqlvar->sqldata);
441 break;
442 }
443 default: {
444 *_size = sizeof(int32_t);
445 __SET_ERROR(SQL::eInvalidBufferSize);
446 return false;
447 }
448 }
449 break;
450 }
451#if ALIGNOF_LONG == 8
452 case ECPGt_long:
453#endif
454 case ECPGt_long_long: {
455 if (*_size == sizeof(int64_t)) {
456 *(int64_t*)_buf = (int64_t) * (int64_t*)(__sqlvar->sqldata);
457 }
458 else {
459 *_size = sizeof(int64_t);
460 __SET_ERROR(SQL::eInvalidBufferSize);
461 return false;
462 }
463 break;
464 }
465 case ECPGt_unsigned_long_long: {
466 if (*_size == sizeof(int64_t)) {
467 *(int64_t*)_buf = (int64_t) * (uint64_t*)(__sqlvar->sqldata);
468 }
469 else {
470 *_size = sizeof(int64_t);
471 __SET_ERROR(SQL::eInvalidBufferSize);
472 return false;
473 }
474 break;
475 }
476 case ECPGt_numeric:
477 case ECPGt_decimal: {
478#if ALIGNOF_LONG == 4
479 if (*_size <= sizeof(int32_t)) {
480#endif
481 long n;
482 if (__sqlvar->sqltype == ECPGt_numeric) {
483 if (PGTYPESnumeric_to_long(
484 (numeric*)(__sqlvar->sqldata), &n) != 0) {
485 __SET_ERROR(SQL::eOutOfRange);
486 return false;
487 }
488 }
489 else {
490 numeric nu;
491 if (PGTYPESnumeric_from_decimal(
492 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
493 __SET_ERROR(SQL::eOutOfRange);
494 return false;
495 }
496 if (PGTYPESnumeric_to_long(&nu, &n) != 0) {
497 __SET_ERROR(SQL::eOutOfRange);
498 return false;
499 }
500 }
501
502 switch (*_size) {
503 case sizeof(int8_t) : {
504 if (n < INT8_MIN || INT8_MAX < n) {
505 __SET_ERROR(SQL::eOutOfRange);
506 return false;
507 }
508 *(int8_t*)_buf = (int8_t)n;
509 break;
510 }
511 case sizeof(int16_t) : {
512 if (n < INT16_MIN || INT16_MAX < n) {
513 __SET_ERROR(SQL::eOutOfRange);
514 return false;
515 }
516 *(int16_t*)_buf = (int16_t)n;
517 break;
518 }
519 case sizeof(int32_t) : {
520#if ALIGNOF_LONG == 8
521 if (n < INT32_MIN || INT32_MAX < n) {
522 __SET_ERROR(SQL::eOutOfRange);
523 return false;
524 }
525#endif
526 *(int32_t*)_buf = (int32_t)n;
527 break;
528 }
529 case sizeof(int64_t) : {
530 *(int64_t*)_buf = (int64_t)n;
531 break;
532 }
533 default: {
534#if ALIGNOF_LONG == 4
535 *_size = sizeof(int32_t);
536#elif ALIGNOF_LONG == 8
537 *_size = sizeof(int64_t);
538#endif
539 __SET_ERROR(SQL::eInvalidBufferSize);
540 return false;
541 }
542 }
543#if ALIGNOF_LONG == 4
544 }
545 else if (*_size == sizeof(int64_t)) {
546 numeric* p = (numeric*)(__sqlvar->sqldata);
547 numeric nu;
548 if (__sqlvar->sqltype == ECPGt_decimal) {
549 if (PGTYPESnumeric_from_decimal(
550 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
551 __SET_ERROR(SQL::eOutOfRange);
552 return false;
553 }
554 p = &nu;
555 }
556 char* s = PGTYPESnumeric_to_asc(p, 0);
557 char* endptr;
558 long long n = strtoll(s, &endptr, 10);
559 PGTYPESchar_free(s);
560 if (n == LLONG_MAX || n == LLONG_MIN) {
561 __SET_ERROR(SQL::eOutOfRange);
562 return false;
563 }
564 *(int64_t*)_buf = n;
565 }
566 else {
567 *_size = sizeof(int64_t);
568 __SET_ERROR(SQL::eInvalidBufferSize);
569 return false;
570 }
571#endif
572 break;
573 }
574 default :
575 __DCL_ASSERT(false);
576 }
577 return true;
578}
579
580bool PeField::getUInteger(void* _buf, size_t* _size)
581{
582 switch(__sqlvar->sqltype) {
583 case ECPGt_bool: {
584 switch (*_size) {
585 case sizeof(uint8_t) : {
586 *(uint8_t*)_buf = (uint8_t) * (uint8_t*)(__sqlvar->sqldata);
587 break;
588 }
589 case sizeof(uint16_t) : {
590 *(uint16_t*)_buf = (uint16_t) * (uint8_t*)(__sqlvar->sqldata);
591 break;
592 }
593 case sizeof(uint32_t) : {
594 *(uint32_t*)_buf = (uint32_t) * (uint8_t*)(__sqlvar->sqldata);
595 break;
596 }
597 case sizeof(uint64_t) : {
598 *(uint64_t*)_buf = (uint64_t) * (uint8_t*)(__sqlvar->sqldata);
599 break;
600 }
601 default: {
602 *_size = sizeof(uint8_t);
603 __SET_ERROR(SQL::eInvalidBufferSize);
604 return false;
605 }
606 }
607 break;
608 }
609 case ECPGt_short: {
610 switch (*_size) {
611 case sizeof(uint16_t) : {
612 *(uint16_t*)_buf = (uint16_t) * (int16_t*)(__sqlvar->sqldata);
613 break;
614 }
615 case sizeof(uint32_t) : {
616 *(uint32_t*)_buf = (uint32_t) * (int16_t*)(__sqlvar->sqldata);
617 break;
618 }
619 case sizeof(uint64_t) : {
620 *(uint64_t*)_buf = (uint64_t) * (int16_t*)(__sqlvar->sqldata);
621 break;
622 }
623 default: {
624 *_size = sizeof(uint16_t);
625 __SET_ERROR(SQL::eInvalidBufferSize);
626 return false;
627 }
628 }
629 break;
630 }
631 case ECPGt_int:
632 case ECPGt_long: {
633 switch (*_size) {
634 case sizeof(uint32_t) : {
635 *(uint32_t*)_buf = (uint32_t) * (int32_t*)(__sqlvar->sqldata);
636 break;
637 }
638 case sizeof(int64_t) : {
639 *(uint64_t*)_buf = (uint64_t) * (int32_t*)(__sqlvar->sqldata);
640 break;
641 }
642 default: {
643 *_size = sizeof(int32_t);
644 __SET_ERROR(SQL::eInvalidBufferSize);
645 return false;
646 }
647 }
648 break;
649 }
650 case ECPGt_long_long: {
651 if (*_size == sizeof(int64_t)) {
652 *(uint64_t*)_buf = (uint64_t) * (int64_t*)(__sqlvar->sqldata);
653 }
654 else {
655 *_size = sizeof(int64_t);
656 __SET_ERROR(SQL::eInvalidBufferSize);
657 return false;
658 }
659 break;
660 }
661 case ECPGt_unsigned_long_long: {
662 if (*_size == sizeof(int64_t)) {
663 *(uint64_t*)_buf = (uint64_t) * (uint64_t*)(__sqlvar->sqldata);
664 }
665 else {
666 *_size = sizeof(int64_t);
667 __SET_ERROR(SQL::eInvalidBufferSize);
668 return false;
669 }
670 break;
671 }
672 case ECPGt_numeric:
673 case ECPGt_decimal: {
674 if (*_size <= sizeof(uint32_t)) {
675 long n;
676 if (__sqlvar->sqltype == ECPGt_numeric) {
677 if (PGTYPESnumeric_to_long(
678 (numeric*)(__sqlvar->sqldata), &n) != 0) {
679 __SET_ERROR(SQL::eOutOfRange);
680 return false;
681 }
682 }
683 else {
684 numeric nu;
685 if (PGTYPESnumeric_from_decimal(
686 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
687 __SET_ERROR(SQL::eOutOfRange);
688 return false;
689 }
690 if (PGTYPESnumeric_to_long(&nu, &n) != 0) {
691 __SET_ERROR(SQL::eOutOfRange);
692 return false;
693 }
694 }
695
696 switch (*_size) {
697 case sizeof(uint8_t) : {
698 if (n < INT8_MIN || INT8_MAX < n)
699 {
700 __SET_ERROR(SQL::eOutOfRange);
701 return false;
702 }
703 *(uint8_t*)_buf = (uint8_t)n;
704 break;
705 }
706 case sizeof(uint16_t) : {
707 if (n < INT16_MIN || INT16_MAX < n)
708 {
709 __SET_ERROR(SQL::eOutOfRange);
710 return false;
711 }
712 *(uint16_t*)_buf = (uint16_t)n;
713 break;
714 }
715 case sizeof(uint32_t) : {
716 *(uint32_t*)_buf = (uint32_t)n;
717 break;
718 }
719 default: {
720 *_size = sizeof(uint32_t);
721 __SET_ERROR(SQL::eInvalidBufferSize);
722 return false;
723 }
724 }
725 }
726 else if (*_size == sizeof(uint64_t)) {
727 numeric* p = (numeric*)(__sqlvar->sqldata);
728 numeric nu;
729 if (__sqlvar->sqltype == ECPGt_decimal) {
730 if (PGTYPESnumeric_from_decimal(
731 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
732 __SET_ERROR(SQL::eOutOfRange);
733 return false;
734 }
735 p = &nu;
736 }
737 char* s = PGTYPESnumeric_to_asc(p, 0);
738 char* endptr;
739 unsigned long long n = strtoull(s, &endptr, 10);
740 PGTYPESchar_free(s);
741 if (n == ULLONG_MAX) {
742 __SET_ERROR(SQL::eOutOfRange);
743 return false;
744 }
745 *(uint64_t*)_buf = n;
746 }
747 else {
748 *_size = sizeof(int64_t);
749 __SET_ERROR(SQL::eInvalidBufferSize);
750 return false;
751 }
752 break;
753 }
754 default :
755 __DCL_ASSERT(false); // PeField::init bug
756 }
757 return true;
758}
759
760bool PeField::getFloat(void* _buf, size_t* _size)
761{
762 switch (__sqlvar->sqltype) {
763 case ECPGt_float: {
764 switch (*_size) {
765 case sizeof(float) : {
766 *(float*)_buf = *(float*)(__sqlvar->sqldata);
767 break;
768 }
769 case sizeof(double) : {
770 *(double*)_buf = *(float*)(__sqlvar->sqldata);
771 break;
772 }
773 default: {
774 *_size = sizeof(float);
775 __SET_ERROR(SQL::eInvalidBufferSize);
776 return false;
777 }
778 }
779 break;
780 }
781 case ECPGt_double: {
782 switch (*_size) {
783 case sizeof(double) : {
784 *(double*)_buf = *(double*)(__sqlvar->sqldata);
785 break;
786 }
787 default: {
788 *_size = sizeof(double);
789 __SET_ERROR(SQL::eInvalidBufferSize);
790 return false;
791 }
792 }
793 break;
794 }
795 case ECPGt_numeric:
796 case ECPGt_decimal: {
797 double d;
798 if (__sqlvar->sqltype == ECPGt_numeric) {
799 if (PGTYPESnumeric_to_double(
800 (numeric*)(__sqlvar->sqldata), &d) != 0) {
801 __SET_ERROR(SQL::eOutOfRange);
802 return false;
803 }
804 }
805 else {
806 numeric nu;
807 if (PGTYPESnumeric_from_decimal(
808 (decimal*)(__sqlvar->sqldata), &nu) != 0) {
809 __SET_ERROR(SQL::eOutOfRange);
810 return false;
811 }
812 if (PGTYPESnumeric_to_double(&nu, &d) != 0) {
813 __SET_ERROR(SQL::eOutOfRange);
814 return false;
815 }
816 }
817
818 switch (*_size) {
819 case sizeof(float) : {
820 if (d < -FLT_MAX || FLT_MAX < d) {
821 __SET_ERROR(SQL::eOutOfRange);
822 return false;
823 }
824 *(float*)_buf = (float)d;
825 break;
826 }
827 case sizeof(double) : {
828 *(double*)_buf = (double)d;
829 break;
830 }
831 default: {
832 *_size = sizeof(double);
833 __SET_ERROR(SQL::eInvalidBufferSize);
834 return false;
835 }
836 }
837 break;
838 }
839 default :
840 __DCL_ASSERT(false);
841 }
842
843 return true;
844}
845
846__DCL_END_NAMESPACE
__THIS_FILE__
#define __THIS_FILE__
Definition _trace.h:14
NULL
#define NULL
Definition Config.h:312
INT32_MAX
#define INT32_MAX
Definition Config.h:290
char_t
wchar_t char_t
Definition Config.h:247
INT32_MIN
#define INT32_MIN
Definition Config.h:285
INT8_MIN
#define INT8_MIN
Definition Config.h:283
INT8_MAX
#define INT8_MAX
Definition Config.h:288
INT16_MAX
#define INT16_MAX
Definition Config.h:289
INT16_MIN
#define INT16_MIN
Definition Config.h:284
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.cpp:50
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:304
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:394
__DCL_TRACE4
#define __DCL_TRACE4(fmt, arg1, arg2, arg3, arg4)
Definition Object.h:402
IMPLEMENT_CLASSINFO
#define IMPLEMENT_CLASSINFO(class_name, base_class_name)
Definition Object.h:245
__T
#define __T(str)
Definition Object.h:60
__DCL_TRACE2
#define __DCL_TRACE2(fmt, arg1, arg2)
Definition Object.h:400
__dataTypeName
const wchar_t * __dataTypeName(const sqlvar_t *_sqlvar)
Definition PeField.cpp:190
SQLTYPE_NAME
#define SQLTYPE_NAME(_dataType, name)
Definition PeField.cpp:188
__decode
__DCL_BEGIN_NAMESPACE void __decode(const date *_s, SQL::Date *_r)
Definition PeTypes.cpp:27
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:149
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
PeField::getFloat
bool getFloat(void *_buf, size_t *_size)
Definition PeField.cpp:760
PeField::init
bool init(SQL::Query *_query, sqlvar_t *_sqlvar)
Definition PeField.cpp:56
PeField::__getData
virtual bool __getData(void *_buf, size_t *_size, SQL::DataType _bufType)
Definition PeField.cpp:263
PeField::serverDataTypeName
virtual const wchar_t * serverDataTypeName() const
Definition PeField.cpp:229
PeField::getInteger
bool getInteger(void *_buf, size_t *_size)
Definition PeField.cpp:405
PeField::__getDataSize
virtual bool __getDataSize(size_t *_size, bool _maxsize)
Definition PeField.cpp:234
PeField::getUInteger
bool getUInteger(void *_buf, size_t *_size)
Definition PeField.cpp:580
PeField::onAfterFetch
bool onAfterFetch(sqlvar_t *_sqlvar)
Definition PeField.cpp:182
PeField::~PeField
virtual ~PeField()
Definition PeField.cpp:51
SQL::DataType
DataType
Definition SQLCore.h:59
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:74
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:64
SQL::typeTime
@ typeTime
Definition SQLCore.h:66
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:62
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:68
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:70
SQL::typeDate
@ typeDate
Definition SQLCore.h:65
SQL::typeOutputStream
@ typeOutputStream
Definition SQLCore.h:82
SQL::typeText
@ typeText
Definition SQLCore.h:73
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:63
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:61
SQL::eOutOfRange
@ eOutOfRange
Definition SQLCore.h:52
SQL::eInvalidBufferSize
@ eInvalidBufferSize
Definition SQLCore.h:50