include/DataType.h

   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 #ifndef DATATYPE_H
  17 #define DATATYPE_H
  18 #include<sqlext.h>
  19 #include<sqltypes.h>
  20 #include<ErrorType.h>
  21 //#include<os.h>
  22 typedef int JulianRep;
  23
  24
  25 /**
  26 * @class DataType
  27 * Data Types supported by the database system.
  28 * <br/>
  29 *
  30 */
  31 enum DataType {
  32    typeInt         =  0, /**<integer type*/
  33    typeLong        =  1,
  34    typeLongLong    =  2,
  35    typeShort       =  3,
  36    typeByteInt     =  4,
  37
  38    typeDouble      =  10,
  39    typeFloat       =  11,
  40    typeDecimal     =  12,
  41
  42    typeDate        =  20,
  43    typeTime        =  21,
  44    typeTimeStamp   =  22,
  45
  46    typeString      =  30,
  47    typeBinary      =  31,
  48
  49    typeComposite   =  98,
  50    typeULong       =  99,
  51    typeUnknown     =  100
  52 };
  53
  54 /**
  55 * @class ComparisionOp
  56 * Comparision operators supported by the database system.
  57 * <br/>
  58 *
  59 */
  60 enum ComparisionOp {
  61     OpEquals = 0,
  62     OpNotEquals,
  63     OpLessThan,
  64     OpLessThanEquals,
  65     OpGreaterThan,
  66     OpGreaterThanEquals,
  67         OpLike, // for Like operator
  68     OpInvalidComparisionOp
  69 };
  70
  71 /**
  72 * @class LogicalOp
  73 * Logical operators supported by the database system.
  74 * <br/>
  75 *
  76 */
  77 enum LogicalOp {
  78     OpAnd = 0,
  79     OpOr,
  80     OpNot,
  81     OpInvalidLogicalOp
  82 };
  83
  84
  85 class AllDataType
  86 {
  87     public:
  88     static long size(DataType type, int length =0);
  89     static char* getSQLString(DataType type);
  90     static SQLSMALLINT convertToSQLType(DataType type);
  91     static SQLSMALLINT convertToSQL_C_Type(DataType type);
  92     static DataType convertFromSQLType(SQLSMALLINT type);
  93
  94     static void copyVal(void* dest, void *src, DataType type, int length = 0);
  95     static void addVal(void* dest, void *src, DataType type);
  96     static void divVal(void* dest, int src, DataType type);
  97     static void subVal(void* dest, void *src, DataType type);
  98     static void mulVal(void* dest, void *src, DataType type);
  99     static void mudVal(void* dest, void *src, DataType type);
 100     static void divVal(void* dest, void *src, DataType type);
 101
 102
 103     static bool compareVal(void *src1, void *src2, ComparisionOp op,
 104                            DataType type, long length = 0);
 105     static bool compareIntVal(void* src1, void* src2, ComparisionOp op);
 106     static bool compareLongVal(void* src1, void* src2, ComparisionOp op);
 107     static bool compareLongLongVal(void* src1, void* src2, ComparisionOp op);
 108     static bool compareShortVal(void* src1, void* src2, ComparisionOp op);
 109     static bool compareByteIntVal(void* src1, void* src2, ComparisionOp op);
 110     static bool compareDoubleVal(void* src1, void* src2, ComparisionOp op);
 111     static bool compareFloatVal(void* src1, void* src2, ComparisionOp op);
 112     static bool compareDateVal(void* src1, void* src2, ComparisionOp op);
 113     static bool compareTimeVal(void* src1, void* src2, ComparisionOp op);
 114     static bool compareTimeStampVal(void* src1, void* src2, ComparisionOp op);
 115     static bool compareStringVal(void* src1, void* src2, ComparisionOp op);
 116     static bool compareBinaryVal(void* src1, void* src2,
 117                                  ComparisionOp op, int length);
 118
 119
 120     static void convert(DataType srcType, void *src, DataType destType, void *dest, int length=0);
 121     static void convertToInt(void* dest, void* src, DataType srcType);
 122     static void convertToLong(void* dest, void* src, DataType srcType);
 123     static void convertToLongLong(void* dest, void* src, DataType srcType);
 124     static void convertToShort(void* dest, void* src, DataType srcType);
 125     static void convertToByteInt(void* dest, void* src, DataType srcType);
 126     static void convertToFloat(void* dest, void* src, DataType srcType);
 127     static void convertToDouble(void* dest, void* src, DataType srcType);
 128     static void convertToString(void* dest, void* src, DataType srcType, int length=0);
 129     static void convertToDate(void* dest, void* src, DataType srcType);
 130     static void convertToTime(void* dest, void* src, DataType srcType);
 131     static void convertToTimeStamp(void* dest, void* src, DataType srcType);
 132         static void convertToBinary(void* dest, void* src, DataType srcType, int length);
 133
 134
 135     static ComparisionOp getComparisionOperator(char *str);
 136
 137     static void* alloc(DataType type, int length =0);
 138     static DbRetVal strToValue(void *dest, char *src, DataType type, int length=0);
 139     static int printVal(void *src, DataType type, int length);
 140
 141
 142 };
 143
 144
 145 /**
 146 * @class ByteInt
 147 * Represents 8 bit integer.
 148 * <br/>
 149 *
 150 */
 151 class ByteInt {
 152
 153     public:
 154     ByteInt() { }
 155
 156     /** copy constructor
 157     */
 158     ByteInt(const ByteInt &v) { val = v.val; }
 159     /** constructor with char
 160     *   @param v char value
 161     */
 162     ByteInt(char v) { val = v; }
 163     operator int() const { return (int) val; }
 164     char operator=(ByteInt v)   { return val = v.val; }
 165     char operator=(char v)          { return val = v; }
 166     char operator+=(ByteInt v)  { return val += v.val; }
 167     char operator+=(char v)         { return val += v; }
 168     char operator-=(ByteInt v)  { return val -= v.val; }
 169     char operator-=(char v)         { return val -= v; }
 170     char operator*=(ByteInt v)  { return val *= v.val; }
 171     char operator*=(char v)         { return val *= v; }
 172     char operator/=(ByteInt v)  { return val /= v.val; }
 173     char operator/=(char v)         { return val /= v; }
 174     char operator%=(ByteInt v)  { return val %= v.val; }
 175     char operator%=(char v)         { return val %= v; }
 176     char operator<<=(ByteInt v) { return val <<= v.val; }
 177     char operator<<=(char v)        { return val <<= v; }
 178     char operator>>=(ByteInt v) { return val >>= v.val; }
 179     char operator>>=(char v)        { return val >>= v; }
 180     char operator&=(ByteInt v)  { return val &= v.val; }
 181     char operator&=(char v)         { return val &= v; }
 182     char operator|=(ByteInt v)  { return val |= v.val; }
 183     char operator|=(char v)         { return val |= v; }
 184     char operator^=(ByteInt v)  { return val ^= v.val; }
 185     char operator^=(char v)         { return val ^= v; }
 186     char operator++()               { return val++; }
 187     char operator++(int)               { char tmp = val; val++; return val; }
 188     char operator--()               { return val--; }
 189     char operator--(int)               { char tmp = val; val--; return val; }
 190
 191     private:
 192     signed char val;
 193 };
 194
 195
 196 /**
 197 * @class Date
 198 * Represents Date Data type.
 199 * <br/>
 200 *
 201 */
 202 class Date {  // The class a user would declare to hold date
 203
 204     public:
 205     Date() {julianDate = 0;}
 206     Date(JulianRep julian) : julianDate(julian) {}
 207
 208     /** constructor with year, month, day
 209     *   @param year year
 210     *   @param month month
 211     *   @param day day
 212     */
 213     Date(int year, int month, int day);
 214
 215     Date(const Date &d2) { julianDate = d2.julianDate; }
 216     Date& operator=(const Date& d2)
 217         { julianDate=d2.julianDate; return *this; }
 218
 219     /** sets the date with specified year, month, day
 220     *   @param year year
 221     *   @param month month
 222     *   @param day day
 223     */
 224     int set(int year, int month, int day);
 225     int set(const struct tm *tmptr);
 226
 227     /** get year, month, day of the date
 228     *   @param year year IN
 229     *   @param month month IN
 230     *   @param day day IN
 231     */
 232     int get(int &year, int &month, int &day) const;
 233
 234     /** checks for the validity of the date
 235     */
 236     bool isValid() const;
 237
 238     /** resets the date to zero
 239     */
 240     void setNull() { julianDate = 0;}
 241
 242     /** returns day of the week
 243     */
 244     int dayOfWeek() const;
 245
 246     /** returns day of the week.
 247     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday".
 248     */
 249     const char *dayOfWeekName() const;
 250
 251     /** returns day of the week abbreviation
 252     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 253     */
 254     const char *dayOfWeekAbbr() const;
 255
 256     /** returns day of the week.
 257     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday".
 258     */
 259     static const char *dayOfWeekName(int day); // 0--> Sunday
 260
 261     /** returns day of the week abbreviation
 262     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 263     */
 264     static const char *dayOfWeekAbbr(int day);
 265
 266     static int dayOfWeek(JulianRep juldate);
 267
 268
 269     /** returns the day of the month. Values are 1 to 31
 270     */
 271     int dayOfMonth() const;
 272
 273     int dayOfYear() const;
 274
 275     /** returns the month Values are 1 to 12.
 276     */
 277     int month() const;
 278
 279     /** returns the month name
 280     *   values are "January", "February", "March",     "April",   "May",      "June",
 281     *   "July",    "August",   "September", "October", "November", "December"
 282     */
 283     const char *monthName() const;
 284
 285     /** returns the month name abbreviation
 286     * values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 287     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 288     */
 289     const char *monthAbbr() const;
 290
 291     /** returns the month name
 292     *   values are "January", "February", "March",     "April",   "May",      "June",
 293     *   "July",    "August",   "September", "October", "November", "December"
 294     */
 295     static const char *monthName(int month);
 296
 297
 298     /** returns the month name abbreviation
 299     * values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 300     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 301     */
 302     static const char *monthAbbr(int month);
 303
 304     /** parses the date string passed and stores it
 305     *It should of the format "mm/dd/yyyy"
 306     */
 307     int parseFrom(const char *s);
 308
 309     Date &operator++() { julianDate++; return *this; }
 310     Date &operator--() { julianDate--; return *this; }
 311
 312     Date &operator+=(int days) { julianDate += days; return *this;}
 313     Date &operator-=(int days) { julianDate -= days; return *this;}
 314
 315     /** returns the year
 316     */
 317     int year() const;
 318
 319     /** checks for the validity of the date
 320     */
 321     static bool isValidDate(int year, int month, int day);
 322
 323     friend Date  operator+(const Date &d1, int days);
 324     friend Date  operator+(int days, const Date &d1);
 325     friend Date  operator-(const Date &d1, int days);
 326     friend int  operator-(const Date &d1, const Date & d2);
 327     friend int  operator<(const Date &d1 ,const Date &d2);
 328     friend int  operator>(const Date &d1 ,const Date &d2);
 329     friend int  operator<=(const Date &d1 ,const Date &d2);
 330     friend int  operator>=(const Date &d1 ,const Date &d2);
 331     friend int  operator==(const Date &d1 ,const Date &d2);
 332     friend int  operator!=(const Date &d1 ,const Date &d2);
 333
 334     /** checks for leap year
 335     */
 336     static bool isLeapYear(int year);
 337
 338     /** returns the number of days in the specified month of the year.
 339     */
 340     static int daysInMonth(int month, int year);
 341
 342     static int YMDToJulian(int year,int mon,int day, JulianRep &julian);
 343     static int julianToYMD(JulianRep julian,int &year,int &month,int &day);
 344
 345     private:
 346     JulianRep julianDate;
 347
 348
 349
 350 };
 351
 352 /**
 353 * @class Time
 354 * Represents Time Data type.
 355 * <br/>
 356 *
 357 */
 358 class Time {  // The class a user would declare to hold time
 359     public:
 360     Time() {timeVal = 0;}
 361
 362     /** Overloaded constructor
 363     *   @param hours hours
 364     *   @param mins mins
 365     *   @param secs secs
 366     *   @param usec usec
 367     */
 368     Time(int hours, int mins, int secs, int usec = 0);
 369     Time(int totalSecs) : timeVal(totalSecs) {;}
 370     Time(const Time &d2) { timeVal = d2.timeVal; }
 371     Time& operator=(const Time& d2) { timeVal=d2.timeVal; return *this; }
 372
 373     /** sets the time with specified hours, mins, secs
 374     *   @param hours hours
 375     *   @param mins mins
 376     *   @param secs secs
 377     *   @param usec usec
 378     */
 379     int set(int hours, int mins, int secs, int usec = 0);
 380
 381     /** retrieves the time using IN parameters
 382     *   @param hours hours
 383     *   @param mins mins
 384     *   @param secs secs
 385     */
 386     int get(int &hours, int &mins, int &secs) const;
 387
 388     /** checks for the validity of the time
 389     */
 390     bool isValid() const;
 391
 392     /** resets the time
 393     */
 394     void setNull() { timeVal = -1;}
 395
 396     int secondsSinceMidnight() const { return timeVal/10000;}
 397
 398     /** returns the microsecs
 399     */
 400     int usec() const; // to nearest 100 of usec.
 401
 402     /** returns the millisecs
 403     */
 404     int msec() const;
 405
 406     /** returns the secs
 407     */
 408     int seconds() const;
 409
 410     /** returns the minutes
 411     */
 412     int minutes() const;
 413
 414     /** returns the hours
 415     */
 416     int hours() const;
 417
 418
 419     /** sets the millisecs
 420     */
 421     int setMsec(int ms);
 422
 423     /** sets the microsecs
 424     */
 425     int setUsec(int us);
 426
 427     /** parses the time string passed and stores it
 428     *It should of the format "hh:mm::ss"
 429     */
 430     int parseFrom(const char *s);
 431
 432     Time &operator++() { timeVal += 10000; return *this; }
 433     Time &operator--() { timeVal -= 10000; return *this; }
 434
 435     Time &operator+=(int seconds) { timeVal += seconds*10000; return *this; }
 436     Time &operator-=(int seconds) { timeVal -= seconds*10000; return *this; }
 437
 438
 439     /** checks for the validity of the time specified
 440     */
 441     static bool isValidTime(int hours, int mins, int secs);
 442
 443     friend Time operator+(const Time &t1, int seconds);
 444     friend Time operator+(int seconds, const Time &t1);
 445     friend Time operator-(const Time &t1, int seconds);
 446     friend int  operator-(const Time &t1, const Time& t2);
 447     friend int  operator<(const Time &t1 ,const Time &t2 );
 448     friend int  operator>(const Time &t1 ,const Time &t2 );
 449     friend int  operator<=(const Time &t1 ,const Time &t2 );
 450     friend int  operator>=(const Time &t1 ,const Time &t2 );
 451     friend int  operator==(const Time &t1 ,const Time &t2 );
 452     friend int  operator!=(const Time &t1 ,const Time &t2 );
 453
 454
 455     private:
 456     int timeVal;
 457 };
 458
 459 /**
 460 * @class TimeStamp
 461 * Represents TimeStamp Data type.
 462 * <br/>
 463 *
 464 */
 465 class TimeStamp {
 466
 467     public:
 468     TimeStamp() {}
 469
 470     /** Overloaded constructor
 471     *   @param year year
 472     *   @param month month
 473     *   @param day day
 474     *   @param hours hours
 475     *   @param mins mins
 476     *   @param secs secs
 477     *   @param usec usec
 478     */
 479     TimeStamp(int year, int month, int day, int hour, int minute, int sec, int usec = 0) :
 480         date(year, month, day), time(hour, minute, sec, usec) { }
 481
 482     TimeStamp(const TimeStamp &ts)
 483     { date = ts.date; time = ts.time; }
 484     TimeStamp(const Date &d, Time &t) : date(d), time(t) {}
 485
 486
 487     TimeStamp& operator=(const TimeStamp& d2)
 488         { date=d2.date; time = d2.time; return *this; }
 489
 490     /** get year, month, day from the date part of the timestamp
 491     *   @param year year IN
 492     *   @param month month IN
 493     *   @param day day IN
 494     */
 495     int getDate(int &year, int &month, int &day)
 496          { return date.get(year, month, day); }
 497
 498     /** get the date part of the timestamp
 499     *   @param Date date
 500     */
 501    void getDate(Date &newDate) const
 502          { newDate = date; }
 503
 504     /** sets the date with specified year, month, day
 505     *   @param year year
 506     *   @param month month
 507     *   @param day day
 508     */
 509     int setDate(int year, int month, int day)
 510          { return date.set(year, month, day); }
 511
 512     /** set the date part of the timestamp
 513     *   @param Date date
 514     */
 515     void setDate(const Date &newDate)
 516          { date = newDate; }
 517
 518
 519     operator Date() { return date; }
 520     operator Time() { return time; }
 521
 522
 523
 524     /** retrieves the time using IN parameters
 525     *   @param hours hours
 526     *   @param mins mins
 527     *   @param secs secs
 528     */
 529     int getTime(int &hours, int &mins, int &secs) const
 530          { return time.get(hours, mins, secs); }
 531     /** retrieves the time part of the timestamp
 532     *   @param newTime Time
 533     */
 534     void getTime(Time &newTime) const
 535          { newTime = time; }
 536
 537     /** sets the time with specified hours, mins, secs
 538     *   @param hours hours
 539     *   @param mins mins
 540     *   @param secs secs
 541     *   @param usec usec
 542     */
 543     int setTime(int hours, int mins, int secs, int usec = 0)
 544          { return time.set(hours, mins, secs, usec); }
 545
 546     /** set the time part of the timestamp
 547     *   @param newTime Time
 548     */
 549     void setTime(const Time &newTime)
 550          { time = newTime; }
 551
 552     /** checks for the validity of the timestamp
 553     */
 554     bool isValid() const { return date.isValid() && time.isValid(); }
 555
 556     /** resets the date and time */
 557     void setNull() { date.setNull(); time.setNull(); }
 558
 559     /** returns day of the week. Values are 1-7
 560     */
 561     int dayOfWeek() const { return date.dayOfWeek(); }
 562
 563    /** returns day of the week.
 564     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Satur
 565 day".
 566     */
 567     const char *dayOfWeekName() const { return date.dayOfWeekName(); }
 568
 569     /** returns day of the week abbreviation
 570     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 571     */
 572     const char *dayOfWeekAbbr() const { return date.dayOfWeekAbbr(); }
 573
 574     /** returns the day of the month. Values are 1 to 31
 575     */
 576     int dayOfMonth() const { return date.dayOfMonth(); }
 577     int dayOfYear() const { return date.dayOfYear(); }
 578
 579     /** returns the month. Values are 1 to 12.
 580     */
 581
 582     int month() const { return date.month(); }
 583
 584     /** returns the month name
 585     *   values are "January", "February", "March",     "April",   "May",      "June",
 586     *   "July",    "August",   "September", "October", "November", "December"
 587     */
 588     const char *monthName() const { return date.monthName(); }
 589
 590     /** returns the month name abbreviation
 591     * Values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 592     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 593     */
 594     const char *monthAbbr() const { return date.monthAbbr(); }
 595
 596     /** returns the year
 597     */
 598     int year() const { return date.year(); }
 599
 600     int secondsSinceMidnight() const { return time.secondsSinceMidnight(); }
 601     /** returns the seconds */
 602     int seconds() const { return time.seconds(); }
 603     /** returns the minutes */
 604     int minutes() const { return time.minutes(); }
 605     /** returns the hours */
 606     int hours() const { return time.hours(); }
 607     /** returns the millisecs */
 608     int msec() const { return time.msec(); }
 609     /** returns the microsecs */
 610     int usec() const { return time.usec(); }
 611
 612     /** sets the millisecs */
 613     int setMsec(int ms) { return time.setMsec(ms) ; }
 614     /** sets the microsecs */
 615     int setUsec(int us) { return time.setUsec(us) ; }
 616
 617     /** parses the date string passed and stores it
 618     *It should of the format "mm/dd/yyyy"
 619     */
 620     int parseDateFrom(const char *s) { return date.parseFrom(s); }
 621
 622     /** parses the time string passed and stores it
 623     *It should of the format "hh:mm::ss"
 624     */
 625
 626     int parseTimeFrom(const char *s) { return time.parseFrom(s); }
 627
 628     int parseFrom(const char *s);
 629     friend int  operator<(const TimeStamp &d1, const TimeStamp &d2);
 630     friend int  operator>(const TimeStamp &d1, const TimeStamp &d2);
 631     friend int  operator<=(const TimeStamp &d1, const TimeStamp &d2);
 632     friend int  operator>=(const TimeStamp &d1, const TimeStamp &d2);
 633     friend int  operator==(const TimeStamp &d1, const TimeStamp &d2);
 634     friend int  operator!=(const TimeStamp &d1, const TimeStamp &d2);
 635
 636
 637     private:
 638     Date date;
 639     Time time;
 640 };
 641
 642
 643 #endif
 644
 645