mySqlTypeMap.h Source File

00001 /*
00002   mySqlTypeMap.h
00003   ==============
00004   mySQL to openField conversion and fixup
00005 */
00006 
00007 #ifndef MY_SQL_TYPE_MAPS_H
00008 #define MY_SQL_TYPE_MAPS_H
00009 
00010 #include "fmtTime.h"
00011 
00012 #define iDateMyFMT "%Y-%m-%d"
00013 #define iTimeMyFMT "%H:%M:%S"
00014 #define iDateTimeMyFMT "%Y-%m-%d %H:%M:%S"
00015 #define oDateMyFMT "%m-%d-%Y"
00016 #define oTimeMyFMT "%H:%M:%S"
00017 #define oDateTimeMyFMT "%m-%d-%Y %H:%M:%S"
00018 
00019 /*
00020   Helper Classes
00021   ==============
00022 */
00023 
00024 struct mysqlColInfo
00025 {
00026   string ColName;
00027   enum enum_field_types mySqlType;
00028   unsigned int length;     // Width of column
00029   unsigned int max_length; // Max width of selected set
00030   unsigned int flags;      // Div flags
00031   unsigned int decimals;   // Number of decimals in field
00032   mysqlColInfo() :length(0),max_length(0),flags(0)
00033   {
00034   }
00035   mysqlColInfo( MYSQL_FIELD *pField )
00036   :length(0),max_length(0),flags(0)
00037   {
00038     if( pField )
00039     {
00040       if(pField->name) ColName = pField->name;
00041       mySqlType = pField->type;
00042       length =  pField->length;
00043       max_length =  pField->max_length;
00044       flags = pField->flags;
00045       decimals = pField->decimals;
00046     }
00047   }
00048   ~mysqlColInfo() {}
00049 };
00050 
00051 // col. pos. based lookup
00052 typedef vector< mysqlColInfo * > my_col_infoVector;
00053 
00054 struct my_mapItem
00055 {
00056   // used for format from client or server (for dates esp.)
00057   bool isClient;
00058   my_mapItem():isClient(false){;}
00059   virtual ~my_mapItem(){;}
00060   virtual basicField * createField( mysqlColInfo * info ) = 0;
00061   virtual basicField * setField( basicField * pFld, const char * pchVal ) = 0;
00062 };
00063 
00064 // MySQL type based lookup
00065 typedef map <enum enum_field_types, my_mapItem *> mysql_to_c_types;
00066 
00067 struct my_mapString : public my_mapItem
00068 {
00069   my_mapString(){;}
00070   virtual ~my_mapString(){;}
00071   virtual basicField * createField( mysqlColInfo * info )
00072   {
00073     // next create the field
00074     return new stringField( "", false, true, (char*) info->ColName.c_str(), "" );
00075   }
00076   virtual basicField * setField( basicField * pFld, const char * pchVal )
00077   {
00078     if( pFld )
00079     {
00080       stringField & rstringF = dynamic_cast<stringField&>(*pFld);
00081       if( pchVal )
00082       {
00083         rstringF.set(pchVal);
00084         rstringF.setNull(false);
00085       }
00086       else
00087       {
00088         rstringF.setNull(true);
00089       }
00090     }
00091     return pFld;
00092   }
00093 };  // end of my_mapString class
00094 
00095 
00096 struct my_mapBool  : public my_mapItem
00097 {
00098   my_mapBool():my_mapItem(){;}
00099   virtual ~my_mapBool(){;}
00100   virtual basicField * createField( mysqlColInfo * info )
00101   {
00102     return new boolField( false, false, true, info->ColName, "" );
00103   }
00104   virtual basicField * setField( basicField * pFld, const char * pchVal )
00105   {
00106     if( pFld )
00107     {
00108       boolField & rboolF = dynamic_cast<boolField&>(*pFld);
00109       bool bVal = false;
00110       if( pchVal )
00111       {
00112         if ( pchVal[0] == 'T' || pchVal[0] == 'Y' || pchVal[0] == '1' ) bVal = true;
00113 
00114         rboolF.set(bVal);
00115         rboolF.setNull(false);
00116       }
00117       else
00118       {
00119         rboolF.setNull(true);
00120       }
00121     }
00122     return pFld;
00123   }
00124 }; // end of my_mapBool class
00125 
00126 struct my_mapShort  : public my_mapItem
00127 {
00128   my_mapShort():my_mapItem(){;}
00129   virtual ~my_mapShort(){;}
00130   virtual basicField * createField( mysqlColInfo * info )
00131   {
00132     return new shortField( 0, false, true, info->ColName, "" );
00133   }
00134   virtual basicField * setField( basicField * pFld, const char * pchVal )
00135   {
00136     if( pFld )
00137     {
00138       shortField & rshortF = dynamic_cast<shortField&>(*pFld);
00139       if( pchVal )
00140       {
00141         short sVal = atoi(pchVal);
00142         rshortF.set(sVal);
00143         rshortF.setNull(false);
00144       }
00145       else
00146       {
00147         rshortF.setNull(true);
00148       }
00149     }
00150     return pFld;
00151   }
00152 }; // end of my_mapShort class
00153 
00154 struct my_mapLong  : public my_mapItem
00155 {
00156   my_mapLong():my_mapItem(){;}
00157   virtual ~my_mapLong(){;}
00158   virtual basicField * createField( mysqlColInfo * info )
00159   {
00160     return new longField( 0, false, true, info->ColName, "" );
00161   }
00162   virtual basicField * setField( basicField * pFld, const char * pchVal )
00163   {
00164     if( pFld )
00165     {
00166       longField & rlongF = dynamic_cast<longField&>(*pFld);
00167       if( pchVal )
00168       {
00169         long lVal = atol(pchVal);
00170         rlongF.set(lVal);
00171         rlongF.setNull(false);
00172       }
00173       else
00174       {
00175         rlongF.setNull(true);
00176       }
00177     }
00178     return pFld;
00179   }
00180 }; // end of my_mapLong class
00181 
00182 
00183 struct my_mapLongLong  : public my_mapItem
00184 {
00185   my_mapLongLong():my_mapItem(){;}
00186   virtual ~my_mapLongLong(){;}
00187   virtual basicField * createField( mysqlColInfo * info )
00188   {
00189     return new longlongField( 0, false, true, info->ColName, "" );
00190   }
00191   virtual basicField * setField( basicField * pFld, const char * pchVal )
00192   {
00193     if( pFld )
00194     {
00195       longlongField & rlongF = dynamic_cast<longlongField&>(*pFld);
00196       if( pchVal )
00197       {
00198         long long lVal = atoll(pchVal);
00199         rlongF.set(lVal);
00200         rlongF.setNull(false);
00201       }
00202       else
00203       {
00204         rlongF.setNull(true);
00205       }
00206     }
00207     return pFld;
00208   }
00209 }; // end of my_mapLong class
00210 
00211 
00212 struct my_mapFloat  : public my_mapItem
00213 {
00214   my_mapFloat():my_mapItem(){;}
00215   virtual ~my_mapFloat(){;}
00216   virtual basicField * createField( mysqlColInfo * info )
00217   {
00218     return new floatField( 0.0, false, true, info->ColName, "" );
00219   }
00220   virtual basicField * setField( basicField * pFld, const char * pchVal )
00221   {
00222     if( pFld )
00223     {
00224       floatField & rfloatF = dynamic_cast<floatField&>(*pFld);
00225       if( pchVal )
00226       {
00227         float fVal = atof(pchVal);
00228         rfloatF.set(fVal);
00229         rfloatF.setNull(false);
00230       }
00231       else
00232       {
00233         rfloatF.setNull(true);
00234       }
00235     }
00236     return pFld;
00237   }
00238 }; // end of my_mapFloat class
00239 
00240 struct my_mapDouble  : public my_mapItem
00241 {
00242   my_mapDouble():my_mapItem(){;}
00243   virtual ~my_mapDouble(){;}
00244   virtual basicField * createField( mysqlColInfo * info )
00245   {
00246     return new doubleField( 0.0, false, true, info->ColName, "" );
00247   }
00248   virtual basicField * setField( basicField * pFld, const char * pchVal )
00249   {
00250     if( pFld )
00251     {
00252       doubleField & rdoubleF = dynamic_cast<doubleField&>(*pFld);
00253       if( pchVal )
00254       {
00255         double fVal = atof(pchVal);
00256         rdoubleF.set(fVal);
00257         rdoubleF.setNull(false);
00258       }
00259       else
00260       {
00261         rdoubleF.setNull(true);
00262       }
00263     }
00264     return pFld;
00265   }
00266 };  // end of my_mapDouble class
00267 
00268 struct my_mapDateTime  : public my_mapItem
00269 {
00270   my_mapDateTime():my_mapItem(){;}
00271   virtual ~my_mapDateTime(){;}
00272   virtual basicField * createField( mysqlColInfo * info )
00273   {
00274     tm t;
00275     currentTime(&t);
00276     dateTimeField *pDateF = new dateTimeField( t, false, true, info->ColName, "" );
00277     // oDateTimeMyFMT format is for the client
00278     pDateF->setFormatMask( oDateTimeMyFMT );
00279     // iDateTimeMyFMT format is for the server
00280     pDateF->setSvrFormatMask( iDateTimeMyFMT );
00281     return pDateF;
00282 
00283   }
00284   virtual basicField * setField( basicField * pFld, const char * pchVal )
00285   {
00286     if( pFld )
00287     {
00288       tm t;
00289       currentTime(&t);
00290       dateTimeField & rdateF = dynamic_cast<dateTimeField&>(*pFld);
00291       if( pchVal )
00292       {
00293         parseTime(pchVal, isClient?oDateTimeMyFMT:iDateTimeMyFMT, &t);
00294         rdateF.set(t);
00295         rdateF.setNull(false);
00296       }
00297       else
00298       {
00299         rdateF.setNull(true);
00300       }
00301     }
00302     return pFld;
00303   }
00304 }; // end of my_mapDateTime class
00305 struct my_mapDate  : public my_mapItem
00306 {
00307   my_mapDate():my_mapItem(){;}
00308   virtual ~my_mapDate(){;}
00309   virtual basicField * createField( mysqlColInfo * info )
00310   {
00311     tm t;
00312     currentTime(&t);
00313     dateTimeField *pDateF = new dateTimeField( t, false, true, info->ColName, "" );
00314     // oDate format is for the client
00315     pDateF->setFormatMask( oDateMyFMT );
00316     // iDate format is for the server
00317     pDateF->setSvrFormatMask( iDateMyFMT );
00318     return pDateF;
00319   }
00320   virtual basicField * setField( basicField * pFld, const char * pchVal )
00321   {
00322     if( pFld )
00323     {
00324       tm t;
00325       currentTime(&t);
00326       dateTimeField & rdateF = dynamic_cast<dateTimeField&>(*pFld);
00327       if( pchVal )
00328       {
00329         // oDate format is for the client
00330         // iDate format is for the server
00331         parseTime(pchVal, isClient?oDateMyFMT:iDateMyFMT, &t);
00332         rdateF.set(t);
00333         rdateF.setNull(false);
00334       }
00335       else
00336       {
00337         rdateF.setNull(true);
00338       }
00339     }
00340     return pFld;
00341   }
00342 }; // end of my_mapDate class
00343 struct my_mapTime  : public my_mapItem
00344 {
00345   my_mapTime():my_mapItem(){;}
00346   virtual ~my_mapTime(){;}
00347   virtual basicField * createField( mysqlColInfo * info )
00348   {
00349     tm t;
00350     currentTime(&t);
00351     dateTimeField *pDateF = new dateTimeField( t, false, true, info->ColName, "" );
00352     // oDate format is for the client
00353     pDateF->setFormatMask( oTimeMyFMT );
00354     // iDate format is for the server
00355     pDateF->setSvrFormatMask( iTimeMyFMT );
00356     return pDateF;
00357   }
00358   virtual basicField * setField( basicField * pFld, const char * pchVal )
00359   {
00360     if( pFld )
00361     {
00362       tm t;
00363       currentTime(&t);
00364       dateTimeField & rtimeF = dynamic_cast<dateTimeField&>(*pFld);
00365       if( pchVal )
00366       {
00367         // oDate format is for the client
00368         // iDate format is for the server
00369         parseTime(pchVal, isClient?oTimeMyFMT:iTimeMyFMT, &t);
00370         rtimeF.set(t);
00371         rtimeF.setNull(false);
00372       }
00373       else
00374       {
00375         rtimeF.setNull(true);
00376       }
00377     }
00378     return pFld;
00379   }
00380 }; // end of my_mapTime class
00381 struct my_mapNumeric : public my_mapItem
00382 {
00383   my_mapNumeric():my_mapItem(){;}
00384   virtual ~my_mapNumeric(){;}
00385   virtual basicField * createField( mysqlColInfo * info )
00386   {
00387     currency temp;
00388     temp.amount=0.0;
00389     return new currencyField( temp, false, true, info->ColName, "" );
00390   }
00391   virtual basicField * setField( basicField * pFld, const char * pchVal )
00392   {
00393     currency cVal;
00394     cVal.amount = 0.0;
00395     if( pFld )
00396     {
00397       currencyField & currencyF = dynamic_cast<currencyField&>(*pFld);
00398       if( pchVal )
00399       {
00400         cVal.amount = atof(pchVal);
00401         currencyF.set(cVal);
00402         currencyF.setNull(false);
00403       }
00404       else
00405       {
00406         currencyF.setNull(true);
00407       }
00408     }
00409     return pFld;
00410   }
00411 };  // end of my_mapNumeric class
00412 
00413 
00414 /*
00415     enum enum_field_types
00416     {
00417     FIELD_TYPE_DECIMAL, FIELD_TYPE_TINY,
00418     FIELD_TYPE_SHORT,  FIELD_TYPE_LONG,
00419     FIELD_TYPE_FLOAT,  FIELD_TYPE_DOUBLE,
00420 
00421     FIELD_TYPE_NULL,   FIELD_TYPE_TIMESTAMP,
00422     FIELD_TYPE_LONGLONG,FIELD_TYPE_INT24,
00423     FIELD_TYPE_DATE,   FIELD_TYPE_TIME,
00424     FIELD_TYPE_DATETIME, FIELD_TYPE_YEAR,
00425     FIELD_TYPE_NEWDATE,
00426 
00427     FIELD_TYPE_ENUM=247,
00428     FIELD_TYPE_SET=248,
00429 
00430     FIELD_TYPE_TINY_BLOB=249,
00431     FIELD_TYPE_MEDIUM_BLOB=250,
00432     FIELD_TYPE_LONG_BLOB=251,
00433     FIELD_TYPE_BLOB=252,
00434     FIELD_TYPE_VAR_STRING=253,
00435     FIELD_TYPE_STRING=254
00436     };
00437 */
00438 
00439 struct mysqlMap
00440 {
00441   mysql_to_c_types data;
00442   mysqlMap()
00443   {
00444     data.insert(make_pair(FIELD_TYPE_DECIMAL,new my_mapNumeric));
00445     data.insert(make_pair(FIELD_TYPE_TINY,new my_mapShort));
00446     data.insert(make_pair(FIELD_TYPE_SHORT,new my_mapShort));
00447     data.insert(make_pair(FIELD_TYPE_LONG,new my_mapLong));
00448     data.insert(make_pair(FIELD_TYPE_FLOAT,new my_mapFloat));
00449     data.insert(make_pair(FIELD_TYPE_DOUBLE,new my_mapDouble));
00450     data.insert(make_pair(FIELD_TYPE_NULL,new my_mapString));
00451     data.insert(make_pair(FIELD_TYPE_TIMESTAMP,new my_mapDateTime));
00452     data.insert(make_pair(FIELD_TYPE_LONGLONG,new my_mapLongLong));
00453     data.insert(make_pair(FIELD_TYPE_INT24,new my_mapLongLong));
00454     data.insert(make_pair(FIELD_TYPE_DATE,new my_mapDate));
00455     data.insert(make_pair(FIELD_TYPE_TIME,new my_mapTime));
00456     data.insert(make_pair(FIELD_TYPE_DATETIME,new my_mapDateTime));
00457     data.insert(make_pair(FIELD_TYPE_TINY_BLOB,new my_mapString));
00458     data.insert(make_pair(FIELD_TYPE_MEDIUM_BLOB,new my_mapString));
00459     data.insert(make_pair(FIELD_TYPE_LONG_BLOB,new my_mapString));
00460     data.insert(make_pair(FIELD_TYPE_BLOB,new my_mapString));
00461     data.insert(make_pair(FIELD_TYPE_VAR_STRING,new my_mapString));
00462     data.insert(make_pair(FIELD_TYPE_STRING,new my_mapString));
00463   }
00464   ~mysqlMap()
00465   {
00466     mysql_to_c_types::iterator pos;
00467 
00468     for( pos = data.begin(); pos != data.end(); ++pos )
00469     {
00470       delete pos->second;
00471     }
00472   }
00473 };
00474 
00475 #endif