DCL 3.7.4
Loading...
Searching...
No Matches
SQLField.cpp
Go to the documentation of this file.
1#include <dcl/Config.h>
2
3#ifdef __WINNT__
4 #include <windows.h>
5#else
6 #include <time.h> // struct tm
7#endif
8
9#include <string.h> // memset
10#include <wctype.h> // iswdigit
11#include <float.h> // FLT_MAX
12#include <math.h> // modf
13#include <wchar.h> // wcsftime
14
15#include <dcl/Object.h>
16
17#if __DCL_HAVE_ALLOC_DEBUG
18#undef __DCL_ALLOC_LEVEL
19#define __DCL_ALLOC_LEVEL __DCL_ALLOC_INTERNAL
20#endif
21
22#include <dcl/Charset.h>
23#include <dcl/SQL.h>
24
25#if __DCL_HAVE_THIS_FILE__
26#undef __THIS_FILE__
27static const char_t __THIS_FILE__[] = __T("dcl/SQLField.cpp");
28#endif
29
30__DCL_BEGIN_NAMESPACE
31
33
41
45
46const String& SQLField::name() const
47{
48 __DCL_ASSERT(__handle != NULL);
49 return __handle->name();
50}
51
52SQL::DataType SQLField::dataType() const
53{
54 __DCL_ASSERT(__handle != NULL);
55 return __handle->dataType();
56}
57
58const wchar_t* SQLField::serverDataTypeName() const
59{
60 __DCL_ASSERT(__handle != NULL);
61 return __handle->serverDataTypeName();
62}
63
64short SQLField::precision() const
65{
66 __DCL_ASSERT(__handle != NULL);
67 return __handle->precision();
68}
69
70short SQLField::scale() const
71{
72 __DCL_ASSERT(__handle != NULL);
73 return __handle->scale();
74}
75
76bool SQLField::isNull() __DCL_THROWS1(SQLException*)
77{
78 __DCL_ASSERT(__handle != NULL);
79 size_t size = (size_t)-1;
80 if (!__handle->getNull(&size)) {
81 throw new SQLException(this, NULL);
82 }
83 return size == (size_t)-1;
84}
85
86size_t SQLField::getDataSize(bool _maxsize)__DCL_THROWS1(SQLException*)
87{
88 __DCL_ASSERT(__handle != NULL);
89 size_t size = (size_t)-1;
90 if (!__handle->getDataSize(&size, _maxsize)) {
91 throw new SQLException(this, NULL);
92 }
93 return size;
94}
95
96void SQLField::getData(
97 void* _buf, // buffer
98 size_t* _size, // sizeof *_buf
99 SQL::DataType _bufType // buffer data type
100) __DCL_THROWS1(SQLException*)
101{
102 __DCL_ASSERT(__handle != NULL);
103 __DCL_ASSERT(!isNull());
104
105 if (!__handle->getData(_buf, _size, _bufType)) {
106 throw new SQLException(this, NULL);
107 }
108}
109
111
112void SQLField::getValue(int8_t& _val) __DCL_THROWS1(SQLException*)
113{
114 __DCL_ASSERT(dataType() == SQL::typeInteger
115 || dataType() == SQL::typeNumeric);
116
117 size_t size = sizeof(int8_t);
118 getData(&_val, &size, SQL::typeInteger);
119}
120
121void SQLField::getValue(uint8_t& _val) __DCL_THROWS1(SQLException*)
122{
123 __DCL_ASSERT(dataType() == SQL::typeUInteger
124 || dataType() == SQL::typeNumeric);
125
126 size_t size = sizeof(uint8_t);
127 getData(&_val, &size, SQL::typeUInteger);
128}
129
130void SQLField::getValue(int16_t& _val) __DCL_THROWS1(SQLException*)
131{
132 __DCL_ASSERT(dataType() == SQL::typeInteger
133 || dataType() == SQL::typeNumeric);
134
135 size_t size = sizeof(int16_t);
136 getData(&_val, &size, SQL::typeInteger);
137}
138
139void SQLField::getValue(uint16_t& _val) __DCL_THROWS1(SQLException*)
140{
141 __DCL_ASSERT(dataType() == SQL::typeUInteger
142 || dataType() == SQL::typeNumeric);
143
144 size_t size = sizeof(uint16_t);
145 getData(&_val, &size, SQL::typeUInteger);
146}
147
148void SQLField::getValue(int32_t& _val) __DCL_THROWS1(SQLException*)
149{
150 __DCL_ASSERT(dataType() == SQL::typeInteger
151 || dataType() == SQL::typeNumeric);
152
153 size_t size = sizeof(int32_t);
154 getData(&_val, &size, SQL::typeInteger);
155}
156
157void SQLField::getValue(uint32_t& _val) __DCL_THROWS1(SQLException*)
158{
159 __DCL_ASSERT(dataType() == SQL::typeUInteger
160 || dataType() == SQL::typeNumeric);
161
162 size_t size = sizeof(uint32_t);
163 getData(&_val, &size, SQL::typeUInteger);
164}
165
166void SQLField::getValue(int64_t& _val) __DCL_THROWS1(SQLException*)
167{
168 __DCL_ASSERT(dataType() == SQL::typeInteger
169 || dataType() == SQL::typeNumeric);
170
171 size_t size = sizeof(int64_t);
172 getData(&_val, &size, SQL::typeInteger);
173}
174
175void SQLField::getValue(uint64_t& _val) __DCL_THROWS1(SQLException*)
176{
177 __DCL_ASSERT(dataType() == SQL::typeUInteger
178 || dataType() == SQL::typeNumeric);
179
180 size_t size = sizeof(uint64_t);
181 getData(&_val, &size, SQL::typeUInteger);
182}
183
184void SQLField::getValue(float& _val) __DCL_THROWS1(SQLException*)
185{
186 __DCL_ASSERT(dataType() == SQL::typeFloat
187 || dataType() == SQL::typeNumeric);
188
189 size_t size = sizeof(float);
190 getData(&_val, &size, SQL::typeFloat);
191}
192
193void SQLField::getValue(double& _val) __DCL_THROWS1(SQLException*)
194{
195 __DCL_ASSERT(dataType() == SQL::typeFloat
196 || dataType() == SQL::typeNumeric);
197
198 size_t size = sizeof(double);
199 getData(&_val, &size, SQL::typeFloat);
200}
201
202void SQLField::getValue(SQL::Date& _val) __DCL_THROWS1(SQLException*)
203{
204 __DCL_ASSERT(dataType() == SQL::typeDate);
205
206 size_t size = sizeof(SQL::Date);
207 getData(&_val, &size, SQL::typeDate);
208}
209
210void SQLField::getValue(SQL::Time& _val) __DCL_THROWS1(SQLException*)
211{
212 __DCL_ASSERT(dataType() == SQL::typeTime
213 || dataType() == SQL::typeTimeTz);
214
215 size_t size = sizeof(SQL::Time);
216 getData(&_val, &size, SQL::typeTime);
217}
218
219void SQLField::getValue(SQL::TimeStamp& _val) __DCL_THROWS1(SQLException*)
220{
221 __DCL_ASSERT(dataType() == SQL::typeTimeStamp
222 || dataType() == SQL::typeTimeStampTz);
223
224 size_t size = sizeof(SQL::TimeStamp);
225 getData(&_val, &size, SQL::typeTimeStamp);
226}
227
228void SQLField::getValue(SQL::Interval& _val) __DCL_THROWS1(SQLException*)
229{
230 __DCL_ASSERT(dataType() == SQL::typeInterval
231 || dataType() == SQL::typeIntervalYm
232 || dataType() == SQL::typeIntervalDs);
233
234 size_t size = sizeof(SQL::Interval);
235 getData(&_val, &size, SQL::typeInterval);
236}
237
238void SQLField::getValue(String& _val)
239 __DCL_THROWS1(SQLException*)
240{
241 __DCL_ASSERT((dataType() == SQL::typeNumeric)
242 || (dataType() == SQL::typeText)
243 || (dataType() == SQL::typeLongText)
244 || (dataType() == SQL::typeClob)
245 );
246
247 ByteString val;
248 getValue(val, SQL::typeText);
249 try {
250 _val = UTF8Decoder::decode(val);
251 }
252 catch(CharsetConvertException* _cause) {
253 throw new SQLException(this, _cause);
254 }
255}
256
257void SQLField::getValue(
258 ByteString& _val,
259 SQL::DataType _bufType // = SQL::typeBinary
260) __DCL_THROWS1(SQLException*)
261{
262 __DCL_ASSERT((dataType() == SQL::typeNumeric)
263 || (dataType() == SQL::typeText)
264 || (dataType() == SQL::typeLongText)
265 || (dataType() == SQL::typeClob)
266 || (dataType() == SQL::typeBinary)
267 || (dataType() == SQL::typeLongBinary)
268 || (dataType() == SQL::typeBlob));
269 __DCL_ASSERT((_bufType == SQL::typeText)
270 || (_bufType == SQL::typeBinary));
271
272 size_t size = dataSize(); // current size
273 __DCL_ASSERT(size <= UINT32_MAX);
274
275 ByteBuffer* buf = ByteBuffer::create(size);
276 try {
277 getData(buf->data(), &size, _bufType);
278 buf->__dataLength = size;
279 _val.assign(buf);
280 buf->release();
281 }
282 catch (SQLException* e) {
283 buf->release();
284 throw e;
285 }
286}
287
288void SQLField::getValue(
289 OutputStream& _output,
290 size_t _size
291) __DCL_THROWS1(SQLException*)
292{
293 __DCL_ASSERT((dataType() == SQL::typeText)
294 || (dataType() == SQL::typeBinary)
295 || (dataType() == SQL::typeLongText)
296 || (dataType() == SQL::typeLongBinary)
297 || (dataType() == SQL::typeClob)
298 || (dataType() == SQL::typeBlob)
299 );
300 getData(&_output, &_size, SQL::typeOutputStream);
301}
302
303bool SQLField::asBoolean() __DCL_THROWS1(SQLException*)
304{
305 static const char_t* _cast = __T("asBoolean");
306 bool result = false;
307 switch(dataType()) {
308 case SQL::typeInteger :
309 case SQL::typeUInteger: {
310 int64_t _val = 0;
311 getValue(_val);
312 result = _val != (int64_t)0;
313 break;
314 }
315 case SQL::typeFloat: {
316 double _val;
317 getValue(_val);
318 result = _val != 0.;
319 break;
320 }
321 case SQL::typeNumeric: {
322 String _val;
323 getValue(_val);
324 const wchar_t* p = (const wchar_t*)_val;
325 while (*p) {
326 if (iswdigit(*p)) {
327 if (*p != __T('0')) {
328 result = true;
329 break;
330 }
331 }
332 else {
333 if (*p != __T('.')) {
334 result = true;
335 break;
336 }
337 }
338 p++;
339 }
340 break;
341 }
342 case SQL::typeText: {
343 String _val;
344 getValue(_val);
345 const wchar_t* p = (const wchar_t*)_val;
346 if (_val.length() == 1) {
347 if (!(*p == __T(' ') || *p == __T('0')
348 || *p == __T('f') || *p == __T('F')))
349 result = true;
350 }
351 else {
352 while (*p) {
353 if (!(*p == __T(' ') || *p == __T('0'))) {
354 result = true;
355 break;
356 }
357 p++;
358 }
359 }
360 break;
361 }
362 default : {
363 // invalid data-type
364 throw new SQLException(
365 this,
366 _cast,
367 SQLException::eInvalidCast
368 );
369 }
370 }
371
372 return result;
373}
374
375int32_t SQLField::asInt32() __DCL_THROWS1(SQLException*)
376{
377 static const char_t* _cast = __T("asInt32");
378 int32_t result = 0;
379 switch(dataType()) {
380 case SQL::typeInteger: {
381 if (dataSizeMax() <= sizeof(int32_t))
382 getValue(result);
383 else {
384 int64_t _val;
385 getValue(_val);
386 if (_val < (int64_t)INT32_MIN || (int64_t)INT32_MAX < _val) {
387 throw new SQLException(
388 this,
389 _cast,
390 SQLException::eOutOfRange
391 );
392 }
393 result = (int32_t)_val;
394 }
395 break;
396 }
397 case SQL::typeUInteger: {
398 if (dataSizeMax() <= sizeof(uint32_t))
399 getValue((uint32_t&)result);
400 else {
401 uint64_t _val;
402 getValue(_val);
403 if ((uint64_t)UINT32_MAX < _val) {
404 throw new SQLException(
405 this,
406 _cast,
407 SQLException::eOutOfRange
408 );
409 }
410 result = (int32_t)_val;
411 }
412 break;
413 }
414 case SQL::typeFloat: {
415 double _val;
416 getValue(_val);
417 double i;
418 modf(_val, &i);
419 if (i < (double)INT32_MIN || (double)INT32_MAX < i) {
420 throw new SQLException(
421 this,
422 _cast,
423 SQLException::eOutOfRange
424 );
425 }
426 result = (int32_t)i;
427 break;
428 }
429 case SQL::typeNumeric: {
430 getValue(result);
431 break;
432 }
433 case SQL::typeText: {
434 String _val;
435 getValue(_val);
436
437 size_t index = _val.indexOf(__T('e'));
438 if (index == (size_t)-1)
439 index = _val.indexOf(__T('E'));
440 if (index != (size_t)-1) {
441 // float format string
442 double d = 0.;
443 try {
444 d = Double::parse(_val);
445 }
446 catch (NumericConvertException* e) {
447 throw new SQLException(this, _cast, e);
448 }
449 double i;
450 modf(d, &i);
451 if (i < (double)INT32_MIN || (double)INT32_MAX < i) {
452 throw new SQLException(
453 this,
454 _cast,
455 SQLException::eOutOfRange
456 );
457 }
458 result = (int32_t)i;
459 }
460 else {
461 // decimal point
462 index = _val.indexOf(__T('.'));
463 if (index != (size_t)-1)
464 _val = _val.left(index);
465 //_val.setLength(index);
466
467 try {
468 result = Int32::parse(_val, 10);
469 }
470 catch (NumericConvertException* e) {
471 // ERANGE
472 throw new SQLException(this, _cast, e);
473 }
474 }
475 break;
476 }
477 default : {
478 // invalid data-type
479 throw new SQLException(
480 this,
481 _cast,
482 SQLException::eInvalidCast
483 );
484 }
485 }
486
487 return result;
488}
489
490int64_t SQLField::asInt64() __DCL_THROWS1(SQLException*)
491{
492 static const char_t* _cast = __T("asInt64");
493 int64_t result = 0;
494 switch(dataType()) {
495 case SQL::typeInteger: {
496 getValue(result);
497 break;
498 }
499 case SQL::typeUInteger: {
500 uint64_t _val;
501 getValue(_val);
502 result = (int64_t)_val;
503 break;
504 }
505 case SQL::typeFloat: {
506 double _val;
507 getValue(_val);
508 double i;
509 modf(_val, &i);
510 if (i < (double)INT64_MIN || (double)INT64_MAX < i) {
511 throw new SQLException(
512 this,
513 _cast,
514 SQLException::eOutOfRange
515 );
516 }
517 result = (int64_t)_val;
518 break;
519 }
520 case SQL::typeNumeric: {
521 getValue(result);
522 break;
523 }
524 case SQL::typeText: {
525 String _val;
526 getValue(_val);
527 size_t index = _val.indexOf(__T('e'));
528 if (index == (size_t)-1)
529 index = _val.indexOf(__T('E'));
530 if (index != (size_t)-1) {
531 // float format string
532 double d = 0.;
533 try {
534 d = Double::parse(_val);
535 }
536 catch (NumericConvertException* e) {
537 throw new SQLException(this, _cast, e);
538 }
539 double i;
540 modf(d, &i);
541 if (i < (double)INT64_MIN || (double)INT64_MAX < i) {
542 throw new SQLException(
543 this,
544 _cast,
545 SQLException::eOutOfRange
546 );
547 }
548 result = (int64_t)i;
549 }
550 else {
551 // decimal point
552 index = _val.indexOf('.');
553 if (index != (size_t)-1)
554 _val = _val.left(index);
555 //_val.setLength(index);
556
557 try {
558 result = Int64::parse(_val, 10);
559 }
560 catch (NumericConvertException* e) {
561 // ERANGE
562 throw new SQLException(this, _cast, e);
563 }
564 }
565 break;
566 }
567 default: {
568 // invalid data-type
569 throw new SQLException(
570 this,
571 _cast,
572 SQLException::eInvalidCast
573 );
574 }
575 }
576
577 return result;
578}
579
580float SQLField::asSingle() __DCL_THROWS1(SQLException*)
581{
582 static const char_t* _cast = __T("asSingle");
583 float result = 0.;
584 switch(dataType()) {
585 case SQL::typeFloat: {
586 if (dataSizeMax() <= sizeof(float))
587 getValue(result);
588 else {
589 double _val;
590 getValue(_val);
591 if (_val < -FLT_MAX || FLT_MAX < _val) {
592 throw new SQLException(
593 this,
594 _cast,
595 SQLException::eOutOfRange
596 );
597 }
598 result = (float)_val;
599 }
600 break;
601 }
602 case SQL::typeInteger: {
603 if (dataSizeMax() <= sizeof(int32_t)) {
604 int32_t _val;
605 getValue(_val);
606 result = (float)_val;
607 }
608 else {
609 int64_t _val;
610 getValue(_val);
611 result = (float)_val;
612 }
613 }
614 case SQL::typeUInteger: {
615 if (dataSizeMax() <= sizeof(uint32_t)) {
616 uint32_t _val;
617 getValue(_val);
618 result = (float)_val;
619 }
620 else {
621 uint64_t _val;
622 getValue(_val);
623 result = (float)_val;
624 }
625 break;
626 }
627 case SQL::typeNumeric: {
628 getValue(result);
629 break;
630 }
631 case SQL::typeText: {
632 String _val;
633 getValue(_val);
634
635 try {
636 result = Single::parse(_val);
637 }
638 catch (NumericConvertException* e) {
639 // ERANGE
640 throw new SQLException(this, _cast, e);
641 }
642 break;
643 }
644 default : {
645 // invalid data-type
646 throw new SQLException(
647 this,
648 _cast,
649 SQLException::eInvalidCast
650 );
651 }
652 }
653
654 return result;
655}
656
657double SQLField::asDouble() __DCL_THROWS1(SQLException*)
658{
659 static const char_t* _cast = __T("asDouble");
660 double result = 0.;
661 switch(dataType()) {
662 case SQL::typeFloat: {
663 getValue(result);
664 break;
665 }
666 case SQL::typeInteger: {
667 if (dataSizeMax() <= sizeof(int32_t)) {
668 int32_t _val;
669 getValue(_val);
670 result = (double)_val;
671 }
672 else {
673 int64_t _val;
674 getValue(_val);
675 result = (double)_val;
676 }
677 break;
678 }
679 case SQL::typeUInteger: {
680 if (dataSizeMax() <= sizeof(uint32_t)) {
681 uint32_t _val;
682 getValue(_val);
683 result = (double)_val;
684 }
685 else {
686 uint64_t _val;
687 getValue(_val);
688 result = (double)_val;
689 }
690 break;
691 }
692 case SQL::typeNumeric: {
693 getValue(result);
694 break;
695 }
696 case SQL::typeText: {
697 String _val;
698 getValue(_val);
699
700 try {
701 result = Double::parse(_val);
702 }
703 catch (NumericConvertException* e) {
704 // ERANGE
705 throw new SQLException(this, _cast, e);
706 }
707 break;
708 }
709 default : {
710 // invalid data-type
711 throw new SQLException(
712 this,
713 _cast,
714 SQLException::eInvalidCast
715 );
716 }
717 }
718
719 return result;
720}
721
722Date SQLField::asDate() __DCL_THROWS1(SQLException*)
723{
724 static const char_t* _cast = __T("asDate");
725 Date result;
726
727 switch(dataType()) {
728 case SQL::typeDate: {
729 SQL::Date _val;
730 getValue(_val);
731 result.assign(_val.year, _val.month, _val.day);
732 break;
733 }
734 case SQL::typeTimeStamp :
735 case SQL::typeTimeStampTz: {
736 SQL::TimeStamp _val;
737 getValue(_val);
738 result.assign(_val.year, _val.month, _val.day);
739 break;
740 }
741 default : {
742 // invalid data-type
743 throw new SQLException(
744 this,
745 _cast,
746 SQLException::eInvalidCast
747 );
748 }
749 }
750
751 return result;
752}
753
754Time SQLField::asTime() __DCL_THROWS1(SQLException*)
755{
756 static const char_t* _cast = __T("asTime");
757 Time result;
758
759 switch(dataType()) {
760 case SQL::typeTime:
761 case SQL::typeTimeTz: {
762 SQL::Time _val;
763 getValue(_val);
764 result.assign(
765 _val.hour,
766 _val.min,
767 _val.sec,
768 _val.frac / 1000000
769 );
770 break;
771 }
772 case SQL::typeTimeStamp :
773 case SQL::typeTimeStampTz: {
774 SQL::TimeStamp _val;
775 getValue(_val);
776 result.assign(
777 _val.hour,
778 _val.min,
779 _val.sec,
780 _val.frac / 1000000
781 );
782 break;
783 }
784 default : {
785 // invalid data-type
786 throw new SQLException(
787 this,
788 _cast,
789 SQLException::eInvalidCast
790 );
791 }
792 }
793
794 return result;
795}
796
797DateTime SQLField::asDateTime() __DCL_THROWS1(SQLException*)
798{
799 static const char_t* _cast = __T("asDateTime");
800 DateTime result;
801
802 switch(dataType()) {
803 case SQL::typeTimeStamp :
804 case SQL::typeTimeStampTz: {
805 SQL::TimeStamp _val;
806 getValue(_val);
807 result.assign(
808 _val.year,
809 _val.month,
810 _val.day,
811 _val.hour,
812 _val.min,
813 _val.sec,
814 _val.frac / 1000000
815 );
816 break;
817 }
818 case SQL::typeDate: {
819 SQL::Date _val;
820 getValue(_val);
821 result.date().assign(
822 _val.year,
823 _val.month,
824 _val.day
825 );
826 break;
827 }
828 case SQL::typeTime:
829 case SQL::typeTimeTz: {
830 SQL::Time _val;
831 getValue(_val);
832 result.time().assign(
833 _val.hour,
834 _val.min,
835 _val.sec,
836 _val.frac / 1000000
837 );
838 break;
839 }
840 default : {
841 // invalid data-type
842 throw new SQLException(
843 this,
844 _cast,
845 SQLException::eInvalidCast
846 );
847 }
848 }
849
850 return result;
851}
852
853static inline int __ABS(int _n)
854{
855 return _n < 0 ? -_n : _n;
856}
857
858Interval SQLField::asInterval() __DCL_THROWS1(SQLException*)
859{
860 static const char_t* _cast = __T("asInterval");
861 Interval result;
862
863 switch(dataType()) {
864 case SQL::typeIntervalYm: {
865 SQL::Interval _val;
866 getValue(_val);
867 if (__ABS(_val.years) > 5965231) {
868 // YEAR TO MONTH의 경우 5965231년 4개월 까지만 유효
869 throw new SQLException(
870 this,
871 _cast,
872 SQLException::eOutOfRange
873 );
874 }
875 result.assign(
876 _val.years * 360 + _val.months * 30,
877 0
878 );
879 break;
880 }
881 case SQL::typeIntervalDs: {
882 SQL::Interval _val;
883 getValue(_val);
884 result.assign(
885 _val.days,
886 _val.hours,
887 _val.mins,
888 _val.secs,
889 _val.fracs / 1000000
890 );
891 break;
892 }
893 case SQL::typeInterval: {
894 SQL::Interval _val;
895 getValue(_val);
896 if (__ABS(_val.years) > 5965231) {
897 // YEAR TO MONTH의 경우 5965231년 4개월 까지만 유효
898 throw new SQLException(
899 this,
900 _cast,
901 SQLException::eOutOfRange
902 );
903 }
904 result.assign(
905 _val.days + _val.years * 360 + _val.months * 30,
906 _val.hours,
907 _val.mins,
908 _val.secs,
909 _val.fracs / 1000000
910 );
911 break;
912 }
913 default : {
914 // invalid data-type
915 throw new SQLException(
916 this,
917 _cast,
918 SQLException::eInvalidCast
919 );
920 }
921 }
922 return result;
923}
924
925String SQLField::asString()
926 __DCL_THROWS1(SQLException*)
927{
928 String result;
929 size_t nDataSize = dataSize(); // current size
930 switch(dataType()) {
931 case SQL::typeInteger: {
932 if (nDataSize <= sizeof(int32_t)) {
933 int32_t _val;
934 getValue(_val);
935 result = Int32::toString(_val, 10);
936 }
937 else {
938 int64_t _val;
939 getValue(_val);
940 result = Int64::toString(_val, 10);
941 }
942 break;
943 }
944 case SQL::typeUInteger: {
945 if (nDataSize <= sizeof(int32_t)) {
946 uint32_t _val;
947 getValue(_val);
948 result = UInt32::toString(_val, 10);
949 }
950 else {
951 uint64_t _val;
952 getValue(_val);
953 result = UInt64::toString(_val, 10);
954 }
955 break;
956 }
957 case SQL::typeFloat: {
958 if (nDataSize == sizeof(float)) {
959 float _val;
960 getValue(_val);
961 result = Single::toString(_val, NULL);
962 }
963 else {
964 double _val;
965 getValue(_val);
966 result = Double::toString(_val, NULL);
967 }
968 break;
969 }
970 case SQL::typeNumeric: {
971 getValue(result);
972 break;
973 }
974 case SQL::typeDate: {
975 SQL::Date _val;
976 getValue(_val);
977 result = String::format(
978 __T("%04d-%02d-%02d"),
979 __ABS(_val.year),
980 _val.month,
981 _val.day
982 );
983 if (_val.year < 0) {
984 result = result + L" BC";
985 }
986 break;
987 }
988 case SQL::typeTime: {
989 SQL::Time _val;
990 getValue(_val);
991 result = String::format(
992 __T("%02d:%02d:%02d.%06d"),
993 _val.hour,
994 _val.min,
995 _val.sec,
996 _val.frac / 1000
997 );
998 break;
999 }
1000 case SQL::typeTimeTz: {
1001 SQL::Time _val;
1002 getValue(_val);
1003 result = String::format(
1004 __T("%02d:%02d:%02d.%06d %+03d:%02d"),
1005 _val.hour,
1006 _val.min,
1007 _val.sec,
1008 _val.frac / 1000,
1009 _val.tzoff / 60,
1010 __ABS(_val.tzoff % 60)
1011 );
1012 break;
1013 }
1014 case SQL::typeTimeStamp: {
1015 SQL::TimeStamp _val;
1016 getValue(_val);
1017 result = String::format(
1018 __T("%04d-%02d-%02d %02d:%02d:%02d.%06d"),
1019 __ABS(_val.year),
1020 _val.month,
1021 _val.day,
1022 _val.hour,
1023 _val.min,
1024 _val.sec,
1025 _val.frac / 1000
1026 );
1027 if (_val.year < 0) {
1028 result = result + L" BC";
1029 }
1030 break;
1031 }
1032 case SQL::typeTimeStampTz: {
1033 SQL::TimeStamp _val;
1034 getValue(_val);
1035 result = String::format(
1036 __T("%04d-%02d-%02d %02d:%02d:%02d.%06d %+03d:%02d"),
1037 __ABS(_val.year),
1038 _val.month,
1039 _val.day,
1040 _val.hour,
1041 _val.min,
1042 _val.sec,
1043 _val.frac / 1000,
1044 _val.tzoff / 60,
1045 __ABS(_val.tzoff % 60)
1046 );
1047 if (_val.year < 0) {
1048 result = result + L" BC";
1049 }
1050 break;
1051 }
1052 case SQL::typeInterval: {
1053 SQL::Interval _val;
1054 getValue(_val);
1055 if (_val.years < 0 || _val.months < 0) {
1056 result = String::format(
1057 // 20,
1058 __T("-%d-%02d"),
1059 -_val.years,
1060 -_val.months
1061 );
1062 }
1063 else if (_val.years > 0 || _val.months > 0) {
1064 result = String::format(
1065 // 20,
1066 __T("+%d-%02d"),
1067 _val.years,
1068 _val.months
1069 );
1070 }
1071 else if (_val.days < 0
1072 || _val.hours < 0 || _val.mins < 0
1073 || _val.secs < 0 || _val.fracs < 0
1074 ) {
1075 result = String::format(
1076 // 30, // 24,
1077 __T("-%d %02d:%02d:%02d.%06d"),
1078 -(_val.days),
1079 -(_val.hours),
1080 -(_val.mins),
1081 -(_val.secs),
1082 -(_val.fracs / 1000)
1083 );
1084 }
1085 else {
1086 result = String::format(
1087 // 30, // 24 = 1 + 10 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 3
1088 __T("+%d %02d:%02d:%02d.%06d"),
1089 (_val.days),
1090 (_val.hours),
1091 (_val.mins),
1092 (_val.secs),
1093 (_val.fracs / 1000)
1094 );
1095 }
1096 break;
1097 }
1098 case SQL::typeIntervalYm: {
1099 SQL::Interval _val;
1100 getValue(_val);
1101 if (_val.years < 0 || _val.months < 0) {
1102 result = String::format(
1103 // 20,
1104 __T("-%d-%02d"),
1105 -_val.years,
1106 -_val.months
1107 );
1108 }
1109 else {
1110 result = String::format(
1111 // 20,
1112 __T("+%d-%02d"),
1113 _val.years,
1114 _val.months
1115 );
1116 }
1117 break;
1118 }
1119 case SQL::typeIntervalDs: {
1120 SQL::Interval _val;
1121 getValue(_val);
1122 if (_val.days < 0
1123 || _val.hours < 0 || _val.mins < 0
1124 || _val.secs < 0 || _val.fracs < 0
1125 ) {
1126 result = String::format(
1127 // 30, // 24,
1128 __T("-%d %02d:%02d:%02d.%06d"),
1129 -(_val.days),
1130 -(_val.hours),
1131 -(_val.mins),
1132 -(_val.secs),
1133 -(_val.fracs / 1000)
1134 );
1135 }
1136 else {
1137 result = String::format(
1138 // 30, // 24 = 1 + 10 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 3
1139 __T("+%d %02d:%02d:%02d.%06d"),
1140 (_val.days),
1141 (_val.hours),
1142 (_val.mins),
1143 (_val.secs),
1144 (_val.fracs / 1000)
1145 );
1146 }
1147 break;
1148 }
1149 case SQL::typeText :
1150 case SQL::typeLongText :
1151 case SQL::typeClob: {
1152 getValue(result);
1153 break;
1154 }
1155 case SQL::typeBinary :
1156 case SQL::typeLongBinary :
1157 case SQL::typeBlob: {
1158 ByteString _val;
1159 getValue(_val);
1160 result = String::tryString(_val, 20);
1161 break;
1162 }
1163 default: {
1164 __DCL_ASSERT(false);
1165 }
1166 }
1167 return result;
1168}
1169
1170// Formatted String
1171String SQLField::asStringF(const char_t* _format /* = NULL */)
1172 __DCL_THROWS1(SQLException*)
1173{
1174 String result;
1175 size_t nDataSize = dataSize(); // current size
1176 switch(dataType()) {
1177 case SQL::typeInteger: {
1178 if (nDataSize <= sizeof(int32_t)) {
1179 int32_t _val;
1180 getValue(_val);
1181 result = Int32::toString(_val, _format);
1182 }
1183 else {
1184 int64_t _val;
1185 getValue(_val);
1186 result = Int64::toString(_val, _format);
1187 }
1188 break;
1189 }
1190 case SQL::typeUInteger: {
1191 if (nDataSize <= sizeof(uint32_t)) {
1192 uint32_t _val;
1193 getValue(_val);
1194 result = UInt32::toString(_val, _format);
1195 }
1196 else {
1197 uint64_t _val;
1198 getValue(_val);
1199 result = UInt64::toString(_val, _format);
1200 }
1201 break;
1202 }
1203 case SQL::typeFloat: {
1204 if (nDataSize == sizeof(float)) {
1205 float _val;
1206 getValue(_val);
1207 result = Single::toString(_val, _format);
1208 }
1209 else {
1210 double _val;
1211 getValue(_val);
1212 result = Double::toString(_val, _format);
1213 }
1214 break;
1215 }
1216 case SQL::typeNumeric: {
1217 getValue(result);
1218 break;
1219 }
1220 case SQL::typeDate: {
1221 if (!_format)
1222 _format = Date::FORMAT_STRING;
1223
1224 SQL::Date _val;
1225 getValue(_val);
1226
1227 struct tm t;
1228 memset(&t, 0, sizeof(struct tm));
1229 t.tm_year = _val.year - 1900;
1230 t.tm_mon = _val.month - 1;
1231 t.tm_mday = _val.day;
1232 t.tm_isdst = -1;
1233
1234 CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
1235 size_t count = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &t);
1236 __DCL_ASSERT(buf->__allocLength >= count);
1237 buf->__dataLength = count;
1238
1239 result.assign(buf);
1240 buf->release();
1241 break;
1242 }
1243 case SQL::typeTime:
1244 case SQL::typeTimeTz: {
1245 if (!_format)
1246 _format = Time::FORMAT_STRING;
1247
1248 SQL::Time _val;
1249 getValue(_val);
1250
1251 struct tm t;
1252 memset(&t, 0, sizeof(struct tm));
1253 t.tm_hour = _val.hour;
1254 t.tm_min = _val.min;
1255 t.tm_sec = _val.sec;
1256 t.tm_isdst = -1;
1257
1258 CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
1259 size_t count = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &t);
1260 __DCL_ASSERT(buf->__allocLength >= count);
1261 buf->__dataLength = count;
1262
1263 result.assign(buf);
1264 buf->release();
1265 break;
1266 }
1267 case SQL::typeTimeStamp:
1268 case SQL::typeTimeStampTz: {
1269 if (!_format)
1270 _format = DateTime::FORMAT_STRING;
1271
1272 SQL::TimeStamp _val;
1273 getValue(_val);
1274
1275 struct tm t;
1276 t.tm_year = _val.year - 1900;
1277 t.tm_mon = _val.month - 1;
1278 t.tm_mday = _val.day;
1279 t.tm_hour = _val.hour;
1280 t.tm_min = _val.min;
1281 t.tm_sec = _val.sec;
1282
1283 t.tm_wday = 0;
1284 t.tm_yday = 0;
1285 t.tm_isdst = -1;
1286
1287 CharBuffer* buf = CharBuffer::create(DATETIME_FORMAT_BUFFER_SIZE);
1288 size_t count = wcsftime(buf->data(), DATETIME_FORMAT_BUFFER_SIZE, _format, &t);
1289 __DCL_ASSERT(buf->__allocLength >= count);
1290 buf->__dataLength = count;
1291
1292 result.assign(buf);
1293 buf->release();
1294 break;
1295 }
1296 case SQL::typeInterval:
1297 case SQL::typeIntervalYm:
1298 case SQL::typeIntervalDs: {
1299 result = asString();
1300 break;
1301 }
1302 case SQL::typeText:
1303 case SQL::typeLongText:
1304 case SQL::typeClob: {
1305 getValue(result);
1306 break;
1307 }
1308 case SQL::typeBinary :
1309 case SQL::typeLongBinary :
1310 case SQL::typeBlob: {
1311 ByteString _val;
1312 getValue(_val);
1313 result = String::tryString(_val, 20);
1314 break;
1315 }
1316 default: {
1317 __DCL_ASSERT(false);
1318 }
1319 }
1320 return result;
1321}
1322
1323__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
INT64_MIN
#define INT64_MIN
Definition Config.h:286
UINT32_MAX
#define UINT32_MAX
Definition Config.h:295
INT64_MAX
#define INT64_MAX
Definition Config.h:291
__DCL_THROWS1
#define __DCL_THROWS1(e)
Definition Config.h:152
DATETIME_FORMAT_BUFFER_SIZE
#define DATETIME_FORMAT_BUFFER_SIZE
Definition DateTime.h:21
__ABS
#define __ABS(n)
Definition MyParam.cpp:145
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:394
IMPLEMENT_CLASSINFO
#define IMPLEMENT_CLASSINFO(class_name, base_class_name)
Definition Object.h:245
__T
#define __T(str)
Definition Object.h:60
Date::assign
void assign(int _year, int _month, int _day)
Definition DateTime.cpp:49
Date::FORMAT_STRING
static const wchar_t * FORMAT_STRING
Definition DateTime.h:66
DateTime::assign
void assign(time_t _timer)
Definition DateTime.cpp:750
DateTime::time
Time & time()
Definition DateTime.inl:162
DateTime::FORMAT_STRING
static const wchar_t * FORMAT_STRING
Definition DateTime.h:246
DateTime::date
Date & date()
Definition DateTime.inl:152
Double::parse
static double parse(const wchar_t *_number) __DCL_THROWS1(NumericConvertException *)
Definition Numeric.cpp:846
Double::toString
String toString() const
Definition Numeric.inl:153
Int32::toString
String toString(unsigned _base=10) const
Definition Numeric.inl:93
Int32::parse
static int32_t parse(const wchar_t *_number, unsigned _base=10) __DCL_THROWS1(NumericConvertException *)
Definition Numeric.cpp:264
Int64::toString
String toString(unsigned _base=10) const
Definition Numeric.inl:117
Int64::parse
static int64_t parse(const wchar_t *_number, unsigned _base=10) __DCL_THROWS1(NumericConvertException *)
Definition Numeric.cpp:511
Interval::assign
void assign(int _days, int _milliseconds)
Definition DateTime.cpp:570
SQLField
Definition SQL.h:48
SQLField::__handle
SQL::Field * __handle
Definition SQL.h:122
SQLField::~SQLField
virtual ~SQLField()
Definition SQLField.cpp:42
SQLField::__query
SQLQuery * __query
Definition SQL.h:123
SQL::DataType
DataType
Definition SQLCore.h:59
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:74
SQL::typeClob
@ typeClob
Definition SQLCore.h:77
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:64
SQL::typeTime
@ typeTime
Definition SQLCore.h:66
SQL::typeLongBinary
@ typeLongBinary
Definition SQLCore.h:76
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:62
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:68
SQL::typeBlob
@ typeBlob
Definition SQLCore.h:78
SQL::typeTimeStampTz
@ typeTimeStampTz
Definition SQLCore.h:69
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:70
SQL::typeIntervalDs
@ typeIntervalDs
Definition SQLCore.h:72
SQL::typeDate
@ typeDate
Definition SQLCore.h:65
SQL::typeOutputStream
@ typeOutputStream
Definition SQLCore.h:82
SQL::typeText
@ typeText
Definition SQLCore.h:73
SQL::typeTimeTz
@ typeTimeTz
Definition SQLCore.h:67
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:63
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:61
SQL::typeIntervalYm
@ typeIntervalYm
Definition SQLCore.h:71
SQL::typeLongText
@ typeLongText
Definition SQLCore.h:75
Single::toString
String toString() const
Definition Numeric.inl:141
Single::parse
static float parse(const wchar_t *_number) __DCL_THROWS1(NumericConvertException *)
Definition Numeric.cpp:740
Time::FORMAT_STRING
static const wchar_t * FORMAT_STRING
Definition DateTime.h:127
Time::assign
void assign(int _hour, int _min, int _sec, int _millisecond=0)
Definition DateTime.cpp:412
UInt32::toString
String toString(unsigned _base=10) const
Definition Numeric.inl:105
UInt64::toString
String toString(unsigned _base=10) const
Definition Numeric.inl:129
SQL::Date::year
int16_t year
Definition SQLCore.h:96
SQL::Date::month
uint8_t month
Definition SQLCore.h:97
SQL::Date::day
uint8_t day
Definition SQLCore.h:98
SQL::Interval::years
int32_t years
Definition SQLCore.h:126
SQL::Interval::days
int32_t days
Definition SQLCore.h:128
SQL::Interval::hours
int8_t hours
Definition SQLCore.h:129
SQL::Interval::mins
int8_t mins
Definition SQLCore.h:130
SQL::Interval::fracs
int32_t fracs
Definition SQLCore.h:132
SQL::Interval::months
int8_t months
Definition SQLCore.h:127
SQL::Interval::secs
int8_t secs
Definition SQLCore.h:131
SQL::Time::hour
uint8_t hour
Definition SQLCore.h:103
SQL::Time::sec
uint8_t sec
Definition SQLCore.h:105
SQL::Time::frac
uint32_t frac
Definition SQLCore.h:106
SQL::Time::min
uint8_t min
Definition SQLCore.h:104
SQL::Time::tzoff
int16_t tzoff
Definition SQLCore.h:107
SQL::TimeStamp::frac
uint32_t frac
Definition SQLCore.h:118
SQL::TimeStamp::tzoff
int16_t tzoff
Definition SQLCore.h:119
SQL::TimeStamp::min
uint8_t min
Definition SQLCore.h:116
SQL::TimeStamp::sec
uint8_t sec
Definition SQLCore.h:117
SQL::TimeStamp::hour
uint8_t hour
Definition SQLCore.h:115
SQL::TimeStamp::day
uint8_t day
Definition SQLCore.h:114
SQL::TimeStamp::year
int16_t year
Definition SQLCore.h:112
SQL::TimeStamp::month
uint8_t month
Definition SQLCore.h:113