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, int length )
 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         case typeString:
 347             size = length;
 348             break;
 349         default:
 350             size  = 0;
 351             break;
 352     }
 353     return size;
 354 }
 355
 356 SQLSMALLINT AllDataType::convertToSQLType(DataType type)
 357 {
 358     //printf("CSQL TYPE is %d\n", type);
 359
 360     switch(type)
 361     {
 362         case typeInt:
 363             return SQL_INTEGER;
 364         case typeLong:
 365             return SQL_INTEGER;
 366         case typeLongLong:
 367             //TODO
 368             return SQL_INTEGER;
 369         case typeShort:
 370             return SQL_SMALLINT;
 371         case typeByteInt:
 372             //TODO
 373             return SQL_INTEGER;
 374         case typeDouble:
 375             return SQL_DOUBLE;
 376         case typeFloat:
 377             return SQL_REAL;
 378         case typeDecimal:
 379             //TODO
 380             return SQL_INTEGER;
 381         case typeDate:
 382             return SQL_TYPE_DATE;
 383         case typeTime:
 384            return SQL_TYPE_TIME;
 385         case typeTimeStamp:
 386            return SQL_TYPE_TIMESTAMP;
 387         case typeString:
 388             return SQL_CHAR;
 389     }
 390     return SQL_INTEGER;
 391 }
 392 SQLSMALLINT AllDataType::convertToSQL_C_Type(DataType type)
 393 {
 394     //printf("CSQL TYPE is %d\n", type);
 395
 396     switch(type)
 397     {
 398         case typeInt:
 399             return SQL_C_SLONG;
 400         case typeLong:
 401             return SQL_C_SLONG;
 402         case typeLongLong:
 403             return SQL_C_SBIGINT;
 404         case typeShort:
 405             return SQL_C_SSHORT;
 406         case typeByteInt:
 407             return SQL_C_STINYINT;
 408         case typeDouble:
 409             return SQL_C_DOUBLE;
 410         case typeFloat:
 411             return SQL_C_FLOAT;
 412         case typeDecimal:
 413             //TODO
 414             return SQL_INTEGER;
 415         case typeDate:
 416             return SQL_C_TYPE_DATE;
 417         case typeTime:
 418            return SQL_C_TYPE_TIME;
 419         case typeTimeStamp:
 420            return SQL_C_TYPE_TIMESTAMP;
 421         case typeString:
 422             return SQL_C_CHAR;
 423     }
 424     return SQL_C_SLONG;
 425 }
 426
 427 DataType  AllDataType::convertFromSQLType(SQLSMALLINT type)
 428 {
 429     //printf("SQL TYPE is %d\n", type);
 430     switch(type)
 431     {
 432         case SQL_INTEGER :
 433             return typeInt;
 434         case  SQL_SMALLINT:
 435             return typeShort;
 436         case  SQL_DOUBLE:
 437             return typeDouble;
 438         case  SQL_FLOAT:
 439         case  SQL_REAL:
 440             return typeFloat;
 441         case SQL_TYPE_DATE:
 442             return typeDate;
 443         case SQL_TYPE_TIME :
 444            return typeTime;
 445         case SQL_TYPE_TIMESTAMP :
 446            return typeTimeStamp;
 447         case SQL_CHAR:
 448             return typeString;
 449         case SQL_VARCHAR:
 450             return typeString;
 451     }
 452     return typeInt;
 453 }
 454 void AllDataType::copyVal(void* dest, void *src, DataType type, int length)
 455 {
 456     switch(type)
 457     {
 458         case typeInt:
 459             *(int*)dest = *(int*)src;
 460             break;
 461         case typeLong:
 462             *(long*)dest = *(long*)src;
 463             break;
 464         case typeLongLong:
 465             *(long long*)dest = *(long long*)src;
 466             break;
 467         case typeShort:
 468             *(short*)dest = *(short*)src;
 469             break;
 470         case typeByteInt:
 471             *(char*)dest = *(char*)src;
 472             break;
 473         case typeDouble:
 474             *(double*)dest = *(double*)src;
 475             break;
 476         case typeFloat:
 477             *(float*)dest = *(float*)src;
 478             break;
 479         case typeDecimal:
 480             //TODO::for porting
 481         case typeDate:
 482             *(Date*)dest = *(Date*)src;
 483             break;
 484         case typeTime:
 485             *(Time*)dest = *(Time*)src;
 486             break;
 487         case typeTimeStamp:
 488             *(TimeStamp*)dest = *(TimeStamp*)src;
 489             break;
 490         case typeString:
 491             {
 492                 strncpy((char*)dest, (char*)src, length);
 493                 char *d =(char*)dest;
 494                 d[length-1] = '\0';
 495                 break;
 496             }
 497         case typeBinary:
 498             os::memcpy((char*)dest, (char*)src, length);
 499             break;
 500         default:
 501             break;
 502         }
 503 }
 504
 505 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
 506                              DataType type, long length)
 507 {
 508     bool result = false;
 509         switch(type)
 510         {
 511        case typeInt:
 512            result = AllDataType::compareIntVal(val1, val2, op );
 513            break;
 514        case typeLong:
 515            result = AllDataType::compareLongVal(val1, val2, op);
 516            break;
 517        case typeLongLong:
 518            result = AllDataType::compareLongLongVal(val1, val2, op);
 519            break;
 520        case typeShort:
 521            result = AllDataType::compareShortVal(val1, val2, op);
 522            break;
 523        case typeByteInt:
 524            result = AllDataType::compareByteIntVal(val1, val2, op);
 525            break;
 526        case typeDouble:
 527            result = AllDataType::compareDoubleVal(val1, val2, op);
 528            break;
 529        case typeFloat:
 530            result = AllDataType::compareFloatVal(val1, val2, op);
 531            break;
 532        case typeDecimal:
 533            //TODO::for porting
 534            break;
 535        case typeDate:
 536            result = AllDataType::compareDateVal(val1, val2, op);
 537            break;
 538        case typeTime:
 539            result = AllDataType::compareTimeVal(val1, val2, op);
 540            break;
 541        case typeTimeStamp:
 542            result = AllDataType::compareTimeStampVal(val1, val2, op);
 543            break;
 544        case typeString:
 545            result = AllDataType::compareStringVal(val1, val2, op);
 546            break;
 547        case typeBinary:
 548            result = AllDataType::compareBinaryVal(val1, val2, op, length);
 549            break;
 550     }
 551     return result;
 552 }
 553
 554 bool AllDataType::compareIntVal(void* src1, void *src2, ComparisionOp op)
 555 {
 556     bool result = false;
 557     switch(op)
 558     {
 559         case OpEquals:
 560             if (*(int*)src1 == *(int*)src2) result = true;
 561             else result = false;
 562             break;
 563         case OpNotEquals:
 564             if (*(int*)src1 != *(int*)src2) result = true;
 565             else result = false;
 566             break;
 567         case OpLessThan:
 568             if (*(int*)src1 < *(int*)src2) result = true;
 569             else result = false;
 570             break;
 571         case OpLessThanEquals:
 572             if (*(int*)src1 <= *(int*)src2) result = true;
 573             else result = false;
 574             break;
 575         case OpGreaterThan:
 576             if (*(int*)src1 > *(int*)src2) result = true;
 577             else result = false;
 578             break;
 579         case OpGreaterThanEquals:
 580             if (*(int*)src1 >= *(int*)src2) result = true;
 581             else result = false;
 582             break;
 583    }
 584    return result;
 585 }
 586
 587 bool AllDataType::compareLongVal(void* src1, void *src2, ComparisionOp op)
 588 {
 589     bool result = false;
 590     switch(op)
 591     {
 592         case OpEquals:
 593             if (*(long*)src1 == *(long*)src2) result = true;
 594             else result = false;
 595             break;
 596         case OpNotEquals:
 597             if (*(long*)src1 != *(long*)src2) result = true;
 598             else result = false;
 599             break;
 600         case OpLessThan:
 601             if (*(long*)src1 < *(long*)src2) result = true;
 602             else result = false;
 603             break;
 604         case OpLessThanEquals:
 605             if (*(long*)src1 <= *(long*)src2) result = true;
 606             else result = false;
 607             break;
 608         case OpGreaterThan:
 609             if (*(long*)src1 > *(long*)src2) result = true;
 610             else result = false;
 611             break;
 612         case OpGreaterThanEquals:
 613             if (*(long*)src1 >= *(long*)src2) result = true;
 614             else result = false;
 615             break;
 616    }
 617    return result;
 618 }
 619
 620 bool AllDataType::compareLongLongVal(void* src1, void *src2,
 621                                       ComparisionOp op)
 622 {
 623     bool result = false;
 624     switch(op)
 625     {
 626         case OpEquals:
 627             if (*(long long*)src1 == *(long long*)src2) result = true;
 628             else result = false;
 629             break;
 630         case OpNotEquals:
 631             if (*(long long*)src1 != *(long long*)src2) result = true;
 632             else result = false;
 633             break;
 634         case OpLessThan:
 635             if (*(long long*)src1 < *(long long*)src2) result = true;
 636             else result = false;
 637             break;
 638         case OpLessThanEquals:
 639             if (*(long long*)src1 <= *(long long*)src2) result = true;
 640             else result = false;
 641             break;
 642         case OpGreaterThan:
 643             if (*(long long*)src1 > *(long long*)src2) result = true;
 644             else result = false;
 645             break;
 646         case OpGreaterThanEquals:
 647             if (*(long long*)src1 >= *(long long*)src2) result = true;
 648             else result = false;
 649             break;
 650    }
 651    return result;
 652 }
 653
 654 bool AllDataType::compareShortVal(void* src1, void *src2, ComparisionOp op)
 655 {
 656     bool result = false;
 657     switch(op)
 658     {
 659         case OpEquals:
 660             if (*(short*)src1 == *(short*)src2) result = true;
 661             else result = false;
 662             break;
 663         case OpNotEquals:
 664             if (*(short*)src1 != *(short*)src2) result = true;
 665             else result = false;
 666             break;
 667         case OpLessThan:
 668             if (*(short*)src1 < *(short*)src2) result = true;
 669             else result = false;
 670             break;
 671         case OpLessThanEquals:
 672             if (*(short*)src1 <= *(short*)src2) result = true;
 673             else result = false;
 674             break;
 675         case OpGreaterThan:
 676             if (*(short*)src1 > *(short*)src2) result = true;
 677             else result = false;
 678             break;
 679         case OpGreaterThanEquals:
 680             if (*(short*)src1 >= *(short*)src2) result = true;
 681             else result = false;
 682             break;
 683    }
 684    return result;
 685 }
 686
 687 bool AllDataType::compareByteIntVal(void* src1, void *src2, ComparisionOp op)
 688 {
 689     bool result = false;
 690     switch(op)
 691     {
 692         case OpEquals:
 693             if (*(ByteInt*)src1 == *(ByteInt*)src2) result = true;
 694             else result = false;
 695             break;
 696         case OpNotEquals:
 697             if (*(ByteInt*)src1 != *(ByteInt*)src2) result = true;
 698             else result = false;
 699             break;
 700         case OpLessThan:
 701             if (*(ByteInt*)src1 < *(ByteInt*)src2) result = true;
 702             else result = false;
 703             break;
 704         case OpLessThanEquals:
 705             if (*(ByteInt*)src1 <= *(ByteInt*)src2) result = true;
 706             else result = false;
 707             break;
 708         case OpGreaterThan:
 709             if (*(ByteInt*)src1 > *(ByteInt*)src2) result = true;
 710             else result = false;
 711             break;
 712         case OpGreaterThanEquals:
 713             if (*(ByteInt*)src1 >= *(ByteInt*)src2) result = true;
 714             else result = false;
 715             break;
 716    }
 717    return result;
 718 }
 719
 720 bool AllDataType::compareDoubleVal(void* src1, void *src2, ComparisionOp op)
 721 {
 722     bool result = false;
 723     switch(op)
 724     {
 725         case OpEquals:
 726             if (*(double*)src1 == *(double*)src2) result = true;
 727             else result = false;
 728             break;
 729         case OpNotEquals:
 730             if (*(double*)src1 != *(double*)src2) result = true;
 731             else result = false;
 732             break;
 733         case OpLessThan:
 734             if (*(double*)src1 < *(double*)src2) result = true;
 735             else result = false;
 736             break;
 737         case OpLessThanEquals:
 738             if (*(double*)src1 <= *(double*)src2) result = true;
 739             else result = false;
 740             break;
 741         case OpGreaterThan:
 742             if (*(double*)src1 > *(double*)src2) result = true;
 743             else result = false;
 744             break;
 745         case OpGreaterThanEquals:
 746             if (*(double*)src1 >= *(double*)src2) result = true;
 747             else result = false;
 748             break;
 749    }
 750    return result;
 751 }
 752
 753 bool AllDataType::compareFloatVal(void* src1, void *src2, ComparisionOp op)
 754 {
 755     bool result = false;
 756     switch(op)
 757     {
 758         case OpEquals:
 759             if (*(float*)src1 == *(float*)src2) result = true;
 760             else result = false;
 761             break;
 762         case OpNotEquals:
 763             if (*(float*)src1 != *(float*)src2) result = true;
 764             else result = false;
 765             break;
 766         case OpLessThan:
 767             if (*(float*)src1 < *(float*)src2) result = true;
 768             else result = false;
 769             break;
 770         case OpLessThanEquals:
 771             if (*(float*)src1 <= *(float*)src2) result = true;
 772             else result = false;
 773             break;
 774         case OpGreaterThan:
 775             if (*(float*)src1 > *(float*)src2) result = true;
 776             else result = false;
 777             break;
 778         case OpGreaterThanEquals:
 779             if (*(float*)src1 >= *(float*)src2) result = true;
 780             else result = false;
 781             break;
 782    }
 783    return result;
 784 }
 785
 786 bool AllDataType::compareDateVal(void* src1, void *src2, ComparisionOp op)
 787 {
 788     bool result = false;
 789     switch(op)
 790     {
 791         case OpEquals:
 792             if (*(Date*)src1 == *(Date*)src2) result = true;
 793             else result = false;
 794             break;
 795         case OpNotEquals:
 796             if (*(Date*)src1 != *(Date*)src2) result = true;
 797             else result = false;
 798             break;
 799         case OpLessThan:
 800             if (*(Date*)src1 < *(Date*)src2) result = true;
 801             else result = false;
 802             break;
 803         case OpLessThanEquals:
 804             if (*(Date*)src1 <= *(Date*)src2) result = true;
 805             else result = false;
 806             break;
 807         case OpGreaterThan:
 808             if (*(Date*)src1 > *(Date*)src2) result = true;
 809             else result = false;
 810             break;
 811         case OpGreaterThanEquals:
 812             if (*(Date*)src1 >= *(Date*)src2) result = true;
 813             else result = false;
 814             break;
 815    }
 816    return result;
 817 }
 818
 819 bool AllDataType::compareTimeVal(void* src1, void *src2, ComparisionOp op)
 820 {
 821     bool result = false;
 822     switch(op)
 823     {
 824         case OpEquals:
 825             if (*(Time*)src1 == *(Time*)src2) result = true;
 826             else result = false;
 827             break;
 828         case OpNotEquals:
 829             if (*(Time*)src1 != *(Time*)src2) result = true;
 830             else result = false;
 831             break;
 832         case OpLessThan:
 833             if (*(Time*)src1 < *(Time*)src2) result = true;
 834             else result = false;
 835             break;
 836         case OpLessThanEquals:
 837             if (*(Time*)src1 <= *(Time*)src2) result = true;
 838             else result = false;
 839             break;
 840         case OpGreaterThan:
 841             if (*(Time*)src1 > *(Time*)src2) result = true;
 842             else result = false;
 843             break;
 844         case OpGreaterThanEquals:
 845             if (*(Time*)src1 >= *(Time*)src2) result = true;
 846             else result = false;
 847             break;
 848    }
 849    return result;
 850 }
 851
 852 bool AllDataType::compareTimeStampVal(void* src1, void *src2, ComparisionOp op)
 853 {
 854     bool result = false;
 855     switch(op)
 856     {
 857         case OpEquals:
 858             if (*(TimeStamp*)src1 == *(TimeStamp*)src2) result = true;
 859             else result = false;
 860             break;
 861         case OpNotEquals:
 862             if (*(TimeStamp*)src1 != *(TimeStamp*)src2) result = true;
 863             else result = false;
 864             break;
 865         case OpLessThan:
 866             if (*(TimeStamp*)src1 < *(TimeStamp*)src2) result = true;
 867             else result = false;
 868             break;
 869         case OpLessThanEquals:
 870             if (*(TimeStamp*)src1 <= *(TimeStamp*)src2) result = true;
 871             else result = false;
 872             break;
 873         case OpGreaterThan:
 874             if (*(TimeStamp*)src1 > *(TimeStamp*)src2) result = true;
 875             else result = false;
 876             break;
 877         case OpGreaterThanEquals:
 878             if (*(TimeStamp*)src1 >= *(TimeStamp*)src2) result = true;
 879             else result = false;
 880             break;
 881    }
 882    return result;
 883 }
 884
 885 bool AllDataType::compareStringVal(void* src1, void *src2, ComparisionOp op)
 886 {
 887     bool result = false;
 888     int ret = strcmp((char*)src1, (char*)src2);
 889     switch(op)
 890     {
 891         case OpEquals:
 892             if (ret == 0 ) result= true; else result = false;
 893             break;
 894         case OpNotEquals:
 895             if (ret != 0 ) result= true; else result = false;
 896             break;
 897         case OpLessThan:
 898             if (ret < 0 ) result= true; else result = false;
 899             break;
 900         case OpLessThanEquals:
 901             printf("Illegal Operator:Not Supported for String\n");
 902             break;
 903         case OpGreaterThan:
 904             if (ret > 0 ) result= true; else result = false;
 905             break;
 906         case OpGreaterThanEquals:
 907             printf("Illegal Operator:Not Supported for String\n");
 908             break;
 909    }
 910    return result;
 911 }
 912
 913 bool AllDataType::compareBinaryVal(void* src1, void *src2,
 914                                  ComparisionOp op, int length)
 915 {
 916     bool result = false;
 917     int ret = os::memcmp(src1, src2, length);
 918     switch(op)
 919     {
 920         case OpEquals:
 921             if (ret == 0 ) result= true; else result = false;
 922             break;
 923         case OpNotEquals:
 924             if (ret != 0 ) result= true; else result = false;
 925             break;
 926         case OpLessThan:
 927             if (ret < 0 ) result= true; else result = false;
 928             break;
 929         case OpLessThanEquals:
 930             printf("Illegal Operator:Not Supported for Binary\n");
 931             break;
 932         case OpGreaterThan:
 933             if (ret > 0 ) result= true; else result = false;
 934             break;
 935         case OpGreaterThanEquals:
 936             printf("Illegal Operator:Not Supported for Binary\n");
 937             break;
 938    }
 939    return result;
 940 }
 941
 942
 943
 944 ComparisionOp AllDataType::getComparisionOperator(char *str)
 945 {
 946     ComparisionOp op;
 947     if (strcmp(str, "<=") == 0)
 948         op = OpLessThanEquals;
 949     else if (strcmp(str, ">=") == 0)
 950         op = OpGreaterThanEquals;
 951     else if (strcmp(str, "<") == 0)
 952         op = OpLessThan;
 953     else if (strcmp(str, ">") == 0)
 954         op = OpGreaterThan;
 955     else if (strcmp(str, "=") == 0)
 956         op = OpEquals;
 957     else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
 958         op = OpNotEquals;
 959     else
 960         op = OpInvalidComparisionOp;
 961     return op;
 962 }
 963
 964 void* AllDataType::alloc(DataType type, int length)
 965 {
 966     void *dest;
 967     switch(type)
 968     {
 969         case typeInt:
 970             dest = malloc(sizeof(int));
 971             break;
 972         case typeLong:
 973             dest = malloc(sizeof(long));
 974             break;
 975         case typeLongLong:
 976             dest = malloc(sizeof(long long));
 977             break;
 978         case typeShort:
 979             dest = malloc(sizeof(short));
 980             break;
 981         case typeByteInt:
 982             dest = malloc(sizeof(char));
 983             break;
 984         case typeDouble:
 985             dest = malloc(sizeof(double));
 986             break;
 987         case typeFloat:
 988             dest = malloc(sizeof(float));
 989             break;
 990         case typeDecimal:
 991             //TODO::for porting
 992             //fldDef.length_ = sizeof(long double);
 993             break;
 994         case typeString:
 995             if (length == 0 ) return NULL;
 996             dest = malloc(length);
 997             break;
 998         case typeDate:
 999             dest = malloc(sizeof(Date));
1000             break;
1001         case typeTime:
1002             dest = malloc(sizeof(Time));
1003             break;
1004         case typeTimeStamp:
1005             dest = malloc(sizeof(TimeStamp));
1006             break;
1007     }
1008     return dest;
1009 }
1010 void AllDataType::strToValue(void* dest, char *src, DataType type, int length)
1011 {
1012     switch(type)
1013     {
1014         case typeInt: {
1015             int val;
1016             sscanf( src, "%d",  &val);
1017             *(int*)dest = val;
1018             break; }
1019         case typeLong: {
1020             long val;
1021             sscanf( src, "%ld",  &val);
1022             *(long*)dest = val;
1023             break; }
1024         case typeLongLong: {
1025             long long val;
1026             sscanf( src, "%lld",  &val);
1027             *(long long*)dest = val;
1028             break; }
1029         case typeShort: {
1030             short val;
1031             sscanf( src, "%hd",  &val);
1032             *(short*)dest = val;
1033             break; }
1034         case typeByteInt: {
1035             char val;
1036             sscanf( src, "%c",  &val);
1037             *(char*)dest = val;
1038             break; }
1039         case typeDouble: {
1040             double val;
1041             sscanf( src, "%lg",  &val);
1042             *(double*)dest = val;
1043             break; }
1044         case typeFloat: {
1045             float val;
1046             sscanf( src, "%f",  &val);
1047             *(float*)dest = val;
1048             break; }
1049         case typeDecimal:
1050             //TODO::for porting
1051         case typeString: {
1052                 strncpy((char*)dest, (char*)src, length);
1053                 char *d =(char*)dest;
1054                 d[length-1] = '\0';
1055                 break;}
1056         case typeDate: {
1057             int d,m,y,res=0;
1058             res = sscanf( src, "%d-%d-%d", &y, &m, &d );
1059             if( res != 3 )
1060                  res = sscanf( src, "%d/%d/%d", &y, &m, &d );
1061             if( res != 3 )
1062             {
1063            fprintf(stderr,"Error reading date. yyyy{-/}mm{-/}dd is the valid format.");
1064                 d=m=y=0;
1065             }
1066             Date dateObj(y,m,d);
1067             *(Date*)dest = dateObj;
1068             break; }
1069         case typeTime: {
1070             int h,m,s,res=0;
1071             res = sscanf( src, "%d:%d:%d", &h, &m, &s );
1072             if( res != 3 )
1073             {
1074                 fprintf(stderr, "Error reading time, hh:mm:ss is the valid format.");
1075                 h=m=s=0;
1076             }
1077             Time timeObj(h,m,s);
1078             *(Time*)dest = timeObj;
1079             break; }
1080         case typeTimeStamp: {
1081             int d,m,y, h,mn,s, res=0;
1082             res = sscanf( src, "%d-%d-%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1083             if( res != 6 )
1084                 res = sscanf( src, "%d-%d-%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1085             if( res != 6 )
1086                 res = sscanf( src, "%d/%d/%d %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1087             if( res != 6 )
1088                 res = sscanf( src, "%d/%d/%d, %d:%d:%d", &y, &m, &d, &h, &mn, &s );
1089             if( res != 6 )
1090             {
1091                 fprintf(stderr, "Error reading timestamp, yyyy{-/}mm{-/}dd[,] hh:mm:ss is the valid format.");
1092                 d=m=y=h=mn=s=0;
1093             }
1094             TimeStamp timeStampObj(y,m,d,h,mn,s);
1095             *(TimeStamp*)dest = timeStampObj;
1096             break; }
1097         default:
1098             break;
1099         }
1100 }
1101
1102
1103 void AllDataType::convert(DataType srcType, void *src,
1104                           DataType destType, void *dest)
1105 {
1106     switch ((DataType) destType )
1107     {
1108         case typeInt:        convertToInt(dest, src, srcType); break;
1109         case typeLong:       convertToLong(dest, src, srcType); break;
1110         case typeLongLong:   convertToLongLong(dest, src, srcType); break;
1111         case typeShort:      convertToShort(dest, src, srcType); break;
1112         case typeByteInt:    convertToByteInt(dest, src, srcType); break;
1113
1114         case typeFloat:      convertToFloat(dest, src, srcType); break;
1115         case typeDouble:     convertToDouble(dest, src, srcType); break;
1116
1117         //TODO
1118         case typeDecimal:    convertToDouble(dest, src, srcType); break;
1119
1120         case typeString:     convertToString(dest, src, srcType); break;
1121
1122         case typeBinary:
1123         case typeDate:
1124         case typeTime:
1125         case typeTimeStamp:
1126         default: return;
1127     }
1128 }
1129
1130 void AllDataType::convertToInt( void* dest, void* src, DataType srcType )
1131 {
1132     switch(srcType)
1133     {
1134         case typeInt:        *(int *)dest = *(int *)src; break;
1135         case typeLong:       *(int *)dest =(int) *(long *)src; break;
1136         case typeLongLong:   *(int *)dest =(int) *(long long *)src; break;
1137         case typeShort:      *(int *)dest =(int) *(short *)src; break;
1138         case typeByteInt:    *(int *)dest =(int) *(char *)src; break;
1139
1140         case typeFloat:      *(int *)dest = (int) *(float *)src; break;
1141         case typeDouble:     *(int *)dest =(int) *(double *)src; break;
1142
1143         case typeString:     sscanf((const char*)src, "%d", (int*) dest); break;
1144
1145         case typeDate:
1146         case typeTime:
1147         case typeTimeStamp:
1148         case typeBinary:
1149         default:             *(int *)dest = (int) 0;
1150     }
1151 }
1152
1153 void AllDataType::convertToLong( void* dest, void* src, DataType srcType )
1154 {
1155     switch(srcType)
1156     {
1157         case typeInt:        *(long *)dest =(long) *(int *)src; break;
1158         case typeLong:       *(long *)dest = *(long *)src; break;
1159         case typeLongLong:   *(long *)dest =(long) *(long long *)src; break;
1160         case typeShort:      *(long *)dest =(long) *(short *)src; break;
1161         case typeByteInt:    *(long *)dest =(long) *(char *)src; break;
1162
1163         case typeFloat:      *(long *)dest = (long) *(float *)src; break;
1164         case typeDouble:     *(long *)dest =(long) *(double *)src; break;
1165
1166         case typeString:     sscanf((const char*)src, "%ld", (long*) dest); break;
1167
1168         case typeDate:
1169         case typeTime:
1170         case typeTimeStamp:
1171         case typeBinary:
1172         default:             *(long *)dest = (long) 0;
1173     }
1174 }
1175
1176
1177 void AllDataType::convertToLongLong( void* dest, void* src, DataType srcType )
1178 {
1179     switch(srcType)
1180     {
1181         case typeInt:        *(long long *)dest =(long long) *(int *)src; break;
1182         case typeLong:       *(long long *)dest = (long long) *(long *)src; break;
1183         case typeLongLong:   *(long long *)dest = *(long long *)src; break;
1184         case typeShort:      *(long long *)dest =(long long) *(short *)src; break;
1185         case typeByteInt:    *(long long *)dest =(long long) *(char *)src; break;
1186
1187         case typeFloat:      *(long long *)dest = (long long) *(float *)src; break;
1188         case typeDouble:     *(long long *)dest =(long long) *(double *)src; break;
1189
1190         case typeString:     sscanf((const char*)src, "%lld", (long long*) dest); break;
1191
1192         case typeDate:
1193         case typeTime:
1194         case typeTimeStamp:
1195         case typeBinary:
1196         default:             *(long long *)dest = (long long) 0;
1197     }
1198 }
1199
1200 void AllDataType::convertToShort( void* dest, void* src, DataType srcType )
1201 {
1202     switch(srcType)
1203     {
1204         case typeInt:        *(short*)dest =(short) *(int*)src; break;
1205         case typeLong:       *(short*)dest = (short) *(long*)src; break;
1206         case typeLongLong:   *(short*)dest = (short) *(long long*)src; break;
1207         case typeShort:      *(short*)dest = *(short*)src; break;
1208         case typeByteInt:    *(short*)dest =(short) *(char *)src; break;
1209
1210         case typeFloat:      *(short*)dest = (short) *(float *)src; break;
1211         case typeDouble:     *(short*)dest =(short) *(double *)src; break;
1212
1213         case typeString:     sscanf((const char*)src, "%hd", (short*) dest); break;
1214
1215         case typeDate:
1216         case typeTime:
1217         case typeTimeStamp:
1218         case typeBinary:
1219         default:             *(short*)dest = (short) 0;
1220     }
1221 }
1222
1223 void AllDataType::convertToByteInt( void* dest, void* src, DataType srcType )
1224 {
1225     switch(srcType)
1226     {
1227         case typeInt:        *(char*)dest = (char) *(int*)src; break;
1228         case typeLong:       *(char*)dest = (char) *(long*)src; break;
1229         case typeLongLong:   *(char*)dest = (char) *(long long*)src; break;
1230         case typeShort:      *(char*)dest = (char) *(short*)src; break;
1231         case typeByteInt:    *(char*)dest = *(char *)src; break;
1232
1233         case typeFloat:      *(char*)dest = (char) *(float *)src; break;
1234         case typeDouble:     *(char*)dest =(char) *(double *)src; break;
1235
1236         case typeString:     sscanf((const char*)src, "%c", (char*) dest); break;
1237
1238         case typeDate:
1239         case typeTime:
1240         case typeTimeStamp:
1241         case typeBinary:
1242         default:             *(char*)dest = (char) 0;
1243     }
1244 }
1245
1246 void AllDataType::convertToFloat( void* dest, void* src, DataType srcType )
1247 {
1248     switch(srcType)
1249     {
1250         case typeInt:        *(float *)dest =(float) *(int *)src; break;
1251         case typeLong:       *(float *)dest =(float) *(long *)src; break;
1252         case typeLongLong:   *(float *)dest =(float) *(long long *)src; break;
1253         case typeShort:      *(float *)dest =(float) *(short *)src; break;
1254         case typeByteInt:    *(float *)dest =(float) *(char *)src; break;
1255
1256         case typeFloat:      *(float *)dest = *(float *)src; break;
1257         case typeDouble:     *(float *)dest =(float) *(double *)src; break;
1258
1259         case typeString:     sscanf((const char*)src, "%f", (float*) dest); break;
1260
1261         case typeDate:
1262         case typeTime:
1263         case typeTimeStamp:
1264         case typeBinary:
1265         default:             *(float *)dest = (float) 0;
1266     }
1267 }
1268
1269 void AllDataType::convertToDouble( void* dest, void* src, DataType srcType )
1270 {
1271     switch(srcType)
1272     {
1273         case typeInt:        *(double *)dest =(double) *(int *)src; break;
1274         case typeLong:       *(double *)dest =(double) *(long *)src; break;
1275         case typeLongLong:   *(double *)dest =(double) *(long long *)src; break;
1276         case typeShort:      *(double *)dest =(double) *(short *)src; break;
1277         case typeByteInt:    *(double *)dest =(double) *(char *)src; break;
1278
1279         case typeFloat:      *(double *)dest =(double) *(float *)src; break;
1280         case typeDouble:     *(double *)dest = *(double *)src; break;
1281
1282         case typeString:     sscanf((const char*)src, "%lf", (double*) dest); break;
1283
1284         case typeDate:
1285         case typeTime:
1286         case typeTimeStamp:
1287         case typeBinary:
1288         default:             *(double *)dest = (double) 0;
1289     }
1290 }
1291
1292 void AllDataType::convertToString( void* dest, void* src, DataType srcType )
1293 {
1294     switch(srcType)
1295     {
1296         case typeInt:
1297         {
1298             sprintf ((char *)dest, "%d", *(int *)src);
1299             break;
1300         }
1301         case typeLong:
1302         {
1303             sprintf ((char *)dest, "%ld", *(long *)src);
1304             break;
1305         }
1306         case typeLongLong:
1307         {
1308             sprintf ((char *)dest, "%lld", *(long long *)src);
1309             break;
1310         }
1311         case typeShort:
1312         {
1313             sprintf ((char *)dest, "%hd", *(short *)src);
1314             break;
1315         }
1316         case typeByteInt:
1317         {
1318             sprintf ((char *)dest, "%hd", *(char *)src);
1319             break;
1320         }
1321
1322         case typeFloat:
1323         {
1324             sprintf ((char *)dest, "%f", *(float *)src);
1325             break;
1326         }
1327         case typeDouble:
1328         {
1329             sprintf ((char *) dest, "%lf", *(double *)src);
1330             break;
1331         }
1332
1333         case typeString:
1334         {
1335             strcpy((char*)dest, (char*)src);
1336             break;
1337         }
1338         case typeDate:
1339         {
1340             Date* dt = (Date*)src;
1341             sprintf((char*) dest, "%d/%d/%d", dt->year(),
1342                                   dt->month(), dt->dayOfMonth());
1343             break;
1344         }
1345         case typeTime:
1346         {
1347             Time* tm = (Time*)src;
1348             sprintf((char*)dest,"%d:%d:%d.%d", tm->hours(), tm->minutes(), tm->seconds(), 0);
1349             break;
1350         }
1351         case typeTimeStamp:
1352         {
1353             TimeStamp* tm = (TimeStamp*)src;
1354             sprintf((char*)dest, "%d/%d/%d %d:%d:%d.%d", tm->year(),
1355                                 tm->month(), tm->dayOfMonth(), tm->hours(),
1356                                 tm->minutes(), tm->seconds(), 0 );
1357             break;
1358         }
1359         default: ((char*)dest)[0] = '\0';
1360     }
1361
1362 }
1363
1364 void AllDataType::printVal(void* src, DataType srcType, int length )
1365 {
1366     switch(srcType)
1367     {
1368         case typeInt:
1369         {
1370             printf ("%d\t", *(int *)src);
1371             break;
1372         }
1373         case typeLong:
1374         {
1375             printf ("%ld\t", *(long *)src);
1376             break;
1377         }
1378         case typeLongLong:
1379         {
1380             printf ("%lld\t", *(long long *)src);
1381             break;
1382         }
1383         case typeShort:
1384         {
1385             printf("%hd\t", *(short *)src);
1386             break;
1387         }
1388         case typeByteInt:
1389         {
1390             printf("%hd\t", *(char *)src);
1391             break;
1392         }
1393
1394         case typeFloat:
1395         {
1396             printf("%f\t", *(float *)src);
1397             break;
1398         }
1399         case typeDouble:
1400         {
1401             printf("%lf\t", *(double *)src);
1402             break;
1403         }
1404
1405         case typeString:
1406         {
1407             printf("%s\t", (char*)src);
1408             break;
1409         }
1410         case typeDate:
1411         {
1412             Date* dt = (Date*)src;
1413             printf("%d/%d/%d\t", dt->year(),
1414                                   dt->month(), dt->dayOfMonth());
1415             break;
1416         }
1417         case typeTime:
1418         {
1419             Time* tm = (Time*)src;
1420             printf("%d:%d:%d.%d\t", tm->hours(), tm->minutes(), tm->seconds(), 0);
1421             break;
1422         }
1423         case typeTimeStamp:
1424         {
1425             TimeStamp* tm = (TimeStamp*)src;
1426             printf("%d/%d/%d %d:%d:%d.%d\t", tm->year(),
1427                                 tm->month(), tm->dayOfMonth(), tm->hours(),
1428                                 tm->minutes(), tm->seconds(), 0 );
1429             break;
1430         }
1431         default: { printf("DataType not supported\n"); break; }
1432     }
1433
1434 }
1435
1436
1437