DbiConnection.cxx

Go to the documentation of this file.

#include <cctype>
#include <cstdlib>
#include <list>
#include <sstream>
#include <string>

#include "TList.h"
#include "TString.h"
#include "TSystem.h"

#include "DatabaseInterface/Dbi.h"
#include "DatabaseInterface/DbiAsciiDbImporter.h"
#include "DatabaseInterface/DbiConnection.h"
#include "DatabaseInterface/DbiExceptionLog.h"
#include "DatabaseInterface/DbiServices.h"
#include "LeakChecker/Lea.h"
#include "MessageService/MsgService.h"

ClassImp(DbiConnection)


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

CVSID("$Id: DbiConnection.cxx,v 1.32 2009/04/18 08:12:37 west Exp $");

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

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

DbiConnection::DbiConnection(const std::string& url      /* = "" */,
                             const std::string& user     /* = "" */,
                             const std::string& password /* = "" */) :

fUrl(url.c_str()),
fUser(user),
fPassword(password),
fUrlValidated(false),
fNumConnectedStatements(0),
fIsTemporary(true),
fServer(0),
fDbType(Dbi::kUnknownDbType)
{
//
//
//  Purpose:  Default constructor

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) << "Creating DbiConnection" << endl;

  if ( this->Open() ) {
    MSG("Dbi",Msg::kInfo) 
          << "Successfully opened connection to: " << this->GetUrl() << endl;
    fUrlValidated =  true;

    // Initialise the list existing supported tables.
    this->SetTableExists();

    string productName(fServer->GetDBMS());
    if      ( productName == "MySQL"    ) fDbType = Dbi::kMySQL;   
    else if ( productName == "Oracle"   ) fDbType = Dbi::kOracle;
    else {
       MAXMSG("Dbi",Msg::kError,20) 
         << "Cannot determine DB type from name: " <<  productName 
         << "\nWill assume MySQL, but it will probably end in tears!" << endl;
      fDbType = Dbi::kMySQL;
    }

    //  If URL looks O.K., check that both client and server support prepared statements.
    if ( fUrlValidated ) {
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,9)
      if ( ! fServer->HasStatement() ) {
#else
      if ( ! fServer->IsSupportStatement() ) {
#endif
        MSG("Dbi",Msg::kError) << "  This client does not support prepared statements." << endl;
        fUrlValidated = false;
      }
      std::string serverInfo(fServer->ServerInfo());
      if ( fDbType == Dbi::kMySQL &&  serverInfo < "4.1" ) {
        MSG("Dbi",Msg::kError) << "This MySQL server (" << serverInfo
                             << ") does not support prepared statements." << endl;
        fUrlValidated = false;
      }
      if ( fUrlValidated ) {
        MSG("Dbi",Msg::kInfo) << "This client, and MySQL server (" << serverInfo
                             << ") does support prepared statements." << endl;
      }
      else {

        MSG("Dbi",Msg::kError) << "\n"
           << "This version of MySQL does not support prepared statements.\n"
           << "\n"
           << "Please upgrade to MySQL (client and server) version 4.1 or greater \n"
           << "\n"
           << endl;
      }

    }
    if ( ! fUrlValidated ) {
      MSG("Dbi",Msg::kFatal) << "Aborting due to above errors" << endl;
      exit(1);
    }

  }

  fDbName = fUrl.GetFile();

}

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

DbiConnection::~DbiConnection() {
//
//
//  Purpose: Destructor

  LEA_DTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) << "Destroying DbiConnection" << endl;
  this->Close(true);

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

Bool_t DbiConnection::Close(Bool_t force /* = false */ ) {
//
//
//  Purpose: Close server connection unless active (or always if forced) . 
//
//  Return:  true if connection now closed. 

  this->ClearExceptionLog();
  if ( this->IsClosed() ) return true;

  if ( fNumConnectedStatements ) {
    if ( ! force ) {
      MSG("Dbi",Msg::kInfo) << "Unable to close connection: " << this->GetUrl()
                            << "; it still has  "
                            << fNumConnectedStatements << "active statements. " << endl;
      return false;
    }
    MSG("Dbi",Msg::kInfo) << "Closing connection: " << this->GetUrl()
                          << "; even though it still has "
                          << fNumConnectedStatements << " active statements. " << endl;
  }

  delete fServer;
  fServer = 0;
  MSG("Dbi",Msg::kDebug)  << "Closed connection: " << this->GetUrl() << endl;
  return true;

}

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

void DbiConnection::CloseIdleConnection() {
//
//
//  Purpose:  Close idle connection.

  if ( fIsTemporary &&  fNumConnectedStatements == 0 ) this->Close();

}


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

TSQLStatement* DbiConnection::CreatePreparedStatement(const std::string& sql) {
//
//
//  Purpose:  Open if necessary and get a prepared statment.
//
//  Return:    Statement - Caller must take ownership.
//             will be 0 if failure.

  TSQLStatement* stmt = 0;
  if ( ! this->Open() ) return stmt;
  stmt = fServer->Statement(sql.c_str());
  if ( ! stmt ) {
    fExceptionLog.AddEntry(*fServer);
  }
  else stmt->EnableErrorOutput(false);

  return stmt;
}
//.....................................................................

