---

CdbRooDb.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooDb.cc,v 1.5 2005/10/13 18:49:10 gapon Exp $

/// The implementation of the CdbRooDb singleton.
/**
  * @see CdbRooDb
  */
#include "BaBar/BaBar.hh"

#include "CdbRooDatabase/CdbRooDb.hh"
#include "CdbRooDatabase/CdbRooDatabase.hh"
#include "CdbRooDatabase/CdbRooDbObject.hh"

#include "CdbSQL/CdbSQLApiDatabase.hh"
#include "CdbSQL/CdbSQLApiDatabaseItr.hh"
#include "CdbSQL/CdbSQLObjectId.hh"
#include "CdbSQL/CdbSQLCondition.hh"
#include "CdbSQL/CdbSQLPartition.hh"

#include "CdbMySQL/CdbMySQL.hh"

#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbCondition.hh"
#include "CdbBase/CdbTransactionBase.hh"
#include "CdbBase/CdbDebugStream.hh"

#include "CdbRoo/CdbRooObjectFactory.hh"

#include "BbrStdUtils/Tokenize.hh"
#include "BbrStdUtils/String.hh"
using namespace babar::String;

#include <stdlib.h>     // getenv()
#include <stdio.h>      // sscanf()

#include <string.h>     // strcmp()
#include <assert.h>

#include <TBuffer.h>
#include <TClass.h>

#include <iostream>
using std::cerr;
using std::cout;
using std::endl;

namespace {

  /// Dummy transaction manager
  /**
    * DESIGN NOTE:
    *
    *   At the moment, we don't have a concept of the "transaction" in the current
    *   implementation of the CDB API, However we must provide this manager to comply
    *   with specifications of the technology-neutral CDB API.
    */
    class CdbRooDatabaseTransaction : public CdbTransactionBase {

    public:

        CdbRooDatabaseTransaction( ) : CdbTransactionBase( ) { }

        virtual ~CdbRooDatabaseTransaction( ) { }

        virtual void commitAndHold( ) { }
    };
}

CdbRooDb::CdbRooDb( ) :
    CdbSQLApi( ),
    _isInitialized              (false),    // For the sake of defered initialization
    _myDatabaseImplementationPtr(0),        // Will be set during an actual initialization
    _defaultDatabaseName        ("host=localhost,user=cdb,database=cdb,port=3306"),  // That's what we'll use of CDB_DATABASE_PATH is not found in the environment
    _defaultViewName            ("<local>::<recent>")
{
    CDB_DEBUG_STREAM << "Condition/DB API instantiated for"
                     << " TECHNOLOGY=\"" << CdbRooDatabase::technology( ) << "\""
                     << " IMPLEMENTATION=\"" << CdbRooDatabase::implementation( ) << "\""
                     << endl;

  // Try to register itself in the API registry.
  //
  // NOTE: If the registration will fail then we may probably encounter a fatal
  //       unrecoverable problem with implementations of CDB API. One of the possible
  //       reasons of the falure would be if another implementation of the API has already
  //       registered itself in the dictionary under the same names.

    CdbPtr myPtr = this;

    CdbStatus status = set( myPtr );
    assert( CdbStatus::Success == status );
}

CdbRooDb::~CdbRooDb( )
{ }

const char*
CdbRooDb::technologyName( ) const
{
    return CdbRooDatabase::technology( );
}

const char*
CdbRooDb::implementationName( ) const
{
    return CdbRooDatabase::implementation( );
}

void
CdbRooDb::initialize( )
{
    const char* fatalStr = "CdbRooDb::initialize() -- FATAL.";

    if( !_isInitialized ) {

      // Get the database parameters from an optional environment variable.
      // If it's not found then we're going to use the default path.

        const char* database = getenv( "CDB_DATABASE_PATH" );
        if( 0 != database ) _defaultDatabaseName = database;

      // Translate the current path and establish connection object for the server

        CdbCPtr<CdbSQL> implementationObjectPtr = createImplementationObject( _defaultDatabaseName );
        if( implementationObjectPtr.isNull( )) {
            cout << fatalStr << endl
                 << "    Failed to create an internal implementation object to deal with the specified" << endl
                 << "    server because of the incorrect value of the CDB_DATABASE_PATH environment variable." << endl
                 << "        CDB_DATABASE_PATH : \"" << _defaultDatabaseName << "\"" << endl
                 << "    The valid syntax should be :" << endl
                 << "        [host=<host>[,user=<user>[,database=<database>[,port=<port>]]]]" << endl;
            assert( 0 );
            return;
        }
        _myDatabaseImplementationPtr = implementationObjectPtr;

      // Get the default view from that database

        if( CdbStatus::Success != _myDatabaseImplementationPtr->find_default_view( _defaultViewName )) {
            cout << fatalStr << endl
                 << "    Failed to find the default view name at the specified/default database" << endl
                 << "        CURRENT/DEFAULT DATABASE NAME : \"" << _defaultDatabaseName << "\"" << endl;
            assert( 0 );
            return;
        }
        _isInitialized = true;
    }
}

