StRoot: StDbBroker/StDbBroker.h Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StDbBroker.h,v 1.32 2011/11/28 17:03:07 dmitry Exp $
00004  *
00005  * Author: S. Vanyashin, V. Perevoztchikov
00006  * Updated by:  R. Jeff Porter
00007  ***************************************************************************
00008  *
00009  * Description: Offline Interface from the Offline Maker interface to the
00010  *              Database interface. 
00011  *
00012  ***************************************************************************
00013  *
00014  * $Log: StDbBroker.h,v $
00015  * Revision 1.32  2011/11/28 17:03:07  dmitry
00016  * dbv override support in StDbLib,StDbBroker,St_db_Maker
00017  *
00018  * Revision 1.31  2011/02/10 17:31:01  dmitry
00019  * added an option to blacklist domains
00020  *
00021  * Revision 1.30  2008/01/15 20:37:44  deph
00022  * Removed DbFill and corresponding calls from StDbBroker
00023  *
00024  * Revision 1.29  2007/09/10 02:36:08  perev
00025  * StDbBroker::Release added
00026  *
00027  * Revision 1.28  2005/08/29 21:43:15  fisyak
00028  * replace UInt_t to Int_t for m_runNumber to avoid problem with undefined run no.
00029  *
00030  * Revision 1.27  2004/07/14 18:46:51  perev
00031  * UInt=>Int for new ROOT
00032  *
00033  * Revision 1.26  2003/01/08 19:43:10  perev
00034  * CleanUp
00035  *
00036  * Revision 1.25  2002/01/15 17:15:36  porter
00037  * moved timestamp translation to a separate method
00038  *
00039  * Revision 1.24  2001/10/30 20:43:29  porter
00040  * timestamp set for failure on query by runNumber
00041  *
00042  * Revision 1.23  2001/10/26 16:36:17  porter
00043  * more runNumber implementation
00044  *
00045  * Revision 1.22  2001/10/26 15:44:02  porter
00046  * add query by runNumber
00047  *
00048  * Revision 1.21  2001/10/24 04:05:56  porter
00049  * added zombie designation per Victor's suggestion
00050  *
00051  * Revision 1.20  2001/09/13 16:54:54  porter
00052  * propogate falvor by table through the brokery
00053  *
00054  * Revision 1.19  2001/01/22 18:40:25  porter
00055  * Added a wrapper for StMessage so one can use it in StDbLib
00056  *
00057  * Revision 1.18  2000/08/15 22:53:14  porter
00058  * Added 2 write methods.
00059  *  - 1 works once "list" is requested from database
00060  *  - 1 works just by specifying the full path from which
00061  *    the code extracts the database name.
00062  *
00063  * Revision 1.17  2000/06/30 02:00:42  porter
00064  * fixed memory leak introduced when making sure top level returned to
00065  * offline is always a database type name
00066  *
00067  * Revision 1.16  2000/06/14 13:39:05  didenko
00068  * Add ClassDef/ClassImp
00069  *
00070  * Revision 1.15  2000/04/25 18:27:48  porter
00071  * Added flavor and production time as query fields to pass to db-api
00072  *
00073  * Revision 1.14  2000/04/14 14:46:41  fine
00074  * new method for Victor has been introduced
00075  *
00076  * Revision 1.13  2000/04/13 20:22:57  porter
00077  * - reconnected tableDescriptor that had been broken via St_tableDescriptor.
00078  * - added unix timestamp as standard
00079  * - top node returned via InitConfig will be a database type
00080  *
00081  * Revision 1.12  2000/03/26 16:47:13  fine
00082  * Adjusted to ROOT 2.24
00083  *
00084  * Revision 1.11  2000/02/28 15:24:20  porter
00085  * add more StDbLib methods to broker: this time, StDbManager::closeAllConnections()
00086  *
00087  * Revision 1.10  2000/01/31 17:11:18  porter
00088  * fix break caused by the interaction design between
00089  * 'StRoot/St_base/tableDescriptor.h' & 'StDbBroker::Descriptor'
00090  * Now  StDbBroker::Descriptor==tableDescriptor_st
00091  * And  StDbBroker::GetTableDescriptor() returns abstract StTableDescriptorI*
00092  * Interface to StDbLib is (and was) handle correctly.
00093  * StDbBroker is now tied to StRoot/St_base via tableDescriptor.h
00094  * No problems would have occured if St_base interactions were based
00095  * on StTableDesciptorI in the first place.
00096  *
00097  * Revision 1.9  2000/01/27 20:30:40  porter
00098  * cleaned up dtor & error logic
00099  *
00100  * Revision 1.8  2000/01/14 14:49:10  porter
00101  * set verbose level for checking, added $Id & $Logs, & made node container
00102  * more robust for interactions with StDbLib
00103  *
00104  * Revision 1.7  2000/01/10 20:31:16  porter
00105  * modified StDbBroker to be an interface to the DB-interface, StDbLib.
00106  *  - old functionality is retained for the short-term & modifications
00107  *    are extensions
00108  *
00109  *
00110  **************************************************************************/
00111 //  
00112 
00113 #ifndef STAR_StDbBroker
00114 #define STAR_StDbBroker
00115 
00116 #include "Rtypes.h"
00117 #include "dbNodeArray.h"
00118 #include "dbConfig.h"
00119 //
00120 // --> had to remove independence from 'St_base'
00121 //     since St_base doesn't know interface
00122 //    
00123 //     Now Broker uses StDbLib's descriptor interface
00124 //     and St_base's concrete descriptor.
00125 //
00126 //#include "tableDescriptor.h" 
00127 #include "St_tableDescriptor.h" 
00128 
00129 #include <map>
00130 #include <utility>
00131 
00132 class StDbConfigNode;
00133 class StDbManager;
00134 class StTableDescriptorI;
00135 class StDbTable;
00136 
00137 /* needed for GetComments only   */
00138 class TTable;
00139 /*this is a temporary quick-and-dirty class for db access*/
00140 
00141 class StDbBroker  {
00142   public:
00143       enum EColumnType {kNAN, kFloat, kInt, kLong, kShort, kDouble, kUInt
00144                              ,kULong, kUShort, kUChar, kChar };
00145 
00146 typedef St_tableDescriptor Descriptor;
00147 
00148 //--> for Sasha's (now obsolete?) Fill & Use routines 
00149 struct oldDescriptor {
00150     char         fColumnName[32];  /* The name of this data-member: */
00151     unsigned int fIndexArray[3];   /* The array of the sizes for each dimen*/
00152     unsigned int fOffset;      /* The first byte in the row of this column  */
00153     unsigned int fSize;   /* The full size of the selected column in bytes  */
00154     unsigned int fTypeSize; /* The type size of the selected column in byte */
00155     unsigned int fDimensions;/* The number of the dimensions for array   */
00156     Int_t        fType;        /* The data type of the selected column   */
00157 };
00158 
00159   protected:
00160     StDbTable*   m_node;
00161     oldDescriptor *m_descriptor;
00162     Descriptor  *mdescriptor;
00163     Char_t *     m_structName;  //name of the struct type used in this TTable
00164     Char_t *     m_tableName;   //name of this instance of TTable
00165     UInt_t       m_sizeOfStruct;// byte size of this struct
00166     UInt_t       m_nElements;   // Number of variables in the structure
00167     UInt_t       m_nRows;       // number of rows in the table
00168 
00169     Int_t        m_DateTime[2]; // Current DateTime
00170 
00171     Int_t        m_BeginDate;   // begin date: 2021 05 31
00172     Int_t        m_BeginTime;   // begin date: HH MM SS
00173     Int_t        m_EndDate;     // end date
00174     Int_t        m_EndTime;     // end time
00175 
00176     UInt_t       m_beginTimeStamp; // unix beginTime
00177     UInt_t       m_endTimeStamp; // unix endTime
00178     UInt_t       m_requestTimeStamp; // unix requestTime
00179 
00180     Int_t        m_runNumber;  // run number of queries of runlog
00181 
00182     char*        m_tableVersion; // name of the version of the table
00183     char*        m_database;     // name of the database for this table
00184     char*        m_ParentType;   // named dbType when "top" db is domain-level
00185 
00186     int       m_isVerbose;
00187     dbNodeArray *m_Nodes;
00188     StDbConfigNode* m_Tree;
00189 
00190     char*        m_flavor;
00191     unsigned int m_prodTime;
00192     std::map<std::pair<char*,char*>,unsigned int> m_prodTimeOverride; // DBV override for specific subsystems
00193 
00194     dbConfig_st*  buildConfig(int& numRows);
00195     int           buildNodes(StDbConfigNode* node, int pID);
00196 
00197     Bool_t         m_isZombie;
00198     
00199     void          makeDateTime(const char* dateTime, Int_t & iDate, Int_t & iTime); 
00200 
00201   public:
00202 
00203     StDbBroker();
00204     virtual ~StDbBroker();
00205     
00206     //    int Init(const char *dbname);// return 0 if OK
00207 
00208     void * Use();
00209     void   SetTableFlavor(const char* flavor, int tabID, int parID);
00210     void * Use(int tabID, int parID);
00211     bool   UseRunLog(StDbTable* table);
00212 
00213     char  **GetComments(St_Table *parentTable);
00214   //  void   Fill(void * pArray, const char **ElementComment);
00215 
00216     // Write Into Database methods
00217     //  with tabID -> assumes StDbBroker::InitConfig() has been called 
00218     //  which returns the list of table names with unique tabID association.
00219     Int_t WriteToDb(void* pArray, int tabID);
00220 
00221     //  with fullPath -> find the database from the path. Table information
00222     //  is requested from db but over-ridden by input options (idList).
00223     //  This method will be slow for writing several tables but speed of writes
00224     //  should not be an issue.
00225     Int_t WriteToDb(void* pArray, const char* fullPath, int* idList=0);
00226 
00227     StDbTable* findTable(const char* databaseName);
00228 
00229     UInt_t GetNRows()                {return m_nRows;       }
00230     Int_t  GetBeginDate()            {return m_BeginDate;   }
00231     Int_t  GetBeginTime()            {return m_BeginTime;   }
00232 const char *GetFlavor();              
00233     Int_t  GetEndDate()              {return m_EndDate;     }
00234     Int_t  GetEndTime()              {return m_EndTime;     }
00235     UInt_t GetRequestTimeStamp()     {return m_requestTimeStamp; }
00236     UInt_t GetBeginTimeStamp()       {return m_beginTimeStamp; }
00237     UInt_t GetEndTimeStamp()         {return m_endTimeStamp; }
00238     UInt_t GetProdTime()             {return m_prodTime;}
00239     Bool_t   IsZombie()              {return m_isZombie; }
00240 
00241 
00242     StTableDescriptorI* GetTableDescriptor();
00243 
00244     void loadOldDescriptor(){};
00245     static const Char_t * GetTypeName( EColumnType type) {
00246       switch (type)
00247         {
00248         case kFloat:  return "float";
00249         case kInt:    return "int";
00250         case kLong:   return "long";
00251         case kShort:  return "short";
00252         case kDouble: return "double";
00253         case kChar:   return "char";
00254           //temporarily
00255         case kUInt:   return "int";
00256         case kULong:  return "long";
00257         case kUShort: return "short";
00258         case kUChar:  return "char";
00259 
00260         case kNAN:    return "";
00261         default:      return "";
00262         } 
00263     };
00264 
00265     void   SetDateTime(Int_t  date,Int_t  time);
00266     void   SetRunNumber(Int_t runNumber)  {m_runNumber=runNumber;};
00267     void   SetDictionary(UInt_t nElements, Descriptor *D)
00268                                      {m_nElements=nElements; mdescriptor = D;}
00269     void   SetDictionary(Descriptor *D)
00270                                      {if (D) { mdescriptor = D;m_nElements=D->NumberOfColumns();}}
00271     void   SetTableName(const Char_t *table_name)
00272                                   {if(m_tableName) delete [] m_tableName;
00273                                    m_tableName=new char[strlen(table_name)+1]; 
00274                                    strcpy(m_tableName,table_name);};
00275     void   SetStructName(const Char_t *struct_name)
00276                                 {if(m_structName) delete [] m_structName;
00277                                  m_structName=new char[strlen(struct_name)+1];
00278                                  strcpy(m_structName,struct_name);};
00279     void   SetVersionName(const char *version) 
00280                                  {if(m_tableVersion) delete [] m_tableVersion;
00281                                   m_tableVersion= new char[strlen(version)+1];
00282                                   strcpy(m_tableVersion,version);}
00283     void   SetDataBaseName(const char *dbName) 
00284                                  {if(m_database) delete [] m_database;
00285                                   m_database= new char[strlen(dbName)+1]; 
00286                                   strcpy(m_database,dbName);}
00287                                            
00288     void   SetStructSize(UInt_t size)     {m_sizeOfStruct=size;    };
00289     void   SetNRows(UInt_t nRows)         {m_nRows = nRows;        }
00290     void   SetBeginDate(Int_t  BeginDate) {m_BeginDate = BeginDate;}
00291     void   SetBeginTime(Int_t  BeginTime) {m_BeginTime = BeginTime;}
00292     void   SetEndDate(Int_t  EndDate)     {m_EndDate = EndDate;    }
00293     void   SetEndTime(Int_t  EndTime)     {m_EndTime = EndTime;    }
00294     void   SetRequestTimeStamp(UInt_t utime) {m_requestTimeStamp = utime; }
00295     void   SetBeginTimeStamp(UInt_t utime)   {m_beginTimeStamp   = utime; }
00296     void   SetEndTimeStamp(UInt_t utime)     {m_endTimeStamp     = utime; }
00297     void   SetProdTime(UInt_t ptime);
00298     void   AddProdTimeOverride(UInt_t ptime, char* dbType = 0, char* dbDomain = 0); // DBV override
00299     void   SetFlavor(const char* flavor);
00300     void   SetZombie(Bool_t zombie)          { m_isZombie=true; }
00301 
00302         void   addBlacklistedDomain(const char* domainName);
00303 
00304     static int DbInit(const char *);            //Sasha's dbInit 
00305     void   setVerbose(int isVerbose) { m_isVerbose = isVerbose; } 
00306     void   printStatistics();
00307     void   CloseAllConnections();
00308     void   Release();
00309 
00310   //-> here's all the real stuff now
00311     dbConfig_st* InitConfig(const char* configName, int& numRows, char* versionName=0);
00312     StDbManager* mgr;
00313   
00314   ClassDef(StDbBroker,0)
00315 };
00316 
00317 // The old C-functions from Sasha's prototype & 1st integration
00318 //extern "C" void DbFill(unsigned int *,         //datetime[4]
00319 //                     const char *,  //tableName
00320 //                     const char *,  //StructName
00321 //                     unsigned int,           //nVar
00322 //                     StDbBroker::oldDescriptor *d,
00323 //                     const char **,       //Comments
00324 //                     unsigned int,           //nRows
00325 //                     unsigned int,           //sizeOfStruct
00326 //                     void *);       //pData
00327                        
00328 extern "C" void *DbUse(unsigned int*,           //&nRows,
00329                        unsigned int *,         //datetime[4]
00330                        const char *,  //tableName
00331                        const char *,  //StructName
00332                        unsigned int,           //nVar
00333                        unsigned int,           //sizeOfStruct
00334                        StDbBroker::oldDescriptor *d);
00335 
00336 extern "C" void *DbRead(unsigned int*,           //&nRows,
00337                        unsigned int *,         //datetime[4]
00338                        const char *,  //tableName
00339                        const char *,  //StructName
00340                        unsigned int,           //nVar
00341                        unsigned int,           //sizeOfStruct
00342                        StDbBroker::oldDescriptor *d,
00343                const char*,            //  database Name
00344                const char*);           // versionName
00345 
00346 extern "C" int DbInit(const char *);            //dbInit
00347 
00348 #endif
00349 
00350 
00351 
00352 
00353 
00354 
00355 
00356 
00357 
00358 
00359