src/server/DataType.cxx

   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
  19 #define SmallestValJulDate (1721426)
  20
  21 Date::Date(int year, int month, int day)
  22     { YMDToJulian(year, month, day, julianDate); }
  23 int Date::set(int year, int month, int day)
  24     { return YMDToJulian(year,month,day,julianDate); }
  25 int Date::get(int &year, int &month, int &day) const
  26     { return julianToYMD(julianDate,year,month,day); }
  27
  28 int Date::parseFrom(const char *s) {
  29     int month,day,year;
  30     int count;
  31     count = sscanf(s,"%d/%d/%d",&month,&day,&year);
  32     if (count < 3) return -1;
  33
  34     if (year < 100) year += 1900;
  35
  36     if (!isValidDate(year, month, day))
  37         return -1;
  38
  39     return set(year,month,day);
  40 }
  41
  42 int Date::dayOfMonth() const {
  43     int year, month, day;
  44     get(year,month,day);
  45     return day;
  46 }
  47 int Date::month() const {
  48     int year, month, day;
  49     get(year,month,day);
  50     return month;
  51 }
  52 int Date::year() const {
  53     int year, month, day;
  54     get(year,month,day);
  55     return year;
  56 }
  57
  58 int Date::dayOfWeek() const { return dayOfWeek(julianDate); }
  59
  60 const char *Date::dayOfWeekName() const
  61     { return dayOfWeekName(dayOfWeek(julianDate)); }
  62
  63 const char *Date::dayOfWeekAbbr() const
  64     { return dayOfWeekAbbr(dayOfWeek(julianDate)); }
  65
  66 static const char *day_names[] = {
  67     "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
  68 };
  69 static const char *day_abbrs[] = {
  70     "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
  71 };
  72
  73 static const char *month_names[] = {
  74     "January", "February", "March",     "April",   "May",      "June",
  75     "July",    "August",   "September", "October", "November", "December"
  76 };
  77 static const char *month_abbrs[] = {
  78     "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
  79     "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
  80 };
  81
  82
  83 static int daysBeforeMonth[] = {
  84 0,  31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
  85 };
  86 static int days_per_month[] = {
  87     31, 28, 31,  30,   31, 30,  31,  31,  30,  31,  30,  31
  88 };
  89
  90 const char * Date::dayOfWeekName(int day)
  91     { return (day < 1 || day > 7) ? 0 : day_names[day-1]; }
  92
  93 const char * Date::dayOfWeekAbbr(int day)
  94     { return (day < 1 || day > 7) ? 0 : day_abbrs[day-1]; }
  95
  96 const char * Date::monthName() const { return monthName(month()); }
  97 const char * Date::monthAbbr() const { return monthAbbr(month()); }
  98 const char * Date::monthName(int month)
  99     { return (month < 1 || month > 12) ? 0 : month_names[month-1]; }
 100 const char * Date::monthAbbr(int month)
 101     { return (month < 1 || month > 12) ? 0 : month_abbrs[month-1]; }
 102 Date operator+(const Date &d1, int days)
 103     { return Date(d1.julianDate + days); }
 104 Date operator+(int days, const Date &d1)
 105     { return Date(d1.julianDate + days); }
 106 Date operator-(const Date &d1, int days)
 107     { return Date(d1.julianDate - days); }
 108
 109 int operator-(const Date &d1, const Date& d2)
 110     { return d1.julianDate - d2.julianDate; }
 111
 112 int operator<(const Date &d1 ,const Date &d2 )
 113     { return d1.julianDate < d2.julianDate; }
 114 int operator>(const Date &d1 ,const Date &d2 )
 115     { return d1.julianDate > d2.julianDate; }
 116 int operator<=(const Date &d1 ,const Date &d2 )
 117     { return d1.julianDate <= d2.julianDate; }
 118 int operator>=(const Date &d1 ,const Date &d2 )
 119     { return d1.julianDate >= d2.julianDate; }
 120 int operator==(const Date &d1 ,const Date &d2 )
 121     { return d1.julianDate == d2.julianDate; }
 122 int operator!=(const Date &d1 ,const Date &d2 )
 123     { return d1.julianDate != d2.julianDate; }
 124
 125 bool Date::isValid() const
 126     { return julianDate >= SmallestValJulDate; }
 127
 128 bool Date::isLeapYear(int year)
 129 {
 130     return (year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0));
 131 }
 132
 133 int Date::dayOfYear() const {
 134     int year,month,day;
 135     get(year,month,day);
 136     int tmp = daysBeforeMonth[month-1];
 137     if (month >= 3 && isLeapYear(year))
 138         tmp++;
 139     return tmp + day;
 140 }
 141
 142 int Date::daysInMonth(int month, int year) {
 143     --month;
 144     int tmp = days_per_month[month];
 145     if (month == 1 && isLeapYear(year)) tmp++;
 146     return tmp;
 147 }
 148
 149 bool Date::isValidDate(int year, int month, int day) {
 150     if (year  < 1 || year  > 10000) return false;
 151     if (month < 1 || month > 12) return false;
 152     return (day >= 1) && (day <= daysInMonth(month,year));
 153 }
 154
 155 // Algorithm Author: Robert G. Tantzen
 156 int Date::YMDToJulian(int year, int mon, int day, JulianRep &jul) {
 157     if (!isValidDate(year, mon, day))
 158         { jul = (JulianRep)0; return -1; }
 159
 160     // year, month, day are assumed to be valid
 161     int m = mon, d = day, y = year;
 162     int c, ya, j;
 163
 164     if (m > 2) m -= 3;
 165     else { m += 9; --y; }
 166     c = y/100;
 167     ya = y - (100 * c);
 168     j = (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5 + d + 1721119;
 169     jul = (JulianRep)j;
 170     return 0;
 171 }
 172
 173 // Julian date converter. Takes a julian date (the number of days since some
 174 // distant epoch or other), and returns month, day of month, and year in
 175 // integer references.
 176 // Algorithm Author: Robert G. Tantzen
 177 int Date::dayOfWeek(JulianRep jul) {
 178     return (int)((jul+1)%7+1);
 179 }
 180
 181 int Date::julianToYMD(JulianRep jul, int &year, int &month, int &day) {
 182     int j = jul;
 183     int d, m, y;
 184
 185     if (j < SmallestValJulDate)
 186         { year = month = day = 0; return -1; }
 187
 188     j -= 1721119;
 189     y = (4 * j - 1)/146097;
 190     j = 4 * j - 1 - 146097 * y;
 191     d = j/4;
 192     j = (4 * d + 3)/1461;
 193     d = 4 * d + 3 - 1461 * j;
 194     d = (d + 4)/4;
 195     m = (5 * d - 3)/153;
 196     d = 5 * d - 3 - 153 * m;
 197     d = (d + 5) / 5;
 198     y = 100 * y + j;
 199     if (m < 10) m += 3;
 200     else { m -= 9; ++y; }
 201     month = m;
 202     day = d;
 203     year = y;
 204     return 0;
 205 }
 206
 207 #define MAX_VALID_SECONDS (60 * 60 * 24 -1)
 208 Time::Time(int hours, int mins, int secs, int usec)
 209     { set(hours,mins,secs, usec); }
 210
 211 int Time::set(int hours, int mins, int secs, int usec) {
 212         if((hours | mins | secs | usec) < 0) { timeVal = -1; return -1; }
 213         if(hours >= 24 | mins >= 60 | secs >= 62)
 214                 { timeVal = -1; return -1; }
 215         timeVal = secs + mins * 60 + hours * 3600;
 216         timeVal *= 10000;
 217         if(usec) timeVal += usec/100;
 218         return 0;
 219 }
 220
 221 int Time::get(int &hours, int &mins, int &secs) const {
 222     if (timeVal < 0) return -1;
 223     int s = timeVal/10000;
 224     secs = s % 60;
 225     s /= 60;
 226     mins = s % 60;
 227     s /= 60;
 228     hours = s;
 229     return 0;
 230 }
 231
 232 int Time::seconds() const { return (timeVal/10000) % 60; }
 233 int Time::minutes() const { return (timeVal /(60*10000)) % 60; }
 234 int Time::hours() const   { return timeVal / (3600*10000); }
 235 int Time::msec() const { return (timeVal % 10000) / 10; }
 236 int Time::usec() const { return (timeVal % 10000) * 100; }
 237
 238 int Time::setMsec(int ms) {
 239         if(ms < 0 || ms >= 1000) return -1;
 240         timeVal = timeVal+(10*ms);
 241     return 0;
 242 }
 243 int Time::setUsec(int us) {
 244         if(us < 0 || us >= 1000000) return -1;
 245         timeVal = timeVal +us/100;
 246     return 0;
 247 }
 248
 249 bool Time::isValid() const
 250     { return timeVal >= 0 && timeVal <= (10000*(MAX_VALID_SECONDS+1)-1); }
 251
 252 bool Time::isValidTime(int hours, int mins, int secs) {
 253     return (hours >= 0 && hours < 24) &&
 254            (mins >= 0 && mins < 60) &&
 255            (secs >= 0 && secs < 60);
 256 }
 257
 258 Time operator+(const Time &t1, int seconds)
 259     { return Time(t1.timeVal + seconds*10000); }
 260 Time operator+(int seconds, const Time &t1)
 261     { return Time(t1.timeVal + seconds*10000); }
 262 Time operator-(const Time &t1, int seconds)
 263     { return Time(t1.timeVal - seconds*10000); }
 264
 265 int operator-(const Time &t1, const Time& t2)
 266     { return (t1.timeVal - t2.timeVal)/10000; }
 267
 268 int operator<(const Time &t1 ,const Time &t2 )
 269     { return t1.timeVal < t2.timeVal; }
 270 int operator>(const Time &t1 ,const Time &t2 )
 271     { return t1.timeVal > t2.timeVal; }
 272 int operator<=(const Time &t1 ,const Time &t2 )
 273     { return t1.timeVal <= t2.timeVal; }
 274 int operator>=(const Time &t1 ,const Time &t2 )
 275     { return t1.timeVal >= t2.timeVal; }
 276 int operator==(const Time &t1 ,const Time &t2 )
 277     { return t1.timeVal == t2.timeVal; }
 278 int operator!=(const Time &t1 ,const Time &t2 )
 279     { return t1.timeVal != t2.timeVal; }
 280
 281 int Time::parseFrom(const char *s) {
 282     int hours,mins,secs;
 283     int count;
 284     count = sscanf(s,"%d:%d:%d",&hours,&mins,&secs);
 285     if (count < 2) return -1;
 286     if (count == 2) secs = 0;
 287
 288     if (!isValidTime(hours,mins,secs))
 289         return -1;
 290     return set(hours,mins,secs);
 291 }
 292
 293 int operator< (const TimeStamp &d1,  const TimeStamp &d2)
 294     { return (d1.date != d2.date) ? d1.date < d2.date : d1.time < d2.time; }
 295 int operator> (const TimeStamp &d1,  const TimeStamp &d2)
 296     { return (d1.date != d2.date) ? d1.date > d2.date : d1.time > d2.time; }
 297 int operator<=(const TimeStamp &d1, const TimeStamp &d2)
 298     { return (d1.date != d2.date) ? d1.date < d2.date : d1.time <= d2.time; }
 299 int operator>=(const TimeStamp &d1, const TimeStamp &d2)
 300     { return (d1.date != d2.date) ? d1.date > d2.date : d1.time >= d2.time; }
 301 int operator==(const TimeStamp &d1, const TimeStamp &d2)
 302     { return d1.date == d2.date && d1.time == d2.time; }
 303 int operator!=(const TimeStamp &d1, const TimeStamp &d2)
 304     { return d1.date != d2.date && d1.time != d2.time; }
 305
 306
 307 long AllDataType::size(DataType type)
 308 {
 309     long size = 0;
 310     switch(type)
 311     {
 312         case typeInt:
 313             size = sizeof(int);
 314             break;
 315         case typeLong:
 316             size = sizeof(long);
 317             break;
 318         case typeLongLong:
 319             size = sizeof(long long);
 320             break;
 321         case typeShort:
 322             size = sizeof(short);
 323             break;
 324         case typeByteInt:
 325             size = sizeof(char);
 326             break;
 327         case typeDouble:
 328             size = sizeof(double);
 329             break;
 330         case typeFloat:
 331             size = sizeof(float);
 332             break;
 333         case typeDecimal:
 334             //TODO::for porting
 335             //fldDef.length_ = sizeof(long double);
 336             break;
 337         case typeDate:
 338             size = sizeof(Date);
 339             break;
 340         case typeTime:
 341             size = sizeof(Time);
 342             break;
 343         case typeTimeStamp:
 344             size = sizeof(TimeStamp);
 345             break;
 346         default:
 347             size  = 0;
 348             break;
 349     }
 350     return size;
 351 }
 352
 353 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
 354 {
 355     switch(type)
 356     {
 357         case typeInt:
 358             *(int*)dest = *(int*)src;
 359             break;
 360         case typeLong:
 361             *(long*)dest = *(long*)src;
 362             break;
 363         case typeLongLong:
 364             *(long long*)dest = *(long long*)src;
 365             break;
 366         case typeShort:
 367             *(short*)dest = *(short*)src;
 368             break;
 369         case typeByteInt:
 370             *(char*)dest = *(char*)src;
 371             break;
 372         case typeDouble:
 373             *(double*)dest = *(double*)src;
 374             break;
 375         case typeFloat:
 376             *(float*)dest = *(float*)src;
 377             break;
 378         case typeDecimal:
 379             //TODO::for porting
 380         case typeDate:
 381             *(Date*)dest = *(Date*)src;
 382             break;
 383         case typeTime:
 384             *(Time*)dest = *(Time*)src;
 385             break;
 386         case typeTimeStamp:
 387             *(TimeStamp*)dest = *(TimeStamp*)src;
 388             break;
 389         case typeString:
 390             {
 391                 strncpy((char*)dest, (char*)src, length);
 392                 char *d =(char*)dest;
 393                 d[length-1] = '\0';
 394                 break;
 395             }
 396         case typeBinary:
 397             os::memcpy((char*)dest, (char*)src, length);
 398             break;
 399         default:
 400             break;
 401         }
 402 }
 403
 404 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
 405                              DataType type, long length)
 406 {
 407     bool result = false;
 408         switch(type)
 409         {
 410        case typeInt:
 411            result = AllDataType::compareIntVal(val1, val2, op );
 412            break;
 413        case typeLong:
 414            result = AllDataType::compareLongVal(val1, val2, op);
 415            break;
 416        case typeLongLong:
 417            result = AllDataType::compareLongLongVal(val1, val2, op);
 418            break;
 419        case typeShort:
 420            result = AllDataType::compareShortVal(val1, val2, op);
 421            break;
 422        case typeByteInt:
 423            result = AllDataType::compareByteIntVal(val1, val2, op);
 424            break;
 425        case typeDouble:
 426            result = AllDataType::compareDoubleVal(val1, val2, op);
 427            break;
 428        case typeFloat:
 429            result = AllDataType::compareFloatVal(val1, val2, op);
 430            break;
 431        case typeDecimal:
 432            //TODO::for porting
 433            break;
 434        case typeDate:
 435            result = AllDataType::compareDateVal(val1, val2, op);
 436            break;
 437        case typeTime:
 438            result = AllDataType::compareTimeVal(val1, val2, op);
 439            break;
 440        case typeTimeStamp:
 441            result = AllDataType::compareTimeStampVal(val1, val2, op);
 442            break;
 443        case typeString:
 444            result = AllDataType::compareStringVal(val1, val2, op);
 445            break;
 446        case typeBinary:
 447            result = AllDataType::compareBinaryVal(val1, val2, op, length);
 448            break;
 449     }
 450     return result;
 451 }
 452
 453 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
 454 {
 455     bool result = false;
 456     switch(op)
 457     {
 458         case OpEquals:
 459             if (*(int*)src1 == *(int*)src2) result = true;
 460             else result = false;
 461             break;
 462         case OpNotEquals:
 463             if (*(int*)src1 != *(int*)src2) result = true;
 464             else result = false;
 465             break;
 466         case OpLessThan:
 467             if (*(int*)src1 < *(int*)src2) result = true;
 468             else result = false;
 469             break;
 470         case OpLessThanEquals:
 471             if (*(int*)src1 <= *(int*)src2) result = true;
 472             else result = false;
 473             break;
 474         case OpGreaterThan:
 475             if (*(int*)src1 > *(int*)src2) result = true;
 476             else result = false;
 477             break;
 478         case OpGreaterThanEquals:
 479             if (*(int*)src1 >= *(int*)src2) result = true;
 480             else result = false;
 481             break;
 482    }
 483    return result;
 484 }
 485
 486 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
 487 {
 488     bool result = false;
 489     switch(op)
 490     {
 491         case OpEquals:
 492             if (*(long*)src1 == *(long*)src2) result = true;
 493             else result = false;
 494             break;
 495         case OpNotEquals:
 496             if (*(long*)src1 != *(long*)src2) result = true;
 497             else result = false;
 498             break;
 499         case OpLessThan:
 500             if (*(long*)src1 < *(long*)src2) result = true;
 501             else result = false;
 502             break;
 503         case OpLessThanEquals:
 504             if (*(long*)src1 <= *(long*)src2) result = true;
 505             else result = false;
 506             break;
 507         case OpGreaterThan:
 508             if (*(long*)src1 > *(long*)src2) result = true;
 509             else result = false;
 510             break;
 511         case OpGreaterThanEquals:
 512             if (*(long*)src1 >= *(long*)src2) result = true;
 513             else result = false;
 514             break;
 515    }
 516    return result;
 517 }
 518
 519 bool AllDataType::compareLongLongVal(void* src1, void *src2,
 520                                       ComparisionOp op)
 521 {
 522     bool result = false;
 523     switch(op)
 524     {
 525         case OpEquals:
 526             if (*(long long*)src1 == *(long long*)src2) result = true;
 527             else result = false;
 528             break;
 529         case OpNotEquals:
 530             if (*(long long*)src1 != *(long long*)src2) result = true;
 531             else result = false;
 532             break;
 533         case OpLessThan:
 534             if (*(long long*)src1 < *(long long*)src2) result = true;
 535             else result = false;
 536             break;
 537         case OpLessThanEquals:
 538             if (*(long long*)src1 <= *(long long*)src2) result = true;
 539             else result = false;
 540             break;
 541         case OpGreaterThan:
 542             if (*(long long*)src1 > *(long long*)src2) result = true;
 543             else result = false;
 544             break;
 545         case OpGreaterThanEquals:
 546             if (*(long long*)src1 >= *(long long*)src2) result = true;
 547             else result = false;
 548             break;
 549    }
 550    return result;
 551 }
 552
 553 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
 554 {
 555     bool result = false;
 556     switch(op)
 557     {
 558         case OpEquals:
 559             if (*(short*)src1 == *(short*)src2) result = true;
 560             else result = false;
 561             break;
 562         case OpNotEquals:
 563             if (*(short*)src1 != *(short*)src2) result = true;
 564             else result = false;
 565             break;
 566         case OpLessThan:
 567             if (*(short*)src1 < *(short*)src2) result = true;
 568             else result = false;
 569             break;
 570         case OpLessThanEquals:
 571             if (*(short*)src1 <= *(short*)src2) result = true;
 572             else result = false;
 573             break;
 574         case OpGreaterThan:
 575             if (*(short*)src1 > *(short*)src2) result = true;
 576             else result = false;
 577             break;
 578         case OpGreaterThanEquals:
 579             if (*(short*)src1 >= *(short*)src2) result = true;
 580             else result = false;
 581             break;
 582    }
 583    return result;
 584 }
 585
 586 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
 587 {
 588     bool result = false;
 589     switch(op)
 590     {
 591         case OpEquals:
 592             if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
 593             else result = false;
 594             break;
 595         case OpNotEquals:
 596             if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
 597             else result = false;
 598             break;
 599         case OpLessThan:
 600             if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
 601             else result = false;
 602             break;
 603         case OpLessThanEquals:
 604             if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
 605             else result = false;
 606             break;
 607         case OpGreaterThan:
 608             if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
 609             else result = false;
 610             break;
 611         case OpGreaterThanEquals:
 612             if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
 613             else result = false;
 614             break;
 615    }
 616    return result;
 617 }
 618
 619 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
 620 {
 621     bool result = false;
 622     switch(op)
 623     {
 624         case OpEquals:
 625             if (*(double*)src1 == *(double*)src2) result = true;
 626             else result = false;
 627             break;
 628         case OpNotEquals:
 629             if (*(double*)src1 != *(double*)src2) result = true;
 630             else result = false;
 631             break;
 632         case OpLessThan:
 633             if (*(double*)src1 < *(double*)src2) result = true;
 634             else result = false;
 635             break;
 636         case OpLessThanEquals:
 637             if (*(double*)src1 <= *(double*)src2) result = true;
 638             else result = false;
 639             break;
 640         case OpGreaterThan:
 641             if (*(double*)src1 > *(double*)src2) result = true;
 642             else result = false;
 643             break;
 644         case OpGreaterThanEquals:
 645             if (*(double*)src1 >= *(double*)src2) result = true;
 646             else result = false;
 647             break;
 648    }
 649    return result;
 650 }
 651
 652 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
 653 {
 654     bool result = false;
 655     switch(op)
 656     {
 657         case OpEquals:
 658             if (*(float*)src1 == *(float*)src2) result = true;
 659             else result = false;
 660             break;
 661         case OpNotEquals:
 662             if (*(float*)src1 != *(float*)src2) result = true;
 663             else result = false;
 664             break;
 665         case OpLessThan:
 666             if (*(float*)src1 < *(float*)src2) result = true;
 667             else result = false;
 668             break;
 669         case OpLessThanEquals:
 670             if (*(float*)src1 <= *(float*)src2) result = true;
 671             else result = false;
 672             break;
 673         case OpGreaterThan:
 674             if (*(float*)src1 > *(float*)src2) result = true;
 675             else result = false;
 676             break;
 677         case OpGreaterThanEquals:
 678             if (*(float*)src1 >= *(float*)src2) result = true;
 679             else result = false;
 680             break;
 681    }
 682    return result;
 683 }
 684
 685 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
 686 {
 687     bool result = false;
 688     switch(op)
 689     {
 690         case OpEquals:
 691             if (*(Date*)src1 == *(Date*)src2) result = true;
 692             else result = false;
 693             break;
 694         case OpNotEquals:
 695             if (*(Date*)src1 != *(Date*)src2) result = true;
 696             else result = false;
 697             break;
 698         case OpLessThan:
 699             if (*(Date*)src1 < *(Date*)src2) result = true;
 700             else result = false;
 701             break;
 702         case OpLessThanEquals:
 703             if (*(Date*)src1 <= *(Date*)src2) result = true;
 704             else result = false;
 705             break;
 706         case OpGreaterThan:
 707             if (*(Date*)src1 > *(Date*)src2) result = true;
 708             else result = false;
 709             break;
 710         case OpGreaterThanEquals:
 711             if (*(Date*)src1 >= *(Date*)src2) result = true;
 712             else result = false;
 713             break;
 714    }
 715    return result;
 716 }
 717
 718 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
 719 {
 720     bool result = false;
 721     switch(op)
 722     {
 723         case OpEquals:
 724             if (*(Time*)src1 == *(Time*)src2) result = true;
 725             else result = false;
 726             break;
 727         case OpNotEquals:
 728             if (*(Time*)src1 != *(Time*)src2) result = true;
 729             else result = false;
 730             break;
 731         case OpLessThan:
 732             if (*(Time*)src1 < *(Time*)src2) result = true;
 733             else result = false;
 734             break;
 735         case OpLessThanEquals:
 736             if (*(Time*)src1 <= *(Time*)src2) result = true;
 737             else result = false;
 738             break;
 739         case OpGreaterThan:
 740             if (*(Time*)src1 > *(Time*)src2) result = true;
 741             else result = false;
 742             break;
 743         case OpGreaterThanEquals:
 744             if (*(Time*)src1 >= *(Time*)src2) result = true;
 745             else result = false;
 746             break;
 747    }
 748    return result;
 749 }
 750
 751 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
 752 {
 753     bool result = false;
 754     switch(op)
 755     {
 756         case OpEquals:
 757             if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
 758             else result = false;
 759             break;
 760         case OpNotEquals:
 761             if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
 762             else result = false;
 763             break;
 764         case OpLessThan:
 765             if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
 766             else result = false;
 767             break;
 768         case OpLessThanEquals:
 769             if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
 770             else result = false;
 771             break;
 772         case OpGreaterThan:
 773             if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
 774             else result = false;
 775             break;
 776         case OpGreaterThanEquals:
 777             if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
 778             else result = false;
 779             break;
 780    }
 781    return result;
 782 }
 783
 784 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
 785 {
 786     bool result = false;
 787     int ret = strcmp((char*)src1, (char*)src2);
 788     switch(op)
 789     {
 790         case OpEquals:
 791             if (ret == 0 ) result= true; else result = false;
 792             break;
 793         case OpNotEquals:
 794             if (ret != 0 ) result= true; else result = false;
 795             break;
 796         case OpLessThan:
 797             if (ret < 0 ) result= true; else result = false;
 798             break;
 799         case OpLessThanEquals:
 800             printf("Illegal Operator:Not Supported for String\n");
 801             break;
 802         case OpGreaterThan:
 803             if (ret > 0 ) result= true; else result = false;
 804             break;
 805         case OpGreaterThanEquals:
 806             printf("Illegal Operator:Not Supported for String\n");
 807             break;
 808    }
 809    return result;
 810 }
 811
 812 bool AllDataType::compareBinaryVal(void* src1, void *src2,
 813                                  ComparisionOp op, int length)
 814 {
 815     bool result = false;
 816     int ret = os::memcmp(src1, src2, length);
 817     switch(op)
 818     {
 819         case OpEquals:
 820             if (ret == 0 ) result= true; else result = false;
 821             break;
 822         case OpNotEquals:
 823             if (ret != 0 ) result= true; else result = false;
 824             break;
 825         case OpLessThan:
 826             if (ret < 0 ) result= true; else result = false;
 827             break;
 828         case OpLessThanEquals:
 829             printf("Illegal Operator:Not Supported for Binary\n");
 830             break;
 831         case OpGreaterThan:
 832             if (ret > 0 ) result= true; else result = false;
 833             break;
 834         case OpGreaterThanEquals:
 835             printf("Illegal Operator:Not Supported for Binary\n");
 836             break;
 837    }
 838    return result;
 839 }
 840
 841
 842
 843 ComparisionOp AllDataType::getComparisionOperator(char *str)
 844 {
 845     ComparisionOp op;
 846     if (strcmp(str, "<=") == 0)
 847         op = OpLessThanEquals;
 848     else if (strcmp(str, ">=") == 0)
 849         op = OpGreaterThanEquals;
 850     else if (strcmp(str, "<") == 0)
 851         op = OpLessThan;
 852     else if (strcmp(str, ">") == 0)
 853         op = OpGreaterThan;
 854     else if (strcmp(str, "=") == 0)
 855         op = OpEquals;
 856     else if (strcmp(str, "!=") == 0)
 857         op = OpNotEquals;
 858     else
 859         op = OpInvalidComparisionOp;
 860     return op;
 861 }
 862
 863 void* AllDataType::alloc(DataType type, int length)
 864 {
 865     void *dest;
 866     switch(type)
 867     {
 868         case typeInt:
 869             dest = malloc(sizeof(int));
 870             break;
 871         case typeLong:
 872             dest = malloc(sizeof(long));
 873             break;
 874         case typeLongLong:
 875             dest = malloc(sizeof(long long));
 876             break;
 877         case typeShort:
 878             dest = malloc(sizeof(short));
 879             break;
 880         case typeByteInt:
 881             dest = malloc(sizeof(char));
 882             break;
 883         case typeDouble:
 884             dest = malloc(sizeof(double));
 885             break;
 886         case typeFloat:
 887             dest = malloc(sizeof(float));
 888             break;
 889         case typeDecimal:
 890             //TODO::for porting
 891             //fldDef.length_ = sizeof(long double);
 892             break;
 893         case typeString:
 894             if (length == 0 ) return NULL;
 895             dest = malloc(length);
 896             break;
 897         case typeDate:
 898             dest = malloc(sizeof(Date));
 899             break;
 900         case typeTime:
 901             dest = malloc(sizeof(Time));
 902             break;
 903         case typeTimeStamp:
 904             dest = malloc(sizeof(TimeStamp));
 905             break;
 906     }
 907     return dest;
 908 }
 909 void AllDataType::strToValue(void* dest, char *src, DataType type, int length)
 910 {
 911     switch(type)
 912     {
 913         case typeInt: {
 914             int val;
 915             sscanf( src, "%d",  &val);
 916             *(int*)dest = val;
 917             break; }
 918         case typeLong: {
 919             long val;
 920             sscanf( src, "%ld",  &val);
 921             *(long*)dest = val;
 922             break; }
 923         case typeLongLong: {
 924             long long val;
 925             sscanf( src, "%lld",  &val);
 926             *(long long*)dest = val;
 927             break; }
 928         case typeShort: {
 929             short val;
 930             sscanf( src, "%hd",  &val);
 931             *(short*)dest = val;
 932             break; }
 933         case typeByteInt: {
 934             char val;
 935             sscanf( src, "%c",  &val);
 936             *(char*)dest = val;
 937             break; }
 938         case typeDouble: {
 939             double val;
 940             sscanf( src, "%g",  &val);
 941             *(double*)dest = val;
 942             break; }
 943         case typeFloat: {
 944             float val;
 945             sscanf( src, "%f",  &val);
 946             *(float*)dest = val;
 947             break; }
 948         case typeDecimal:
 949             //TODO::for porting
 950         case typeString: {
 951                 strncpy((char*)dest, (char*)src, length);
 952                 char *d =(char*)dest;
 953                 d[length-1] = '\0';
 954                 break;}
 955         case typeDate: {
 956             int d,m,y,res=0;
 957             res = sscanf( src, "%d-%d-%d", &d, &m, &y );
 958             if( res != 3 )
 959                  res = sscanf( src, "%d/%d/%d", &d, &m, &y );
 960             if( res != 3 )
 961             {
 962            fprintf(stderr,"Error reading date. dd{-/}mm{-/}yyyy is the valid format.");
 963                 d=m=y=0;
 964             }
 965             Date dateObj(y,m,d);
 966             *(Date*)dest = dateObj;
 967             break; }
 968         case typeTime: {
 969             int h,m,s,res=0;
 970             res = sscanf( src, "%d:%d:%d", &h, &m, &s );
 971             if( res != 3 )
 972             {
 973                 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
 974                 h=m=s=0;
 975             }
 976             Time timeObj(h,m,s);
 977             *(Time*)dest = timeObj;
 978             break; }
 979         case typeTimeStamp: {
 980             int d,m,y, h,mn,s, res=0;
 981             res = sscanf( src, "%d-%d-%d %d:%d:%d", &d, &m, &y, &h, &mn, &s );
 982             if( res != 6 )
 983                 res = sscanf( src, "%d/%d/%d %d:%d:%d", &d, &m, &y, &h, &mn, &s );
 984             if( res != 6 )
 985                 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &d, &m, &y, &h, &mn, &s );
 986             if( res != 6 )
 987             {
 988                 fprintf(stderr, "Error reading timestamp, dd{-/}mm{-/}yyyy[,] hh:mm:ss is the valid format.");
 989                 d=m=y=h=mn=s=0;
 990             }
 991             TimeStamp timeStampObj(y,m,d,h,mn,s);
 992             *(TimeStamp*)dest = timeStampObj;
 993             break; }
 994         default:
 995             break;
 996         }
 997 }
 998
 999
