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