DbiTableProxyRegistry.cxx

Go to the documentation of this file.

// $Id: DbiTableProxyRegistry.cxx,v 1.38 2008/08/22 10:27:57 nwest Exp $
#include <vector>

#include "TSystem.h"

#include "TString.h"

#include "DatabaseInterface/DbiExceptionLog.h"
#include "DatabaseInterface/DbiBinaryFile.h"
#include "DatabaseInterface/DbiCache.h"
#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiConfigSet.h"
#include "DatabaseInterface/DbiRecord.h"
#include "DatabaseInterface/DbiServices.h"
#include "DatabaseInterface/DbiTableProxyRegistry.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "LeakChecker/Lea.h"
#include "MessageService/MsgService.h"
#include "Util/UtilString.h" 

ClassImp(DbiTableProxyRegistry)

//   Definition of static data members
//   *********************************

CVSID("$Id: DbiTableProxyRegistry.cxx,v 1.38 2008/08/22 10:27:57 nwest Exp $");

DbiTableProxyRegistry* DbiTableProxyRegistry::fgInstance       = 0;
int                    DbiTableProxyRegistry::Cleaner::fgCount = 0;

//    Definition of all member functions (static or otherwise)
//    *******************************************************
//
//    -  ordered: ctors, dtor, operators then in alphabetical order.

//.....................................................................

DbiTableProxyRegistry::DbiTableProxyRegistry() :
fCascader(0)
{
//
//
//  Purpose:  Constructor
//
//  Arguments: None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create factory

//  Program Notes:-
//  =============

//  None.

  LEA_CTOR    //Leak Checker

// Create cascader for database access.

  fCascader = new DbiCascader;

// Get any environment configuration.

  this->SetConfigFromEnvironment();

// Create a DbiRecord to record a summary of all DbiResults in memory
// and register it as a service.
  DbiServices::SetRecord(new DbiRecord);
  
  MSG("Dbi", Msg::kVerbose) << "Creating DbiTableProxyRegistry" 
    << endl;


}

//.....................................................................

DbiTableProxyRegistry::~DbiTableProxyRegistry() {
//
//
//  Purpose: Destructor
//
//  Arguments: 
//    None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Destroy all DbiTableProxies if Shutdown required.


  LEA_DTOR    //Leak Checker

  if (  DbiExceptionLog::GetGELog().Size() ) {
     MSG("Dbi",Msg::kInfo) << "Database Global Exception Log contains " 
          << DbiExceptionLog::GetGELog().Size() << " entries:-" << endl;;
     DbiExceptionLog::GetGELog().Print();
  }

  int shutdown = 0;
  if (    ! this->GetConfig().Get("Shutdown",shutdown)
         || shutdown == 0 ) {
    MSG("Dbi",Msg::kInfo) << "DatabaseInterface shutdown not requested" << endl;
    return;
  }

  MSG("Dbi",Msg::kInfo) << "DatabaseInterface shutting down..." << endl;

// Destroy all owned objects.

  for ( std::map<std::string,DbiTableProxy*>::iterator itr = fTPmap.begin();
        itr != fTPmap.end();
        ++itr) {
    DbiTableProxy* tp = (*itr).second;
    delete tp;
  }

  delete fCascader;
  fCascader = 0;

  delete DbiServices::GetRecord();
  DbiServices::SetRecord(0);

  MSG("Dbi", Msg::kVerbose) 
    << "Destroying DbiTableProxyRegistry" << endl;

  MSG("Dbi", Msg::kInfo) << "DatabaseInterface shutdown complete." << endl;
  DbiTableProxyRegistry::fgInstance = 0;

}

//.....................................................................

void DbiTableProxyRegistry::ApplySqlCondition() const {
//
//
//  Purpose: Apply Sql condition to existing DbiTableProxys.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Apply global Sql condition, together with any prevailing rollback to 
//    all existing DbiTableProxys.

  std::map<std::string,DbiTableProxy*>::const_iterator itr = fTPmap.begin();
  std::map<std::string,DbiTableProxy*>::const_iterator itrEnd = fTPmap.end();
  for ( ; itr != itrEnd; ++itr) this->ApplySqlCondition(itr->second);
}

