TDbiDatabaseManager.cxx

Go to the documentation of this file.

// $Id: TDbiDatabaseManager.cxx,v 1.2 2011/06/09 14:44:29 finch Exp $
#include <vector>
#include <cstdlib>

#include "TSystem.h"

#include "TString.h"

#include "TDbiExceptionLog.hxx"
#include "TDbiBinaryFile.hxx"
#include "TDbiCache.hxx"
#include "TDbiCascader.hxx"
#include "TDbiConfigSet.hxx"
#include "TDbiServices.hxx"
#include "TDbiDatabaseManager.hxx"
#include "TSK_DBI_Log.hxx"
#include "TDbiTableProxy.hxx"
#include <MsgFormat.h>
using std::endl;
#include "UtilString.hxx"

ClassImp(TDbiDatabaseManager)

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


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

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

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

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

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

//  None.


// Create cascader for database access.

  fCascader = new TDbiCascader;

// Get any environment configuration.

  this->SetConfigFromEnvironment();

  SK_DBI_Trace( "Creating TDbiDatabaseManager"
    << "  ");


}

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

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



  if (  TDbiExceptionLog::GetGELog().Size() ) {
     SK_DBI_Info( "Database Global Exception Log contains "
          << TDbiExceptionLog::GetGELog().Size() << " entries:-" << "  ");;
     TDbiExceptionLog::GetGELog().Print();
  }

  int shutdown = 0;
  if (    ! this->GetConfig().Get("Shutdown",shutdown)
         || shutdown == 0 ) {
    SK_DBI_Info( "DatabaseInterface shutdown not requested" << "  ");
    return;
  }

  SK_DBI_Info( "DatabaseInterface shutting down..." << "  ");

// Destroy all owned objects.

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

  delete fCascader;
  fCascader = 0;

  SK_DBI_Trace(  "Destroying TDbiDatabaseManager" << "  ");

  SK_DBI_Info( "DatabaseInterface shutdown complete." << "  ");
  TDbiDatabaseManager::fgInstance = 0;

}

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

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

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

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

void TDbiDatabaseManager::ApplySqlCondition(TDbiTableProxy* proxy) const {
//
//
//  Purpose: Apply Sql condition to specific TDbiTableProxy.
//
//  Arguments:
//    proxy        in    TDbiTableProxy 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 += "\'";
  }
  const string& epoch_condition = fEpochRollback.GetEpochCondition(tableName);
  if ( epoch_condition.size() ) {
    if ( sqlFull.size() ) sqlFull += " and ";
    sqlFull += epoch_condition;
  }

  proxy->SetSqlCondition(sqlFull);
}

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

void TDbiDatabaseManager::ClearRollbacks() {

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

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

void TDbiDatabaseManager::ClearSimFlagAssociation() {

  fSimFlagAss.Clear();
}
//.....................................................................
///
///
///  Purpose:  Reconfigure after internal registry update.
///
///
///    Throws  EBadTDbiRegistryKeys()  if TDbiRegistry contains any unknown keys
void TDbiDatabaseManager::Config() {
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o

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

//  None.

  TDbiRegistry& reg = this->GetConfig();

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

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

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

  // If Level 2 cache enabled establish working directory
  // for TDbiBinaryFile.
  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 = "./";
      SK_DBI_Warn( "Directory name expansion failed, using "
                             << dir << " instead" << "  ");
    }
    else {
      dir = tmp.Data();
    }

    TDbiBinaryFile::SetWorkDir(dir);
    SK_DBI_Log( "TDbiDatabaseManager: Setting L2 Cache to: " << dir << "  ");
  }

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

  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);
      SK_DBI_Info( "Making all database connections permanent" << "  ");
      // Inform TDbiServices so that TDbiConnection can check when opening new connections.
      TDbiServices::fAsciiDBConectionsTemporary = false;
    }
    else {
      while ( --dbNo >= 0 ) fCascader->SetPermanent(dbNo,false);
      SK_DBI_Info( "Forcing all connections, including ASCII DB, to be temporary" << "  ");
      // Inform TDbiServices so that TDbiConnection can check when opening new connections.
      TDbiServices::fAsciiDBConectionsTemporary = true;
    }
  }

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

  int OrderContextQuery = 0;
  if ( reg.Get("OrderContextQuery",OrderContextQuery) ) {
    reg.RemoveKey("OrderContextQuery");
    if ( OrderContextQuery ) {
      TDbiServices::fOrderContextQuery = true;
      SK_DBI_Info( "Forcing ordering of all context queries" << "  ");
    }
  }

  // Abort if TDbiRegistry contains any unknown keys

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

  TDbiRegistry::TDbiRegistryKey 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 ) {
     SK_DBI_Severe( "FATAL: "
        << "Illegal registry item: " << foundKey << "  ");
       hasUnknownKeys = true;
    }
  }

  if ( hasUnknownKeys ) {
    SK_DBI_Severe( "FATAL: " << "Aborting due to illegal registry items." << "  ");
    throw  EBadTDbiRegistryKeys();
  }
}

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

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

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

//  None.

// Force upper case name.
  std::string tableName = UtilString::ToUpper(tableNameReq);
  std::string proxyName = tableName;

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

  return *qpp;

}

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

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

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

//  None.

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

}

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

void TDbiDatabaseManager::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,TDbiTableProxy*>::iterator itr = fTPmap.begin();
        itr != fTPmap.end();
        ++itr) {
    TDbiTableProxy* tp = (*itr).second;
    tp->GetCache()->Purge();
  }

}

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

void TDbiDatabaseManager::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 TDbiSqlValPacket after
//  it has created a new table in the database.  In such cases
//  the pre-existing corresponding TDbiTableProxy.hxxas to be refreshed.

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

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

void TDbiDatabaseManager::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;

  SK_DBI_Info( "\nConfiguring DatabaseInterface from the environmental "
             << "variable ENV_DBI:-\n  " << strENV_DBI << "  ");
  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 TDbiDatabaseManager::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 TDbiTableProxys.


//  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 TDbiDatabaseManager::ShowStatistics() const {
//
//
//  Purpose:  Show total statistics.
//
//  Contact:   N. West

}