1000 void AllDataType::convert(DataType srcType, void *src,
1001                           DataType destType, void *dest)
1002 {
1003     switch ((DataType) destType )
1004     {
1005         case typeInt:        convertToInt(dest, src, srcType); break;
1006         case typeLong:       convertToLong(dest, src, srcType); break;
1007         case typeLongLong:   convertToLongLong(dest, src, srcType); break;
1008         case typeShort:      convertToShort(dest, src, srcType); break;
1009         case typeByteInt:    convertToByteInt(dest, src, srcType); break;
1010
1011         case typeFloat:      convertToFloat(dest, src, srcType); break;
1012         case typeDouble:     convertToDouble(dest, src, srcType); break;
1013
1014         //TODO
1015         case typeDecimal:    convertToDouble(dest, src, srcType); break;
1016
1017         case typeString:     convertToString(dest, src, srcType); break;
1018
1019         case typeBinary:
1020         case typeDate:
1021         case typeTime:
1022         case typeTimeStamp:
1023         default: return;
1024     }
1025 }
1026
1027 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1028 {
1029     switch(srcType)
1030     {
1031         case typeInt:        *(int *)dest = *(int *)src; break;
1032         case typeLong:       *(int *)dest =(int) *(long *)src; break;
1033         case typeLongLong:   *(int *)dest =(int) *(long long *)src; break;
1034         case typeShort:      *(int *)dest =(int) *(short *)src; break;
1035         case typeByteInt:    *(int *)dest =(int) *(char *)src; break;
1036
1037         case typeFloat:      *(int *)dest = (int) *(float *)src; break;
1038         case typeDouble:     *(int *)dest =(int) *(double *)src; break;
1039
1040         case typeString:     sscanf((const char*)src, "%d", (int*) dest); break;
1041
1042         case typeDate:
1043         case typeTime:
1044         case typeTimeStamp:
1045         case typeBinary:
1046         default:             *(int *)dest = (int) 0;
1047     }
1048 }
1049
1050 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1051 {
1052     switch(srcType)
1053     {
1054         case typeInt:        *(long *)dest =(long) *(int *)src; break;
1055         case typeLong:       *(long *)dest = *(long *)src; break;
1056         case typeLongLong:   *(long *)dest =(long) *(long long *)src; break;
1057         case typeShort:      *(long *)dest =(long) *(short *)src; break;
1058         case typeByteInt:    *(long *)dest =(long) *(char *)src; break;
1059
1060         case typeFloat:      *(long *)dest = (long) *(float *)src; break;
1061         case typeDouble:     *(long *)dest =(long) *(double *)src; break;
1062
1063         case typeString:     sscanf((const char*)src, "%ld", (long*) dest); break;
1064
1065         case typeDate:
1066         case typeTime:
1067         case typeTimeStamp:
1068         case typeBinary:
1069         default:             *(long *)dest = (long) 0;
1070     }
1071 }
1072
1073
1074 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1075 {
1076     switch(srcType)
1077     {
1078         case typeInt:        *(long long *)dest =(long long) *(int *)src; break;
1079         case typeLong:       *(long long *)dest = (long long) *(long *)src; break;
1080         case typeLongLong:   *(long long *)dest = *(long long *)src; break;
1081         case typeShort:      *(long long *)dest =(long long) *(short *)src; break;
1082         case typeByteInt:    *(long long *)dest =(long long) *(char *)src; break;
1083
1084         case typeFloat:      *(long long *)dest = (long long) *(float *)src; break;
1085         case typeDouble:     *(long long *)dest =(long long) *(double *)src; break;
1086
1087         case typeString:     sscanf((const char*)src, "%lld", (long long*) dest); break;
1088
1089         case typeDate:
1090         case typeTime:
1091         case typeTimeStamp:
1092         case typeBinary:
1093         default:             *(long long *)dest = (long long) 0;
1094     }
1095 }
1096
1097 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1098 {
1099     switch(srcType)
1100     {
1101         case typeInt:        *(short*)dest =(short) *(int*)src; break;
1102         case typeLong:       *(short*)dest = (short) *(long*)src; break;
1103         case typeLongLong:   *(short*)dest = (short) *(long long*)src; break;
1104         case typeShort:      *(short*)dest = *(short*)src; break;
1105         case typeByteInt:    *(short*)dest =(short) *(char *)src; break;
1106
1107         case typeFloat:      *(short*)dest = (short) *(float *)src; break;
1108         case typeDouble:     *(short*)dest =(short) *(double *)src; break;
1109
1110         case typeString:     sscanf((const char*)src, "%hd", (short*) dest); break;
1111
1112         case typeDate:
1113         case typeTime:
1114         case typeTimeStamp:
1115         case typeBinary:
1116         default:             *(short*)dest = (short) 0;
1117     }
1118 }
1119
1120 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1121 {
1122     switch(srcType)
1123     {
1124         case typeInt:        *(char*)dest = (char) *(int*)src; break;
1125         case typeLong:       *(char*)dest = (char) *(long*)src; break;
1126         case typeLongLong:   *(char*)dest = (char) *(long long*)src; break;
1127         case typeShort:      *(char*)dest = (char) *(short*)src; break;
1128         case typeByteInt:    *(char*)dest = *(char *)src; break;
1129
1130         case typeFloat:      *(char*)dest = (char) *(float *)src; break;
1131         case typeDouble:     *(char*)dest =(char) *(double *)src; break;
1132
1133         case typeString:     sscanf((const char*)src, "%c", (char*) dest); break;
1134
1135         case typeDate:
1136         case typeTime:
1137         case typeTimeStamp:
1138         case typeBinary:
1139         default:             *(char*)dest = (char) 0;
1140     }
1141 }
1142
1143 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1144 {
1145     switch(srcType)
1146     {
1147         case typeInt:        *(float *)dest =(float) *(int *)src; break;
1148         case typeLong:       *(float *)dest =(float) *(long *)src; break;
1149         case typeLongLong:   *(float *)dest =(float) *(long long *)src; break;
1150         case typeShort:      *(float *)dest =(float) *(short *)src; break;
1151         case typeByteInt:    *(float *)dest =(float) *(char *)src; break;
1152
1153         case typeFloat:      *(float *)dest = *(float *)src; break;
1154         case typeDouble:     *(float *)dest =(float) *(double *)src; break;
1155
1156         case typeString:     sscanf((const char*)src, "%f", (float*) dest); break;
1157
1158         case typeDate:
1159         case typeTime:
1160         case typeTimeStamp:
1161         case typeBinary:
1162         default:             *(float *)dest = (float) 0;
1163     }
1164 }
1165
1166 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1167 {
1168     switch(srcType)
1169     {
1170         case typeInt:        *(double *)dest =(double) *(int *)src; break;
1171         case typeLong:       *(double *)dest =(double) *(long *)src; break;
1172         case typeLongLong:   *(double *)dest =(double) *(long long *)src; break;
1173         case typeShort:      *(double *)dest =(double) *(short *)src; break;
1174         case typeByteInt:    *(double *)dest =(double) *(char *)src; break;
1175
1176         case typeFloat:      *(double *)dest =(double) *(float *)src; break;
1177         case typeDouble:     *(double *)dest = *(double *)src; break;
1178
1179         case typeString:     sscanf((const char*)src, "%lf", (double*) dest); break;
1180
1181         case typeDate:
1182         case typeTime:
1183         case typeTimeStamp:
1184         case typeBinary:
1185         default:             *(double *)dest = (double) 0;
1186     }
1187 }
1188
1189 void AllDataType::convertToString( void* dest, void* src, DataType srcType )
1190 {
1191     switch(srcType)
1192     {
1193         case typeInt:
1194         {
1195             sprintf ((char *)dest, "%d", *(int *)src);
1196             break;
1197         }
1198         case typeLong:
1199         {
1200             sprintf ((char *)dest, "%ld", *(long *)src);
1201             break;
1202         }
1203         case typeLongLong:
1204         {
1205             sprintf ((char *)dest, "%lld", *(long long *)src);
1206             break;
1207         }
1208         case typeShort:
1209         {
1210             sprintf ((char *)dest, "%hd", *(short *)src);
1211             break;
1212         }
1213         case typeByteInt:
1214         {
1215             sprintf ((char *)dest, "%hd", *(char *)src);
1216             break;
1217         }
1218
1219         case typeFloat:
1220         {
1221             sprintf ((char *)dest, "%f", *(float *)src);
1222             break;
1223         }
1224         case typeDouble:
1225         {
1226             sprintf ((char *) dest, "%lf", *(double *)src);
1227             break;
1228         }
1229
1230         case typeString:
1231         {
1232             strcpy((char*)dest, (char*)src);
1233             break;
1234         }
1235         case typeDate:
1236         {
1237             Date* dt = (Date*)src;
1238             sprintf((char*) dest, "%d/%d/%d", dt->dayOfMonth(),
1239                                   dt->month(), dt->year());
1240             break;
1241         }
1242         case typeTime:
1243         {
1244             Time* tm = (Time*)src;
1245             sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1246             break;
1247         }
1248         case typeTimeStamp:
1249         {
1250             TimeStamp* tm = (TimeStamp*)src;
1251             sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->dayOfMonth(),
1252                                 tm->month(), tm->year(), tm->hours(),
1253                                 tm->minutes(), tm->seconds(), 0 );
1254             break;
1255         }
1256         default: ((char*)dest)[0] = '\0';
1257     }
1258
1259 }
1260
1261 void AllDataType::printVal(void* src, DataType srcType, int length )
1262 {
1263     switch(srcType)
1264     {
1265         case typeInt:
1266         {
1267             printf ("%d\t", *(int *)src);
1268             break;
1269         }
1270         case typeLong:
1271         {
1272             printf ("%ld\t", *(long *)src);
1273             break;
1274         }
1275         case typeLongLong:
1276         {
1277             printf ("%lld\t", *(long long *)src);
1278             break;
1279         }
1280         case typeShort:
1281         {
1282             printf("%hd\t", *(short *)src);
1283             break;
1284         }
1285         case typeByteInt:
1286         {
1287             printf("%hd\t", *(char *)src);
1288             break;
1289         }
1290
1291         case typeFloat:
1292         {
1293             printf("%f\t", *(float *)src);
1294             break;
1295         }
1296         case typeDouble:
1297         {
1298             printf("%lf\t", *(double *)src);
1299             break;
1300         }
1301
1302         case typeString:
1303         {
1304             printf("%s\t", (char*)src);
1305             break;
1306         }
1307         case typeDate:
1308         {
1309             Date* dt = (Date*)src;
1310             printf("%d/%d/%d\t", dt->dayOfMonth(),
1311                                   dt->month(), dt->year());
1312             break;
1313         }
1314         case typeTime:
1315         {
1316             Time* tm = (Time*)src;
1317             printf("%d:%d:%d.%d\t", tm->hours(), tm->minutes(), tm->seconds(), 0);
1318             break;
1319         }
1320         case typeTimeStamp:
1321         {
1322             TimeStamp* tm = (TimeStamp*)src;
1323             printf("%d/%d/%d %d:%d:%d.%d\t", tm->dayOfMonth(),
1324                                 tm->month(), tm->year(), tm->hours(),
1325                                 tm->minutes(), tm->seconds(), 0 );
1326             break;
1327         }
1328         default: { printf("DataType not supported\n"); break; }
1329     }
1330
1331 }
1332
1333
1334