//.....................................................................

void DbiTableProxyRegistry::ApplySqlCondition(DbiTableProxy* proxy) const {
//
//
//  Purpose: Apply Sql condition to specific DbiTableProxy.
//
//  Arguments: 
//    proxy        in    DbiTableProxy to which condition is to be applied.
//
//  Contact:   N. West
//

  string sqlFull = fSqlCondition;
  const string tableName(proxy->GetTableName());
  const string& date = fRollbackDates.GetDate(tableName);
  if ( date.size() ) {
    if ( sqlFull.size() ) sqlFull += " and ";
    sqlFull += fRollbackDates.GetType(tableName);
    sqlFull += " < \'";
    sqlFull += date;
    sqlFull += "\'";
  }

  proxy->SetSqlCondition(sqlFull);
}

//.....................................................................

void DbiTableProxyRegistry::ClearRollbackDates() {

  fRollbackDates.Clear();
  this->ApplySqlCondition();
}

//.....................................................................

void DbiTableProxyRegistry::ClearSimFlagAssociation() {

  fSimFlagAss.Clear();
}
//.....................................................................

void DbiTableProxyRegistry::Config() {
//
//
//  Purpose:  Reconfigure after internal registry update.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 

//  Program Notes:-
//  =============

//  None.

  Registry& reg = this->GetConfig();

  //Load up SimFlag Associations and remove them from the Registry.
  fSimFlagAss.Set(reg);

  //Load up Rollback dates and remove them from the Registry.
  fRollbackDates.Set(reg);

  //Apply any rollback now in force.
  this->ApplySqlCondition();

  // If Level 2 cache enabled establish working directory 
  // for DbiBinaryFile. 
  const char*  dir;
  if ( reg.Get("Level2Cache",dir) ) {
    // Expand any environmental variables.
    TString tmp(dir);
    //  March 2004 ExpandPathName returns false even if it works, so test for failure
    //  by looking for an unexpanded symbol.
    gSystem->ExpandPathName(tmp);
    if ( tmp.Contains("$" ) ) {
      dir = "./";
      MSG("Dbi",Msg::kWarning) << "Directory name expansion failed, using "
                             << dir << " instead" << endl;
    }
    else {
      dir = tmp.Data();
    }
    
    DbiBinaryFile::SetWorkDir(dir);
    MSG("Dbi",Msg::kInfo) << "DbiTableProxyRegistry: Setting L2 Cache to: " << dir << endl;
  }

  // Check for request to make all cascade connections permanent
  // and remove from the Registry.

  int connectionsPermanent = 0;
  if ( reg.Get("MakeConnectionsPermanent",connectionsPermanent) ) {
    reg.RemoveKey("MakeConnectionsPermanent");
    Int_t dbNo =fCascader->GetNumDb();
    if ( connectionsPermanent > 0 ) {
      while ( --dbNo >= 0 ) fCascader->SetPermanent(dbNo);
      MSG("Dbi",Msg::kInfo) << "Making all database connections permanent" << endl;
      // Inform DbiServices so that DbiConnection can check when opening new connections.
      DbiServices::fAsciiDBConectionsTemporary = false;
    }
    else {
      while ( --dbNo >= 0 ) fCascader->SetPermanent(dbNo,false);
      MSG("Dbi",Msg::kInfo) << "Forcing all connections, including ASCII DB, to be temporary" << endl;
      // Inform DbiServices so that DbiConnection can check when opening new connections.
      DbiServices::fAsciiDBConectionsTemporary = true;
    }
  }

  // Check for request to order context queries and remove from the Registry.

  int OrderContextQuery = 0;
  if ( reg.Get("OrderContextQuery",OrderContextQuery) ) {
    reg.RemoveKey("OrderContextQuery");
    if ( OrderContextQuery ) {
      DbiServices::fOrderContextQuery = true;
      MSG("Dbi",Msg::kInfo) << "Forcing ordering of all context queries" << endl;
    }
  }

  // Abort if Registry contains any unknown keys

  const char* knownKeys[]   = { "Level2Cache",
                                "Shutdown" };
  int numKnownKeys          = sizeof(knownKeys)/sizeof(char*);
  bool hasUnknownKeys       = false;

  Registry::RegistryKey keyItr(&this->GetConfig());
  while ( const char* foundKey = keyItr() ) {
    bool keyUnknown = true;
    for (int keyNum = 0; keyNum < numKnownKeys; ++keyNum ) {
      if ( ! strcmp(foundKey,knownKeys[keyNum]) ) keyUnknown = false;
    }
    if ( keyUnknown ) {
       MSG("Dbi",Msg::kFatal) 
        << "Illegal registry item: " << foundKey << endl;
       hasUnknownKeys = true;
    }
  }

  if ( hasUnknownKeys ) {
    MSG("Dbi",Msg::kFatal) << "Aborting due to illegal registry items." << endl;
    abort();
  }
}

