StRoot: StDbLib/StDbTableDescriptor.h Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StDbTableDescriptor.h,v 1.12 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.h,v $
00014  * Revision 1.12  2009/09/28 19:14:10  dmitry
00015  * row size is not *static* anymore, tables have different row sizes
00016  *
00017  * Revision 1.11  2009/09/10 18:06:08  dmitry
00018  * struct alignment fix, does not rely on fixed 4 byte cap anymore - runtime align calculation is now in use
00019  *
00020  * Revision 1.10  2007/09/03 05:39:03  fisyak
00021  * Anti Cint corrections
00022  *
00023  * Revision 1.9  2005/09/07 22:04:02  deph
00024  * update to correct padding issue for packed tables
00025  *
00026  * Revision 1.8  2001/12/05 17:16:35  porter
00027  * stand-alone make file no longer had "DLINUX" in compile but this is still needed
00028  * and returned. Also retrieve elementID list  in query by whereClause for plotting
00029  * many row instances.
00030  *
00031  * Revision 1.7  2001/01/22 18:38:00  porter
00032  * Update of code needed in next year running. This update has little
00033  * effect on the interface (only 1 method has been changed in the interface).
00034  * Code also preserves backwards compatibility so that old versions of
00035  * StDbLib can read new table structures.
00036  *  -Important features:
00037  *    a. more efficient low-level table structure (see StDbSql.cc)
00038  *    b. more flexible indexing for new systems (see StDbElememtIndex.cc)
00039  *    c. environment variable override KEYS for each database
00040  *    d. StMessage support & clock-time logging diagnostics
00041  *  -Cosmetic features
00042  *    e. hid stl behind interfaces (see new *Impl.* files) to again allow rootcint access
00043  *    f. removed codes that have been obsolete for awhile (e.g. db factories)
00044  *       & renamed some classes for clarity (e.g. tableQuery became StDataBaseI
00045  *       and mysqlAccessor became StDbSql)
00046  *
00047  * Revision 1.6  2000/03/28 17:03:19  porter
00048  * Several upgrades:
00049  * 1. configuration by timestamp for Conditions
00050  * 2. query by whereClause made more systematic
00051  * 3. conflict between db-stored comments & number lists resolved
00052  * 4. ensure endtime is correct for certain query falures
00053  * 5. dbstl.h->handles ObjectSpace & RogueWave difference (Online vs Offline)
00054  *
00055  * Revision 1.5  1999/12/03 19:02:02  porter
00056  * modified descriptor to accept tableDescriptor once this St_base object
00057  * has been updated to have longer name lengths.
00058  *
00059  * Revision 1.4  1999/10/19 14:30:40  porter
00060  * modifications relevant to use with StDbBroker and future merging with
00061  * "params" database structure + some docs + suppressing diagnostics messages
00062  *
00063  * Revision 1.3  1999/09/30 02:06:10  porter
00064  * add StDbTime to better handle timestamps, modify SQL content (mysqlAccessor)
00065  * allow multiple rows (StDbTable), & Added the comment sections at top of
00066  * each header and src file
00067  *
00068  **************************************************************************/
00069 #ifndef STDBTABLEDESCRIPTOR_HH
00070 #define STDBTABLEDESCRIPTOR_HH
00071 
00072 #include <string.h>
00073 #include "StTableDescriptorI.h"
00074 #ifndef __CINT__
00075 #include "StDbBuffer.h"
00076 #else
00077 class StDbBuffer;
00078 #endif
00079 struct tableDescriptor {
00080   StTypeE type;      // enumerated basic type
00081   char name[60];     //  element name
00082   unsigned int size; //  element size in bytes
00083   unsigned int  offset; // byte offset in table to this element
00084   unsigned int  dimensionlen[4]; // len per dimension if multi-D array
00085 };
00086 
00087 
00088 class StDbTableDescriptor : public StTableDescriptorI {
00089 
00090 protected:
00091 
00092  unsigned int mnumElements;
00093  unsigned int mtableSize;
00094  int offsetToNextEmptyByte;
00095  int offsetToLast4Bytes;
00096  StTypeE lastType;
00097  int padsize;
00098 
00099  unsigned int mAlign[Stmaxtype];
00100 
00101  tableDescriptor* mcols;
00102  int mMax;
00103  int mCur;
00104 
00105  // db unique ids
00106  int mstructID;
00107  int mschemaID;
00108  int rowSizeTT;
00109  bool misValid;  // schema has been filled
00110  bool mhasDouble;
00111  unsigned int maxAlign;
00112 
00113   void init();
00114   virtual void reSize();
00115   virtual void fillSizeAndOffset(char* length, int elementNum);
00116   virtual void fillLengths(char* length, int elementNum);
00117   virtual StTypeE getType(char* type);
00118   virtual unsigned int getSize(StTypeE type);
00119   virtual unsigned int getAlign(StTypeE type);
00120 
00121 public:
00122 
00123   StDbTableDescriptor();
00124   StDbTableDescriptor(int structID, int schemaID);
00125   StDbTableDescriptor(StDbTableDescriptor& d);
00126   virtual ~StDbTableDescriptor() {if(mcols) delete [] mcols; }
00127   virtual void fillElement(StDbBuffer* buff, int tableID);
00128 
00129   virtual StTableDescriptorI* getCpy();
00130   virtual tableDescriptor* getTableDescriptor() const;
00131   virtual unsigned int getNumElements() const;
00132   virtual unsigned int getTotalSizeInBytes() const;
00133   virtual char* getElementName(int elementNum) const;
00134   virtual unsigned int getElementOffset(int elementNum) const;
00135   virtual unsigned int getElementSize(int elementNum)  const;
00136   virtual StTypeE getElementType(int elementNum) const;
00137   virtual unsigned int* getElementDimensions(int elementNum) const;
00138   virtual unsigned int getElementLength(int elementNum) const;
00139   virtual unsigned int getElementNumDimensions(int elementNum) const;
00140   virtual unsigned int getElementIndexLength(int elementNum, int dimensionNum) const;
00141   
00142    
00143   int getSchemaID() const;
00144   int getStructID() const;
00145   void setSchemaID(int id);
00146   void setStructID(int id);
00147   bool IsValid() const;
00148   int getCurrentInternalSize();
00149   int getTrowSize() ;  
00150   void endRowPadding();
00151   void storeRowSize(int rowSize);
00152   unsigned int getMaxAlign();
00153   
00154 };
00155 #ifndef __CINT__
00156 inline unsigned int
00157 StDbTableDescriptor::getNumElements() const {return mnumElements;}
00158 
00159 inline unsigned int
00160 StDbTableDescriptor::getTotalSizeInBytes() const {return mtableSize;}
00161 
00162 inline char*
00163 StDbTableDescriptor::getElementName(int elementNum) const { 
00164 char* retVal = new char[strlen(mcols[elementNum].name)+1];
00165 strcpy(retVal,mcols[elementNum].name);
00166 return retVal;
00167 }
00168 
00169 inline unsigned int
00170 StDbTableDescriptor::getElementOffset(int elementNum) const { 
00171 return mcols[elementNum].offset;
00172 }
00173 
00174 inline unsigned int StDbTableDescriptor::getElementSize(int elementNum) const{ 
00175 return mcols[elementNum].size;
00176 }
00177 
00178 inline StTypeE StDbTableDescriptor::getElementType(int elementNum) const { 
00179 return mcols[elementNum].type;
00180 }
00181 
00182 inline unsigned int* 
00183 StDbTableDescriptor::getElementDimensions(int elementNum) const { 
00184 return &mcols[elementNum].dimensionlen[0];
00185 }
00186 
00188 
00189 inline unsigned int 
00190 StDbTableDescriptor::getElementLength(int elementNum) const { 
00191 
00192 int retVal=1;
00193 int j;
00194   int k= (int)(sizeof(mcols[elementNum].dimensionlen)/sizeof(j));
00195   for(j=0;j<k;j++)retVal *= mcols[elementNum].dimensionlen[j]; 
00196 return retVal;
00197 }
00198 
00200 
00201 inline unsigned int
00202 StDbTableDescriptor::getElementNumDimensions(int elementNum) const { 
00203 int retVal=1;
00204 int j;
00205   int k= (int)(sizeof(mcols[elementNum].dimensionlen)/sizeof(j));
00206   for(j=0;j<k;j++){
00207     if(mcols[elementNum].dimensionlen[j]>1)retVal=j+1;  // last dimension >1
00208   }
00209 return retVal;
00210 }
00211 
00212 inline unsigned int
00213 StDbTableDescriptor::getElementIndexLength(int elementNum, int dimensionNum) const { 
00214 return mcols[elementNum].dimensionlen[dimensionNum];
00215 }
00216 
00217 inline unsigned int StDbTableDescriptor::getSize(StTypeE type){ return mycsize[type];}
00218 inline unsigned int StDbTableDescriptor::getAlign(StTypeE type){ return mAlign[type];}
00219 inline int  StDbTableDescriptor::getSchemaID() const { return mschemaID; }
00220 inline int  StDbTableDescriptor::getStructID() const { return mstructID; }
00221 inline void StDbTableDescriptor::setSchemaID(int id) { mschemaID=id; }
00222 inline void StDbTableDescriptor::setStructID(int id) { mstructID=id; }
00223 inline bool StDbTableDescriptor::IsValid() const { return misValid; }
00224 inline int  StDbTableDescriptor::getCurrentInternalSize() { return mMax; };
00225 inline void StDbTableDescriptor::storeRowSize(int rowSize) { rowSizeTT = rowSize; }
00226 inline int  StDbTableDescriptor::getTrowSize() { return rowSizeTT; };
00227 inline unsigned int  StDbTableDescriptor::getMaxAlign() { return maxAlign; };
00228 #endif
00229 
00230 #endif
00231 
00232 
00233 
00234 
00235 
00236