?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removing dependency for Cache module in MMDB build
[csql.git] / src / storage / DataType.cxx
blobf86d62a45f7b62dd7837b33063119d4a29b4a5f9
1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 ***************************************************************************/
16 #include<os.h>
17 #include<DataType.h>
18 #include<Debug.h>
19 //#include<Config.h>
20 #define SmallestValJulDate (1721426)
21 #if defined(SOLARIS)
22 #undef _TIME_H
23 #endif
24
25
26 Date::Date(int year, int month, int day)
27 { YMDToJulian(year, month, day, julianDate); }
28 int Date::set(int year, int month, int day)
29 { return YMDToJulian(year,month,day,julianDate); }
30 int Date::get(int &year, int &month, int &day) const
31 { return julianToYMD(julianDate,year,month,day); }
32
33 int Date::parseFrom(const char *s) {
34 int month,day,year;
35 int count;char *p;
36 if(strcmp(s,"now")==0 || strcmp(s,"NOW")==0){
37 time_t cnow = ::time(NULL);
38 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
39 struct std::tm *tmval = (struct std::tm*) localtime(&cnow);
40 return set(year=tmval->tm_year+1900, month=tmval->tm_mon+1, day=tmval->tm_mday);
41 #else
42 struct tm *tmval = localtime(&cnow);
43 return set(year=tmval->tm_year+1900,month=tmval->tm_mon+1,day=tmval->tm_mday);
44 #endif
45 }
46 else{
47 p=(char*)s;
48 while(*p!='\0'){
49 if(*p=='-'){
50 count = sscanf(s,"%d-%d-%d",&year,&month,&day);
51 break;
52 }
53 if(*p=='/'){
54 count = sscanf(s,"%d/%d/%d",&year,&month,&day);
55 break;
56 }
57 p++;
58 }
59 if (count < 3) return -1;
60 if (year < 100) year += 1900;
61 if (!isValidDate(year, month, day))
62 return -1;
63 return set(year,month,day);
64 }
65 }
66
67 void Date::changeToCsqlFormat(char *src)
68 {
69 char dst[10]="";
70 char *srcPtr = src;
71 char *dstPtr = dst;
72 dst[0]='\0';
73 srcPtr = src + 7;
74 strncpy(dstPtr, srcPtr, 4);
75 dst[4] = '-';
76 dstPtr = &dst[5];
77 srcPtr = src + 3;
78 if(strncasecmp(srcPtr,"JAN",3) == 0) strncpy(dstPtr, "01", 2);
79 else if(strncasecmp(srcPtr,"FEB",3)== 0) strncpy(dstPtr, "02", 2);
80 else if(strncasecmp(srcPtr,"MAR",3)== 0) strncpy(dstPtr, "03", 2);
81 else if(strncasecmp(srcPtr,"APR",3)== 0) strncpy(dstPtr, "04", 2);
82 else if(strncasecmp(srcPtr,"MAY",3)== 0) strncpy(dstPtr, "05", 2);
83 else if(strncasecmp(srcPtr,"JUN",3)== 0) strncpy(dstPtr, "06", 2);
84 else if(strncasecmp(srcPtr,"JUL",3)== 0) strncpy(dstPtr, "07", 2);
85 else if(strncasecmp(srcPtr,"AUG",3)== 0) strncpy(dstPtr, "08", 2);
86 else if(strncasecmp(srcPtr,"SEP",3)== 0) strncpy(dstPtr, "09", 2);
87 else if(strncasecmp(srcPtr,"OCT",3)== 0) strncpy(dstPtr, "10", 2);
88 else if(strncasecmp(srcPtr,"NOV",3)== 0) strncpy(dstPtr, "11", 2);
89 else if(strncasecmp(srcPtr,"DEC",3)== 0) strncpy(dstPtr, "12", 2);
90 dst[7]='-';
91 dstPtr = &dst[8];
92 strncpy(dstPtr, src, 2);
93 dst[10] = '\0';
94 strcpy(src, dst);
95 return;
96 }
97
98
99 int Date::dayOfMonth() const {
100 int year, month, day;
101 get(year,month,day);
102 return day;
103 }
104 int Date::month() const {
105 int year, month, day;
106 get(year,month,day);
107 return month;
108 }
109 int Date::year() const {
110 int year, month, day;
111 get(year,month,day);
112 return year;
113 }
114
115 int Date::dayOfWeek() const { return dayOfWeek(julianDate); }
116
117 const char *Date::dayOfWeekName() const
118 { return dayOfWeekName(dayOfWeek(julianDate)); }
119
120 const char *Date::dayOfWeekAbbr() const
121 { return dayOfWeekAbbr(dayOfWeek(julianDate)); }
122
123 static const char *day_names[] = {
124 "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
125 };
126 static const char *day_abbrs[] = {
127 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
128 };
129
130 static const char *month_names[] = {
131 "January", "February", "March", "April", "May", "June",
132 "July", "August", "September", "October", "November", "December"
133 };
134 static const char *month_abbrs[] = {
135 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
136 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
137 };
138
139
140 static int daysBeforeMonth[] = {
141 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
142 };
143 static int days_per_month[] = {
144 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
145 };
146
147 const char * Date::dayOfWeekName(int day)
148 { return (day < 1 || day > 7) ? 0 : day_names[day-1]; }
149
150 const char * Date::dayOfWeekAbbr(int day)
151 { return (day < 1 || day > 7) ? 0 : day_abbrs[day-1]; }
152
153 const char * Date::monthName() const { return monthName(month()); }
154 const char * Date::monthAbbr() const { return monthAbbr(month()); }
155 const char * Date::monthName(int month)
156 { return (month < 1 || month > 12) ? 0 : month_names[month-1]; }
157 const char * Date::monthAbbr(int month)
158 { return (month < 1 || month > 12) ? 0 : month_abbrs[month-1]; }
159 Date operator+(const Date &d1, int days)
160 { return Date(d1.julianDate + days); }
161 Date operator+(int days, const Date &d1)
162 { return Date(d1.julianDate + days); }
163 Date operator-(const Date &d1, int days)
164 { return Date(d1.julianDate - days); }
165
166 int operator-(const Date &d1, const Date& d2)
167 { return d1.julianDate - d2.julianDate; }
168
169 int operator<(const Date &d1 ,const Date &d2 )
170 { return d1.julianDate < d2.julianDate; }
171 int operator>(const Date &d1 ,const Date &d2 )
172 { return d1.julianDate > d2.julianDate; }
173 int operator<=(const Date &d1 ,const Date &d2 )
174 { return d1.julianDate <= d2.julianDate; }
175 int operator>=(const Date &d1 ,const Date &d2 )
176 { return d1.julianDate >= d2.julianDate; }
177 int operator==(const Date &d1 ,const Date &d2 )
178 { return d1.julianDate == d2.julianDate; }
179 int operator!=(const Date &d1 ,const Date &d2 )
180 { return d1.julianDate != d2.julianDate; }
181
182 bool Date::isValid() const
183 { return julianDate >= SmallestValJulDate; }
184
185 bool Date::isLeapYear(int year)
186 {
187 return (year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0));
188 }
189
190 int Date::dayOfYear() const {
191 int year,month,day;
192 get(year,month,day);
193 int tmp = daysBeforeMonth[month-1];
194 if (month >= 3 && isLeapYear(year))
195 tmp++;
196 return tmp + day;
197 }
198
199 int Date::daysInMonth(int month, int year) {
200 --month;
201 int tmp = days_per_month[month];
202 if (month == 1 && isLeapYear(year)) tmp++;
203 return tmp;
204 }
205
206 bool Date::isValidDate(int year, int month, int day) {
207
208 if (year < 1 || year >= 9999) return false;
209 if (month < 1 || month > 12) return false;
210 return (day >= 1) && (day <= daysInMonth(month,year));
211 }
212
213 // Algorithm Author: Robert G. Tantzen
214 int Date::YMDToJulian(int year, int mon, int day, JulianRep &jul) {
215 if (!isValidDate(year, mon, day))
216 { jul = (JulianRep)0; return -1; }
217
218 // year, month, day are assumed to be valid
219 int m = mon, d = day, y = year;
220 int c, ya, j;
221
222 if (m > 2) m -= 3;
223 else { m += 9; --y; }
224 c = y/100;
225 ya = y - (100 * c);
226 j = (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5 + d + 1721119;
227 jul = (JulianRep)j;
228 return 0;
229 }
230
231 // Julian date converter. Takes a julian date (the number of days since some
232 // distant epoch or other), and returns month, day of month, and year in
233 // integer references.
234 // Algorithm Author: Robert G. Tantzen
235 int Date::dayOfWeek(JulianRep jul) {
236 return (int)((jul+1)%7+1);
237 }
238
239 int Date::julianToYMD(JulianRep jul, int &year, int &month, int &day) {
240 int j = jul;
241 int d, m, y;
242
243 if (j < SmallestValJulDate)
244 { year = month = day = 0; return -1; }
245
246 j -= 1721119;
247 y = (4 * j - 1)/146097;
248 j = 4 * j - 1 - 146097 * y;
249 d = j/4;
250 j = (4 * d + 3)/1461;
251 d = 4 * d + 3 - 1461 * j;
252 d = (d + 4)/4;
253 m = (5 * d - 3)/153;
254 d = 5 * d - 3 - 153 * m;
255 d = (d + 5) / 5;
256 y = 100 * y + j;
257 if (m < 10) m += 3;
258 else { m -= 9; ++y; }
259 month = m;
260 day = d;
261 year = y;
262 return 0;
263 }
264
265 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
266 Time::Time(int hours, int mins, int secs, int usec)
267 { set(hours,mins,secs, usec); }
268
269 int Time::set(int hours, int mins, int secs, int usec) {
270 if((hours | mins | secs | usec) < 0) { timeVal = -1; return -1; }
271 if(hours >= 24 | mins >= 60 | secs >= 62)
272 { timeVal = -1; return -1; }
273 timeVal = secs + mins * 60 + hours * 3600;
274 timeVal *= 10000;
275 if(usec) timeVal += usec/100;
276 return 0;
277 }
278
279 int Time::get(int &hours, int &mins, int &secs) const {
280 if (timeVal < 0) return -1;
281 int s = timeVal/10000;
282 secs = s % 60;
283 s /= 60;
284 mins = s % 60;
285 s /= 60;
286 hours = s;
287 return 0;
288 }
289
290 int Time::seconds() const { return (timeVal/10000) % 60; }
291 int Time::minutes() const { return (timeVal /(60*10000)) % 60; }
292 int Time::hours() const { return timeVal / (3600*10000); }
293 int Time::msec() const { return (timeVal % 10000) / 10; }
294 int Time::usec() const { return (timeVal % 10000) * 100; }
295
296 int Time::setMsec(int ms) {
297 if(ms < 0 || ms >= 1000) return -1;
298 timeVal = timeVal+(10*ms);
299 return 0;
300 }
301 int Time::setUsec(int us) {
302 if(us < 0 || us >= 1000000) return -1;
303 timeVal = timeVal +us/100;
304 return 0;
305 }
306
307 bool Time::isValid() const
308 { return timeVal >= 0 && timeVal <= (10000*(MAX_VALID_SECONDS+1)-1); }
309
310 bool Time::isValidTime(int hours, int mins, int secs) {
311 return (hours >= 0 && hours < 24) &&
312 (mins >= 0 && mins < 60) &&
313 (secs >= 0 && secs < 60);
314 }
315
316 Time operator+(const Time &t1, int seconds)
317 { return Time(t1.timeVal + seconds*10000); }
318 Time operator+(int seconds, const Time &t1)
319 { return Time(t1.timeVal + seconds*10000); }
320 Time operator-(const Time &t1, int seconds)
321 { return Time(t1.timeVal - seconds*10000); }
322
323 int operator-(const Time &t1, const Time& t2)
324 { return (t1.timeVal - t2.timeVal)/10000; }
325
326 int operator<(const Time &t1 ,const Time &t2 )
327 { return t1.timeVal < t2.timeVal; }
328 int operator>(const Time &t1 ,const Time &t2 )
329 { return t1.timeVal > t2.timeVal; }
330 int operator<=(const Time &t1 ,const Time &t2 )
331 { return t1.timeVal <= t2.timeVal; }
332 int operator>=(const Time &t1 ,const Time &t2 )
333 { return t1.timeVal >= t2.timeVal; }
334 int operator==(const Time &t1 ,const Time &t2 )
335 { return t1.timeVal == t2.timeVal; }
336 int operator!=(const Time &t1 ,const Time &t2 )
337 { return t1.timeVal != t2.timeVal; }
338
339 int Time::parseFrom(const char *s) {
340 int hours,mins,secs;
341 int count;char *p;
342 if(strcmp(s,"now")==0 || strcmp(s,"NOW")==0){
343 time_t cnow = ::time(NULL);
344 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
345 struct std::tm *tmval = (struct std::tm*) localtime(&cnow);
346 return set(hours=tmval->tm_hour,mins=tmval->tm_min,secs=tmval->tm_sec);
347 #else
348 struct tm *tmval = localtime(&cnow);
349 return set(hours=tmval->tm_hour,mins=tmval->tm_min,secs=tmval->tm_sec);
350 #endif
351 }
352 else{
353 count = sscanf(s,"%d:%d:%d",&hours,&mins,&secs);
354 if (count < 2) return -1;
355 if (count == 2) secs = 0;
356
357 if (!isValidTime(hours,mins,secs))
358 return -1;
359 return set(hours,mins,secs);
360 }
361 }
362 int TimeStamp::parseFrom(const char *s) {
363 int hours,mins,secs;
364 int month,day,year;
365 int count;char *p;
366 if(strcmp(s,"now")==0 || strcmp(s,"NOW")==0){
367 time_t cnow = ::time(NULL);
368 #if defined(SOLARIS) && defined(REMOTE_SOLARIS)
369 struct std::tm *tmval = (struct std::tm*) localtime(&cnow);
370 setDate(year=tmval->tm_year+1900,month=tmval->tm_mon+1,day=tmval->tm_mday);
371 return setTime(hours=tmval->tm_hour,mins=tmval->tm_min,secs=tmval->tm_sec);
372 #else
373 struct tm *tmval = localtime(&cnow);
374 setDate(year=tmval->tm_year+1900,month=tmval->tm_mon+1,day=tmval->tm_mday);
375 return setTime(hours=tmval->tm_hour,mins=tmval->tm_min,secs=tmval->tm_sec);
376 #endif
377 }
378 else{
379 p=(char*)s;
380 while(*p!='\0'){
381 if(*p=='-'){
382 count = sscanf(s,"%d-%d-%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
383 break;
384 }
385 if(*p=='/'){
386 count = sscanf(s,"%d/%d/%d %d:%d:%d",&year,&month,&day, &hours, &mins, &secs);
387 break;
388 }
389 p++;
390 }
391 if (count < 5) return -1;
392 if (count == 5) secs = 0;
393 if (year < 100) year += 1900;
394
395 if (!date.isValidDate(year, month, day))
396 return -1;
397
398 setDate(year,month,day);
399
400
401 if (!time.isValidTime(hours,mins,secs))
402 return -1;
403 return setTime(hours,mins,secs);
404 }
405 }
406
407 void TimeStamp::changeToCsqlFormat(char *src)
408 {
409 char dst[20];
410 char *srcPtr = src;
411 char *dstPtr = dst;
412 dst[0]='\0';
413 srcPtr = src + 7;
414 strncpy(dstPtr, srcPtr, 4);
415 dst[4] = '-';
416 dstPtr = &dst[5];
417 srcPtr = src + 3;
418 if(strncasecmp(srcPtr,"JAN",3) == 0) strncpy(dstPtr, "01", 2);
419 else if(strncasecmp(srcPtr,"FEB",3)== 0) strncpy(dstPtr, "02", 2);
420 else if(strncasecmp(srcPtr,"MAR",3)== 0) strncpy(dstPtr, "03", 2);
421 else if(strncasecmp(srcPtr,"APR",3)== 0) strncpy(dstPtr, "04", 2);
422 else if(strncasecmp(srcPtr,"MAY",3)== 0) strncpy(dstPtr, "05", 2);
423 else if(strncasecmp(srcPtr,"JUN",3)== 0) strncpy(dstPtr, "06", 2);
424 else if(strncasecmp(srcPtr,"JUL",3)== 0) strncpy(dstPtr, "07", 2);
425 else if(strncasecmp(srcPtr,"AUG",3)== 0) strncpy(dstPtr, "08", 2);
426 else if(strncasecmp(srcPtr,"SEP",3)== 0) strncpy(dstPtr, "09", 2);
427 else if(strncasecmp(srcPtr,"OCT",3)== 0) strncpy(dstPtr, "10", 2);
428 else if(strncasecmp(srcPtr,"NOV",3)== 0) strncpy(dstPtr, "11", 2);
429 else if(strncasecmp(srcPtr,"DEC",3)== 0) strncpy(dstPtr, "12", 2);
430 dst[7]='-';
431 dstPtr = &dst[8];
432 strncpy(dstPtr, src, 2);
433 dstPtr = &dst[10];
434 srcPtr = src + 11;
435 strncpy(dstPtr, srcPtr, 9);
436 dst[19]='\0';
437 strcpy(src, dst);
438 return;
439 }
440 int operator< (const TimeStamp &d1, const TimeStamp &d2)
441 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time < d2.time; }
442 int operator> (const TimeStamp &d1, const TimeStamp &d2)
443 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time > d2.time; }
444 int operator<=(const TimeStamp &d1, const TimeStamp &d2)
445 { return (d1.date != d2.date) ? d1.date < d2.date : d1.time <= d2.time; }
446 int operator>=(const TimeStamp &d1, const TimeStamp &d2)
447 { return (d1.date != d2.date) ? d1.date > d2.date : d1.time >= d2.time; }
448 int operator==(const TimeStamp &d1, const TimeStamp &d2)
449 { return d1.date == d2.date && d1.time == d2.time; }
450 int operator!=(const TimeStamp &d1, const TimeStamp &d2)
451 { return d1.date != d2.date || d1.time != d2.time; }
452
453
454 char* AllDataType::getSQLString(DataType type)
455 {
456 switch(type)
457 {
458 case typeInt: return "INT";
459 case typeLong: return "INT";
460 case typeLongLong: return "BIGINT";
461 case typeShort: return "SMALLINT";
462 case typeByteInt: return "TINYINT";
463 case typeDouble: return "REAL";
464 case typeFloat: return "FLOAT";
465 case typeDate: return "DATE";
466 case typeTime: return "TIME";
467 case typeTimeStamp: return "TIMESTAMP";
468 case typeString: return "CHAR";
469 case typeBinary: return "BINARY";
470 default: return "UNKNOWN";
471 }
472 }
473
474
475 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
476 {
477 switch(type)
478 {
479 case typeInt:
480 return SQL_INTEGER;
481 case typeLong:
482 return SQL_INTEGER;
483 case typeLongLong:
484 //TODO
485 return SQL_BIGINT;
486 case typeShort:
487 return SQL_SMALLINT;
488 case typeByteInt:
489 //TODO
490 return SQL_INTEGER;
491 case typeDouble:
492 return SQL_DOUBLE;
493 case typeFloat:
494 return SQL_REAL;
495 case typeDecimal:
496 //TODO
497 return SQL_INTEGER;
498 case typeDate:
499 return SQL_TYPE_DATE;
500 case typeTime:
501 return SQL_TYPE_TIME;
502 case typeTimeStamp:
503 return SQL_TYPE_TIMESTAMP;
504 case typeString:
505 return SQL_CHAR;
506 case typeBinary:
507 return SQL_BINARY;
508 }
509 return SQL_INTEGER;
510 }
511 SQLSMALLINT AllDataType::convertToCSQLSQLType(DataType type)
512 {
513 switch(type)
514 {
515 case typeInt:
516 return SQL_INTEGER;
517 case typeLong:
518 return SQL_INTEGER;
519 case typeLongLong:
520 //TODO
521 return SQL_BIGINT;
522 case typeShort:
523 return SQL_SMALLINT;
524 case typeByteInt:
525 //TODO
526 return SQL_TINYINT;
527 case typeDouble:
528 return SQL_DOUBLE;
529 case typeFloat:
530 return SQL_REAL;
531 case typeDecimal:
532 //TODO
533 return SQL_INTEGER;
534 case typeDate:
535 return SQL_TYPE_DATE;
536 case typeTime:
537 return SQL_TYPE_TIME;
538 case typeTimeStamp:
539 return SQL_TYPE_TIMESTAMP;
540 case typeString:
541 return SQL_CHAR;
542 case typeBinary:
543 return SQL_BINARY;
544 }
545 return SQL_INTEGER;
546 }
547
548 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type,TDBInfo tdbname)
549 {
550 switch(type)
551 {
552 case typeInt:
553 return SQL_C_SLONG;
554 case typeLong:
555 return SQL_C_SLONG;
556 case typeLongLong:
557 {
558 if(tdbname == postgres)
559 return SQL_C_CHAR;
560 else
561 return SQL_C_SBIGINT;
562 }
563 case typeShort:
564 return SQL_C_SSHORT;
565 case typeByteInt:
566 return SQL_C_STINYINT;
567 case typeDouble:
568 return SQL_C_DOUBLE;
569 case typeFloat:
570 return SQL_C_FLOAT;
571 case typeDecimal:
572 //TODO
573 return SQL_INTEGER;
574 case typeDate:
575 return SQL_C_TYPE_DATE;
576 case typeTime:
577 return SQL_C_TYPE_TIME;
578 case typeTimeStamp:
579 return SQL_C_TYPE_TIMESTAMP;
580 case typeString:
581 return SQL_C_CHAR;
582 case typeBinary:
583 return SQL_C_BINARY;
584 }
585 return SQL_C_SLONG;
586 }
587
588 DataType AllDataType::convertFromSQLType(SQLSMALLINT type,int length,int scale,TDBInfo tdbname)
589 {
590 if(tdbname==postgres)
591 {
592 switch(type)
593 {
594 case SQL_INTEGER :
595 return typeInt;
596 case SQL_SMALLINT:
597 return typeShort;
598 case SQL_BIGINT:
599 return typeLongLong;
600 case SQL_FLOAT:
601 case SQL_DOUBLE:
602 return typeDouble;
603 case SQL_REAL:
604 return typeFloat;
605 case SQL_TYPE_DATE:
606 return typeDate;
607 case SQL_TYPE_TIME :
608 return typeTime;
609 case SQL_TYPE_TIMESTAMP :
610 return typeTimeStamp;
611 case SQL_CHAR:
612 return typeString;
613 case SQL_LONGVARCHAR:
614 return typeString;
615 case SQL_VARCHAR:
616 return typeString;
617 case SQL_BINARY:
618 return typeBinary;
619 }
620 return typeInt;
621 }
622 switch(type)
623 {
624 case SQL_TINYINT:
625 return typeByteInt;
626 case SQL_INTEGER :
627 return typeInt;
628 case SQL_SMALLINT:
629 return typeShort;
630 case SQL_BIGINT:
631 return typeLongLong;
632 case SQL_DOUBLE:
633 return typeDouble;
634 case SQL_FLOAT:
635 case SQL_REAL:
636 return typeFloat;
637 case SQL_TYPE_DATE:
638 return typeDate;
639 case SQL_TYPE_TIME :
640 return typeTime;
641 case SQL_TYPE_TIMESTAMP :
642 return typeTimeStamp;
643 case SQL_CHAR:
644 return typeString;
645 case SQL_LONGVARCHAR:
646 return typeString;
647 case SQL_VARCHAR:
648 return typeString;
649 case SQL_BINARY:
650 return typeBinary;
651 }
652 return typeInt;
653 }
654 void AllDataType::subVal(void* dest, void *src, DataType type)
655 {
656 switch(type)
657 {
658 case typeInt:
659 *(int*)dest = *(int*)dest - *(int*)src;
660 break;
661 case typeLong:
662 *(long*)dest = *(long*)dest - *(long*)src;
663 break;
664 case typeLongLong:
665 *(long long*)dest = *(long long*)dest - *(long long*)src;
666 break;
667 case typeShort:
668 *(short*)dest = *(short*)dest - *(short*)src;
669 break;
670 case typeByteInt:
671 *(char*)dest = *(char*)dest - *(char*)src;
672 break;
673 case typeDouble:
674 *(double*)dest = *(double*)dest - *(double*)src;
675 break;
676 case typeFloat:
677 *(float*)dest = *(float*)dest - *(float*)src;
678 break;
679 case typeDecimal:
680 case typeDate:
681 case typeTime:
682 case typeTimeStamp:
683 case typeBinary:
684 default:
685 break;
686 }
687 return;
688 }
689 void AllDataType::mulVal(void* dest, void *src, DataType type)
690 {
691 switch(type)
692 {
693 case typeInt:
694 *(int*)dest = *(int*)dest * (*(int*)src);
695 break;
696 case typeLong:
697 *(long*)dest = *(long*)dest * (*(long*)src);
698 break;
699 case typeLongLong:
700 *(long long*)dest = *(long long*)dest * (*(long long*)src);
701 break;
702 case typeShort:
703 *(short*)dest = *(short*)dest * (*(short*)src);
704 break;
705 case typeByteInt:
706 *(char*)dest = *(char*)dest * (*(char*)src);
707 break;
708 case typeDouble:
709 *(double*)dest = *(double*)dest * (*(double*)src);
710 break;
711 case typeFloat:
712 *(float*)dest = *(float*)dest * (*(float*)src);
713 break;
714 case typeDecimal:
715 case typeDate:
716 case typeTime:
717 case typeTimeStamp:
718 case typeBinary:
719 default:
720 break;
721 }
722 return;
723 }
724 void AllDataType::mudVal(void* dest, void *src, DataType type)
725 {
726 if (type == typeInt)
727 {
728 *(int*)dest = *(int*)dest % (*(int*)src);
729 return;
730 }
731 switch(type)
732 {
733 case typeInt:
734 *(int*)dest = *(int*)dest % (*(int*)src);
735 break;
736 case typeLong:
737 *(long*)dest = *(long*)dest % (*(long*)src);
738 break;
739 case typeLongLong:
740 *(long long*)dest = *(long long*)dest % (*(long long*)src);
741 break;
742 case typeShort:
743 *(short*)dest = *(short*)dest % (*(short*)src);
744 break;
745 case typeByteInt:
746 *(char*)dest = *(char*)dest % (*(char*)src);
747 break;
748 case typeDouble:
749 *(double*)dest = *(long long*)dest % (*(long long*)src);
750 break;
751 case typeFloat:
752 *(float*)dest = *(int*)dest % (*(int*)src);
753 break;
754 case typeDecimal:
755 case typeDate:
756 case typeTime:
757 case typeTimeStamp:
758 case typeBinary:
759 default:
760 break;
761 }
762 return;
763 }
764 void AllDataType::divVal(void* dest, void *src, DataType type)
765 {
766 if (type == typeInt)
767 {
768 *(int*)dest = *(int*)dest / (*(int*)src);
769 return;
770 }
771 switch(type)
772 {
773 case typeInt:
774 *(int*)dest = *(int*)dest / (*(int*)src);
775 break;
776 case typeLong:
777 *(long*)dest = *(long*)dest / (*(long*)src);
778 break;
779 case typeLongLong:
780 *(long long*)dest = *(long long*)dest / (*(long long*)src);
781 break;
782 case typeShort:
783 *(short*)dest = *(short*)dest / (*(short*)src);
784 break;
785 case typeByteInt:
786 *(char*)dest = *(char*)dest / (*(char*)src);
787 break;
788 case typeDouble:
789 *(double*)dest = *(double *)dest / (*(double*)src);
790 break;
791 case typeFloat:
792 *(float*)dest = *(float*)dest / (*(float*)src);
793 break;
794 case typeDecimal:
795 case typeDate:
796 case typeTime:
797 case typeTimeStamp:
798 case typeBinary:
799 default:
800 break;
801 }
802 return;
803 }
804 void AllDataType::divVal(double* dest, int src, DataType type)
805 {
806 switch(type)
807 {
808 case typeInt:
809 case typeLong:
810 case typeLongLong:
811 case typeShort:
812 case typeByteInt:
813 case typeDouble:
814 case typeFloat:
815 case typeDecimal:
816 *dest = *dest / src;
817 break;
818 //TODO::for porting
819 case typeDate:
820 case typeTime:
821 case typeTimeStamp:
822 case typeBinary:
823 default:
824 break;
825 }
826 return;
827 }
828
829 void AllDataType::increment(void* dest, void *src, DataType type)
830 {
831 switch(type)
832 {
833 case typeInt:
834 *(int*)dest = *(int*)src + 1;
835 break;
836 case typeLong:
837 *(long*)dest = *(long*)src + 1;
838 break;
839 case typeLongLong:
840 *(long long*)dest = *(long long*)src + 1;
841 break;
842 case typeByteInt:
843 *(char*)dest = *(char*)src + 1;
844 break;
845 case typeShort:
846 *(short*)dest = *(short*)src + 1;
847 break;
848 case typeDouble:
849 *(double*)dest = *(double*)src + 1;
850 break;
851 case typeFloat:
852 *(float*)dest = *(float*)src+ 1;
853 break;
854 default:
855 break;
856 }
857 }
858
859 bool AllDataType::isValueZero(void *src, DataType type)
860 {
861 switch(type)
862 {
863 case typeInt:
864 if (*(int*)src == 0) return true;
865 else return false;
866 case typeLong:
867 if (*(int*)src == 0) return true;
868 else return false;
869 case typeLongLong:
870 if (*(int*)src == 0) return true;
871 else return false;
872 case typeShort:
873 if (*(int*)src == 0) return true;
874 else return false;
875 case typeDouble:
876 if (*(int*)src == 0) return true;
877 else return false;
878 case typeFloat:
879 if (*(int*)src == 0) return true;
880 else return false;
881 default:
882 break;
883 }
884 return false;
885 }
886
887 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
888 {
889 printf("This function should never be called by anyone\n");
890 if (OpEquals == op) {
891 if (*(int*)src1 == *(int*)src2) return true;
892 else return false;
893 }else if (OpGreaterThan == op) {
894 if (*(int*)src1 > *(int*)src2) return true;
895 else return false;
896 }else if (OpLessThan == op) {
897 if (*(int*)src1 < *(int*)src2) return true;
898 else return false;
899 }else if (OpLessThanEquals == op) {
900 if (*(int*)src1 <= *(int*)src2) return true;
901 else return false;
902 }else if (OpGreaterThanEquals == op) {
903 if (*(int*)src1 >= *(int*)src2) return true;
904 else return false;
905 }else if (OpNotEquals == op) {
906 if (*(int*)src1 != *(int*)src2) return true;
907 else return false;
908 }
909 return false;
910 }
911
912 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
913 {
914 bool result = false;
915 switch(op)
916 {
917 case OpEquals:
918 if (*(long*)src1 == *(long*)src2) result = true;
919 else result = false;
920 break;
921 case OpNotEquals:
922 if (*(long*)src1 != *(long*)src2) result = true;
923 else result = false;
924 break;
925 case OpLessThan:
926 if (*(long*)src1 < *(long*)src2) result = true;
927 else result = false;
928 break;
929 case OpLessThanEquals:
930 if (*(long*)src1 <= *(long*)src2) result = true;
931 else result = false;
932 break;
933 case OpGreaterThan:
934 if (*(long*)src1 > *(long*)src2) result = true;
935 else result = false;
936 break;
937 case OpGreaterThanEquals:
938 if (*(long*)src1 >= *(long*)src2) result = true;
939 else result = false;
940 break;
941 }
942 return result;
943 }
944
945 bool AllDataType::compareLongLongVal(void* src1, void *src2,
946 ComparisionOp op)
947 {
948 bool result = false;
949 switch(op)
950 {
951 case OpEquals:
952 if (*(long long*)src1 == *(long long*)src2) result = true;
953 else result = false;
954 break;
955 case OpNotEquals:
956 if (*(long long*)src1 != *(long long*)src2) result = true;
957 else result = false;
958 break;
959 case OpLessThan:
960 if (*(long long*)src1 < *(long long*)src2) result = true;
961 else result = false;
962 break;
963 case OpLessThanEquals:
964 if (*(long long*)src1 <= *(long long*)src2) result = true;
965 else result = false;
966 break;
967 case OpGreaterThan:
968 if (*(long long*)src1 > *(long long*)src2) result = true;
969 else result = false;
970 break;
971 case OpGreaterThanEquals:
972 if (*(long long*)src1 >= *(long long*)src2) result = true;
973 else result = false;
974 break;
975 }
976 return result;
977 }
978
979 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
980 {
981 bool result = false;
982 switch(op)
983 {
984 case OpEquals:
985 if (*(short*)src1 == *(short*)src2) result = true;
986 else result = false;
987 break;
988 case OpNotEquals:
989 if (*(short*)src1 != *(short*)src2) result = true;
990 else result = false;
991 break;
992 case OpLessThan:
993 if (*(short*)src1 < *(short*)src2) result = true;
994 else result = false;
995 break;
996 case OpLessThanEquals:
997 if (*(short*)src1 <= *(short*)src2) result = true;
998 else result = false;
999 break;
1000 case OpGreaterThan:
1001 if (*(short*)src1 > *(short*)src2) result = true;
1002 else result = false;
1003 break;
1004 case OpGreaterThanEquals:
1005 if (*(short*)src1 >= *(short*)src2) result = true;
1006 else result = false;
1007 break;
1008 }
1009 return result;
1010 }
1011
1012 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
1013 {
1014 bool result = false;
1015 switch(op)
1016 {
1017 case OpEquals:
1018 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
1019 else result = false;
1020 break;
1021 case OpNotEquals:
1022 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
1023 else result = false;
1024 break;
1025 case OpLessThan:
1026 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
1027 else result = false;
1028 break;
1029 case OpLessThanEquals:
1030 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
1031 else result = false;
1032 break;
1033 case OpGreaterThan:
1034 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
1035 else result = false;
1036 break;
1037 case OpGreaterThanEquals:
1038 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
1039 else result = false;
1040 break;
1041 }
1042 return result;
1043 }
1044
1045 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
1046 {
1047 bool result = false;
1048 switch(op)
1049 {
1050 case OpEquals:
1051 if (*(double*)src1 == *(double*)src2) result = true;
1052 else result = false;
1053 break;
1054 case OpNotEquals:
1055 if (*(double*)src1 != *(double*)src2) result = true;
1056 else result = false;
1057 break;
1058 case OpLessThan:
1059 if (*(double*)src1 < *(double*)src2) result = true;
1060 else result = false;
1061 break;
1062 case OpLessThanEquals:
1063 if (*(double*)src1 <= *(double*)src2) result = true;
1064 else result = false;
1065 break;
1066 case OpGreaterThan:
1067 if (*(double*)src1 > *(double*)src2) result = true;
1068 else result = false;
1069 break;
1070 case OpGreaterThanEquals:
1071 if (*(double*)src1 >= *(double*)src2) result = true;
1072 else result = false;
1073 break;
1074 }
1075 return result;
1076 }
1077
1078 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1079 {
1080 bool result = false;
1081 switch(op)
1082 {
1083 case OpEquals:
1084 if (*(float*)src1 == *(float*)src2) result = true;
1085 else result = false;
1086 break;
1087 case OpNotEquals:
1088 if (*(float*)src1 != *(float*)src2) result = true;
1089 else result = false;
1090 break;
1091 case OpLessThan:
1092 if (*(float*)src1 < *(float*)src2) result = true;
1093 else result = false;
1094 break;
1095 case OpLessThanEquals:
1096 if (*(float*)src1 <= *(float*)src2) result = true;
1097 else result = false;
1098 break;
1099 case OpGreaterThan:
1100 if (*(float*)src1 > *(float*)src2) result = true;
1101 else result = false;
1102 break;
1103 case OpGreaterThanEquals:
1104 if (*(float*)src1 >= *(float*)src2) result = true;
1105 else result = false;
1106 break;
1107 }
1108 return result;
1109 }
1110
1111 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1112 {
1113 bool result = false;
1114 switch(op)
1115 {
1116 case OpEquals:
1117 if (*(Date*)src1 == *(Date*)src2) result = true;
1118 else result = false;
1119 break;
1120 case OpNotEquals:
1121 if (*(Date*)src1 != *(Date*)src2) result = true;
1122 else result = false;
1123 break;
1124 case OpLessThan:
1125 if (*(Date*)src1 < *(Date*)src2) result = true;
1126 else result = false;
1127 break;
1128 case OpLessThanEquals:
1129 if (*(Date*)src1 <= *(Date*)src2) result = true;
1130 else result = false;
1131 break;
1132 case OpGreaterThan:
1133 if (*(Date*)src1 > *(Date*)src2) result = true;
1134 else result = false;
1135 break;
1136 case OpGreaterThanEquals:
1137 if (*(Date*)src1 >= *(Date*)src2) result = true;
1138 else result = false;
1139 break;
1140 }
1141 return result;
1142 }
1143
1144 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1145 {
1146 bool result = false;
1147 switch(op)
1148 {
1149 case OpEquals:
1150 if (*(Time*)src1 == *(Time*)src2) result = true;
1151 else result = false;
1152 break;
1153 case OpNotEquals:
1154 if (*(Time*)src1 != *(Time*)src2) result = true;
1155 else result = false;
1156 break;
1157 case OpLessThan:
1158 if (*(Time*)src1 < *(Time*)src2) result = true;
1159 else result = false;
1160 break;
1161 case OpLessThanEquals:
1162 if (*(Time*)src1 <= *(Time*)src2) result = true;
1163 else result = false;
1164 break;
1165 case OpGreaterThan:
1166 if (*(Time*)src1 > *(Time*)src2) result = true;
1167 else result = false;
1168 break;
1169 case OpGreaterThanEquals:
1170 if (*(Time*)src1 >= *(Time*)src2) result = true;
1171 else result = false;
1172 break;
1173 }
1174 return result;
1175 }
1176
1177 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1178 {
1179 bool result = false;
1180 switch(op)
1181 {
1182 case OpEquals:
1183 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1184 else result = false;
1185 break;
1186 case OpNotEquals:
1187 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1188 else result = false;
1189 break;
1190 case OpLessThan:
1191 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1192 else result = false;
1193 break;
1194 case OpLessThanEquals:
1195 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1196 else result = false;
1197 break;
1198 case OpGreaterThan:
1199 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1200 else result = false;
1201 break;
1202 case OpGreaterThanEquals:
1203 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1204 else result = false;
1205 break;
1206 }
1207 return result;
1208 }
1209
1210 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1211 {
1212 if (OpEquals == op) {
1213 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1214 else return false;
1215 }else if (OpGreaterThan == op) {
1216 if (strcmp((char*)src1, (char*)src2) >0) return true;
1217 else return false;
1218 }else if (OpLessThan == op) {
1219 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1220 else return false;
1221 }else if (OpLessThanEquals == op) {
1222 // printf("Illegal Operator:Not Supported for String\n");
1223 // return false;
1224 if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1225 else return false;
1226 }else if (OpGreaterThanEquals == op) {
1227 // printf("Illegal Operator:Not Supported for String\n");
1228 // return false;
1229 if (strcmp((char*)src1, (char*)src2) >=0) return true;
1230 else return false;
1231 }else if (OpNotEquals == op) {
1232 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1233 else return false;
1234 }else if (OpLike == op) {
1235 return !os::strmatch((char*)src2, (char*)src1);
1236 }
1237 printf("Illegeal Operator:Not supported for String\n");
1238 return false;
1239 }
1240
1241 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1242 ComparisionOp op, int length)
1243 {
1244 bool result = false;
1245 int ret = os::memcmp(src1, src2, length);
1246 switch(op)
1247 {
1248 case OpEquals:
1249 if (ret == 0 ) result= true; else result = false;
1250 break;
1251 case OpNotEquals:
1252 if (ret != 0 ) result= true; else result = false;
1253 break;
1254 case OpLessThan:
1255 if (ret < 0 ) result= true; else result = false;
1256 break;
1257 case OpLessThanEquals:
1258 printf("Illegal Operator:Not Supported for Binary\n");
1259 break;
1260 case OpGreaterThan:
1261 if (ret > 0 ) result= true; else result = false;
1262 break;
1263 case OpGreaterThanEquals:
1264 printf("Illegal Operator:Not Supported for Binary\n");
1265 break;
1266 }
1267 return result;
1268 }
1269
1270 void* AllDataType::alloc(DataType type, int length)
1271 {
1272 void *dest;
1273 switch(type)
1274 {
1275 case typeInt:
1276 dest = malloc(sizeof(int));
1277 break;
1278 case typeLong:
1279 dest = malloc(sizeof(long));
1280 break;
1281 case typeLongLong:
1282 dest = malloc(sizeof(long long));
1283 break;
1284 case typeShort:
1285 dest = malloc(sizeof(short));
1286 break;
1287 case typeByteInt:
1288 dest = malloc(sizeof(char));
1289 break;
1290 case typeDouble:
1291 dest = malloc(sizeof(double));
1292 break;
1293 case typeFloat:
1294 dest = malloc(sizeof(float));
1295 break;
1296 case typeDecimal:
1297 //TODO::for porting
1298 //fldDef.length_ = sizeof(long double);
1299 break;
1300 case typeString:
1301 if (length == 0 ) return NULL;
1302 dest = malloc(length);
1303 break;
1304 case typeBinary:
1305 if (length == 0 || length > 512) return NULL;
1306 dest = malloc(length);
1307 memset(dest, 0, length);
1308 break;
1309 case typeDate:
1310 dest = malloc(sizeof(Date));
1311 break;
1312 case typeTime:
1313 dest = malloc(sizeof(Time));
1314 break;
1315 case typeTimeStamp:
1316 dest = malloc(sizeof(TimeStamp));
1317 break;
1318 }
1319 return dest;
1320 }
1321
1322 void AllDataType::memoryset(void *value,DataType type)
1323 {
1324 switch(type)
1325 {
1326 case typeInt:
1327 value= ::memset(value, 0, sizeof(int));
1328 break;
1329 case typeLong:
1330 value = ::memset(value, 0, sizeof(long));
1331 break;
1332 case typeLongLong:
1333 value =::memset(value, 0, sizeof(long long));
1334 break;
1335 case typeShort:
1336 value = ::memset(value, 0, sizeof(short));
1337 break;
1338 case typeByteInt:
1339 value = ::memset(value, 0, sizeof(char));
1340 break;
1341 case typeDouble:
1342 value = ::memset(value, 0, sizeof(double));
1343 break;
1344 case typeFloat:
1345 value = ::memset(value, 0, sizeof(float));
1346 break;
1347 case typeDecimal:
1348 break;
1349 case typeString:
1350 *(char*)value = '\0';
1351 //if (length == 0 ) return NULL;
1352 //dest = malloc(length);
1353 break;
1354 case typeBinary:
1355 /* if (length == 0 || length > 256 ) return NULL;
1356
1357 memset(dest, 0, length);*/
1358 break;
1359 case typeDate:
1360 value = ::memset(value, 0, sizeof(Date));
1361 break;
1362 case typeTime:
1363 value = ::memset(value, 0, sizeof(Time));
1364 break;
1365 case typeTimeStamp:
1366 value = ::memset(value, 0, sizeof(TimeStamp));
1367 break;
1368 defalut:
1369 break;
1370 }
1371 }
1372
1373
1374 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1375 {
1376 switch(type)
1377 {
1378 case typeInt: {
1379 int val;
1380 sscanf( src, "%d", &val);
1381 *(int*)dest = val;
1382 break; }
1383 case typeLong: {
1384 long val;
1385 sscanf( src, "%ld", &val);
1386 *(long*)dest = val;
1387 break; }
1388 case typeLongLong: {
1389 long long val;
1390 sscanf( src, "%lld", &val);
1391 *(long long*)dest = val;
1392 break; }
1393 case typeShort: {
1394 short val;
1395 sscanf( src, "%hd", &val);
1396 *(short*)dest = val;
1397 break; }
1398 case typeByteInt: {
1399 char val;
1400 sscanf( src, "%hhd", &val);
1401 *(char*)dest = *(char *)&val;
1402 break; }
1403 case typeDouble: {
1404 double val;
1405 sscanf( src, "%lg", &val);
1406 *(double*)dest = val;
1407 break; }
1408 case typeFloat: {
1409 float val;
1410 sscanf( src, "%f", &val);
1411 *(float*)dest = val;
1412 break; }
1413 case typeDecimal:
1414 //TODO::for porting
1415 case typeString: {
1416 strncpy((char*)dest, (char*)src, length);
1417 char *d =(char*)dest;
1418 d[length-1] = '\0';
1419 break;}
1420 case typeDate: {
1421 int d,m,y,res=0;
1422 if (strlen(src) == 11) {
1423 if ( src[6] == '-' || src[6] == '/' ) {
1424 Date::changeToCsqlFormat(src);
1425 }
1426 }
1427 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1428 if( res != 3 )
1429 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1430 if (strcmp(src,"now")==0 || strcmp(src,"NOW")==0){
1431 Date *dt = (Date*) dest;
1432 dt->parseFrom((char*)src);
1433 break;
1434 }
1435 if( res != 3 )
1436 {
1437 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1438 d=m=y=0;
1439 }
1440 Date dateObj(y,m,d);
1441 *(Date*)dest = dateObj;
1442 break; }
1443 case typeTime: {
1444 int h,m,s,res=0;
1445 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1446 if(strcmp(src,"now")==0 || strcmp(src,"NOW")==0){
1447 Time *dt = (Time*) dest;
1448 dt->parseFrom((char*)src);
1449 break;
1450 }
1451 if( res != 3 )
1452 {
1453 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1454 h=m=s=0;
1455 }
1456 Time timeObj(h,m,s);
1457 *(Time*)dest = timeObj;
1458 break; }
1459 case typeTimeStamp: {
1460 int d,m,y, h,mn,s, res=0;
1461 bool isNow = ( strcasecmp(src,"now")==0 );
1462 if(!isNow && isalpha(int(src[5]))) {
1463 TimeStamp::changeToCsqlFormat(src);
1464 }
1465 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1466 if( res != 6 )
1467 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1468 if( res != 6 )
1469 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1470 if( res != 6 )
1471 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1472
1473 if(isNow){
1474 TimeStamp *dt = (TimeStamp*) dest;
1475 dt->parseFrom((char*)src);
1476 break;
1477 }
1478 if ( res != 6 )
1479 {
1480 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1481 d=m=y=h=mn=s=0;
1482 }
1483 TimeStamp timeStampObj(y,m,d,h,mn,s);
1484 *(TimeStamp*)dest = timeStampObj;
1485 break; }
1486 case typeBinary: {
1487 memset ((void *) dest, 0, length);
1488 unsigned char c = 0;
1489 const char *str = (const char *)src;
1490 int i=0;
1491 i = strlen(src)-1;
1492 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1493 bool evenlegth=false;
1494 if(i%2){ evenlegth=true;}
1495 unsigned char *val = (unsigned char *)dest+(length-1);
1496 while (i >= 0) {
1497 c = str[i];
1498 if (!isxdigit((int)c)) {
1499 printError(ErrBadArg, "Invalid hexadecimal value");
1500 return ErrBadArg;
1501 }
1502 if (c <= '9') c -= '0';
1503 else if (c >= 'a') c = c - 'a' + 10;
1504 else c = c - 'A' + 10;
1505 if(evenlegth)
1506 {
1507 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1508 else { *val = c; }
1509 }else{
1510 if (i % 2) { *val = *val | (c<<4); val--;}
1511 else { *val = c; }
1512 }
1513 i--;
1514 }
1515 break;
1516 }
1517 default:
1518 break;
1519 }
1520 return OK;
1521 }
1522
1523
1524 void AllDataType::convert(DataType srcType, void *src,
1525 DataType destType, void *dest, int length)
1526 {
1527 switch ((DataType) destType )
1528 {
1529 case typeInt: convertToInt(dest, src, srcType); break;
1530 case typeLong: convertToLong(dest, src, srcType); break;
1531 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1532 case typeShort: convertToShort(dest, src, srcType); break;
1533 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1534
1535 case typeFloat: convertToFloat(dest, src, srcType); break;
1536 case typeDouble: convertToDouble(dest, src, srcType); break;
1537
1538 //TODO
1539 case typeDecimal: convertToDouble(dest, src, srcType); break;
1540
1541 case typeString: convertToString(dest, src, srcType); break;
1542 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1543 case typeDate: convertToDate(dest, src, srcType); break;
1544 case typeTime: convertToTime(dest, src, srcType); break;
1545 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1546 default: return;
1547 }
1548 }
1549
1550 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1551 {
1552 switch(srcType)
1553 {
1554 case typeInt: *(int *)dest = *(int *)src; break;
1555 case typeLong: *(int *)dest =(int) *(long *)src; break;
1556 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1557 case typeShort: *(int *)dest =(int) *(short *)src; break;
1558 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1559
1560 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1561 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1562
1563 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1564
1565 case typeDate:
1566 case typeTime:
1567 case typeTimeStamp:
1568 case typeBinary:
1569 default: *(int *)dest = (int) 0;
1570 }
1571 }
1572
1573 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1574 {
1575 switch(srcType)
1576 {
1577 case typeInt: *(long *)dest =(long) *(int *)src; break;
1578 case typeLong: *(long *)dest = *(long *)src; break;
1579 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1580 case typeShort: *(long *)dest =(long) *(short *)src; break;
1581 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1582
1583 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1584 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1585
1586 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1587
1588 case typeDate:
1589 case typeTime:
1590 case typeTimeStamp:
1591 case typeBinary:
1592 default: *(long *)dest = (long) 0;
1593 }
1594 }
1595
1596
1597 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1598 {
1599 switch(srcType)
1600 {
1601 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1602 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1603 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1604 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1605 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1606
1607 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1608 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1609
1610 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1611
1612 case typeDate:
1613 case typeTime:
1614 case typeTimeStamp:
1615 case typeBinary:
1616 default: *(long long *)dest = (long long) 0;
1617 }
1618 }
1619
1620 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1621 {
1622 switch(srcType)
1623 {
1624 case typeInt: *(short*)dest =(short) *(int*)src; break;
1625 case typeLong: *(short*)dest = (short) *(long*)src; break;
1626 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1627 case typeShort: *(short*)dest = *(short*)src; break;
1628 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1629
1630 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1631 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1632
1633 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1634
1635 case typeDate:
1636 case typeTime:
1637 case typeTimeStamp:
1638 case typeBinary:
1639 default: *(short*)dest = (short) 0;
1640 }
1641 }
1642
1643 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1644 {
1645 switch(srcType)
1646 {
1647 case typeInt: *(char*)dest = (char) *(int*)src; break;
1648 case typeLong: *(char*)dest = (char) *(long*)src; break;
1649 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1650 case typeShort: *(char*)dest = (char) *(short*)src; break;
1651 case typeByteInt: *(char*)dest = *(char *)src; break;
1652
1653 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1654 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1655
1656 case typeString: sscanf((const char*)src, "%hhd", (char*) dest); break;
1657
1658 case typeDate:
1659 case typeTime:
1660 case typeTimeStamp:
1661 case typeBinary:
1662 default: *(char*)dest = (char) 0;
1663 }
1664 }
1665
1666 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1667 {
1668 switch(srcType)
1669 {
1670 case typeInt: *(float *)dest =(float) *(int *)src; break;
1671 case typeLong: *(float *)dest =(float) *(long *)src; break;
1672 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1673 case typeShort: *(float *)dest =(float) *(short *)src; break;
1674 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1675
1676 case typeFloat: *(float *)dest = *(float *)src; break;
1677 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1678
1679 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1680
1681 case typeDate:
1682 case typeTime:
1683 case typeTimeStamp:
1684 case typeBinary:
1685 default: *(float *)dest = (float) 0;
1686 }
1687 }
1688
1689 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1690 {
1691 switch(srcType)
1692 {
1693 case typeInt: *(double *)dest =(double) *(int *)src; break;
1694 case typeLong: *(double *)dest =(double) *(long *)src; break;
1695 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1696 case typeShort: *(double *)dest =(double) *(short *)src; break;
1697 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1698
1699 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1700 case typeDouble: *(double *)dest = *(double *)src; break;
1701
1702 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1703
1704 case typeDate:
1705 case typeTime:
1706 case typeTimeStamp:
1707 case typeBinary:
1708 default: *(double *)dest = (double) 0;
1709 }
1710 }
1711
1712 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length,TDBInfo tdbname )
1713 {
1714 switch(srcType)
1715 {
1716 case typeInt:
1717 {
1718 Util::itoa(*(int*)src, (char*)dest);
1719 break;
1720 }
1721 case typeLong:
1722 {
1723 sprintf ((char *)dest, "%ld", *(long *)src);
1724 break;
1725 }
1726 case typeLongLong:
1727 {
1728 sprintf ((char *)dest, "%lld", *(long long *)src);
1729 break;
1730 }
1731 case typeShort:
1732 {
1733 sprintf ((char *)dest, "%hd", *(short *)src);
1734 break;
1735 }
1736 case typeByteInt:
1737 {
1738 sprintf ((char *)dest, "%hhd", *(char *)src);
1739 break;
1740 }
1741
1742 case typeFloat:
1743 {
1744 sprintf ((char *)dest, "%f", *(float *)src);
1745 break;
1746 }
1747 case typeDouble:
1748 {
1749 sprintf ((char *) dest, "%lf", *(double *)src);
1750 break;
1751 }
1752
1753 case typeString:
1754 {
1755 strcpy((char*)dest, (char*)src);
1756 break;
1757 }
1758 case typeDate:
1759 {
1760 Date* dt = (Date*)src;
1761 sprintf((char*) dest, "%d/%d/%d", dt->year(),dt->month(), dt->dayOfMonth());
1762 break;
1763 }
1764 case typeTime:
1765 {
1766 Time* tm = (Time*)src;
1767 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1768 break;
1769 }
1770 case typeTimeStamp:
1771 {
1772 TimeStamp* tm = (TimeStamp*)src;
1773 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),tm->month(), tm->dayOfMonth(), tm->hours(),tm->minutes(), tm->seconds(), 0 );
1774 break;
1775 }
1776 case typeBinary:
1777 {
1778 unsigned char *c = (unsigned char *) src;
1779 unsigned char *str = (unsigned char *) dest;
1780 unsigned char p = 0;
1781 int i = 0;
1782 while (i < length) {
1783 p = *c >> 4;
1784 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1785 else sprintf((char *)str++, "%c", 'A' + p - 10);
1786 p = *c & 0xF;
1787 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1788 else sprintf((char *)str++, "%c", 'A' + p - 10);
1789 i++; c++;
1790 }
1791 break;
1792 }
1793
1794 default: ((char*)dest)[0] = '\0';
1795 }
1796
1797 }
1798 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1799 {
1800 switch(srcType)
1801 {
1802 case typeInt:
1803 case typeLong:
1804 case typeLongLong:
1805 case typeShort:
1806 case typeByteInt:
1807 case typeFloat:
1808 case typeDouble:
1809 case typeDate:
1810 case typeTime:
1811 case typeTimeStamp:
1812 case typeString:
1813 {
1814 Date *dt = (Date*) dest;
1815 dt->parseFrom((char*)src);
1816 break;
1817 }
1818 default: ((char*)dest)[0] = '\0';
1819 }
1820 }
1821
1822 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1823 {
1824 switch(srcType)
1825 {
1826 case typeInt:
1827 case typeLong:
1828 case typeLongLong:
1829 case typeShort:
1830 case typeByteInt:
1831 case typeFloat:
1832 case typeDouble:
1833 case typeDate:
1834 case typeTime:
1835 case typeTimeStamp:
1836 case typeString:
1837 {
1838 Time *dt = (Time*) dest;
1839 dt->parseFrom((char*)src);
1840 break;
1841 }
1842 default: ((char*)dest)[0] = '\0';
1843 }
1844 }
1845
1846 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1847 {
1848 switch(srcType)
1849 {
1850 case typeInt:
1851 case typeLong:
1852 case typeLongLong:
1853 case typeShort:
1854 case typeByteInt:
1855 case typeFloat:
1856 case typeDouble:
1857 case typeDate:
1858 case typeTime:
1859 case typeTimeStamp:
1860 case typeString:
1861 {
1862 TimeStamp *dt = (TimeStamp*) dest;
1863 dt->parseFrom((char*)src);
1864 break;
1865 }
1866 default: ((char*)dest)[0] = '\0';
1867 }
1868 }
1869
1870 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1871 {
1872 switch(srcType)
1873 {
1874 case typeString:
1875 {
1876 memset ((void *) dest, 0, length);
1877 unsigned char c = 0;
1878 const char *str = (const char *)src;
1879 int i=0;
1880 i = strlen((char*)src)-1;
1881 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1882 bool evenlegth=false;
1883 if(i%2){ evenlegth=true;}
1884 unsigned char *val = (unsigned char *)dest+(length-1);
1885 while (i >= 0) {
1886 c = str[i];
1887 if (c <= '9') c -= '0';
1888 else if (c >= 'a') c = c - 'a' + 10;
1889 else c = c - 'A' + 10;
1890 if(evenlegth)
1891 {
1892 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1893 else { *val = c; }
1894 }else{
1895 if (i % 2) { *val = *val | (c<<4); val--;}
1896 else { *val = c; }
1897 }
1898 i--;
1899 }
1900 break;
1901 }
1902 }
1903 }
1904 int AllDataType::printVal(void* src, DataType srcType, int length,int dbFlag )
1905 {
1906 //dbFlag is the database flag 0:mysql (default), 1:postgres
1907 int count = 0;
1908 switch(srcType)
1909 {
1910 case typeInt:
1911 {
1912 count = printf ("%d", *(int *)src);
1913 break;
1914 }
1915 case typeLong:
1916 {
1917 count = printf ("%ld", *(long *)src);
1918 break;
1919 }
1920 case typeLongLong:
1921 {
1922 if(1 == dbFlag){
1923 long long temp = 0;
1924 convertToLongLong((void*)&temp, src,typeString);
1925 count = printf ("%lld", temp );
1926 }
1927 else count = printf ("%lld", *(long long *)src);
1928 break;
1929 }
1930 case typeShort:
1931 {
1932 count = printf("%hd", *(short *)src);
1933 break;
1934 }
1935 case typeByteInt:
1936 {
1937 count = printf("%hhd", *(char *)src);
1938 break;
1939 }
1940
1941 case typeFloat:
1942 {
1943 count = printf("%f", *(float *)src);
1944 break;
1945 }
1946 case typeDouble:
1947 {
1948 if (*(double*)src > 9999999999999999.0F)
1949 count = printf("%g", *(double *)src);
1950 else
1951 count = printf("%lf", *(double *)src);
1952 break;
1953 }
1954
1955 case typeString:
1956 {
1957 count = printf("%s", (char*)src);
1958 break;
1959 }
1960 case typeDate:
1961 {
1962 Date* dt = (Date*)src;
1963 count = printf("%d/%d/%d", dt->year(),
1964 dt->month(), dt->dayOfMonth());
1965 break;
1966 }
1967 case typeTime:
1968 {
1969 Time* tm = (Time*)src;
1970 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1971 break;
1972 }
1973 case typeTimeStamp:
1974 {
1975 TimeStamp* tm = (TimeStamp*)src;
1976 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1977 tm->month(), tm->dayOfMonth(), tm->hours(),
1978 tm->minutes(), tm->seconds(), 0 );
1979 break;
1980 }
1981 case typeBinary:
1982 {
1983 unsigned char *c = (unsigned char *) src;
1984 unsigned char p = 0;
1985 int i = 0;
1986 bool isDigitFound=false;
1987 while (i < length) {
1988 p = *c >> 4;
1989 if(('0'+p)!='0'|| isDigitFound){
1990 if (p < 10) printf ("%c", '0' + p);
1991 else printf("%c", 'A' + p - 10);
1992 isDigitFound=true;
1993 }
1994 p = *c & 0xF;
1995 if(('0'+p)!='0' || isDigitFound){
1996 if (p < 10) printf ("%c", '0' + p);
1997 else printf("%c", 'A' + p - 10);
1998 isDigitFound=true;
1999 }
2000 i++; c++;
2001 }
2002 count = length * 2;
2003 break;
2004 }
2005 default: { printf("DataType not supported\n"); break; }
2006 }
2007 return count;
2008 }
Main memory database SQL engine (cvs import)