//.....................................................................

DbiTableProxy& DbiTableProxyRegistry::GetTableProxy
                                    (const std::string& tableNameReq, 
                                     const DbiTableRow* tableRow) {
//
//
//  Purpose:  Locate, or if necessary create, DbiTableProxy for 
//            named table. 
//
//  Arguments: 
//    tableNameReq in    Name of table requested.
//    tableRow     in    Example of a Table Row object.
//
//  Return:    DbiTableProxy for table. 
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Locate, or if necessary create, DbiTableProxy for named table.
//
//  o If creating apply prevailing SQL condition.

//  Program Notes:-
//  =============

//  None.

// Assume upper case name if cannot find request.
  std::string tableName = tableNameReq;
  std::string vldSuffix = "Validity";
  if ( ! fCascader->TableExists(tableName + vldSuffix ) ) {
    tableName = UtilString::ToUpper(tableName);
    vldSuffix = "VLD";
  }
  std::string proxyName = tableName;

  proxyName.append("::");
  proxyName.append(tableRow->ClassName());
  DbiTableProxy* qpp = fTPmap[proxyName];
  if ( ! qpp ) {
    qpp = new DbiTableProxy(fCascader,tableName,vldSuffix,tableRow);
    this->ApplySqlCondition(qpp);
    fTPmap[proxyName] = qpp;
  }

  return *qpp;

}

//.....................................................................

Bool_t DbiTableProxyRegistry::HasRowCounter(const std::string& tableName) {
//
//
//  Purpose:  Test to see if table has a ROW_COUNTER column.
//
//  Arguments: 
//    tableName    in    Name of table to be checked.
//
//  Return:    true of table has ROW_COUNTER.

//  Program Notes:-
//  =============

//  This is a temporary method to help migration to main tables 
//  with a primary key (SEQNO,ROW_COUNTER) by providing a simple
//  way for clients to detect if any specific table has migrated
//  and adapt accordingly.

//  Once migration is complete, this method will be withdrawn as
//  it should not be needed and creates otherwise useless DbiTableProxys.

  DbiConfigSet cfs;
  DbiTableProxy& tp = this->GetTableProxy(tableName,&cfs);
  return tp.GetMetaData().HasRowCounter();

}

//.....................................................................

DbiTableProxyRegistry& DbiTableProxyRegistry::Instance() {
//
//
//  Purpose: Locate, or create, DbiTableProxyRegistry singleton.   
//
//  Arguments:     None.
//
//  Return:    DbiTableProxyRegistry singleton. 
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Locate, or if necessary create, DbiTableProxyRegistry singleton.

//  Program Notes:-
//  =============

//  None.

  if ( ! fgInstance ) {
// Delete is handled by Cleaner class based on #include count
    fgInstance = new DbiTableProxyRegistry();
  }
  return *fgInstance;

}

//.....................................................................

