ROOT_528-00b_version: include/TSQLFile.h Source File

00001 // @(#)root/sql:$Id: TSQLFile.h 34444 2010-07-16 02:17:39Z pcanal $
00002 // Author: Sergey Linev  20/11/2005
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TSQLFile
00013 #define ROOT_TSQLFile
00014 
00015 
00016 /////////////////////////////////////////////////////////////////////////
00017 //                                                                     //
00018 // TSQLFile provides TFile interface to SQL data base                  //
00019 //                                                                     //
00020 /////////////////////////////////////////////////////////////////////////
00021 
00022 
00023 #ifndef ROOT_TFile
00024 #include "TFile.h"
00025 #endif
00026 #include <stdlib.h>
00027 
00028 class TList;
00029 class TStreamerElement;
00030 class TVirtualStreamerInfo;
00031 
00032 class TSQLServer;
00033 class TSQLStatement;
00034 class TSQLResult;
00035 class TSQLRow;
00036 class TKeySQL;
00037 class TBufferSQL2;
00038 class TSQLClassInfo;
00039 
00040 class TSQLFile : public TFile {
00041     
00042    friend class TBufferSQL2;
00043    friend class TKeySQL;
00044    friend class TSQLStructure;
00045    friend class TSQLTableData;
00046    friend class TSqlRegistry; 
00047    friend class TSqlRawBuffer;
00048    friend class TSqlCmdsBuffer;
00049     
00050 protected:
00051    enum ELockingKinds {
00052        kLockFree  = 0,
00053        kLockBusy  = 1
00054    };
00055 
00056    // Interface to basic system I/O routines, suppressed
00057    virtual Int_t     SysOpen(const char*, Int_t, UInt_t) { return 0; }
00058    virtual Int_t     SysClose(Int_t) { return 0; }
00059    virtual Int_t     SysRead(Int_t, void*, Int_t) { return 0; }
00060    virtual Int_t     SysWrite(Int_t, const void*, Int_t) { return 0; }
00061    virtual Long64_t  SysSeek(Int_t, Long64_t, Int_t) { return 0; }
00062    virtual Int_t     SysStat(Int_t, Long_t*, Long64_t*, Long_t*, Long_t*) { return 0; }
00063    virtual Int_t     SysSync(Int_t) { return 0; }
00064 
00065    // Overwrite methods for directory I/O
00066    virtual Long64_t DirCreateEntry(TDirectory*);
00067    virtual Int_t    DirReadKeys(TDirectory*);
00068    virtual void     DirWriteKeys(TDirectory*);
00069    virtual void     DirWriteHeader(TDirectory*);
00070 
00071    // functions to manipulate basic tables (Configurations, Objects, Keys) in database
00072    void              SaveToDatabase();
00073    Bool_t            ReadConfigurations();
00074    Bool_t            IsTablesExists();
00075    void              InitSqlDatabase(Bool_t create);
00076    void              CreateBasicTables();
00077    void              IncrementModifyCounter();
00078    void              SetLocking(Int_t mode);
00079    Int_t             GetLocking();
00080   
00081    // function for read/write access infos
00082    Bool_t            IsWriteAccess();
00083    Bool_t            IsReadAccess();
00084   
00085    // generic sql functions
00086    TSQLResult*       SQLQuery(const char* cmd, Int_t flag = 0, Bool_t* res = 0);
00087    Bool_t            SQLCanStatement();
00088    TSQLStatement*    SQLStatement(const char* cmd, Int_t bufsize = 1000);
00089    void              SQLDeleteStatement(TSQLStatement* stmt);
00090    Bool_t            SQLApplyCommands(TObjArray* cmds);
00091    Bool_t            SQLTestTable(const char* tablename);
00092    Long64_t          SQLMaximumValue(const char* tablename, const char* columnname);
00093    void              SQLDeleteAllTables();
00094    Bool_t            SQLStartTransaction();
00095    Bool_t            SQLCommit();
00096    Bool_t            SQLRollback();
00097    Int_t             SQLMaxIdentifierLength();
00098 
00099    // operation with keys structures in database
00100    void              DeleteKeyFromDB(Long64_t keyid);
00101    Bool_t            WriteKeyData(TKeySQL* key);
00102    Bool_t            UpdateKeyData(TKeySQL* key);
00103    TKeySQL*          FindSQLKey(TDirectory* dir, Long64_t keyid);
00104    Long64_t          DefineNextKeyId();
00105    Int_t             StreamKeysForDirectory(TDirectory* dir, Bool_t doupdate, Long64_t specialkeyid = -1, TKeySQL** specialkey = 0);
00106 
00107    // handling SQL class info structures
00108    TSQLClassInfo*    FindSQLClassInfo(const char* clname, Int_t version);
00109    TSQLClassInfo*    FindSQLClassInfo(const TClass* cl);
00110    TSQLClassInfo*    RequestSQLClassInfo(const char* clname, Int_t version);
00111    TSQLClassInfo*    RequestSQLClassInfo(const TClass* cl);
00112    Bool_t            CreateClassTable(TSQLClassInfo* sqlinfo, TObjArray* colinfos);
00113    Bool_t            CreateRawTable(TSQLClassInfo* sqlinfo);
00114    
00115    Bool_t            ProduceClassSelectQuery(TVirtualStreamerInfo* info, TSQLClassInfo* sqlinfo, TString& columns, TString& tables, Int_t& tablecnt);
00116    void              AddIdEntry(Long64_t tableid, Int_t subid, Int_t type,
00117                                 const char* name, const char* sqlname, const char* info);
00118    void              ReadSQLClassInfos();
00119    TString           DefineTableName(const char* clname, Int_t version, Bool_t rawtable);
00120    Bool_t            HasTable(const char* name);
00121 
00122    // operations with long string table
00123    TString           CodeLongString(Long64_t objid, Int_t strid);
00124    Int_t             IsLongStringCode(Long64_t objid, const char* value);
00125    Bool_t            VerifyLongStringTable();
00126    Bool_t            GetLongString(Long64_t objid, Int_t strid, TString& value);
00127 
00128    // operation with object tables in database
00129    Long64_t          VerifyObjectTable();
00130    Bool_t            SQLObjectInfo(Long64_t objid, TString& clname, Version_t &version);
00131    TObjArray*        SQLObjectsInfo(Long64_t keyid);
00132    TSQLResult*       GetNormalClassData(Long64_t objid, TSQLClassInfo* sqlinfo);
00133    TSQLResult*       GetNormalClassDataAll(Long64_t minobjid, Long64_t maxobjid, TSQLClassInfo* sqlinfo);
00134    TSQLResult*       GetBlobClassData(Long64_t objid, TSQLClassInfo* sqlinfo);
00135    TSQLStatement*    GetBlobClassDataStmt(Long64_t objid, TSQLClassInfo* sqlinfo);
00136    Long64_t          StoreObjectInTables(Long64_t keyid, const void* obj, const TClass* cl);
00137    Bool_t            WriteSpecialObject(Long64_t keyid, TObject* obj, const char* name, const char* title);
00138    TObject*          ReadSpecialObject(Long64_t keyid, TObject* obj = 0);
00139   
00140    // sql specific types
00141    const char*       SQLCompatibleType(Int_t typ) const;
00142    const char*       SQLIntType() const;
00143    const char*       SQLSmallTextType() const      { return fOtherTypes[0]; }
00144    Int_t             SQLSmallTextTypeLimit() const { return atoi(fOtherTypes[1]); }
00145    const char*       SQLBigTextType() const        { return fOtherTypes[2]; }
00146    const char*       SQLDatetimeType() const       { return fOtherTypes[3]; }
00147    const char*       SQLIdentifierQuote() const    { return fOtherTypes[4]; }
00148    const char*       SQLDirIdColumn() const        { return fOtherTypes[5]; }
00149    const char*       SQLKeyIdColumn() const        { return fOtherTypes[6]; }
00150    const char*       SQLObjectIdColumn() const     { return fOtherTypes[7]; }
00151    const char*       SQLRawIdColumn() const        { return fOtherTypes[8]; }
00152    const char*       SQLStrIdColumn() const        { return fOtherTypes[9]; }
00153    const char*       SQLNameSeparator() const      { return fOtherTypes[10]; }
00154    const char*       SQLValueQuote() const         { return fOtherTypes[11]; }
00155    const char*       SQLDefaultTableType() const   { return fOtherTypes[12]; }
00156   
00157    TSQLServer*       fSQL;             //! interface to SQL database 
00158   
00159    TList*            fSQLClassInfos;   //! list of SQL class infos
00160   
00161    Bool_t            fUseSuffixes;     //! use suffixes in column names like fValue:Int_t or fObject:pointer
00162    Int_t             fSQLIOversion;    //! version of SQL I/O which is stored in configurations
00163    Int_t             fArrayLimit;      //! limit for array size. when array bigger, its content converted to raw format
00164    Bool_t            fCanChangeConfig; //! variable indicates can be basic configuration changed or not
00165    TString           fTablesType;      //! type, used in CREATE TABLE statements
00166    Int_t             fUseTransactions; //! use transaction statements for writing data into the tables
00167    Int_t             fUseIndexes;      //! use indexes for tables: 0 - off, 1 - only for basic tables, 2  + normal class tables, 3 - all tables
00168    Int_t             fModifyCounter;   //! indicates how many changes was done with database tables
00169    Int_t             fQuerisCounter;   //! how many query was applied
00170   
00171    const char**      fBasicTypes;      //! pointer on list of basic types specific for currently connected SQL server
00172    const char**      fOtherTypes;      //! pointer on list of other SQL types like TEXT or blob
00173   
00174    TString           fUserName;       //! user name, used to access objects from database
00175   
00176    std::ofstream*    fLogFile;        //! log file with SQL statements
00177    
00178    Bool_t            fIdsTableExists; //! indicate if IdsTable exists
00179    Int_t             fStmtCounter;    //! count numbers of active statements
00180 
00181 private:
00182    //let the compiler do the job. gcc complains when the following line is activated
00183    //TSQLFile(const TSQLFile &) {}            //Files cannot be copied
00184    void operator=(const TSQLFile &);
00185 
00186 public:
00187    enum ETransactionKinds {
00188        kTransactionsOff  = 0,
00189        kTransactionsAuto = 1,
00190        kTransactionsUser = 2
00191    };
00192    
00193    enum EIndexesKinds {
00194        kIndexesNone      = 0,
00195        kIndexesBasic     = 1,
00196        kIndexesClass     = 2,
00197        kIndexesAll       = 3
00198    };
00199 
00200    TSQLFile();
00201    TSQLFile(const char* dbname, Option_t* option = "read", const char* user = "user", const char* pass = "pass");
00202    virtual ~TSQLFile();
00203 
00204    // configuration of SQL 
00205    Bool_t            GetUseSuffixes() const { return fUseSuffixes; }
00206    void              SetUseSuffixes(Bool_t on = kTRUE);
00207    Int_t             GetArrayLimit() const { return fArrayLimit; }
00208    void              SetArrayLimit(Int_t limit = 20);
00209    void              SkipArrayLimit() { SetArrayLimit(-1); }
00210    void              SetTablesType(const char* table_type);
00211    const char*       GetTablesType() const { return fTablesType.Data(); }
00212    void              SetUseTransactions(Int_t mode = kTransactionsAuto);
00213    Int_t             GetUseTransactions() const { return fUseTransactions; }
00214    void              SetUseIndexes(Int_t use_type = kIndexesBasic);
00215    Int_t             GetUseIndexes() const { return fUseIndexes; }
00216    Int_t             GetQuerisCounter() const { return fQuerisCounter; }
00217 
00218    TString           MakeSelectQuery(TClass* cl);
00219    Bool_t            StartTransaction();
00220    Bool_t            Commit();
00221    Bool_t            Rollback();
00222   
00223    // log file for SQL statements
00224    void              StartLogFile(const char* fname);  // *MENU*
00225    void              StopLogFile();                    // *MENU*
00226 
00227    virtual void      Close(Option_t *option="");       // *MENU*
00228    virtual TKey*     CreateKey(TDirectory* mother, const TObject* obj, const char* name, Int_t bufsize);
00229    virtual TKey*     CreateKey(TDirectory* mother, const void* obj, const TClass* cl, const char* name, Int_t bufsize);
00230    virtual void      DrawMap(const char* ="*",Option_t* ="") {} 
00231    virtual void      FillBuffer(char* &) {}
00232    virtual void      Flush() {}
00233 
00234    virtual Long64_t  GetEND() const { return 0; }
00235    virtual Int_t     GetErrno() const { return 0; }
00236    virtual void      ResetErrno() const {}
00237 
00238    const char*       GetDataBaseName() const;
00239    virtual Int_t     GetNfree() const { return 0; }
00240    virtual Int_t     GetNbytesInfo() const {return 0; }
00241    virtual Int_t     GetNbytesFree() const {return 0; }
00242    virtual Long64_t  GetSeekFree() const {return 0; }
00243    virtual Long64_t  GetSeekInfo() const {return 0; }
00244    virtual Long64_t  GetSize() const { return 0; }
00245    virtual TList*    GetStreamerInfoList();
00246 
00247    Bool_t            IsMySQL() const;
00248    virtual Bool_t    IsOpen() const;
00249    Bool_t            IsOracle() const;
00250    Bool_t            IsODBC() const;
00251 
00252    virtual void      MakeFree(Long64_t, Long64_t) {}
00253    virtual void      MakeProject(const char *, const char* ="*", Option_t* ="new") {} // *MENU*
00254    virtual void      Map() {} // 
00255    virtual void      Paint(Option_t* ="") {}
00256    virtual void      Print(Option_t* ="") const {}
00257    virtual Bool_t    ReadBuffer(char*, Int_t) { return kFALSE; }
00258    virtual Bool_t    ReadBuffer(char*, Long64_t, Int_t) { return kFALSE; }
00259    virtual void      ReadFree() {}
00260    virtual Int_t     Recover() { return 0; }
00261    virtual Int_t     ReOpen(Option_t *mode);
00262    virtual void      Seek(Long64_t, ERelativeTo=kBeg) {}
00263 
00264    virtual void      SetEND(Long64_t) {}
00265    virtual Int_t     Sizeof() const { return 0; }
00266 
00267    virtual void      UseCache(Int_t = 10, Int_t = 0) {}
00268    virtual Bool_t    WriteBuffer(const char*, Int_t) { return kFALSE; }
00269    virtual Int_t     Write(const char* =0, Int_t=0, Int_t=0) { return 0; }
00270    virtual Int_t     Write(const char* =0, Int_t=0, Int_t=0) const { return 0; }
00271    virtual void      WriteFree() {}
00272    virtual void      WriteHeader();
00273    virtual void      WriteStreamerInfo();
00274   
00275    ClassDef(TSQLFile,1)   // ROOT TFile interface to SQL database
00276 };
00277 
00278 #endif