?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Varchar Implementation part 1
[csql.git] / src / storage / DataType.cxx
blobfb98642f03bacc19c6788d37f30d52041544999b
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 typeVarchar: return "VARCHAR";
470 case typeBinary: return "BINARY";
471 default: return "UNKNOWN";
472 }
473 }
474
475
476 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
477 {
478 switch(type)
479 {
480 case typeInt:
481 return SQL_INTEGER;
482 case typeLong:
483 return SQL_INTEGER;
484 case typeLongLong:
485 //TODO
486 return SQL_BIGINT;
487 case typeShort:
488 return SQL_SMALLINT;
489 case typeByteInt:
490 //TODO
491 return SQL_INTEGER;
492 case typeDouble:
493 return SQL_DOUBLE;
494 case typeFloat:
495 return SQL_REAL;
496 case typeDecimal:
497 //TODO
498 return SQL_INTEGER;
499 case typeDate:
500 return SQL_TYPE_DATE;
501 case typeTime:
502 return SQL_TYPE_TIME;
503 case typeTimeStamp:
504 return SQL_TYPE_TIMESTAMP;
505 case typeString:
506 return SQL_CHAR;
507 case typeBinary:
508 return SQL_BINARY;
509 }
510 return SQL_INTEGER;
511 }
512 SQLSMALLINT AllDataType::convertToCSQLSQLType(DataType type)
513 {
514 switch(type)
515 {
516 case typeInt:
517 return SQL_INTEGER;
518 case typeLong:
519 return SQL_INTEGER;
520 case typeLongLong:
521 //TODO
522 return SQL_BIGINT;
523 case typeShort:
524 return SQL_SMALLINT;
525 case typeByteInt:
526 //TODO
527 return SQL_TINYINT;
528 case typeDouble:
529 return SQL_DOUBLE;
530 case typeFloat:
531 return SQL_REAL;
532 case typeDecimal:
533 //TODO
534 return SQL_INTEGER;
535 case typeDate:
536 return SQL_TYPE_DATE;
537 case typeTime:
538 return SQL_TYPE_TIME;
539 case typeTimeStamp:
540 return SQL_TYPE_TIMESTAMP;
541 case typeString:
542 return SQL_CHAR;
543 case typeBinary:
544 return SQL_BINARY;
545 }
546 return SQL_INTEGER;
547 }
548
549 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type,TDBInfo tdbname)
550 {
551 switch(type)
552 {
553 case typeInt:
554 return SQL_C_SLONG;
555 case typeLong:
556 return SQL_C_SLONG;
557 case typeLongLong:
558 {
559 if(tdbname == postgres)
560 return SQL_C_CHAR;
561 else
562 return SQL_C_SBIGINT;
563 }
564 case typeShort:
565 return SQL_C_SSHORT;
566 case typeByteInt:
567 return SQL_C_STINYINT;
568 case typeDouble:
569 return SQL_C_DOUBLE;
570 case typeFloat:
571 return SQL_C_FLOAT;
572 case typeDecimal:
573 //TODO
574 return SQL_INTEGER;
575 case typeDate:
576 return SQL_C_TYPE_DATE;
577 case typeTime:
578 return SQL_C_TYPE_TIME;
579 case typeTimeStamp:
580 return SQL_C_TYPE_TIMESTAMP;
581 case typeString:
582 return SQL_C_CHAR;
583 case typeBinary:
584 return SQL_C_BINARY;
585 }
586 return SQL_C_SLONG;
587 }
588
589 DataType AllDataType::convertFromSQLType(SQLSMALLINT type,int length,int scale,TDBInfo tdbname)
590 {
591 if(tdbname==postgres)
592 {
593 switch(type)
594 {
595 case SQL_INTEGER :
596 return typeInt;
597 case SQL_SMALLINT:
598 return typeShort;
599 case SQL_BIGINT:
600 return typeLongLong;
601 case SQL_FLOAT:
602 case SQL_DOUBLE:
603 return typeDouble;
604 case SQL_REAL:
605 return typeFloat;
606 case SQL_TYPE_DATE:
607 return typeDate;
608 case SQL_TYPE_TIME :
609 return typeTime;
610 case SQL_TYPE_TIMESTAMP :
611 return typeTimeStamp;
612 case SQL_CHAR:
613 return typeString;
614 case SQL_LONGVARCHAR:
615 return typeString;
616 case SQL_VARCHAR:
617 return typeString;
618 case SQL_BINARY:
619 return typeBinary;
620 }
621 return typeInt;
622 }
623 switch(type)
624 {
625 case SQL_TINYINT:
626 return typeByteInt;
627 case SQL_INTEGER :
628 return typeInt;
629 case SQL_SMALLINT:
630 return typeShort;
631 case SQL_BIGINT:
632 return typeLongLong;
633 case SQL_DOUBLE:
634 return typeDouble;
635 case SQL_FLOAT:
636 case SQL_REAL:
637 return typeFloat;
638 case SQL_TYPE_DATE:
639 return typeDate;
640 case SQL_TYPE_TIME :
641 return typeTime;
642 case SQL_TYPE_TIMESTAMP :
643 return typeTimeStamp;
644 case SQL_CHAR:
645 return typeString;
646 case SQL_LONGVARCHAR:
647 return typeString;
648 case SQL_VARCHAR:
649 return typeString;
650 case SQL_BINARY:
651 return typeBinary;
652 }
653 return typeInt;
654 }
655 void AllDataType::subVal(void* dest, void *src, DataType type)
656 {
657 switch(type)
658 {
659 case typeInt:
660 *(int*)dest = *(int*)dest - *(int*)src;
661 break;
662 case typeLong:
663 *(long*)dest = *(long*)dest - *(long*)src;
664 break;
665 case typeLongLong:
666 *(long long*)dest = *(long long*)dest - *(long long*)src;
667 break;
668 case typeShort:
669 *(short*)dest = *(short*)dest - *(short*)src;
670 break;
671 case typeByteInt:
672 *(char*)dest = *(char*)dest - *(char*)src;
673 break;
674 case typeDouble:
675 *(double*)dest = *(double*)dest - *(double*)src;
676 break;
677 case typeFloat:
678 *(float*)dest = *(float*)dest - *(float*)src;
679 break;
680 case typeDecimal:
681 case typeDate:
682 case typeTime:
683 case typeTimeStamp:
684 case typeBinary:
685 default:
686 break;
687 }
688 return;
689 }
690 void AllDataType::mulVal(void* dest, void *src, DataType type)
691 {
692 switch(type)
693 {
694 case typeInt:
695 *(int*)dest = *(int*)dest * (*(int*)src);
696 break;
697 case typeLong:
698 *(long*)dest = *(long*)dest * (*(long*)src);
699 break;
700 case typeLongLong:
701 *(long long*)dest = *(long long*)dest * (*(long long*)src);
702 break;
703 case typeShort:
704 *(short*)dest = *(short*)dest * (*(short*)src);
705 break;
706 case typeByteInt:
707 *(char*)dest = *(char*)dest * (*(char*)src);
708 break;
709 case typeDouble:
710 *(double*)dest = *(double*)dest * (*(double*)src);
711 break;
712 case typeFloat:
713 *(float*)dest = *(float*)dest * (*(float*)src);
714 break;
715 case typeDecimal:
716 case typeDate:
717 case typeTime:
718 case typeTimeStamp:
719 case typeBinary:
720 default:
721 break;
722 }
723 return;
724 }
725 void AllDataType::mudVal(void* dest, void *src, DataType type)
726 {
727 if (type == typeInt)
728 {
729 *(int*)dest = *(int*)dest % (*(int*)src);
730 return;
731 }
732 switch(type)
733 {
734 case typeInt:
735 *(int*)dest = *(int*)dest % (*(int*)src);
736 break;
737 case typeLong:
738 *(long*)dest = *(long*)dest % (*(long*)src);
739 break;
740 case typeLongLong:
741 *(long long*)dest = *(long long*)dest % (*(long long*)src);
742 break;
743 case typeShort:
744 *(short*)dest = *(short*)dest % (*(short*)src);
745 break;
746 case typeByteInt:
747 *(char*)dest = *(char*)dest % (*(char*)src);
748 break;
749 case typeDouble:
750 *(double*)dest = *(long long*)dest % (*(long long*)src);
751 break;
752 case typeFloat:
753 *(float*)dest = *(int*)dest % (*(int*)src);
754 break;
755 case typeDecimal:
756 case typeDate:
757 case typeTime:
758 case typeTimeStamp:
759 case typeBinary:
760 default:
761 break;
762 }
763 return;
764 }
765 void AllDataType::divVal(void* dest, void *src, DataType type)
766 {
767 if (type == typeInt)
768 {
769 *(int*)dest = *(int*)dest / (*(int*)src);
770 return;
771 }
772 switch(type)
773 {
774 case typeInt:
775 *(int*)dest = *(int*)dest / (*(int*)src);
776 break;
777 case typeLong:
778 *(long*)dest = *(long*)dest / (*(long*)src);
779 break;
780 case typeLongLong:
781 *(long long*)dest = *(long long*)dest / (*(long long*)src);
782 break;
783 case typeShort:
784 *(short*)dest = *(short*)dest / (*(short*)src);
785 break;
786 case typeByteInt:
787 *(char*)dest = *(char*)dest / (*(char*)src);
788 break;
789 case typeDouble:
790 *(double*)dest = *(double *)dest / (*(double*)src);
791 break;
792 case typeFloat:
793 *(float*)dest = *(float*)dest / (*(float*)src);
794 break;
795 case typeDecimal:
796 case typeDate:
797 case typeTime:
798 case typeTimeStamp:
799 case typeBinary:
800 default:
801 break;
802 }
803 return;
804 }
805 void AllDataType::divVal(double* dest, int src, DataType type)
806 {
807 switch(type)
808 {
809 case typeInt:
810 case typeLong:
811 case typeLongLong:
812 case typeShort:
813 case typeByteInt:
814 case typeDouble:
815 case typeFloat:
816 case typeDecimal:
817 *dest = *dest / src;
818 break;
819 //TODO::for porting
820 case typeDate:
821 case typeTime:
822 case typeTimeStamp:
823 case typeBinary:
824 default:
825 break;
826 }
827 return;
828 }
829
830 void AllDataType::increment(void* dest, void *src, DataType type)
831 {
832 switch(type)
833 {
834 case typeInt:
835 *(int*)dest = *(int*)src + 1;
836 break;
837 case typeLong:
838 *(long*)dest = *(long*)src + 1;
839 break;
840 case typeLongLong:
841 *(long long*)dest = *(long long*)src + 1;
842 break;
843 case typeByteInt:
844 *(char*)dest = *(char*)src + 1;
845 break;
846 case typeShort:
847 *(short*)dest = *(short*)src + 1;
848 break;
849 case typeDouble:
850 *(double*)dest = *(double*)src + 1;
851 break;
852 case typeFloat:
853 *(float*)dest = *(float*)src+ 1;
854 break;
855 default:
856 break;
857 }
858 }
859
860 bool AllDataType::isValueZero(void *src, DataType type)
861 {
862 switch(type)
863 {
864 case typeInt:
865 if (*(int*)src == 0) return true;
866 else return false;
867 case typeLong:
868 if (*(int*)src == 0) return true;
869 else return false;
870 case typeLongLong:
871 if (*(int*)src == 0) return true;
872 else return false;
873 case typeShort:
874 if (*(int*)src == 0) return true;
875 else return false;
876 case typeDouble:
877 if (*(int*)src == 0) return true;
878 else return false;
879 case typeFloat:
880 if (*(int*)src == 0) return true;
881 else return false;
882 default:
883 break;
884 }
885 return false;
886 }
887
888 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
889 {
890 printf("This function should never be called by anyone\n");
891 if (OpEquals == op) {
892 if (*(int*)src1 == *(int*)src2) return true;
893 else return false;
894 }else if (OpGreaterThan == op) {
895 if (*(int*)src1 > *(int*)src2) return true;
896 else return false;
897 }else if (OpLessThan == op) {
898 if (*(int*)src1 < *(int*)src2) return true;
899 else return false;
900 }else if (OpLessThanEquals == op) {
901 if (*(int*)src1 <= *(int*)src2) return true;
902 else return false;
903 }else if (OpGreaterThanEquals == op) {
904 if (*(int*)src1 >= *(int*)src2) return true;
905 else return false;
906 }else if (OpNotEquals == op) {
907 if (*(int*)src1 != *(int*)src2) return true;
908 else return false;
909 }
910 return false;
911 }
912
913 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
914 {
915 bool result = false;
916 switch(op)
917 {
918 case OpEquals:
919 if (*(long*)src1 == *(long*)src2) result = true;
920 else result = false;
921 break;
922 case OpNotEquals:
923 if (*(long*)src1 != *(long*)src2) result = true;
924 else result = false;
925 break;
926 case OpLessThan:
927 if (*(long*)src1 < *(long*)src2) result = true;
928 else result = false;
929 break;
930 case OpLessThanEquals:
931 if (*(long*)src1 <= *(long*)src2) result = true;
932 else result = false;
933 break;
934 case OpGreaterThan:
935 if (*(long*)src1 > *(long*)src2) result = true;
936 else result = false;
937 break;
938 case OpGreaterThanEquals:
939 if (*(long*)src1 >= *(long*)src2) result = true;
940 else result = false;
941 break;
942 }
943 return result;
944 }
945
946 bool AllDataType::compareLongLongVal(void* src1, void *src2,
947 ComparisionOp op)
948 {
949 bool result = false;
950 switch(op)
951 {
952 case OpEquals:
953 if (*(long long*)src1 == *(long long*)src2) result = true;
954 else result = false;
955 break;
956 case OpNotEquals:
957 if (*(long long*)src1 != *(long long*)src2) result = true;
958 else result = false;
959 break;
960 case OpLessThan:
961 if (*(long long*)src1 < *(long long*)src2) result = true;
962 else result = false;
963 break;
964 case OpLessThanEquals:
965 if (*(long long*)src1 <= *(long long*)src2) result = true;
966 else result = false;
967 break;
968 case OpGreaterThan:
969 if (*(long long*)src1 > *(long long*)src2) result = true;
970 else result = false;
971 break;
972 case OpGreaterThanEquals:
973 if (*(long long*)src1 >= *(long long*)src2) result = true;
974 else result = false;
975 break;
976 }
977 return result;
978 }
979
980 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
981 {
982 bool result = false;
983 switch(op)
984 {
985 case OpEquals:
986 if (*(short*)src1 == *(short*)src2) result = true;
987 else result = false;
988 break;
989 case OpNotEquals:
990 if (*(short*)src1 != *(short*)src2) result = true;
991 else result = false;
992 break;
993 case OpLessThan:
994 if (*(short*)src1 < *(short*)src2) result = true;
995 else result = false;
996 break;
997 case OpLessThanEquals:
998 if (*(short*)src1 <= *(short*)src2) result = true;
999 else result = false;
1000 break;
1001 case OpGreaterThan:
1002 if (*(short*)src1 > *(short*)src2) result = true;
1003 else result = false;
1004 break;
1005 case OpGreaterThanEquals:
1006 if (*(short*)src1 >= *(short*)src2) result = true;
1007 else result = false;
1008 break;
1009 }
1010 return result;
1011 }
1012
1013 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
1014 {
1015 bool result = false;
1016 switch(op)
1017 {
1018 case OpEquals:
1019 if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
1020 else result = false;
1021 break;
1022 case OpNotEquals:
1023 if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
1024 else result = false;
1025 break;
1026 case OpLessThan:
1027 if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
1028 else result = false;
1029 break;
1030 case OpLessThanEquals:
1031 if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
1032 else result = false;
1033 break;
1034 case OpGreaterThan:
1035 if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
1036 else result = false;
1037 break;
1038 case OpGreaterThanEquals:
1039 if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
1040 else result = false;
1041 break;
1042 }
1043 return result;
1044 }
1045
1046 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
1047 {
1048 bool result = false;
1049 switch(op)
1050 {
1051 case OpEquals:
1052 if (*(double*)src1 == *(double*)src2) result = true;
1053 else result = false;
1054 break;
1055 case OpNotEquals:
1056 if (*(double*)src1 != *(double*)src2) result = true;
1057 else result = false;
1058 break;
1059 case OpLessThan:
1060 if (*(double*)src1 < *(double*)src2) result = true;
1061 else result = false;
1062 break;
1063 case OpLessThanEquals:
1064 if (*(double*)src1 <= *(double*)src2) result = true;
1065 else result = false;
1066 break;
1067 case OpGreaterThan:
1068 if (*(double*)src1 > *(double*)src2) result = true;
1069 else result = false;
1070 break;
1071 case OpGreaterThanEquals:
1072 if (*(double*)src1 >= *(double*)src2) result = true;
1073 else result = false;
1074 break;
1075 }
1076 return result;
1077 }
1078
1079 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
1080 {
1081 bool result = false;
1082 switch(op)
1083 {
1084 case OpEquals:
1085 if (*(float*)src1 == *(float*)src2) result = true;
1086 else result = false;
1087 break;
1088 case OpNotEquals:
1089 if (*(float*)src1 != *(float*)src2) result = true;
1090 else result = false;
1091 break;
1092 case OpLessThan:
1093 if (*(float*)src1 < *(float*)src2) result = true;
1094 else result = false;
1095 break;
1096 case OpLessThanEquals:
1097 if (*(float*)src1 <= *(float*)src2) result = true;
1098 else result = false;
1099 break;
1100 case OpGreaterThan:
1101 if (*(float*)src1 > *(float*)src2) result = true;
1102 else result = false;
1103 break;
1104 case OpGreaterThanEquals:
1105 if (*(float*)src1 >= *(float*)src2) result = true;
1106 else result = false;
1107 break;
1108 }
1109 return result;
1110 }
1111
1112 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
1113 {
1114 bool result = false;
1115 switch(op)
1116 {
1117 case OpEquals:
1118 if (*(Date*)src1 == *(Date*)src2) result = true;
1119 else result = false;
1120 break;
1121 case OpNotEquals:
1122 if (*(Date*)src1 != *(Date*)src2) result = true;
1123 else result = false;
1124 break;
1125 case OpLessThan:
1126 if (*(Date*)src1 < *(Date*)src2) result = true;
1127 else result = false;
1128 break;
1129 case OpLessThanEquals:
1130 if (*(Date*)src1 <= *(Date*)src2) result = true;
1131 else result = false;
1132 break;
1133 case OpGreaterThan:
1134 if (*(Date*)src1 > *(Date*)src2) result = true;
1135 else result = false;
1136 break;
1137 case OpGreaterThanEquals:
1138 if (*(Date*)src1 >= *(Date*)src2) result = true;
1139 else result = false;
1140 break;
1141 }
1142 return result;
1143 }
1144
1145 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
1146 {
1147 bool result = false;
1148 switch(op)
1149 {
1150 case OpEquals:
1151 if (*(Time*)src1 == *(Time*)src2) result = true;
1152 else result = false;
1153 break;
1154 case OpNotEquals:
1155 if (*(Time*)src1 != *(Time*)src2) result = true;
1156 else result = false;
1157 break;
1158 case OpLessThan:
1159 if (*(Time*)src1 < *(Time*)src2) result = true;
1160 else result = false;
1161 break;
1162 case OpLessThanEquals:
1163 if (*(Time*)src1 <= *(Time*)src2) result = true;
1164 else result = false;
1165 break;
1166 case OpGreaterThan:
1167 if (*(Time*)src1 > *(Time*)src2) result = true;
1168 else result = false;
1169 break;
1170 case OpGreaterThanEquals:
1171 if (*(Time*)src1 >= *(Time*)src2) result = true;
1172 else result = false;
1173 break;
1174 }
1175 return result;
1176 }
1177
1178 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
1179 {
1180 bool result = false;
1181 switch(op)
1182 {
1183 case OpEquals:
1184 if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
1185 else result = false;
1186 break;
1187 case OpNotEquals:
1188 if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
1189 else result = false;
1190 break;
1191 case OpLessThan:
1192 if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
1193 else result = false;
1194 break;
1195 case OpLessThanEquals:
1196 if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
1197 else result = false;
1198 break;
1199 case OpGreaterThan:
1200 if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
1201 else result = false;
1202 break;
1203 case OpGreaterThanEquals:
1204 if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
1205 else result = false;
1206 break;
1207 }
1208 return result;
1209 }
1210
1211 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
1212 {
1213 if (OpEquals == op) {
1214 if (strcmp((char*)src1, (char*)src2) ==0) return true;
1215 else return false;
1216 }else if (OpGreaterThan == op) {
1217 if (strcmp((char*)src1, (char*)src2) >0) return true;
1218 else return false;
1219 }else if (OpLessThan == op) {
1220 if (strcmp((char*)src1, (char*)src2) <0 ) return true;
1221 else return false;
1222 }else if (OpLessThanEquals == op) {
1223 // printf("Illegal Operator:Not Supported for String\n");
1224 // return false;
1225 if (strcmp((char*)src1, (char*)src2)<= 0) return true;
1226 else return false;
1227 }else if (OpGreaterThanEquals == op) {
1228 // printf("Illegal Operator:Not Supported for String\n");
1229 // return false;
1230 if (strcmp((char*)src1, (char*)src2) >=0) return true;
1231 else return false;
1232 }else if (OpNotEquals == op) {
1233 if (strcmp((char*)src1, (char*)src2) != 0) return true;
1234 else return false;
1235 }else if (OpLike == op) {
1236 return !os::strmatch((char*)src2, (char*)src1);
1237 }
1238 printf("Illegeal Operator:Not supported for String\n");
1239 return false;
1240 }
1241
1242 bool AllDataType::compareBinaryVal(void* src1, void *src2,
1243 ComparisionOp op, int length)
1244 {
1245 bool result = false;
1246 int ret = os::memcmp(src1, src2, length);
1247 switch(op)
1248 {
1249 case OpEquals:
1250 if (ret == 0 ) result= true; else result = false;
1251 break;
1252 case OpNotEquals:
1253 if (ret != 0 ) result= true; else result = false;
1254 break;
1255 case OpLessThan:
1256 if (ret < 0 ) result= true; else result = false;
1257 break;
1258 case OpLessThanEquals:
1259 printf("Illegal Operator:Not Supported for Binary\n");
1260 break;
1261 case OpGreaterThan:
1262 if (ret > 0 ) result= true; else result = false;
1263 break;
1264 case OpGreaterThanEquals:
1265 printf("Illegal Operator:Not Supported for Binary\n");
1266 break;
1267 }
1268 return result;
1269 }
1270
1271 void* AllDataType::alloc(DataType type, int length)
1272 {
1273 void *dest;
1274 switch(type)
1275 {
1276 case typeInt:
1277 dest = malloc(sizeof(int));
1278 break;
1279 case typeLong:
1280 dest = malloc(sizeof(long));
1281 break;
1282 case typeLongLong:
1283 dest = malloc(sizeof(long long));
1284 break;
1285 case typeShort:
1286 dest = malloc(sizeof(short));
1287 break;
1288 case typeByteInt:
1289 dest = malloc(sizeof(char));
1290 break;
1291 case typeDouble:
1292 dest = malloc(sizeof(double));
1293 break;
1294 case typeFloat:
1295 dest = malloc(sizeof(float));
1296 break;
1297 case typeDecimal:
1298 //TODO::for porting
1299 //fldDef.length_ = sizeof(long double);
1300 break;
1301 case typeVarchar:
1302 case typeString:
1303 if (length == 0 ) return NULL;
1304 dest = malloc(length);
1305 break;
1306 case typeBinary:
1307 if (length == 0 || length > 512) return NULL;
1308 dest = malloc(length);
1309 memset(dest, 0, length);
1310 break;
1311 case typeDate:
1312 dest = malloc(sizeof(Date));
1313 break;
1314 case typeTime:
1315 dest = malloc(sizeof(Time));
1316 break;
1317 case typeTimeStamp:
1318 dest = malloc(sizeof(TimeStamp));
1319 break;
1320 }
1321 return dest;
1322 }
1323
1324 void AllDataType::memoryset(void *value,DataType type)
1325 {
1326 switch(type)
1327 {
1328 case typeInt:
1329 value= ::memset(value, 0, sizeof(int));
1330 break;
1331 case typeLong:
1332 value = ::memset(value, 0, sizeof(long));
1333 break;
1334 case typeLongLong:
1335 value =::memset(value, 0, sizeof(long long));
1336 break;
1337 case typeShort:
1338 value = ::memset(value, 0, sizeof(short));
1339 break;
1340 case typeByteInt:
1341 value = ::memset(value, 0, sizeof(char));
1342 break;
1343 case typeDouble:
1344 value = ::memset(value, 0, sizeof(double));
1345 break;
1346 case typeFloat:
1347 value = ::memset(value, 0, sizeof(float));
1348 break;
1349 case typeDecimal:
1350 break;
1351 case typeString:
1352 *(char*)value = '\0';
1353 //if (length == 0 ) return NULL;
1354 //dest = malloc(length);
1355 break;
1356 case typeBinary:
1357 /* if (length == 0 || length > 256 ) return NULL;
1358
1359 memset(dest, 0, length);*/
1360 break;
1361 case typeDate:
1362 value = ::memset(value, 0, sizeof(Date));
1363 break;
1364 case typeTime:
1365 value = ::memset(value, 0, sizeof(Time));
1366 break;
1367 case typeTimeStamp:
1368 value = ::memset(value, 0, sizeof(TimeStamp));
1369 break;
1370 defalut:
1371 break;
1372 }
1373 }
1374
1375
1376 DbRetVal AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1377 {
1378 switch(type)
1379 {
1380 case typeInt: {
1381 int val;
1382 sscanf( src, "%d", &val);
1383 *(int*)dest = val;
1384 break; }
1385 case typeLong: {
1386 long val;
1387 sscanf( src, "%ld", &val);
1388 *(long*)dest = val;
1389 break; }
1390 case typeLongLong: {
1391 long long val;
1392 sscanf( src, "%lld", &val);
1393 *(long long*)dest = val;
1394 break; }
1395 case typeShort: {
1396 short val;
1397 sscanf( src, "%hd", &val);
1398 *(short*)dest = val;
1399 break; }
1400 case typeByteInt: {
1401 char val;
1402 sscanf( src, "%hhd", &val);
1403 *(char*)dest = *(char *)&val;
1404 break; }
1405 case typeDouble: {
1406 double val;
1407 sscanf( src, "%lg", &val);
1408 *(double*)dest = val;
1409 break; }
1410 case typeFloat: {
1411 float val;
1412 sscanf( src, "%f", &val);
1413 *(float*)dest = val;
1414 break; }
1415 case typeDecimal:
1416 //TODO::for porting
1417 case typeString:
1418 case typeVarchar: {
1419 strncpy((char*)dest, (char*)src, length);
1420 char *d =(char*)dest;
1421 d[length-1] = '\0';
1422 break;}
1423 case typeDate: {
1424 int d,m,y,res=0;
1425 if (strlen(src) == 11) {
1426 if ( src[6] == '-' || src[6] == '/' ) {
1427 Date::changeToCsqlFormat(src);
1428 }
1429 }
1430 res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1431 if( res != 3 )
1432 res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1433 if (strcmp(src,"now")==0 || strcmp(src,"NOW")==0){
1434 Date *dt = (Date*) dest;
1435 dt->parseFrom((char*)src);
1436 break;
1437 }
1438 if( res != 3 )
1439 {
1440 fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1441 d=m=y=0;
1442 }
1443 Date dateObj(y,m,d);
1444 *(Date*)dest = dateObj;
1445 break; }
1446 case typeTime: {
1447 int h,m,s,res=0;
1448 res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1449 if(strcmp(src,"now")==0 || strcmp(src,"NOW")==0){
1450 Time *dt = (Time*) dest;
1451 dt->parseFrom((char*)src);
1452 break;
1453 }
1454 if( res != 3 )
1455 {
1456 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1457 h=m=s=0;
1458 }
1459 Time timeObj(h,m,s);
1460 *(Time*)dest = timeObj;
1461 break; }
1462 case typeTimeStamp: {
1463 int d,m,y, h,mn,s, res=0;
1464 bool isNow = ( strcasecmp(src,"now")==0 );
1465 if(!isNow && isalpha(int(src[5]))) {
1466 TimeStamp::changeToCsqlFormat(src);
1467 }
1468 res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1469 if( res != 6 )
1470 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1471 if( res != 6 )
1472 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1473 if( res != 6 )
1474 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1475
1476 if(isNow){
1477 TimeStamp *dt = (TimeStamp*) dest;
1478 dt->parseFrom((char*)src);
1479 break;
1480 }
1481 if ( res != 6 )
1482 {
1483 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1484 d=m=y=h=mn=s=0;
1485 }
1486 TimeStamp timeStampObj(y,m,d,h,mn,s);
1487 *(TimeStamp*)dest = timeStampObj;
1488 break; }
1489 case typeBinary: {
1490 memset ((void *) dest, 0, length);
1491 unsigned char c = 0;
1492 const char *str = (const char *)src;
1493 int i=0;
1494 i = strlen(src)-1;
1495 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1496 bool evenlegth=false;
1497 if(i%2){ evenlegth=true;}
1498 unsigned char *val = (unsigned char *)dest+(length-1);
1499 while (i >= 0) {
1500 c = str[i];
1501 if (!isxdigit((int)c)) {
1502 printError(ErrBadArg, "Invalid hexadecimal value");
1503 return ErrBadArg;
1504 }
1505 if (c <= '9') c -= '0';
1506 else if (c >= 'a') c = c - 'a' + 10;
1507 else c = c - 'A' + 10;
1508 if(evenlegth)
1509 {
1510 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1511 else { *val = c; }
1512 }else{
1513 if (i % 2) { *val = *val | (c<<4); val--;}
1514 else { *val = c; }
1515 }
1516 i--;
1517 }
1518 break;
1519 }
1520 default:
1521 break;
1522 }
1523 return OK;
1524 }
1525
1526
1527 void AllDataType::convert(DataType srcType, void *src,
1528 DataType destType, void *dest, int length)
1529 {
1530 switch ((DataType) destType )
1531 {
1532 case typeInt: convertToInt(dest, src, srcType); break;
1533 case typeLong: convertToLong(dest, src, srcType); break;
1534 case typeLongLong: convertToLongLong(dest, src, srcType); break;
1535 case typeShort: convertToShort(dest, src, srcType); break;
1536 case typeByteInt: convertToByteInt(dest, src, srcType); break;
1537
1538 case typeFloat: convertToFloat(dest, src, srcType); break;
1539 case typeDouble: convertToDouble(dest, src, srcType); break;
1540
1541 //TODO
1542 case typeDecimal: convertToDouble(dest, src, srcType); break;
1543
1544 case typeString: convertToString(dest, src, srcType); break;
1545 case typeBinary: convertToBinary(dest, src, srcType,length); break;
1546 case typeDate: convertToDate(dest, src, srcType); break;
1547 case typeTime: convertToTime(dest, src, srcType); break;
1548 case typeTimeStamp: convertToTimeStamp(dest, src, srcType); break;
1549 default: return;
1550 }
1551 }
1552
1553 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1554 {
1555 switch(srcType)
1556 {
1557 case typeInt: *(int *)dest = *(int *)src; break;
1558 case typeLong: *(int *)dest =(int) *(long *)src; break;
1559 case typeLongLong: *(int *)dest =(int) *(long long *)src; break;
1560 case typeShort: *(int *)dest =(int) *(short *)src; break;
1561 case typeByteInt: *(int *)dest =(int) *(char *)src; break;
1562
1563 case typeFloat: *(int *)dest = (int) *(float *)src; break;
1564 case typeDouble: *(int *)dest =(int) *(double *)src; break;
1565
1566 case typeString: sscanf((const char*)src, "%d", (int*) dest); break;
1567
1568 case typeDate:
1569 case typeTime:
1570 case typeTimeStamp:
1571 case typeBinary:
1572 default: *(int *)dest = (int) 0;
1573 }
1574 }
1575
1576 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1577 {
1578 switch(srcType)
1579 {
1580 case typeInt: *(long *)dest =(long) *(int *)src; break;
1581 case typeLong: *(long *)dest = *(long *)src; break;
1582 case typeLongLong: *(long *)dest =(long) *(long long *)src; break;
1583 case typeShort: *(long *)dest =(long) *(short *)src; break;
1584 case typeByteInt: *(long *)dest =(long) *(char *)src; break;
1585
1586 case typeFloat: *(long *)dest = (long) *(float *)src; break;
1587 case typeDouble: *(long *)dest =(long) *(double *)src; break;
1588
1589 case typeString: sscanf((const char*)src, "%ld", (long*) dest); break;
1590
1591 case typeDate:
1592 case typeTime:
1593 case typeTimeStamp:
1594 case typeBinary:
1595 default: *(long *)dest = (long) 0;
1596 }
1597 }
1598
1599
1600 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1601 {
1602 switch(srcType)
1603 {
1604 case typeInt: *(long long *)dest =(long long) *(int *)src; break;
1605 case typeLong: *(long long *)dest = (long long) *(long *)src; break;
1606 case typeLongLong: *(long long *)dest = *(long long *)src; break;
1607 case typeShort: *(long long *)dest =(long long) *(short *)src; break;
1608 case typeByteInt: *(long long *)dest =(long long) *(char *)src; break;
1609
1610 case typeFloat: *(long long *)dest = (long long) *(float *)src; break;
1611 case typeDouble: *(long long *)dest =(long long) *(double *)src; break;
1612
1613 case typeString: sscanf((const char*)src, "%lld", (long long*) dest); break;
1614
1615 case typeDate:
1616 case typeTime:
1617 case typeTimeStamp:
1618 case typeBinary:
1619 default: *(long long *)dest = (long long) 0;
1620 }
1621 }
1622
1623 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1624 {
1625 switch(srcType)
1626 {
1627 case typeInt: *(short*)dest =(short) *(int*)src; break;
1628 case typeLong: *(short*)dest = (short) *(long*)src; break;
1629 case typeLongLong: *(short*)dest = (short) *(long long*)src; break;
1630 case typeShort: *(short*)dest = *(short*)src; break;
1631 case typeByteInt: *(short*)dest =(short) *(char *)src; break;
1632
1633 case typeFloat: *(short*)dest = (short) *(float *)src; break;
1634 case typeDouble: *(short*)dest =(short) *(double *)src; break;
1635
1636 case typeString: sscanf((const char*)src, "%hd", (short*) dest); break;
1637
1638 case typeDate:
1639 case typeTime:
1640 case typeTimeStamp:
1641 case typeBinary:
1642 default: *(short*)dest = (short) 0;
1643 }
1644 }
1645
1646 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1647 {
1648 switch(srcType)
1649 {
1650 case typeInt: *(char*)dest = (char) *(int*)src; break;
1651 case typeLong: *(char*)dest = (char) *(long*)src; break;
1652 case typeLongLong: *(char*)dest = (char) *(long long*)src; break;
1653 case typeShort: *(char*)dest = (char) *(short*)src; break;
1654 case typeByteInt: *(char*)dest = *(char *)src; break;
1655
1656 case typeFloat: *(char*)dest = (char) *(float *)src; break;
1657 case typeDouble: *(char*)dest =(char) *(double *)src; break;
1658
1659 case typeString: sscanf((const char*)src, "%hhd", (char*) dest); break;
1660
1661 case typeDate:
1662 case typeTime:
1663 case typeTimeStamp:
1664 case typeBinary:
1665 default: *(char*)dest = (char) 0;
1666 }
1667 }
1668
1669 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1670 {
1671 switch(srcType)
1672 {
1673 case typeInt: *(float *)dest =(float) *(int *)src; break;
1674 case typeLong: *(float *)dest =(float) *(long *)src; break;
1675 case typeLongLong: *(float *)dest =(float) *(long long *)src; break;
1676 case typeShort: *(float *)dest =(float) *(short *)src; break;
1677 case typeByteInt: *(float *)dest =(float) *(char *)src; break;
1678
1679 case typeFloat: *(float *)dest = *(float *)src; break;
1680 case typeDouble: *(float *)dest =(float) *(double *)src; break;
1681
1682 case typeString: sscanf((const char*)src, "%f", (float*) dest); break;
1683
1684 case typeDate:
1685 case typeTime:
1686 case typeTimeStamp:
1687 case typeBinary:
1688 default: *(float *)dest = (float) 0;
1689 }
1690 }
1691
1692 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1693 {
1694 switch(srcType)
1695 {
1696 case typeInt: *(double *)dest =(double) *(int *)src; break;
1697 case typeLong: *(double *)dest =(double) *(long *)src; break;
1698 case typeLongLong: *(double *)dest =(double) *(long long *)src; break;
1699 case typeShort: *(double *)dest =(double) *(short *)src; break;
1700 case typeByteInt: *(double *)dest =(double) *(char *)src; break;
1701
1702 case typeFloat: *(double *)dest =(double) *(float *)src; break;
1703 case typeDouble: *(double *)dest = *(double *)src; break;
1704
1705 case typeString: sscanf((const char*)src, "%lf", (double*) dest); break;
1706
1707 case typeDate:
1708 case typeTime:
1709 case typeTimeStamp:
1710 case typeBinary:
1711 default: *(double *)dest = (double) 0;
1712 }
1713 }
1714
1715 void AllDataType::convertToString( void* dest, void* src, DataType srcType, int length,TDBInfo tdbname )
1716 {
1717 switch(srcType)
1718 {
1719 case typeInt:
1720 {
1721 Util::itoa(*(int*)src, (char*)dest);
1722 break;
1723 }
1724 case typeLong:
1725 {
1726 sprintf ((char *)dest, "%ld", *(long *)src);
1727 break;
1728 }
1729 case typeLongLong:
1730 {
1731 sprintf ((char *)dest, "%lld", *(long long *)src);
1732 break;
1733 }
1734 case typeShort:
1735 {
1736 sprintf ((char *)dest, "%hd", *(short *)src);
1737 break;
1738 }
1739 case typeByteInt:
1740 {
1741 sprintf ((char *)dest, "%hhd", *(char *)src);
1742 break;
1743 }
1744
1745 case typeFloat:
1746 {
1747 sprintf ((char *)dest, "%f", *(float *)src);
1748 break;
1749 }
1750 case typeDouble:
1751 {
1752 sprintf ((char *) dest, "%lf", *(double *)src);
1753 break;
1754 }
1755
1756 case typeString:
1757 {
1758 strcpy((char*)dest, (char*)src);
1759 break;
1760 }
1761 case typeDate:
1762 {
1763 Date* dt = (Date*)src;
1764 sprintf((char*) dest, "%d/%d/%d", dt->year(),dt->month(), dt->dayOfMonth());
1765 break;
1766 }
1767 case typeTime:
1768 {
1769 Time* tm = (Time*)src;
1770 sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1771 break;
1772 }
1773 case typeTimeStamp:
1774 {
1775 TimeStamp* tm = (TimeStamp*)src;
1776 sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),tm->month(), tm->dayOfMonth(), tm->hours(),tm->minutes(), tm->seconds(), 0 );
1777 break;
1778 }
1779 case typeBinary:
1780 {
1781 unsigned char *c = (unsigned char *) src;
1782 unsigned char *str = (unsigned char *) dest;
1783 unsigned char p = 0;
1784 int i = 0;
1785 while (i < length) {
1786 p = *c >> 4;
1787 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1788 else sprintf((char *)str++, "%c", 'A' + p - 10);
1789 p = *c & 0xF;
1790 if (p < 10) sprintf ((char *)str++, "%c", '0' + p);
1791 else sprintf((char *)str++, "%c", 'A' + p - 10);
1792 i++; c++;
1793 }
1794 break;
1795 }
1796
1797 default: ((char*)dest)[0] = '\0';
1798 }
1799
1800 }
1801 void AllDataType::convertToDate( void* dest, void* src, DataType srcType )
1802 {
1803 switch(srcType)
1804 {
1805 case typeInt:
1806 case typeLong:
1807 case typeLongLong:
1808 case typeShort:
1809 case typeByteInt:
1810 case typeFloat:
1811 case typeDouble:
1812 case typeDate:
1813 case typeTime:
1814 case typeTimeStamp:
1815 case typeString:
1816 {
1817 Date *dt = (Date*) dest;
1818 dt->parseFrom((char*)src);
1819 break;
1820 }
1821 default: ((char*)dest)[0] = '\0';
1822 }
1823 }
1824
1825 void AllDataType::convertToTime( void* dest, void* src, DataType srcType )
1826 {
1827 switch(srcType)
1828 {
1829 case typeInt:
1830 case typeLong:
1831 case typeLongLong:
1832 case typeShort:
1833 case typeByteInt:
1834 case typeFloat:
1835 case typeDouble:
1836 case typeDate:
1837 case typeTime:
1838 case typeTimeStamp:
1839 case typeString:
1840 {
1841 Time *dt = (Time*) dest;
1842 dt->parseFrom((char*)src);
1843 break;
1844 }
1845 default: ((char*)dest)[0] = '\0';
1846 }
1847 }
1848
1849 void AllDataType::convertToTimeStamp( void* dest, void* src, DataType srcType )
1850 {
1851 switch(srcType)
1852 {
1853 case typeInt:
1854 case typeLong:
1855 case typeLongLong:
1856 case typeShort:
1857 case typeByteInt:
1858 case typeFloat:
1859 case typeDouble:
1860 case typeDate:
1861 case typeTime:
1862 case typeTimeStamp:
1863 case typeString:
1864 {
1865 TimeStamp *dt = (TimeStamp*) dest;
1866 dt->parseFrom((char*)src);
1867 break;
1868 }
1869 default: ((char*)dest)[0] = '\0';
1870 }
1871 }
1872
1873 void AllDataType::convertToBinary(void *dest, void *src, DataType srcType, int length)
1874 {
1875 switch(srcType)
1876 {
1877 case typeString:
1878 {
1879 memset ((void *) dest, 0, length);
1880 unsigned char c = 0;
1881 const char *str = (const char *)src;
1882 int i=0;
1883 i = strlen((char*)src)-1;
1884 if( i > (length*2)-1 ){ i = (length*2)-1 ; }
1885 bool evenlegth=false;
1886 if(i%2){ evenlegth=true;}
1887 unsigned char *val = (unsigned char *)dest+(length-1);
1888 while (i >= 0) {
1889 c = str[i];
1890 if (c <= '9') c -= '0';
1891 else if (c >= 'a') c = c - 'a' + 10;
1892 else c = c - 'A' + 10;
1893 if(evenlegth)
1894 {
1895 if ((i+1) % 2) { *val = *val | (c<<4); val--;}
1896 else { *val = c; }
1897 }else{
1898 if (i % 2) { *val = *val | (c<<4); val--;}
1899 else { *val = c; }
1900 }
1901 i--;
1902 }
1903 break;
1904 }
1905 }
1906 }
1907 int AllDataType::printVal(void* src, DataType srcType, int length,int dbFlag )
1908 {
1909 //dbFlag is the database flag 0:mysql (default), 1:postgres
1910 int count = 0;
1911 switch(srcType)
1912 {
1913 case typeInt:
1914 {
1915 count = printf ("%d", *(int *)src);
1916 break;
1917 }
1918 case typeLong:
1919 {
1920 count = printf ("%ld", *(long *)src);
1921 break;
1922 }
1923 case typeLongLong:
1924 {
1925 if(1 == dbFlag){
1926 long long temp = 0;
1927 convertToLongLong((void*)&temp, src,typeString);
1928 count = printf ("%lld", temp );
1929 }
1930 else count = printf ("%lld", *(long long *)src);
1931 break;
1932 }
1933 case typeShort:
1934 {
1935 count = printf("%hd", *(short *)src);
1936 break;
1937 }
1938 case typeByteInt:
1939 {
1940 count = printf("%hhd", *(char *)src);
1941 break;
1942 }
1943
1944 case typeFloat:
1945 {
1946 count = printf("%f", *(float *)src);
1947 break;
1948 }
1949 case typeDouble:
1950 {
1951 if (*(double*)src > 9999999999999999.0F)
1952 count = printf("%g", *(double *)src);
1953 else
1954 count = printf("%lf", *(double *)src);
1955 break;
1956 }
1957
1958 case typeString:
1959 case typeVarchar:
1960 {
1961 count = printf("%s", (char*)src);
1962 break;
1963 }
1964 case typeDate:
1965 {
1966 Date* dt = (Date*)src;
1967 count = printf("%d/%d/%d", dt->year(),
1968 dt->month(), dt->dayOfMonth());
1969 break;
1970 }
1971 case typeTime:
1972 {
1973 Time* tm = (Time*)src;
1974 count = printf("%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1975 break;
1976 }
1977 case typeTimeStamp:
1978 {
1979 TimeStamp* tm = (TimeStamp*)src;
1980 count = printf("%d/%d/%d %d:%d:%d.%d", tm->year(),
1981 tm->month(), tm->dayOfMonth(), tm->hours(),
1982 tm->minutes(), tm->seconds(), 0 );
1983 break;
1984 }
1985 case typeBinary:
1986 {
1987 unsigned char *c = (unsigned char *) src;
1988 unsigned char p = 0;
1989 int i = 0;
1990 bool isDigitFound=false;
1991 while (i < length) {
1992 p = *c >> 4;
1993 if(('0'+p)!='0'|| isDigitFound){
1994 if (p < 10) printf ("%c", '0' + p);
1995 else printf("%c", 'A' + p - 10);
1996 isDigitFound=true;
1997 }
1998 p = *c & 0xF;
1999 if(('0'+p)!='0' || isDigitFound){
2000 if (p < 10) printf ("%c", '0' + p);
2001 else printf("%c", 'A' + p - 10);
2002 isDigitFound=true;
2003 }
2004 i++; c++;
2005 }
2006 count = length * 2;
2007 break;
2008 }
2009 default: { printf("DataType not supported\n"); break; }
2010 }
2011 return count;
2012 }
Main memory database SQL engine (cvs import)