w3systemsDevelopment: openData/pgTypeOids.h Source File

00001 #ifndef PGTYPE_OIDS_H
00002 #define PGTYPE_OIDS_H
00003 #include "fmtTime.h"
00004 #include <ctype.h>
00005 /*
00006 Lost one day struggling with the BINARY CURSOR and gave up:
00007 - After reverse engineering postgres source (there is NO documentation on this!):
00008    For all types it's pretty clear what the BE gives back,
00009    BUT with the Timestamp value (double) it really wasn't clear what the value means.
00010 Postgres really should provide FE functions to turn the Timestamp into a tm struct.
00011 It should also provide an FE function to unpack the packed values of the
00012 Numeric and Decimal (synonomous) types.
00013 I have decided to give in and use the character return data, only to convert it to the native type.
00014 The major issue for me with this is that I KNOW that precision is going to be lost on the
00015 floating point and double values.  I have already seen this in the return string
00016 representation of the data.
00017 Also there is the performance issue of formatting to strings, converting to a native type, then
00018 re-formatting again for a web page (or XML stream.)
00019 
00020 David McCombs 12/14/2001
00021 NOTE!!!!:  NEED TO ADD TEXT FIELD TYPE HANDLER! DKMc 10/20/2002
00022 DONE! , Also implemented longlongField use. DKMc 7/30/03
00023 
00024 */
00025 /*
00026 For reference - this is the openFields enumeration
00027 enum fieldTypes
00028 {
00029   shortType, longType,  floatType, doubleType,
00030   stringType, currencyType, dateTimeType, boolType
00031 };
00032 SEE /usr/include/pgsql/server/catalog for type defs
00033 */
00034 enum pgTypeOids
00035 {
00036   pgBooleanOid       =16, //BOOLOID        - probably char or short loot at size
00037   pgLongOid          =20, //INT8OID        -  long long
00038   pgShortOid         =21, //INT2OID        -  short
00039   pgIntegerOid       =23, //INT4OID        -  int
00040   pgTextOid          =25,  // TEXT               
00041   pgFloatOid         =700, //FLOAT4OID     - float
00042   pgDoubleOid        =701, //FLOAT8OID     - double
00043   pgCharOid          =1042, //BPCHAROID    - char *
00044   pgCharArrayOid     =1042, //BPCHAROID    - char *
00045   pgVarCharArrayOid  =1043, //VARCHAROID   - char *
00046   pgTimestampOid = 1114,   // TIMESTAMPOID      1114
00047   pgDateOid          =1082, //DATEOID      - Timestamp
00048   pgTimeOid          =1083, //TIMEOID      - Timestamp  
00049   pgTimestampTzOid     =1184, //TIMESTAMPTZOID  - Timestamp  
00050   pgDecimalOid       =1700, //NUMERICOID   - packed decimal
00051   pgNumericOid       =1700 //NUMERICOID    - packed decimal
00052 };
00053 
00054 #define iDateFMT "%Y-%m-%d"
00055 #define iTimeFMT "%H:%M:%S"
00056 #define iDateTimeFMT "%Y-%m-%d %H:%M:%S"
00057 #define oDateFMT "%m-%d-%Y"
00058 #define oTimeFMT "%I:%M %p"
00059 #define oDateTimeFMT "%m-%d-%Y %H:%M:%S"
00060 
00061 #ifdef JUST_PG_FIELD_INTERFACES
00062 basicField * createField( pgTypeOids oid, bool isNull, string value, string  name, bool isClient=false );
00063 basicField & setField( basicField & rBF, pgTypeOids oid, bool isNull, string value, bool isClient=false );
00064 #else
00065 basicField * createField( pgTypeOids oid, bool isNull, string value, string  name, bool isClient=false )
00066 {
00067   basicField * pBF = NULL;
00068   tm t;
00069   char chVal = '\0';
00070   bool bVal = false;
00071   short sVal = 0;
00072   long lVal = 0l;
00073   long long llVal = 0l;
00074   float fVal = 0.0;
00075   double dVal = 0.0;
00076   currency cVal;
00077   cVal.amount = 0.0;
00078   currentTime(&t);
00079 
00080   switch( oid )
00081   {
00082     case pgBooleanOid:
00083       bVal = false;
00084       chVal = toupper( value[0] );
00085       // T,Y,1 is true  F,N,0 is false
00086       if ( chVal == 'T' || chVal == 'Y' || chVal == '1' ) bVal = true;
00087       pBF = new boolField( bVal, isNull, true, name, "" );
00088       break;
00089 
00090     case pgShortOid:
00091       sVal = atoi( value.c_str());
00092       pBF = new shortField( sVal, isNull, true, name, "" );
00093       break;
00094 
00095     case pgIntegerOid:
00096       lVal = atol( value.c_str());
00097       pBF = new longField( lVal, isNull, true, name, "" );
00098       break;
00099     case pgLongOid:
00100       llVal = atoll( value.c_str());
00101       pBF = new longlongField( llVal, isNull, true, name, "" );
00102       break;
00103 
00104     case pgFloatOid:
00105       fVal = (float) atof( value.c_str());
00106       pBF = new floatField( fVal, isNull, true, name, "" );
00107       break;
00108 
00109     case pgDoubleOid:
00110       dVal = atof( value.c_str());
00111       pBF = new doubleField( dVal, isNull, true, name, "" );
00112       break;
00113 
00114     // case pgCharOid:
00115     case pgCharArrayOid:
00116     case pgVarCharArrayOid:
00117     case pgTextOid:
00118       pBF = new stringField( value, isNull, true, name, "" );
00119       break;
00120 
00121     case pgDateOid:
00122       if( value.length() == 0 )  isNull = true;
00123       else parseTime(value.c_str(), isClient?oDateFMT:iDateFMT, &t);
00124       pBF = new dateTimeField( t, isNull, true, name, "" );
00125       pBF->setFormatMask(string(oDateFMT));
00126       pBF->setSvrFormatMask(string(iDateFMT));
00127       break;
00128 
00129     case pgTimeOid:
00130       if( value.length() == 0 )  isNull = true;
00131       else parseTime(value.c_str(), isClient?oTimeFMT:iTimeFMT, &t);
00132       pBF = new dateTimeField( t, isNull, true, name, "" );
00133       pBF->setFormatMask(oTimeFMT);
00134       pBF->setSvrFormatMask(string(iTimeFMT));
00135       break;
00136 
00137     case pgTimestampOid:
00138       if( value.length() == 0 )  isNull = true;
00139       else parseTime(value.c_str(), isClient?oDateTimeFMT:iDateTimeFMT, &t);
00140       pBF = new dateTimeField( t, isNull, true, name, "" );
00141       pBF->setFormatMask(oDateTimeFMT);
00142       pBF->setSvrFormatMask(string(iDateTimeFMT));
00143       break;
00144 
00145     //case pgDecimalOid:
00146     case pgNumericOid:
00147       cVal.amount = atof( value.c_str());
00148       pBF = new currencyField( cVal, isNull, true, name, "" );
00149       break;
00150 
00151     default:
00152       // fprintf( stderr, " Do not know about this type: %d\n", oid );
00153     break;
00154 
00155   }
00156   return pBF;
00157 };
00158 basicField & setField( basicField & rBF, pgTypeOids oid, bool isNull, string value, bool isClient=false )
00159 {
00160   tm t;
00161   bool bVal;
00162   char chVal;
00163   short sVal;
00164   long lVal;
00165   long long llVal = 0l;
00166   float fVal;
00167   double dVal;
00168   currency cVal;
00169 
00170   switch( oid )
00171   {
00172     case pgBooleanOid:
00173     {
00174       bVal = false;
00175       chVal = toupper( value[0] );
00176       // T,Y,1 is true  F,N,0 is false
00177       if ( chVal == 'T' || chVal == 'Y' || chVal == '1' ) bVal = true;
00178       boolField & rboolF = dynamic_cast<boolField&>(rBF);
00179       rboolF.set(bVal);
00180       rboolF.setNull(isNull);
00181       break;
00182     }
00183     case pgShortOid:
00184     {
00185       sVal = atoi( value.c_str());
00186       shortField & rshortF = dynamic_cast<shortField&>(rBF);
00187       rshortF.set(sVal);
00188       rshortF.setNull(isNull);
00189       break;
00190     }
00191     case pgIntegerOid:
00192     {
00193       lVal = atol( value.c_str());
00194       longField & rlongF = dynamic_cast<longField&>(rBF);
00195       rlongF.set(lVal);
00196       rlongF.setNull(isNull);
00197       break;
00198     }
00199     case pgLongOid:
00200     {
00201       llVal = atoll( value.c_str());
00202       longlongField & rlongF = dynamic_cast<longlongField&>(rBF);
00203       rlongF.set(llVal);
00204       rlongF.setNull(isNull);
00205       break;
00206     }
00207     case pgFloatOid:
00208     {
00209       fVal = (float) atof( value.c_str());
00210       floatField & rfloatF = dynamic_cast<floatField&>(rBF);
00211       rfloatF.set(fVal);
00212       rfloatF.setNull(isNull);
00213       break;
00214     }
00215     case pgDoubleOid:
00216     {
00217       dVal = atof( value.c_str());
00218       doubleField & rdoubleF = dynamic_cast<doubleField&>(rBF);
00219       rdoubleF.set(dVal);
00220       rdoubleF.setNull(isNull);
00221       break;
00222     }
00223     // case pgCharOid:
00224     case pgTextOid:
00225     case pgCharArrayOid:
00226     case pgVarCharArrayOid:
00227     {
00228       stringField & rstringF = dynamic_cast<stringField&>(rBF);
00229       rstringF.set( value);
00230       rstringF.setNull(isNull);
00231       break;
00232     }
00233     case pgDateOid:
00234     {
00235       parseTime(value.c_str(), isClient?oDateFMT:iDateFMT, &t);
00236       dateTimeField & rdateF = dynamic_cast<dateTimeField&>(rBF);
00237       rdateF.set(t);
00238       rdateF.setNull(isNull);
00239       break;
00240     }
00241     case pgTimeOid:
00242     {
00243       parseTime(value.c_str(), isClient?oTimeFMT:iTimeFMT, &t);
00244       dateTimeField & rtimeF = dynamic_cast<dateTimeField&>(rBF);
00245       rtimeF.set(t);
00246       rtimeF.setNull(isNull);
00247       break;
00248     }
00249     case pgTimestampOid:
00250     {
00251       parseTime(value.c_str(), isClient?oDateTimeFMT:iDateTimeFMT, &t);
00252       dateTimeField & rdatetimeBF = dynamic_cast<dateTimeField&>(rBF);
00253       rdatetimeBF.set(t);
00254       rdatetimeBF.setNull(isNull);
00255       break;
00256     }
00257     //case pgDecimalOid:
00258     case pgNumericOid:
00259     {
00260       cVal.amount = atof( value.c_str());
00261       currencyField & currencyF = dynamic_cast<currencyField&>(rBF);
00262       currencyF.set(cVal);
00263       currencyF.setNull(isNull);
00264       break;
00265     }
00266     default:
00267     break;
00268 
00269   }
00270   return rBF;
00271 };
00272 #endif
00273 #endif