void DbiTableProxyRegistry::PurgeCaches() {
//
//
//  Purpose: Purge all caches.
//
//  Arguments: 
//    None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Purge all caches.


//  Program Notes:-
//  =============

//  None.

// Pruge all caches.

  for ( std::map<std::string,DbiTableProxy*>::iterator itr = fTPmap.begin();
        itr != fTPmap.end();
        ++itr) {
    DbiTableProxy* tp = (*itr).second;
    tp->GetCache()->Purge();
  }

}

//.....................................................................

void DbiTableProxyRegistry::RefreshMetaData(const std::string& tableName) {
//
//
//  Purpose: Refresh meta data for specied table.
//
//  Arguments: 
//    tableName    in    Name of table to be refreshed.


//  Program Notes:-
//  =============

//  This method is currently only used by DbiSqlValPacket after
//  it has created a new table in the database.  In such cases
//  the pre-existing corresponding DbiTableProxy has to be refreshed.

  std::map<std::string,DbiTableProxy*>::iterator itr = fTPmap.begin();
  std::map<std::string,DbiTableProxy*>::iterator itrEnd = fTPmap.end();
  for ( ; itr != itrEnd; ++itr) {
    DbiTableProxy* table = (*itr).second;
    if ( table && table->GetTableName() == tableName ) table->RefreshMetaData();
  }

}
//.....................................................................

void DbiTableProxyRegistry::SetConfigFromEnvironment() {
//
//
//  Purpose:  Set up configuration from ENV_DBI environmental variable
//            which consists of a semi-colon separated list of DBI
//            configuration requests.

  const char* strENV_DBI = gSystem->Getenv("ENV_DBI");
  if ( strENV_DBI == 0  || strlen(strENV_DBI) == 0 ) return;

  MSG("Dbi",Msg::kInfo) << "\nConfiguring DatabaseInterface from the environmental "
             << "variable ENV_DBI:-\n  " << strENV_DBI << endl;
  std::vector<std::string> configRequests;
  UtilString::StringTok(configRequests, strENV_DBI, ";");

  for (unsigned entry = 0; entry < configRequests.size(); ++entry ) 
                  this->Set(configRequests[entry].c_str());
  this->Update();
}

//.....................................................................

void DbiTableProxyRegistry::SetSqlCondition(const std::string& sql) {
//
//
//  Purpose: Record and apply global SQL condition.
//
//  Arguments: 
//    sql          in    SQL condition string (excluding where).
//
//                       See Program Notes.
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Record global SQL condition and apply to existing DbiTableProxys.


//  Program Notes:-
//  =============

//  The SQL condition must behave as a single expression as 
//  additional conditions e.g. rollback, may be appended using
// AND.  This means that if the expression contains sub-expressions
//  combined using OR, then the entire expression should be enclosed
//  in parentheses.


  fSqlCondition = sql;
  this->ApplySqlCondition();
}

//.....................................................................

void DbiTableProxyRegistry::ShowStatistics() const {
//
//
//  Purpose:  Show total statistics.
//
//  Contact:   N. West

  MsgStream msg = MSGSTREAM("Dbi",Msg::kInfo);
  msg << "\n\nCache statistics:-\n\n"
      << "Table Name                             "
      << "    Current   Maximum     Total     Total\n"
      << "                                       "
      << "       Size      Size   Adopted    Reused" << endl;
  
// Loop over all owned objects.

  for ( std::map<std::string,DbiTableProxy*>::const_iterator itr = fTPmap.begin();
        itr != fTPmap.end();
        ++itr) {
    const DbiTableProxy* tp = (*itr).second;
    std::string name = (*itr).first;
    if ( name.size() < 40 ) name.append(40-name.size(),' ');
    msg << name;
//  Only want to look at cache so by-pass constness.
    const_cast<DbiTableProxy*>(tp)->GetCache()->ShowStatistics(msg);
   msg << endl;
  }
  msg << "\n" << endl;

//  Only want to look at cascader so by-pass constness.

  MSG("Dbi",Msg::kInfo) << const_cast<DbiTableProxyRegistry*>(this)->GetCascader();


}

---