StRoot: StDbLib/StDbTableDescriptor.cc Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StDbTableDescriptor.cc,v 1.28 2009/09/28 19:14:10 dmitry Exp $
00004  *
00005  * Author: R. Jeff Porter
00006  ***************************************************************************
00007  *
00008  * Description: Class implement table-descriptor (memory/name of data-elements)
00009  *              this descriptor is loaded from database
00010  *
00011  ***************************************************************************
00012  *
00013  * $Log: StDbTableDescriptor.cc,v $
00014  * Revision 1.28  2009/09/28 19:14:10  dmitry
00015  * row size is not *static* anymore, tables have different row sizes
00016  *
00017  * Revision 1.27  2009/09/10 20:01:30  dmitry
00018  * removed redundant output
00019  *
00020  * Revision 1.26  2009/09/10 18:06:08  dmitry
00021  * struct alignment fix, does not rely on fixed 4 byte cap anymore - runtime align calculation is now in use
00022  *
00023  * Revision 1.25  2005/09/07 22:04:02  deph
00024  * update to correct padding issue for packed tables
00025  *
00026  * Revision 1.24  2004/01/15 00:02:25  fisyak
00027  * Replace ostringstream => StString, add option for alpha
00028  *
00029  * Revision 1.23  2003/10/28 20:58:31  perev
00030  *  Linux ==> __linux__
00031  *
00032  * Revision 1.22  2003/09/16 22:44:18  porter
00033  * got rid of all ostrstream objects; replaced with StString+string.
00034  * modified rules.make and added file stdb_streams.h for standalone compilation
00035  *
00036  * Revision 1.21  2003/09/02 17:57:50  perev
00037  * gcc 3.2 updates + WarnOff
00038  *
00039  * Revision 1.20  2002/01/30 15:40:48  porter
00040  * changed limits on flavor tag & made defaults retrieving more readable
00041  *
00042  * Revision 1.19  2001/12/05 17:16:35  porter
00043  * stand-alone make file no longer had "D__linux__" in compile but this is still needed
00044  * and returned. Also retrieve elementID list  in query by whereClause for plotting
00045  * many row instances.
00046  *
00047  * Revision 1.18  2001/10/24 04:05:20  porter
00048  * added long long type to I/O and got rid of obsolete dataIndex table
00049  *
00050  * Revision 1.17  2001/02/08 23:23:56  porter
00051  * fixed initialization of schemaID in table & fixed some warnings when
00052  * compiled with NODEBUG
00053  *
00054  * Revision 1.16  2001/01/22 18:38:00  porter
00055  * Update of code needed in next year running. This update has little
00056  * effect on the interface (only 1 method has been changed in the interface).
00057  * Code also preserves backwards compatibility so that old versions of
00058  * StDbLib can read new table structures.
00059  *  -Important features:
00060  *    a. more efficient low-level table structure (see StDbSql.cc)
00061  *    b. more flexible indexing for new systems (see StDbElememtIndex.cc)
00062  *    c. environment variable override KEYS for each database
00063  *    d. StMessage support & clock-time logging diagnostics
00064  *  -Cosmetic features
00065  *    e. hid stl behind interfaces (see new *Impl.* files) to again allow rootcint access
00066  *    f. removed codes that have been obsolete for awhile (e.g. db factories)
00067  *       & renamed some classes for clarity (e.g. tableQuery became StDataBaseI
00068  *       and mysqlAccessor became StDbSql)
00069  *
00070  * Revision 1.15  2000/03/28 17:03:19  porter
00071  * Several upgrades:
00072  * 1. configuration by timestamp for Conditions
00073  * 2. query by whereClause made more systematic
00074  * 3. conflict between db-stored comments & number lists resolved
00075  * 4. ensure endtime is correct for certain query falures
00076  * 5. dbstl.h->handles ObjectSpace & RogueWave difference (Online vs Offline)
00077  *
00078  * Revision 1.14  2000/03/06 17:11:49  porter
00079  * - WriteDb(table) returns true if no data is in table
00080  * - fixed memory leak introduced in 2/18/00 update.
00081  * - modified descriptor algorythm for OnlRunDescriptor.
00082  *
00083  * Revision 1.13  2000/03/01 20:56:16  porter
00084  * 3 items:
00085  *    1. activated reConnect for server timeouts
00086  *    2. activated connection sharing; better resource utilization but poorer
00087  *       logging
00088  *    3. made rollback method in mysqlAccessor more robust (affects writes only)
00089  *
00090  * Revision 1.12  2000/02/24 20:30:47  porter
00091  * fixed padding for uchar; beginTime in mysqlAccessor;
00092  * added rollback safety checkes in StDbManger
00093  *
00094  * Revision 1.11  2000/02/15 20:27:45  porter
00095  * Some updates to writing to the database(s) via an ensemble (should
00096  * not affect read methods & haven't in my tests.
00097  *  - closeAllConnections(node) & closeConnection(table) method to mgr.
00098  *  - 'NullEntry' version to write, with setStoreMode in table;
00099  *  -  updated both StDbTable's & StDbTableDescriptor's copy-constructor
00100  *
00101  * Revision 1.10  2000/01/27 05:54:35  porter
00102  * Updated for compiling on CC5 + HPUX-aCC + KCC (when flags are reset)
00103  * Fixed reConnect()+transaction model mismatch
00104  * added some in-code comments
00105  *
00106  * Revision 1.9  2000/01/19 20:20:07  porter
00107  * - finished transaction model needed by online
00108  * - fixed CC5 compile problem in StDbNodeInfo.cc
00109  * - replace TableIter class by StDbTableIter to prevent name problems
00110  *
00111  * Revision 1.8  2000/01/10 20:37:55  porter
00112  * expanded functionality based on planned additions or feedback from Online work.
00113  * update includes:
00114  *      1. basis for real transaction model with roll-back
00115  *      2. limited SQL access via the manager for run-log & tagDb
00116  *      3. balance obtained between enumerated & string access to databases
00117  *      4. 3-levels of diagnostic output: Quiet, Normal, Verbose
00118  *      5. restructured Node model for better XML support
00119  *
00120  * Revision 1.7  1999/12/07 21:25:25  porter
00121  * some fixes for __linux__ warnings
00122  *
00123  * Revision 1.6  1999/12/03 19:02:01  porter
00124  * modified descriptor to accept tableDescriptor once this St_base object
00125  * has been updated to have longer name lengths.
00126  *
00127  * Revision 1.5  1999/10/19 14:30:40  porter
00128  * modifications relevant to use with StDbBroker and future merging with
00129  * "params" database structure + some docs + suppressing diagnostics messages
00130  *
00131  * Revision 1.4  1999/09/30 02:06:10  porter
00132  * add StDbTime to better handle timestamps, modify SQL content (mysqlAccessor)
00133  * allow multiple rows (StDbTable), & Added the comment sections at top of
00134  * each header and src file
00135  *
00136  **************************************************************************/
00137 #include "StDbTableDescriptor.h"
00138 #include <stdlib.h>
00139 #include <math.h>
00140 #include "stdb_streams.h"
00141 #include <iostream>
00142 
00143 // Alignment test struct
00144 template <typename T>                                                                                                                                        
00145 struct StCompilerAlignTest {                                                                                                                                 
00146    char m0;                                                                                                                                                  
00147       T m1;                                                                                                                                                     
00148 };                                                                                                                                                           
00149                                                                                                                                                                    
00150 #define st_alignof(TYPE)     (size_t)&(((StCompilerAlignTest<TYPE>*)0)->m1) 
00151 
00153 
00154 StDbTableDescriptor::StDbTableDescriptor(){  init(); }
00155 
00157 
00158 StDbTableDescriptor::StDbTableDescriptor(int structID, int schemaID){
00159 
00160   init();
00161   mstructID=structID;
00162   mschemaID=schemaID;
00163 
00164 };
00165 
00167 
00168 void
00169 StDbTableDescriptor::init(){
00170 
00171 mtableSize=0;
00172 mCur = 0;
00173 mMax = 100;
00174 offsetToNextEmptyByte = 0;
00175 offsetToLast4Bytes = -4;
00176 mnumElements = 0;
00177 lastType=Stdouble;
00178 padsize = 0;
00179 mcols = new tableDescriptor[mMax];
00180 memset(mcols,0,mMax*sizeof(tableDescriptor));
00181 mschemaID=mstructID=0;
00182 misValid=false;
00183 mhasDouble=false;
00184 rowSizeTT = 0;
00185 
00186 mAlign[Stchar] = st_alignof(char);
00187 mAlign[Stuchar] = st_alignof(unsigned char);
00188 mAlign[Stshort] = st_alignof(short);
00189 mAlign[Stushort] = st_alignof(unsigned short);
00190 mAlign[Stint] = st_alignof(int);
00191 mAlign[Stuint] = st_alignof(unsigned int);
00192 mAlign[Stlong] = st_alignof(long);
00193 mAlign[Stulong] = st_alignof(unsigned long);
00194 mAlign[Stlonglong] = st_alignof(long long);
00195 mAlign[Stfloat] = st_alignof(float);
00196 mAlign[Stdouble] = st_alignof(double);
00197 
00198 maxAlign = mAlign[Stchar];
00199 
00200 }
00201 
00203 
00204 StDbTableDescriptor::StDbTableDescriptor(StDbTableDescriptor& d){
00205 
00206 mCur = (int)d.getNumElements()-1;
00207 mMax = d.getCurrentInternalSize();
00208 offsetToNextEmptyByte = 0;
00209 offsetToLast4Bytes = 0;
00210 mcols = d.getTableDescriptor();
00211 mnumElements=d.getNumElements();
00212 mtableSize = d.getTotalSizeInBytes();
00213 mschemaID=d.getSchemaID();
00214 mstructID=d.getStructID();
00215 misValid=d.IsValid();
00216 mhasDouble=d.mhasDouble;
00217 maxAlign=d.maxAlign;
00218 rowSizeTT = d.rowSizeTT;
00219 
00220 mAlign[Stchar] = st_alignof(char);
00221 mAlign[Stuchar] = st_alignof(unsigned char);
00222 mAlign[Stshort] = st_alignof(short);
00223 mAlign[Stushort] = st_alignof(unsigned short);
00224 mAlign[Stint] = st_alignof(int);
00225 mAlign[Stuint] = st_alignof(unsigned int);
00226 mAlign[Stlong] = st_alignof(long);
00227 mAlign[Stulong] = st_alignof(unsigned long);
00228 mAlign[Stlonglong] = st_alignof(long long);
00229 mAlign[Stfloat] = st_alignof(float);
00230 mAlign[Stdouble] = st_alignof(double);
00231 
00232 }
00233 
00235 
00236 tableDescriptor*
00237 StDbTableDescriptor::getTableDescriptor() const {
00238 
00239   tableDescriptor* dScr = new tableDescriptor[mMax];
00240   memset(dScr,0,(mMax)*sizeof(tableDescriptor));
00241   memcpy(dScr,mcols,(mMax)*sizeof(tableDescriptor));
00242 
00243 return dScr;
00244 }
00246 
00247 StTableDescriptorI*
00248 StDbTableDescriptor::getCpy(){
00249 
00250 StTableDescriptorI* dScr = new StDbTableDescriptor(*this);
00251 return dScr;
00252 
00253 }
00255 
00256 void
00257 StDbTableDescriptor::fillElement(StDbBuffer* buff, int tableID){
00258     
00259   //bool ClientMode;
00260 //  if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00261   int schemaID;
00262   if(tableID){  // mask off elements if tableID is non-zero
00263    if(!(buff->ReadScalar(schemaID,"schemaID") && (schemaID==tableID)) ){  
00264        // skip this one
00265        return;
00266    }
00267   }
00268 
00269    reSize(); // increase array if needed
00270    int i = mCur;
00271    char* mtype = 0;
00272    char* mname = 0;
00273    buff->ReadScalar(mname,"name");
00274    if(mname)strcpy(mcols[i].name,mname);
00275    if(mname) delete [] mname;
00276    if(buff->ReadScalar(mtype,"type")){
00277        mcols[i].type = getType(mtype);
00278        if(mtype)delete [] mtype;
00279        char* length=0;
00280        if(buff->ReadScalar(length,"length"))fillSizeAndOffset(length,i);
00281        if(length) delete [] length;
00282    }
00283 
00284    if (mcols[i].type==Stlonglong || mcols[i].type==Stdouble ) mhasDouble=true;
00285    if (getAlign(mcols[i].type) > maxAlign) { maxAlign = getAlign(mcols[i].type); }
00286    
00287    mCur++;
00288    mnumElements++;
00289 
00290    // for multiple rows, add padding as needed at end of structure (tableSize)
00291 
00292    int rowpad;
00293    if ( ( rowpad = offsetToNextEmptyByte%2 ) ) { rowpad = 2 - rowpad; }
00294 
00295    //mtableSize = offsetToNextEmptyByte + rowpad;
00296 
00297    // correct padding should be based on max align:
00298    mtableSize = int(ceil(float(offsetToNextEmptyByte) / float(maxAlign)) * maxAlign);
00299 
00300    //if(!ClientMode)buff->SetStorageMode();  // reset to StorageMode
00301 
00302  misValid=true; 
00303 
00304 }
00305 
00307 
00308 
00309 void
00310 StDbTableDescriptor::reSize(){
00311 
00312   // simply add 10 elements
00313 
00314   if(mCur<mMax) return;
00315 
00316   int newMax = mMax+10;
00317   tableDescriptor* dScr = new tableDescriptor[newMax];
00318   memcpy(dScr,mcols,(mMax)*sizeof(tableDescriptor));
00319   if(mcols)delete [] mcols;
00320   mcols=dScr;
00321   mMax=newMax;
00322 
00323 }
00324 
00326 
00327 void
00328 StDbTableDescriptor::fillLengths(char* length, int elementNum){
00329 
00330 int ip = 0;
00331 int i=elementNum;
00332 char* id= strstr(length,",");
00333 
00334 // preset lengths to 1;
00335 
00336   int k= (int)(sizeof(mcols[i].dimensionlen)/sizeof(ip));
00337   for(int j=0;j<k;j++)mcols[i].dimensionlen[j]=1;
00338 
00339  while (id && ip<3) {
00340    id[0]='\0';
00341    mcols[i].dimensionlen[ip] = atoi(length);
00342    ip++;
00343    id++;
00344    length=id;
00345    id= strstr(length,",");
00346  }
00347  mcols[i].dimensionlen[ip]=atoi(length); 
00348 
00349 }
00350 
00352 
00353 void
00354 StDbTableDescriptor::fillSizeAndOffset(char* length, int elementNum){
00355 
00356   fillLengths(length,elementNum);
00357   StTypeE type = mcols[elementNum].type;
00358 
00359   int j = 0;
00360   mcols[elementNum].size = getSize(mcols[elementNum].type);
00361 
00362   int k= (int)(sizeof(mcols[elementNum].dimensionlen)/sizeof(j));
00363   for (j=0; j<k; j++) mcols[elementNum].size *= mcols[elementNum].dimensionlen[j];
00364 
00365   int offp = int(ceil(float(offsetToNextEmptyByte) / float(getAlign(type))) * getAlign(type));
00366   mcols[elementNum].offset = offp;
00367   offsetToNextEmptyByte = mcols[elementNum].offset + mcols[elementNum].size;
00368 
00369 }
00370 
00372 
00373 StTypeE
00374 StDbTableDescriptor::getType(char* type) {
00375 
00376 StTypeE retVal=Stchar;
00377 
00378 //char* typenames[] = {"Stchar","Stuchar","Stshort","Stushort","Stint","Stuint","Stlong","Stulong","Stfloat","Stdouble","Stascii","Ststring"};
00379 const char* typenames[] = {"char","uchar","short","ushort","int","uint","long","ulong","longlong","float","double","ascii","string"};
00380 
00381  for(int i=0; i<12;i++){
00382    if(strcmp(type,typenames[i])==0){
00383      retVal=(StTypeE)i;
00384      break;
00385    }
00386  }
00387 
00388 return retVal;
00389 }
00390 
00392 void StDbTableDescriptor::endRowPadding(){
00393 
00394   //simple item for solaris & use of doubles & longlong.
00395   // if the struct contains such an entity, it's size must
00396   // be divisable by 8.
00397 
00398 #ifndef __linux__
00399   if(mhasDouble){
00400      int checkPadding=mtableSize%8;
00401      if(checkPadding>0 && checkPadding<5)mtableSize+=4;
00402   }
00403 #endif
00404 
00405 };
00406 
00407 
00408 
00409 
00410 
00411        
00412        
00413       
00414 
00415 
00416 
00417 
00418 
00419 
00420 
00421 
00422 
00423 
00424