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