include/DataTypeInline.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *    Copyright (C) Lakshya Solutions Ltd. All rights reserved.            *
   4  *                                                                         *
   5  ***************************************************************************/
   6
   7 #include<os.h>
   8 #include<DataType.h>
   9 #include<Config.h>
  10 long AllDataType::size(DataType type, int length )
  11 {
  12     if (type == typeInt) return sizeof(int);
  13     else if (type == typeString) return length;
  14
  15     long size = 0;
  16     switch(type)
  17     {
  18         case typeInt:
  19             size = sizeof(int);
  20             break;
  21         case typeLong:
  22             size = sizeof(long);
  23             break;
  24         case typeLongLong:
  25             size = sizeof(long long);
  26             break;
  27         case typeShort:
  28             size = sizeof(short);
  29             break;
  30         case typeByteInt:
  31             size = sizeof(char);
  32             break;
  33         case typeDouble:
  34             size = sizeof(double);
  35             break;
  36         case typeFloat:
  37             size = sizeof(float);
  38             break;
  39         case typeDecimal:
  40             //TODO::for porting
  41             //fldDef.length_ = sizeof(long double);
  42             break;
  43         case typeDate:
  44             size = sizeof(Date);
  45             break;
  46         case typeTime:
  47             size = sizeof(Time);
  48             break;
  49         case typeTimeStamp:
  50             size = sizeof(TimeStamp);
  51             break;
  52         case typeString:
  53         case typeBinary:
  54         case typeComposite:
  55             size = length;
  56             break;
  57         default:
  58             size  = 0;
  59             break;
  60     }
  61     return size;
  62 }
  63 void AllDataType::cachecopyVal(void* dest, void *src, DataType type, int length,int dbFlag)
  64 {
  65     if (typeInt == type )
  66     {
  67         *(int*)dest = *(int*)src;
  68         return;
  69     }else if (typeString == type)
  70     {
  71         //null is always put at the last byte by insert
  72         //so using strcpy is safe
  73         //strcpy((char*)dest, (char*)src);
  74         Util::trimRight((char*)src);
  75         strncpy((char*)dest, (char*)src, length);
  76         //strncpy((char*)dest, (char*)src, length);
  77         //char *d =(char*)dest;
  78         //d[length-1] = '\0';
  79         return;
  80     }else if (typeShort == type) {
  81         *(short*)dest = *(short*)src;
  82     }else if (typeDouble == type) {
  83         *(double*)dest = *(double*)src;
  84     }else if (typeTimeStamp == type) {
  85         *(TimeStamp*)dest = *(TimeStamp*)src;
  86     }else if (typeDate == type) {
  87         *(Date*)dest = *(Date*)src;
  88     }else if (typeFloat == type) {
  89         *(float*)dest = *(float*)src;
  90     }else if (typeTime == type) {
  91         *(Time*)dest = *(Time*)src;
  92     }else if (typeLong == type) {
  93         *(long*)dest = *(long*)src;
  94     }else if (typeLongLong == type) {
  95          if(1 == dbFlag)
  96              convertToLongLong(dest, src,typeString);
  97          else
  98              *(long long*)dest = *(long long*)src;
  99     }else if (typeByteInt == type) {
 100         *(char*)dest = *(char*)src;
 101     }else if (typeBinary == type) {
 102         os::memcpy(dest, src, length);
 103     }else if (typeComposite == type) {
 104         os::memcpy(dest, src, length);
 105     }
 106     return;
 107 }
 108
 109 void AllDataType::copyVal(void* dest, void *src, DataType type, int length,int dbFlag)
 110 {
 111     //Performance optimization. putting likely case first
 112     if (typeInt == type )
 113     {
 114         *(int*)dest = *(int*)src;
 115         return;
 116     }else if (typeString == type)
 117     {
 118         //null is always put at the last byte by insert
 119         //so using strcpy is safe
 120         //strcpy((char*)dest, (char*)src);
 121         memcpy(dest, src, length);
 122         //strncpy((char*)dest, (char*)src, length);
 123         char *d =(char*)dest;
 124         d[length-1] = '\0';
 125         return;
 126     }else if (typeShort == type) {
 127         *(short*)dest = *(short*)src;
 128     }else if (typeDouble == type) {
 129         *(double*)dest = *(double*)src;
 130     }else if (typeTimeStamp == type) {
 131         *(TimeStamp*)dest = *(TimeStamp*)src;
 132     }else if (typeDate == type) {
 133         *(Date*)dest = *(Date*)src;
 134     }else if (typeFloat == type) {
 135         *(float*)dest = *(float*)src;
 136     }else if (typeTime == type) {
 137         *(Time*)dest = *(Time*)src;
 138     }else if (typeLong == type) {
 139         *(long*)dest = *(long*)src;
 140     }else if (typeLongLong == type) {
 141         *(long long*)dest = *(long long*)src;
 142     }else if (typeByteInt == type) {
 143         *(char*)dest = *(char*)src;
 144     }else if (typeBinary == type) {
 145         os::memcpy(dest, src, length);
 146     }else if (typeComposite == type) {
 147         os::memcpy(dest, src, length);
 148     }
 149     return;
 150 }
 151 void AllDataType::copyZeroVal(void *dest, DataType type, int length)
 152 {
 153     if (typeInt == type )
 154     {
 155         *(int*)dest = 0;
 156     }else if (typeString == type)
 157     {
 158         char *d =(char*)dest;
 159         d[0] = '\0';
 160     }else if (typeShort == type) {
 161         *(short*)dest = 0;
 162     }else if (typeDouble == type) {
 163         *(double*)dest = 0;
 164     }else if (typeTimeStamp == type) {
 165         ((TimeStamp*)dest)->setDate(0,0,0);
 166         ((TimeStamp*)dest)->setTime(0,0,0);
 167     }else if (typeDate == type) {
 168         ((Date*)dest)->set(0,0,0);
 169     }else if (typeFloat == type) {
 170         *(float*)dest = 0;
 171     }else if (typeTime == type) {
 172         ((Time*)dest)->set(0,0,0);
 173     }else if (typeLong == type) {
 174         *(long*)dest = 0;
 175     }else if (typeLongLong == type) {
 176         *(long long*)dest = 0;
 177     }else if (typeByteInt == type) {
 178         *(char*)dest = 0;
 179     }else if (typeBinary == type) {
 180         os::memset(dest, 0, length);
 181     }else if (typeComposite == type) {
 182         os::memset(dest, 0, length);
 183     }
 184     return;
 185
 186 }
 187
 188 void AllDataType::addVal(void* dest, void *src, DataType type)
 189 {
 190     if (type == typeInt)
 191     {
 192         *(int*)dest = *(int*)dest + *(int*)src;
 193         return;
 194     }
 195     switch(type)
 196     {
 197         case typeInt:
 198             *(int*)dest = *(int*)dest + *(int*)src;
 199             break;
 200         case typeLong:
 201             *(long*)dest = *(long*)dest + *(long*)src;
 202             break;
 203         case typeLongLong:
 204             *(long long*)dest = *(long long*)dest + *(long long*)src;
 205             break;
 206         case typeShort:
 207             *(short*)dest = *(short*)dest + *(short*)src;
 208             break;
 209         case typeByteInt:
 210             *(char*)dest = *(char*)dest + *(char*)src;
 211             break;
 212         case typeDouble:
 213             *(double*)dest = *(double*)dest + *(double*)src;
 214             break;
 215         case typeFloat:
 216             *(float*)dest = *(float*)dest + *(float*)src;
 217             break;
 218         case typeDecimal:
 219             //TODO::for porting
 220         case typeDate:
 221         case typeTime:
 222         case typeTimeStamp:
 223         case typeBinary:
 224         default:
 225              break;
 226      }
 227      return;
 228 }
 229
 230 bool AllDataType::compareVal(void *val1, void *val2, ComparisionOp op,
 231                              DataType type, long length)
 232 {
 233     //Performance optimization.
 234     //do not convert compareXXXVal to virtual functions. it takes more time
 235     if (typeInt == type)
 236     {
 237         //as int is the heavily used type, hardcoding the compare here itself
 238         if (OpEquals == op) {
 239             if (*(int*)val1 == *(int*)val2) return true;
 240             else return false;
 241         }else if (OpLessThan == op) {
 242             if (*(int*)val1 < *(int*)val2) return true;
 243             else return false;
 244         }else if (OpGreaterThan == op) {
 245             if (*(int*)val1 > *(int*)val2) return true;
 246             else return false;
 247         }else if (OpLessThanEquals == op) {
 248             if (*(int*)val1 <= *(int*)val2) return true;
 249             else return false;
 250         }else if (OpGreaterThanEquals == op) {
 251             if (*(int*)val1 >= *(int*)val2) return true;
 252             else return false;
 253         }else if (OpNotEquals == op) {
 254             if (*(int*)val1 != *(int*)val2) return true;
 255             else return false;
 256         }
 257
 258     }else if(typeString == type) {
 259         return AllDataType::compareStringVal(val1, val2, op);
 260     } else if (typeShort == type) {
 261         return AllDataType::compareShortVal(val1, val2, op);
 262     } else if (typeDouble == type) {
 263         return AllDataType::compareDoubleVal(val1, val2, op);
 264     } else if (typeFloat == type) {
 265         return AllDataType::compareFloatVal(val1, val2, op);
 266     } else if (typeLong == type) {
 267         return AllDataType::compareLongVal(val1, val2, op);
 268     } else if (typeLongLong == type) {
 269         return AllDataType::compareLongLongVal(val1, val2, op);
 270     } else if (typeByteInt == type) {
 271         return AllDataType::compareByteIntVal(val1, val2, op);
 272     } else if (typeTimeStamp == type) {
 273         return AllDataType::compareTimeStampVal(val1, val2, op);
 274     } else if (typeDate == type) {
 275         return AllDataType::compareDateVal(val1, val2, op);
 276     } else if (typeTime == type) {
 277         return AllDataType::compareTimeVal(val1, val2, op);
 278     } else if (typeBinary == type) {
 279         return AllDataType::compareBinaryVal(val1, val2, op, length);
 280     } else if (typeComposite == type) {
 281         return AllDataType::compareBinaryVal(val1, val2, op, length);
 282     }
 283 }
 284 ComparisionOp AllDataType::getComparisionOperator(char *str)
 285 {
 286     ComparisionOp op;
 287     if (strcmp(str, "<=") == 0)
 288         op = OpLessThanEquals;
 289     else if (strcmp(str, ">=") == 0)
 290         op = OpGreaterThanEquals;
 291     else if (strcmp(str, "<") == 0)
 292         op = OpLessThan;
 293     else if (strcmp(str, ">") == 0)
 294         op = OpGreaterThan;
 295     else if (strcmp(str, "=") == 0)
 296         op = OpEquals;
 297     else if (strcmp(str, "!=") == 0 || strcmp(str, "<>") == 0 )
 298         op = OpNotEquals;
 299     else if (strcasecmp(str, "LIKE") == 0 )
 300         op = OpLike;
 301     else
 302         op = OpInvalidComparisionOp;
 303     return op;
 304 }
 305
 306 bool AllDataType::isValidFieldForAvg(DataType type)
 307 {
 308     switch(type) {
 309         case typeInt:     case typeLong:   case typeLongLong: case typeShort:
 310         case typeByteInt: case typeDouble: case typeFloat:    case typeDecimal:
 311             //TODO::for porting
 312             return true;
 313         case typeDate:
 314         case typeTime:
 315         case typeTimeStamp:
 316         case typeBinary:
 317         case typeString:
 318         default:
 319             return false;
 320     }
 321 }