TSQLServer* DbiConnection::GetServer() {
//
//
//  Purpose:  Open if necessary and get a TSQLServer.
//
//  Return:    Server ( = 0 if connection not open).
//
//  WARNING:  The server returned remains is being borrowed from the
//            DbiConnection and remains under its ownership and must
//            not be deleted.  However the caller must invoke the
//            Connect() method on this DbiConnection before borrowing
//            it and must invoke the DisConnect() when it has finished
//            using it to ensure the DbiConnection does not close it
//            prematurely i.e.:-
//
//            void Demo(DbiConnection* con) {
//              con->Connect();
//              TSQLServer* server = con->GetServer();
//              // Do stuff
//              con->DisConnect();
//            }

  if ( ! this->Open() ) return 0;
  return fServer;
}

//.....................................................................
const std::string& DbiConnection::GetUrl() const {

  // Don't ask me why TUrl::GetUrl() is non-const, just accept that it is!

  // Note: This function returns a reference to a shared string; use the
  //       value or make a copy of it before any subsequent call to this
  //       function.

  static std::string url;
  url = const_cast<DbiConnection*>(this)->fUrl.GetUrl();
  return url;

}

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

Bool_t DbiConnection::Open() {
//
//  Purpose:  Open connection if necessary.
//

  this->ClearExceptionLog();
  if ( ! this->IsClosed() ) return true;

  if ( ! fUrl.IsValid() ) {
    ostringstream oss;
    oss << "Unable to open connection: URL '" << fUrl.GetUrl() << "' is invalid";
    MAXMSG("Dbi",Msg::kError,20) << oss.str() << endl;
    fExceptionLog.AddEntry(oss.str());
    return false;
  }

  // Make several attempts (or more if URL is known to be O.K.) to open connection.
  int maxAttempt = fUrlValidated ? 100 : 20; 
  for (int attempt = 1; attempt <= maxAttempt; ++attempt) {
    fServer = TSQLServer::Connect(fUrl.GetUrl(),fUser.c_str(),fPassword.c_str()); 
    if ( ! fServer ) {
      ostringstream oss;
      oss << "Failing to open: " << fUrl.GetUrl() << " for user " << fUser
          << " and password " << fPassword << " (attempt " << attempt << ")";
      fExceptionLog.AddEntry(oss.str());
      if ( attempt == 1 ) {
        MAXMSG("Dbi",Msg::kError,20) << oss.str() << " retrying ... " << endl;
      }
      gSystem->Sleep(attempt*1000);
    }

    else {
      fServer->EnableErrorOutput(false);
      if ( attempt > 1 ) MSG("Dbi",Msg::kWarning)  << "... Connection opened on attempt " << attempt << endl;
      MSG("Dbi",Msg::kDebug)
        << "Successfully opened connection to: " << fUrl.GetUrl() << endl;

      // If this is an ASCII database, populate it and make the connection permanent
      // unless even ASCII DB connections are temporary.

      TString ascii_file = fUrl.GetAnchor();
      if ( ascii_file.IsNull() ) return true;
      gSystem->Setenv("DBI_CATALOGUE_PATH",gSystem->DirName(fUrl.GetAnchor()));
      DbiAsciiDbImporter importer(ascii_file,fServer);
      const DbiExceptionLog& el(importer.GetExceptionLog());
      if ( ! el.IsEmpty() ) {
        MSG("Dbi",Msg::kError) << "Failed to populate ASCII database from " << fUrl.GetUrl() << "\n"
                               << el << endl;
        delete fServer;
        fServer = 0;
        return false;
      }
      fIsTemporary = DbiServices::AsciiDBConectionsTemporary();
      // Add imported tables names.
      const std::list<std::string> tableNames(importer.GetImportedTableNames());
      std::list<std::string>::const_iterator itr(tableNames.begin()), itrEnd(tableNames.end());
      while ( itr != itrEnd ) {
        this->SetTableExists(*itr);
        ++itr;
      }
      return true;

    }
  }
  MAXMSG("Dbi",Msg::kError,20) 
    << "... Failed to open a connection to: " << fUrl.GetUrl() 
    << " for user " << fUser << " and pwd " << fPassword << endl;
 
  return false;

}

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

Bool_t DbiConnection::PrintExceptionLog(Int_t level) const {
//
//
//  Purpose:  Print all warning at supplied  Msg log level.
//
//  Return:    kTRUE if warnings have occurred

  MSG("Dbi",level) << fExceptionLog;
  return fExceptionLog.Size() != 0;

}

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

void  DbiConnection::RecordException() {
//
//  Purpose:  Record an exception that has occurred while a client was using its TSQLServer.

  fExceptionLog.AddEntry(*fServer);

}

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

void  DbiConnection::SetTableExists(const std::string& tableName) {
//
//  Purpose: Add name to list of existing tables (necessary when creating tables) 
//
//  Note: If tableName is null refresh list from the database.

  if ( tableName == "" ) {
    TSQLStatement* stmt =  CreatePreparedStatement("show tables");
    if ( stmt ) {
      if (stmt->Process()) {
        stmt->StoreResult();
        while (stmt->NextResultRow()) {
          std::string tn(stmt->GetString(0));
          this->SetTableExists(tn);
        }
      }
      delete stmt;
      stmt = 0;
    }
  }
  else {
    if ( ! this->TableExists(tableName) ) {
      fExistingTableList += ",'";
      fExistingTableList += tableName;
      fExistingTableList += "'";
    }
  }
}

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

Bool_t  DbiConnection::TableExists(const std::string& tableName) const {
//
//  Purpose: Check to see table exists in connected database.

  std::string test("'");
  test += tableName;
  test += "'";
  return fExistingTableList.find(test) != std::string::npos;
}

---