bool
CdbRooDb::isInitialized( )
{
    return _isInitialized;
}

CdbStatus
CdbRooDb::getDefaultDatabase( std::string& theDatabaseName)
{
    assert( isInitialized( ));

    theDatabaseName = _defaultDatabaseName;

    return CdbStatus::Success;
}

CdbStatus
CdbRooDb::getDefaultView( std::string& theViewName,
                          const char*  theDatabaseName )
{
    assert( isInitialized( ));

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the current default path
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( ! (( 0 == strcmp( theDatabaseName, "<default>" )) ||
               ( 0 == strcmp( theDatabaseName, _defaultDatabaseName.c_str( ))))) break;

      // Return the current default.

        theViewName = _defaultViewName;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbRooDb::setDefaultDatabase( const char* theDatabaseName )
{
    const char* errorStr = "CdbRooDb::setDefaultDatabase() -- ERROR.";

    assert( isInitialized( ));

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the new default path to be checked for the correctness of its syntax
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( 0 == strcmp( theDatabaseName, "<default>" )) {

          // Go along with whatever we already have

            ;

        } else {

          // Try to translate the specified database path, and if it all okay - then use it.

            std::string     database                = theDatabaseName;
            CdbCPtr<CdbSQL> implementationObjectPtr = createImplementationObject( database );

            if( implementationObjectPtr.isNull( )) {

                cout << errorStr << endl
                     << "    Failed to create an internal implementation object to deal with the specified" << endl
                     << "    server because of the incorrect value of the passed database name." << endl
                     << "        DATABASE : \"" << database << "\"" << endl
                     << "    The valid syntax is:" << endl
                     << "        [host=<host>[,user=<user>[,database=<database>[,port=<port>]]]]" << endl;

                result = CdbStatus::IllegalParameters;
                break;
            }
            _defaultDatabaseName         = database;
            _myDatabaseImplementationPtr = implementationObjectPtr;

          // Also reset the view to the new default value as the previous name only made
          // a sense in the scope of its (older) database.

            _defaultViewName = "<local>::<recent>";
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbRooDb::setDefaultView( const char* theViewName,
                               const char* theDatabaseName )
{
    assert( isInitialized( ));

  // This method will checks for the correctness of the database and view names.
  //
  // IMPLEMENTATION NOTE: It will NOT check if specified view is present in the database.
  //                      The reason is that certain operations with CDB may be permitted
  //                      without having finally established database.

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the current default path
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( ! (( 0 == strcmp( theDatabaseName, "<default>" )) ||
               ( 0 == strcmp( theDatabaseName, _defaultDatabaseName.c_str( ))))) break;

      // Verify the view name

        if( 0 == theViewName ) break;

/**
 ** IMPLEMENTATION NOTE: The following code is disabled to allow operations with
 **                      incomplete CDB.
 **
      // Try open the database and the view to check if they both exist.

        CdbDatabasePtr databasePtr;
        if( CdbStatus::Success != findDatabase( databasePtr )) break;

        CdbViewPtr viewPtr;
        if( CdbStatus::Success != databasePtr->findView( viewPtr, theViewName  )) break;
 **
 **/
      // Done

        _defaultViewName = theViewName;

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbRooDb::findDatabase( CdbDatabasePtr& thePtr,
                        const char*     theName )
{
    assert( isInitialized( ));

    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed. The "<default>" string is also allowed
      // since the current implementation maps it onto whatever current default is.
      //
      // IMPLEMENTATION NOTE: This policy may be reconsidered in the future to allow
      //                      connecting to the new database w/o changing the current
      //                      default value.

        std::string defaultDatabaseName;
        if( CdbStatus::Success != getDefaultDatabase( defaultDatabaseName )) break;

        std::string databaseName = defaultDatabaseName;
        if( 0 != theName ) {
            if( 0 != strcmp( "<default>", theName )) {

              // This is a special keyword to be mapped onto whatever default
              // database path name we have.

                ;

            } else {
                databaseName = theName;
            }
        }
        if( databaseName != defaultDatabaseName ) {

            cout << "CdbRooDb::findDatabase( ) -- ERROR" << endl
                 << "    No such database in this implementation:  \"" << databaseName.c_str( )        << "\"" << endl
                 << "    The only name allowed is the default one: \"" << defaultDatabaseName.c_str( ) << "\"" << endl;

            break;
        }

      // NOTE: - the above corrected parameters object is used.
      //       - a smart pointer onto itself is found through the registry.

        CdbPtr selfPtr;
        if( CdbStatus::Success != get( selfPtr,
                                       technologyName( ),
                                       implementationName( ))) {
            cout << "CdbRooDb::findDatabase( ) -- FATAL ERROR" << endl
                 << "    Failed to recover its own instance of the CDB API." << endl
                 << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
                 << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

            assert( 0 );

            break;
        }
        thePtr = new CdbSQLApiDatabase( selfPtr,
                                        databaseName.c_str( ),
                                        _myDatabaseImplementationPtr );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooDb::databaseIterator( CdbDatabaseItr& theItr )
{
    assert( isInitialized( ));

  // Note, that we find its own smart pointer through the Registry

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    CdbPtr selfPtr;
    if( CdbStatus::Success != get( selfPtr,
                                   technologyName( ),
                                   implementationName( ))) {
        cout << "CdbRooDb::databaseIterator( ) -- FATAL ERROR" << endl
             << "    Failed to recover its own instance of the CDB API." << endl
             << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
             << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

        assert( 0 );

        return CdbStatus::Error;
    }
    theItr = CdbDatabaseItr( new CdbSQLApiDatabaseItr( selfPtr ));

    return CdbStatus::Success;
}

CdbTransactionBase*
CdbRooDb::transaction( CdbTransaction::Mode theMode ) const
{
    return new CdbRooDatabaseTransaction( );
}

CdbStatus
CdbRooDb::createObject( CdbObjectPtr&          theObjectPtr,
                        const CdbConditionPtr& theParentConditionPtr,
                        const BdbTime&         theOriginalValidityBeginTime,
                        const BdbTime&         theOriginalValidityEndTime,
                        const BdbTime&         theVisibleValidityBeginTime,
                        const BdbTime&         theVisibleValidityEndTime,
                        const BdbTime&         theDurationBeginTime,
                        const BdbTime&         theDurationEndTime,
                        const BdbTime&         theInsertionTime,
                        const CdbSQLObjectId&  theObjectId )
{
    assert( isInitialized( ));

  // Verify input parameters

//  if( theParentConditionPtr.isNull( )) return CdbStatus::IllegalParameters;
    assert( !theParentConditionPtr.isNull( ));

//  if( theOriginalValidityBeginTime >= theOriginalValidityEndTime ) return CdbStatus::IllegalParameters;
    assert( !( theOriginalValidityBeginTime >= theOriginalValidityEndTime ));

//  if( theVisibleValidityBeginTime  >= theVisibleValidityEndTime  ) return CdbStatus::IllegalParameters;
    assert( !( theVisibleValidityBeginTime  >= theVisibleValidityEndTime  ));

//  if( theDurationBeginTime         >= theDurationEndTime         ) return CdbStatus::IllegalParameters;
    assert( !( theDurationBeginTime         >= theDurationEndTime         ));

//  if( BdbTime::plusInfinity == theInsertionTime ) return CdbStatus::IllegalParameters;
    assert( !( BdbTime::plusInfinity == theInsertionTime ));

//  if( !theObjectId.isValid( )) return CdbStatus::IllegalParameters;
    assert( theObjectId.isValid( ));

  // Create the object

    theObjectPtr = new CdbRooDbObject( theParentConditionPtr,
                                       theOriginalValidityBeginTime,
                                       theOriginalValidityEndTime,
                                       theVisibleValidityBeginTime,
                                       theVisibleValidityEndTime,
                                       theDurationBeginTime,
                                       theDurationEndTime,
                                       theInsertionTime,
                                       theObjectId,
                                       _myDatabaseImplementationPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbRooDb::storeObject( CdbObjectPtr&             theObjectPtr,
                       CdbObjectFactoryBase&     theObjectFactory,
                       CdbCPtr<CdbSQLCondition>& thePersistentConditionPtr,
                       CdbCPtr<CdbSQLPartition>& thePersistentPartitionPtr,
                       const CdbConditionPtr&    theParentConditionPtr,
                       const BdbTime&            theOriginalValidityBeginTime,
                       const BdbTime&            theOriginalValidityEndTime )
{
    const char* errorStr = "CdbRooDb::storeObject() -- ERROR.";

  // Invoke the object creator.
  //
  // DESIGN NOTE:
  //
  //   In the current implementation of the API and its factory objects
  //   the create method will only create a persistent object, which
  //   we will get on the next step and proceed with serizlizing it into
  //   a BLOB and registering in the database. That's why we're passing
  //   an illegal validity interval for the new object. 
  //
  //   The supplied metadata object pointer should be returned 0.

    if( CdbStatus::Success != theObjectFactory.create( theObjectPtr,
                                                       theParentConditionPtr,
                                                       BdbTime::plusInfinity,
                                                       BdbTime::minusInfinity )) {
        cerr << errorStr << "\n"
             << "    Failed to create a persistent object via the supplied factory." << endl;
        return CdbStatus::Error;
    }
    assert( theObjectPtr.isNull( ));

  // Get the actual persistent object which was created above
  //
  // NOTE: Make sure the right type is passed as a factory base.

    CdbRooObjectFactory* objectFactoryPtr = dynamic_cast< CdbRooObjectFactory* >( &theObjectFactory );
    assert( 0 != objectFactoryPtr );

    CdbCPtr<CdbRooObjectR> persistentObjectPtr = objectFactoryPtr->persistentObjectPtr( );
    assert( !persistentObjectPtr.isNull( ));

  // This is going to be the insertion time for the new object

    BdbTime insertionTime( BdbTime::now( ));

  // Serialize the object

    const std::string typeName = persistentObjectPtr->ClassName( );

    TBuffer tBuffer( TBuffer::kWrite );
    if( 1 != tBuffer.WriteObjectAny( persistentObjectPtr.get( ),
                                     CdbRooObjectR::Class( ))) {
        cerr << errorStr << "\n"
             << "    Failed to serialzie an object of type: " << typeName << "\n"
             << "    by a pointer onto its base class: " << CdbRooObjectR::Class( )->GetName( ) << endl;
        return CdbStatus::Error;
    }

  // And store it in the persistent condition
  //
  // NOTE: This operation will also generate a unique persistent object identifier

    CdbSQLObjectId persistentObjectId;

    if( CdbStatus::Success != thePersistentConditionPtr->store_object( persistentObjectId,
                                                                       thePersistentPartitionPtr,
                                                                       theOriginalValidityBeginTime,
                                                                       theOriginalValidityEndTime,
                                                                       insertionTime,
                                                                       typeName,
                                                                       tBuffer.Buffer( ) + tBuffer.GetBufferDisplacement( ),
                                                                       tBuffer.Length( ) )) {
        cerr << errorStr << "\n"
             << "    Failed to store an object of type: " << typeName << endl;
        return CdbStatus::Error;
    }

  // Update partition's modification time if the current condition
  // is the partitionable one.

    if( thePersistentConditionPtr->isPartitionable( )) {
        if( CdbStatus::Success != thePersistentPartitionPtr->update( insertionTime )) {

            cerr << errorStr << errorStr << "\n"
                 << "    Failed to update the partition modification time.\"n"
                 << "        PARTITION ID:   " << thePersistentPartitionPtr->id( ) << "\n"
                 << "        CONDITION NAME: \"" << theParentConditionPtr->name( ) << "\"" << endl;
            return CdbStatus::Error;
        }
    }

  // Produce a transient metadata object for the stored object

    return createObject( theObjectPtr,
                         theParentConditionPtr,
                         theOriginalValidityBeginTime,  // begin of the 'original' validity interval
                         theOriginalValidityEndTime,    // end   of the 'original' validity interval
                         theOriginalValidityBeginTime,  // begin of the 'visible'  validity interval
                         theOriginalValidityEndTime,    // end   of the 'visible'  validity interval
                         insertionTime,                 // begin of the 'duration' interval
                         BdbTime::plusInfinity,         // end   of the 'duration' interval
                         insertionTime,                 // creation time of the object
                         persistentObjectId );
}

CdbCPtr<CdbSQL>
CdbRooDb::createImplementationObject( const std::string& theDatabaseName )
{
    if( theDatabaseName.empty( )) return 0;

    std::string host     = "localhost";
    std::string user     = "cdb";
    std::string database = "cdb";

    unsigned int port = 3306;
    {
        Tokenize    parameters( theDatabaseName );
        std::string parameter;

        while ( !( parameter = parameters( "," )).empty( )) {

            Tokenize key_value( parameter );

            std::string key   = key_value( "=" );
            std::string value = key_value( "=" );

//            cout << "DEBUG: key = \"" << key << "\", value = \"" << value << "\"" << endl;

            if( key.empty( ) || value.empty( )) return 0;

            if( "host" == key ) {
                host = value;
            } else if( "user" == key ) {
                user = value;
            } else if( "database" == key ) {
                database = value;
            } else if( "port" == key ) {
                if( 1 != sscanf( value.c_str( ), "%u", &port )) return 0;
            } else {
                return 0;
            }
        }
    }

  // Create a top-level implementation object
  //
  // NOTE: We expect the database to exist before opening it. The API will operate only
  //       on a properly created and initialized database.

    const bool notExistingDatabaseFlag = false;

    return CdbCPtr<CdbSQL>( new CdbMySQL( host,
                                          user,
                                          notExistingDatabaseFlag,
                                          database,
                                          port ));
}

/////////////////
// End Of File //
/////////////////

---