---

CdbSQLApiDatabase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbSQLApiDatabase.cc,v 1.2 2005/10/22 00:40:54 gapon Exp $

/// The implementation of the CdbSQLApiDatabase class.
/**
  * @see CdbSQLApiDatabase
  */

#include "BaBar/BaBar.hh"

#include "CdbSQL/CdbSQLApiDatabase.hh"
#include "CdbSQL/CdbSQLApiView.hh"
#include "CdbSQL/CdbSQLApiCondition.hh"
#include "CdbSQL/CdbSQL.hh"
#include "CdbSQL/CdbSQLOrigin.hh"
#include "CdbSQL/CdbSQLView.hh"
#include "CdbSQL/CdbSQLPartition.hh"
#include "CdbSQL/CdbSQLCondition.hh"
#include "CdbSQL/CdbSQLConditionAtFolder.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbOrigin.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbProperty.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbCondition.hh"
#include "CdbBase/CdbPartition.hh"
#include "CdbBase/CdbVectorAdapterItr.hh"
#include "CdbBase/CdbEmptyItr.hh"
#include "CdbBase/CdbSimpleVectorAdapterItr.hh"
#include "CdbBase/CdbSTD2CStrAdapterItr.hh"

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

namespace {

  /////////////////////////////////////
  // Class CdbSQLApiPartitionItr //
  /////////////////////////////////////

    class CdbSQLApiPartitionItr : public CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLPartition> > {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        CdbSQLApiPartitionItr( );

      /// The assignment operator (NOT IMPLEMENTED)

        CdbSQLApiPartitionItr& operator=( const CdbSQLApiPartitionItr& );

    protected:

      /// The copy constructor

        CdbSQLApiPartitionItr( const CdbSQLApiPartitionItr& theItr ) :
            CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLPartition> >( theItr )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        CdbSQLApiPartitionItr( const std::vector< CdbCPtr<CdbSQLPartition> >& theList ) :
            CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLPartition> >( theList )
        { }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual CdbIItr<unsigned short>* clone( ) const
        {
            return new CdbSQLApiPartitionItr( *this );
        }

    protected:

      /// User defined translation for the currently reffered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual ValueType toValue( const CdbCPtr<CdbSQLPartition>& thePtr ) const
        {
            return thePtr->id( );
        }
    };

  //////////////////////////////////
  // Class CdbSQLApiPartition //
  //////////////////////////////////

    class CdbSQLApiPartition : public CdbPartition {

    private:

      /// The default constructor (NOT IMPLEMENTED)
      /**
        */
        CdbSQLApiPartition( );

      /// The copy constructor (NOT IMPLEMENTED)
      /**
        * More details to come...
        */
        CdbSQLApiPartition( const CdbSQLApiPartition& thePartition );

      /// The assignment operator (NOT IMPLEMENTED)
      /**
        * More details to come...
        */
        CdbSQLApiPartition& operator=( const CdbSQLApiPartition& thePartition );

    public:

      /// The normal constructor
      /**
        */
        CdbSQLApiPartition( const CdbDatabasePtr&           theDatabasePtr,                      
                            const CdbCPtr<CdbSQLPartition>& thePartitionPtr,
                            const std::string&              theOwnerName );

      /// The destructor
      /**
        * Details...
        */
        virtual ~CdbSQLApiPartition( );

      /// The begin time in the "insertion" dimension
      /**
        * Implements the corresponding method of its base class or an interface.
        *
        * @see CdbPartition::endInsertion()
        */
        virtual BdbTime endInsertion( ) const;

      /// The recent modification time of the partition
      /**
        * Implements the corresponding method of its base class or an interface.
        *
        * @see CdbPartition::modified()
        */
        virtual BdbTime modified( ) const;

      /// The status of the partition
      /**
        * Implements the corresponding method of its base class or an interface.
        *
        * @see CdbPartition::isClosed()
        */
        virtual bool isClosed( ) const;

      /// The status of the partition
      /**
        * Implements the corresponding method of its base class or an interface.
        *
        * @see CdbPartition::isInstantiated()
        */
        virtual bool isInstantiated( ) const;

    private:

        CdbCPtr<CdbSQLPartition> _partitionPtr;
    };

    CdbSQLApiPartition::CdbSQLApiPartition( const CdbDatabasePtr&           theDatabasePtr,
                                            const CdbCPtr<CdbSQLPartition>& thePartitionPtr,
                                            const std::string&              theOwnerName ) :
        CdbPartition( theDatabasePtr,
                      thePartitionPtr->id( ),
                      thePartitionPtr->originId( ),
                      theOwnerName.c_str( ),
                      thePartitionPtr->description( ).c_str( ),
                      thePartitionPtr->created( ),
                      thePartitionPtr->beginValidity( ),
                      thePartitionPtr->endValidity( ),
                      thePartitionPtr->beginInsertion( )),
       _partitionPtr(thePartitionPtr)
    { }

    CdbSQLApiPartition::~CdbSQLApiPartition( )
    { }

    BdbTime 
    CdbSQLApiPartition::endInsertion( ) const
    {
        return _partitionPtr->endInsertion( );
    }

    BdbTime
    CdbSQLApiPartition::modified( ) const
    {
        return _partitionPtr->modified( );
    }

    bool
    CdbSQLApiPartition::isClosed( ) const
    {
        return _partitionPtr->isClosed( );
    }

    bool
    CdbSQLApiPartition::isInstantiated( ) const
    {
        return _partitionPtr->isInstantiated( );
    }

  //////////////////////////////////
  // Class CdbSQLApiOriginItr //
  //////////////////////////////////

    class CdbSQLApiOriginItr : public CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLOrigin> > {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        CdbSQLApiOriginItr( );

      /// The assignment operator (NOT IMPLEMENTED)

        CdbSQLApiOriginItr& operator=( const CdbSQLApiOriginItr& );

    protected:

      /// The copy constructor

        CdbSQLApiOriginItr( const CdbSQLApiOriginItr& theItr ) :
            CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLOrigin> >( theItr )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        CdbSQLApiOriginItr( const std::vector< CdbCPtr<CdbSQLOrigin> >& theList ) :
            CdbVectorAdapterItr<unsigned short, CdbCPtr<CdbSQLOrigin> >( theList )
        { }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual CdbIItr<unsigned short>* clone( ) const
        {
            return new CdbSQLApiOriginItr( *this );
        }

    protected:

      /// User defined translation for the currently reffered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual ValueType toValue( const CdbCPtr<CdbSQLOrigin>& thePtr ) const
        {
            return thePtr->id( );
        }
    };

  ///////////////////////////////
  // Class CdbSQLApiOrigin //
  ///////////////////////////////

  /// An implementation of a transient origin
  /**
    * More details to come...
    */
    class CdbSQLApiOrigin : public CdbOrigin {

    private:

      /// The constructor (NOT IMPLEMENTED)
      /**
        * Is disabled...
        */
        CdbSQLApiOrigin( );

      /// The copy constructor (NOT IMPLEMENTED)
      /**
        * Is disabled...
        */
        CdbSQLApiOrigin( const CdbSQLApiOrigin& theOrigin );

      /// The assignment operator (NOT IMPLEMENTED)
      /**
        * Is disabled...
        */
        CdbSQLApiOrigin& operator=( const CdbSQLApiOrigin& theOrigin );

    public:

      /// The normal constructor.
      /**
        * Initialize context with specified parameters.
        *
        * @see CdbDatabase
        * @see CdbDatabasePtr
        */
        CdbSQLApiOrigin( const CdbDatabasePtr&        theDatabasePtr,   /**< the smart pointer providing a back back link to the parent database object */
                         const CdbCPtr<CdbSQLOrigin>& theOriginPtr      /**< the persistent origin */
                       );

      /// The destructor.
      /**
        * More details...
        */
        virtual ~CdbSQLApiOrigin( );

      /// Obtain the creation time of the origin
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::created()
        */
        virtual BdbTime created( );

      /// Obtain the origin description
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::description()
        */
        virtual std::string description( );

      /// Check if this origin is the local one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isLocal()
        */
        virtual bool isLocal( ) const;

      /// Check if data corresponding to this origin are available in the local database
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isInstantiated()
        */
        virtual bool isInstantiated( ) const;

      /// Check if this origin is the "master" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isMaster()
        */
        virtual bool isMaster( ) const;

      /// Check if this origin is a "slave" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isSlave()
        */
        virtual bool isSlave( ) const;

      /// Check if this origin is a "test" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isTest()
        */
        virtual bool isTest( ) const;

      /// Set up an iterator of properties
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::propertyIterator()
        */
        virtual CdbStatus propertyIterator( CdbItr<CdbProperty>& theItr );

    private:

        CdbCPtr<CdbSQLOrigin> _originPtr;
    };

    CdbSQLApiOrigin::CdbSQLApiOrigin( const CdbDatabasePtr&        theDatabasePtr,
                                      const CdbCPtr<CdbSQLOrigin>& theOriginPtr ) :
        CdbOrigin( theDatabasePtr,
                   theOriginPtr->name( ).c_str( ),
                   theOriginPtr->id( )),
        _originPtr(theOriginPtr)
    { }

    CdbSQLApiOrigin::~CdbSQLApiOrigin( )
    { }

    BdbTime
    CdbSQLApiOrigin::created( )
    {
        return  _originPtr->created( );
    }

    std::string
    CdbSQLApiOrigin::description( )
    {
        return _originPtr->description( );
    }

    bool
    CdbSQLApiOrigin::isLocal( ) const
    {
      // Use parent object to get the local origin's identifier.

        return parent( )->localOrigin( )->id( ) == _originPtr->id( );
    }

    bool
    CdbSQLApiOrigin::isInstantiated( ) const
    {
        return _originPtr->isInstantiated( );
    }

    bool
    CdbSQLApiOrigin::isMaster( ) const
    {
        return _originPtr->type( ) == CdbSQLOrigin::TYPE_MASTER;
    }

    bool
    CdbSQLApiOrigin::isSlave( ) const
    {
        return _originPtr->type( ) == CdbSQLOrigin::TYPE_SLAVE;
    }

    bool
    CdbSQLApiOrigin::isTest( ) const
    {
        return _originPtr->type( ) == CdbSQLOrigin::TYPE_TEST;
    }

    CdbStatus
    CdbSQLApiOrigin::propertyIterator( CdbItr<CdbProperty>& theItr )
    {
        theItr = CdbItr<CdbProperty>( new CdbEmptyItr<CdbProperty>( ));
        return CdbStatus::Success;
    }
}

/////////////////////////////////
// Class CdbSQLApiDatabase //
/////////////////////////////////

CdbDatabase*
CdbSQLApiDatabase::clone( ) const
{
  // Get rid of the "const" to access non-const methods

    CdbSQLApiDatabase* mySelf = const_cast<CdbSQLApiDatabase*>( this );
    return new CdbSQLApiDatabase( mySelf->parent( ),
                                  mySelf->name( ),
                                  _mySQLPtr );
}

CdbSQLApiDatabase::CdbSQLApiDatabase( const CdbPtr&          theCdbPtr,
                                      const char*            theName,
                                      const CdbCPtr<CdbSQL>& theSQLPtr ) :
    CdbDatabase( theCdbPtr,
                 theName ),
    _isValid                (true),
    _isOpen                 (false),
    _cachedLocalOriginAPIPtr(0),
    _mySQLPtr               (theSQLPtr),
    _myMasterSQLOriginPtr   (0),
    _myLocalSQLOriginPtr    (0)
{ }

CdbSQLApiDatabase::~CdbSQLApiDatabase( )
{ }

bool
CdbSQLApiDatabase::isValid( )
{
    return _isValid;
}

bool
CdbSQLApiDatabase::isOpen( )
{
    return _isOpen;
}

CdbStatus
CdbSQLApiDatabase::open( )
{
    const char* errorStr = "CdbSQLApiDatabase::open() - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

        if( ! _isOpen ) {

          // Find and cache local SQL origin

            if( CdbStatus::Success != _mySQLPtr->find_origin( _myLocalSQLOriginPtr, "<local>" )) {
                cout << errorStr << endl
                     << "    Failed to find the local origin. The database was not properly" << endl
                     << "    initialized/loaded." << endl;
                break;
            }

          // Find and cache the master SQL origin

            if( _myLocalSQLOriginPtr->type( ) == CdbSQLOrigin::TYPE_MASTER ) {
                _myMasterSQLOriginPtr = _myLocalSQLOriginPtr;
            } else {
                if( CdbStatus::Success != _mySQLPtr->find_origin( _myMasterSQLOriginPtr, "<master>" )) {
                    cout << errorStr << endl
                         << "    Failed to find the master origin. The database was not properly" << endl
                         << "    initialized/loaded." << endl;
                    break;
                }
            }
            _isOpen = true;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::close( )
{
    if( _isOpen ) {
        _isOpen = false;

        _cachedLocalOriginAPIPtr = 0;

        _myMasterSQLOriginPtr = 0;
        _myLocalSQLOriginPtr  = 0;
    }
    return CdbStatus::Success;
}

BdbTime
CdbSQLApiDatabase::id( )
{

  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return BdbTime::plusInfinity;
    }

  // IMPLEMENTATION NOTE: It has to be a unique identifier of the distributed CDB
  //                      in here. This identifier is most likely a creation time
  //                      of the MASTER CDB.
  //
  //                      Unfortunatelly the current design of SQL tables does not
  //                      provide this information. This issues will be resolved in
  //                      the future.

    return BdbTime::minusInfinity;
}

BdbTime
CdbSQLApiDatabase::created( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return BdbTime::plusInfinity;
    }

  // IMPLEMENTATION NOTE: It has to be a creation time of the local database installation
  //                      in here.
  //
  //                      Unfortunatelly the current design of SQL tables does not
  //                      provide this information. This issues will be resolved in
  //                      the future.

    return BdbTime::minusInfinity;
}

std::string
CdbSQLApiDatabase::description( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return std::string( );
    }

  // IMPLEMENTATION NOTE: It has to be a description of the local database installation
  //                      in here.
  //
  //                      Unfortunatelly the current design of SQL tables does not
  //                      provide this information. This issues will be resolved in
  //                      the future.

    return "";
}

std::string
CdbSQLApiDatabase::defaultView( ) const
{
    return CdbEnvironment::defaultView( parent( )->technologyName( ),
                                        parent( )->implementationName( ),
                                        name( ));
}

CdbStatus
CdbSQLApiDatabase::findView( CdbViewPtr& thePtr,
                             const char* theName )
{
    const char* errorStr = "CdbSQLApiDatabase::findView(name) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed.

        std::string viewName = defaultView( );
        if( 0 != theName ) viewName = theName;

        CdbCompositeName vName( viewName.c_str( ));
        if( !vName.isValid( )) {
            cout << errorStr << endl
                 << "    The view name passed to the procedure has invalid format: \"" << viewName.c_str( ) << "\"" << endl;
            break;
        }

      // Extract origin name and local view names

        std::string originName    = vName.first( );
        std::string localViewName = vName.last( );

      // Find a persistent origin where the specified view is supposed to belong to.

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    originName )) {
            cout << errorStr << endl
                 << "    An owner origin for the specified view was not found." << endl
                 << "        VIEW NAME : \"" << theName << "\"." << endl;
            break;
        }

      // Find the view by its name in the scope of the origin.
      //
      // NOTE: Watch for side track in case if view nicknames are used.

        CdbCPtr<CdbSQLView> viewPtr;

        if( "<recent>" == localViewName ) {

            CdbStatus status = originPtr->find_view( viewPtr );
            if( CdbStatus::Success != status ) {
                result = status;
                break;
            }

        } else {

            CdbStatus status = originPtr->find_view( viewPtr,
                                                     localViewName );
            if( CdbStatus::Success != status ) {
                result = status;
                break;
            }
        }

      // Construct the transient API object

        thePtr = new CdbSQLApiView( CdbDatabasePtr( this->clone( )),
                                    viewName.c_str( ),
                                    CdbId( originPtr->id( ),
                                           viewPtr->id( )),
                                    viewPtr,
                                    _myMasterSQLOriginPtr,
                                    _myLocalSQLOriginPtr );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::findView( CdbViewPtr&  thePtr,
                             const CdbId& theId )
{
    const char* errorStr = "CdbSQLApiDatabase::findView(id) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find a persistent origin where the specified view is supposed to belong to.

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    theId.origin )) {
            cout << errorStr << endl
                 << "    An owner origin for the specified view was not found." << endl
                 << "        VIEW ID : " << theId << "." << endl;
            break;
        }

      // Find the view by its identifier in the scope of the origin.

        CdbCPtr<CdbSQLView> viewPtr;
        {
            CdbStatus status = originPtr->find_view( viewPtr,
                                                     theId.local );
            if( CdbStatus::Success != status ) {
                result = status;
                break;
            }
        }

      // Build the full name of the view

        std::string viewName = originPtr->name( ) + "::" + viewPtr->name( );

      // Construct the transient CDB API object

        thePtr = new CdbSQLApiView( CdbDatabasePtr( this->clone( )),
                                    viewName.c_str( ),
                                    theId,
                                    viewPtr,
                                    _myMasterSQLOriginPtr,
                                    _myLocalSQLOriginPtr );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::viewIterator( CdbViewItr& theItr )
{
    const char* errorStr = "CdbSQLApiDatabase::viewIterator() -- ERROR" ;

    CdbStatus status = CdbStatus::Error;

   // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Get a list of all origins where the view will be extracted from

    std::vector< CdbCPtr<CdbSQLOrigin> > vectorOfOrigins;

    if( CdbStatus::Success != ( status = _mySQLPtr->origins( vectorOfOrigins ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to get a list of origins in a scope of the database." << endl
                      << "        DATABASE : \"" << name( ) << "\"" << endmsg;
        return status;
    }

  // Buuild a list of full names of all views in the found origins.

    std::vector< std::string > vectorOfAllViews;

    for( std::vector< CdbCPtr<CdbSQLOrigin> >::const_iterator originItr = vectorOfOrigins.begin( );
                                                              originItr != vectorOfOrigins.end( );
                                                            ++originItr ) {
        CdbCPtr<CdbSQLOrigin> originPtr = *originItr;

      // Skip the origin if it's not instantiated yet

        if( !originPtr->isInstantiated( )) continue;

        std::vector< CdbCPtr<CdbSQLView> > vectorOfViews;

        if( CdbStatus::Success != ( status = originPtr->views( vectorOfViews ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to get a list of views in a scope of the origin." << endl
                          << "        DATABASE : \"" << name( ) << "\"" << endl
                          << "        ORIGIN   : \"" << originPtr->name( ) << "\"" << endmsg;
            return status;
        }
        for( std::vector< CdbCPtr<CdbSQLView> >::const_iterator viewItr = vectorOfViews.begin( );
                                                                viewItr != vectorOfViews.end( );
                                                              ++viewItr ) {
            CdbCPtr<CdbSQLView> viewPtr = *viewItr;

            vectorOfAllViews.push_back( CdbCompositeName( originPtr->name( ).c_str( ),
                                                          viewPtr->name( ).c_str( )).getName( ));
        }
    }

  // Turn the vector into the iterator

    theItr = CdbViewItr( new CdbSTD2CStrAdapterItr( new CdbSimpleVectorAdapterItr< std::string >( vectorOfAllViews )));

    return CdbStatus::Success;
}


CdbStatus
CdbSQLApiDatabase::physicalConditionIterator( CdbItr<CdbId>& theItr )
{
    const char* errorStr = "CdbSQLApiDatabase::physicalConditionIterator() -- ERROR" ;

    CdbStatus result = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != ( result = open( ))) return result;

  // Find all physical conditions and put their 'global physical identifiers'
  // into thsi vector.

    std::vector< CdbId > vectorOfIds;

    std::vector< CdbCPtr<CdbSQLOrigin> > vectorOfOrigins;

    if( CdbStatus::Success != ( result = _mySQLPtr->origins( vectorOfOrigins ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to obtain a list of origins." << endmsg;
        return result;
    }
    for( std::vector< CdbCPtr<CdbSQLOrigin> >::const_iterator originItr = vectorOfOrigins.begin( );
                                                              originItr != vectorOfOrigins.end( );
                                                            ++originItr ) {

        CdbCPtr<CdbSQLOrigin> originPtr = *originItr;

      // Skip the origin if it's not instantiated yet

        if( !originPtr->isInstantiated( )) continue;

      // Get all conditions in that origin.

        std::vector< CdbCPtr<CdbSQLCondition> > vectorOfConditions;

        if( CdbStatus::Success != ( result = originPtr->conditions( vectorOfConditions ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to obtain a list of 'physical' conditions in the origin" << endl
                          << "        ORIGIN ID:" << originPtr->id( ) << "." << endmsg;
            return result;
        }
        for( std::vector< CdbCPtr<CdbSQLCondition> >::const_iterator conditionItr = vectorOfConditions.begin( );
                                                                     conditionItr != vectorOfConditions.end( );
                                                                   ++conditionItr ) {
            CdbCPtr<CdbSQLCondition> conditionPtr = *conditionItr;

          // Create a record

            vectorOfIds.push_back( CdbId( originPtr->id( ),
                                          conditionPtr->id( )));
        }
    }

  // Build an iterator out of the vector

    theItr = CdbItr<CdbId>( new CdbSimpleVectorAdapterItr<CdbId>( vectorOfIds ));

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findCondition( CdbConditionPtr& thePtr,
                                  const CdbId&     theId )
{
    const char* errorStr = "CdbSQLApiDatabase::findCondition('physical address') -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find a persistent origin where the specified physical condition
      // is supposed to belong to.

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    theId.origin )) {
            cout << errorStr << endl
                 << "    An owner origin for the specified condition was not found." << endl
                 << "        VIEW ID : " << theId << "." << endl;
            break;
        }

      // Find the condition by its identifier in the scope of the origin.

        CdbCPtr<CdbSQLCondition> conditionPtr;
        {
            CdbStatus status = originPtr->find_condition( conditionPtr,
                                                          theId.local );
            if( CdbStatus::Success != status ) {
                result = status;
                break;
            }
        }

      // Build the full name of the condition

        std::string conditionName = originPtr->name( ) + "::" + conditionPtr->name( );

      // DESIGN NOTE: The condition API component is going to be disjoined from
      //              any view or a folder. The direct database pointer will be added instead.

        CdbFolderPtr                     parentFolderPtr      = 0;
        CdbCPtr<CdbSQLConditionAtFolder> conditionAtFolderPtr = 0;

      // Construct the transient CDB API object

        thePtr = new CdbSQLApiCondition( parentFolderPtr,
                                         CdbDatabasePtr( this->clone( )),
                                         conditionName.c_str( ),
                                         conditionAtFolderPtr,
                                         conditionPtr,
                                         _myMasterSQLOriginPtr,
                                         _myLocalSQLOriginPtr );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::findCondition( CdbConditionPtr&        thePtr,
                                  const CdbCompositeName& thePhysicalName )
{
    const char* errorStr = "CdbSQLApiDatabase::findCondition('physical name') -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Verify parameters

        if( !thePhysicalName.isValid( )) {
            cout << errorStr << endl
                 << "    The 'physical name' name passed to the procedure has invalid format: \"" << thePhysicalName.getName( ).c_str( ) << "\"" << endl;
            break;
        }

      // Extract origin name and local condition names

        std::string originName         = thePhysicalName.first( );
        std::string localConditionName = thePhysicalName.last( );

      // Find a persistent origin where the specified 'physical' condition
      // is supposed to belong to.

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    originName )) {
            cout << errorStr << endl
                 << "    An owner origin for the specified 'physical' condition was not found." << endl
                 << "        CONDITION NAME : \"" << thePhysicalName.getName( ) << "\"." << endl;
            break;
        }

      // Find the condition by its name in the scope of the origin.

        CdbCPtr<CdbSQLCondition> conditionPtr;
        {
            CdbStatus status = originPtr->find_condition( conditionPtr,
                                                          localConditionName );
            if( CdbStatus::Success != status ) {
                result = status;
                break;
            }
        }

      // DESIGN NOTE: The condition API component is going to be disjoined from
      //              any view or a folder. The direct database pointer will be added instead.

        CdbFolderPtr                     parentFolderPtr      = 0;
        CdbCPtr<CdbSQLConditionAtFolder> conditionAtFolderPtr = 0;

      // Construct the transient CDB API object

        thePtr = new CdbSQLApiCondition( parentFolderPtr,
                                         CdbDatabasePtr( this->clone( )),
                                         thePhysicalName.getName( ).c_str( ),
                                         conditionAtFolderPtr,
                                         conditionPtr,
                                         _myMasterSQLOriginPtr,
                                         _myLocalSQLOriginPtr );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::historyEventIterator( CdbHistoryEventItr& theItr,
                                         const BdbTime&      theBeginTime,
                                         const BdbTime&      theEndTime,
                                         const char**        theEventsToSelect )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbSQLApiDatabase::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbSQLApiDatabase::partitionIterator( CdbItr<unsigned short>& theItr )
{
    const char* errorStr = "CdbSQLApiDatabase::partitionIterator() -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Get a list of all known partition from the MASTER origin. This list will be used
      // by an iterator to be constructed at the next stage.

        std::vector< CdbCPtr<CdbSQLPartition> > partitions;
        if( CdbStatus::Success != _myMasterSQLOriginPtr->partitions( partitions )) {
            cout << errorStr << endl
                 << "    Failed to obtain a list of known partitions from MASTER." << endl;
            return CdbStatus::Error;
        }

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

        theItr = CdbItr<unsigned short>( new CdbSQLApiPartitionItr( partitions ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                      unsigned int            theOriginId )
{
    const char* errorStr = "CdbSQLApiDatabase::partitionIterator(by origin id) - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding persistent origin by its identifier

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    theOriginId )) {
            cout << errorStr << endl
                 << "    Failed to find the specified origin." << endl
                 << "        ORIGIN ID : " << theOriginId << "." << endl;
            break;
        }

      // Get a list of all known partition from the found origin. This list will be used
      // by an iterator to be constructed at the next stage.

        std::vector< CdbCPtr<CdbSQLPartition> > partitions;
        if( CdbStatus::Success != originPtr->partitions( partitions )) {
            cout << errorStr << endl
                 << "    Failed to obtain a list of known partitions from the specified origin." << endl
                 << "        ORIGIN ID : " << theOriginId << "." << endl;
            return CdbStatus::Error;
        }

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

        theItr = CdbItr<unsigned short>( new CdbSQLApiPartitionItr( partitions ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                      const char*             theOriginName )
{
    const char* errorStr = "CdbSQLApiDatabase::partitionIterator(by origin name) - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding persistent origin by its name

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    theOriginName )) {
            cout << errorStr << endl
                 << "    Failed to find the specified origin." << endl
                 << "        ORIGIN NAME : \"" << theOriginName << "\"." << endl;
            break;
        }

      // Get a list of all known partition from the found origin. This list will be used
      // by an iterator to be constructed at the next stage.

        std::vector< CdbCPtr<CdbSQLPartition> > partitions;
        if( CdbStatus::Success != originPtr->partitions( partitions )) {
            cout << errorStr << endl
                 << "    Failed to obtain a list of known partitions from the specified origin." << endl
                 << "        ORIGIN NAME : \"" << theOriginName << "\"." << endl;
            return CdbStatus::Error;
        }

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

        theItr = CdbItr<unsigned short>( new CdbSQLApiPartitionItr( partitions ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::findPartition( CdbPartitionPtr& thePtr,
                                  unsigned short   thePartitionId )
{
    const char* errorStr = "CdbSQLApiDatabase::findPartition() -- ERROR" ;

    CdbStatus status = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Find specified partition
  //
  // NOTE: This algorithm will use partition object from the local
  //       origin if it will discover that the partition belongs to the current
  //       database. This is a typical scenario for the SLAVE type databases.

    CdbCPtr<CdbSQLPartition> partitionPtr;
    {
      // First step is to find the partition in MASTER where all partitions
      // are described.

        if( CdbStatus::Success != ( status = _myMasterSQLOriginPtr->find_partition( partitionPtr,
                                                                                    thePartitionId ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find the specified partition in the MASTER Registry." << endl
                          << "        PARTITION ID: " << thePartitionId << endmsg;
            return status;
        }

      // Refind the search if it's a local partition and the local origin is
      // not the MASTER one.

        if( partitionPtr->originId( ) != _myMasterSQLOriginPtr->id( )) {
            if( partitionPtr->originId( ) == _myLocalSQLOriginPtr->id( )) {

                if( CdbStatus::Success != ( status = _myLocalSQLOriginPtr->find_partition( partitionPtr,
                                                                                           thePartitionId ))) {
                    ErrMsg(error) << errorStr << endl
                                  << "    Failed to find partition with ID=" << thePartitionId << " at the current" << endl
                                  << "    database to whom the partition is supposed to belong to. The database" << endl
                                  << "    may not be properly initialized/loaded." << endl
                                  << "        ORIGIN NAME  : \"" << _myLocalSQLOriginPtr->name( ) << "\"" << endl
                                  << "        PARTITION ID : " << thePartitionId << endmsg;
                    return status;
                }
            }
        }
    }

  // Get the owner's origin name of this partition.

    std::string ownerOriginName;
    {
        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                               partitionPtr->originId( )))) {
            ErrMsg(error) << errorStr << endl
                          << "    There is no information on the origin ID=" << partitionPtr->originId( ) << endl
                          << "    in the corresponding collection of the MASTER's registry." << endl
                          << "    The database may be corrupted or in an inconsistent state." << endmsg;
            return status;
        }
        ownerOriginName = originPtr->name( );
    }

  // Construct the transient CDB API object

    thePtr = new CdbSQLApiPartition( CdbDatabasePtr( this->clone( )),
                                     partitionPtr,
                                     ownerOriginName );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findPartition( CdbPartitionPtr& thePtr,
                                  unsigned short   thePartitionId,
                                  unsigned int     theOriginId )
{
    const char* errorStr = "CdbSQLApiDatabase::findPartition(by origin id) -- ERROR" ;

    CdbStatus status = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Find the corresponding persistent origin

    CdbCPtr<CdbSQLOrigin> originPtr;
    if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                           theOriginId ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to find the origin." << endl
                      << "        ORIGIN    : " << theOriginId << endmsg;
        return status;
    }

  // Find the specified partition in the scope of the found origin

    CdbCPtr<CdbSQLPartition> partitionPtr;
    if( CdbStatus::Success != ( status = originPtr->find_partition( partitionPtr,
                                                                    thePartitionId ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to find the partition in a scope of the specified origin." << endl
                      << "        ORIGIN    : " << theOriginId << endl
                      << "        PARTITION : " << thePartitionId << endmsg;
        return status;
    }

  // Get the owner's origin name of this partition.

    std::string ownerOriginName;
    {
        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                               partitionPtr->originId( )))) {
            ErrMsg(error) << errorStr << endl
                          << "    There is no information on the origin ID=" << partitionPtr->originId( ) << endl
                          << "    in the corresponding collection of the MASTER's registry." << endl
                          << "    The database may be corrupted or in an inconsistent state." << endmsg;
            return status;
        }
        ownerOriginName = originPtr->name( );
    }

  // Construct the transient CDB API object

    thePtr = new CdbSQLApiPartition( CdbDatabasePtr( this->clone( )),
                                     partitionPtr,
                                     ownerOriginName );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findPartition( CdbPartitionPtr& thePtr,
                                  unsigned short   thePartitionId,
                                  const char*      theOriginName )
{
    const char* errorStr = "CdbSQLApiDatabase::findPartition(by origin name) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding persistent origin

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != findOriginObject( originPtr,
                                                    theOriginName )) {
            cout << errorStr << endl
                 << "    Failed to find the origin with NAME=\"" << theOriginName << "\"." << endl;
            break;
        }

      // Delegate the rest of the procedure to a similar method using
      // the identifier.

        result = findPartition( thePtr,
                                thePartitionId,
                                originPtr->id( ));
    } while( false );

    return result;
}

CdbOriginPtr
CdbSQLApiDatabase::localOrigin( )
{

  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return 0;
    }

  // Use cached object pointer if possible

    if( _cachedLocalOriginAPIPtr.isNull( )) {
        if( CdbStatus::Success != findOrigin( _cachedLocalOriginAPIPtr,
                                              _myLocalSQLOriginPtr->id( ))) {
            assert( 0 );
            return 0;
        }
    }
    return _cachedLocalOriginAPIPtr;
}

CdbStatus
CdbSQLApiDatabase::originIterator( CdbItr<unsigned short>& theItr )
{
    const char* errorStr = "CdbSQLApiDatabase::originIterator() -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Get a list of all known origins

        std::vector<CdbCPtr<CdbSQLOrigin> > origins;
        if( CdbStatus::Success != _mySQLPtr->origins( origins )) {
            cout << errorStr << endl
                 << "    Failed to obtain a list of all known origins from the database." << endl;
            break;
        }

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

        theItr = CdbItr<unsigned short>( new CdbSQLApiOriginItr( origins ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiDatabase::findOrigin( CdbOriginPtr& thePtr,
                               const char*   theName )
{
    const char* errorStr = "CdbSQLApiDatabase::findOrigin(name) -- ERROR" ;

    assert( 0 != theName );

    CdbStatus status = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Find the corresponding persistent origin

    CdbCPtr<CdbSQLOrigin> originPtr;
    if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                           theName ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to find the specified origin." << endl
                      << "        ORIGIN NAME : \"" << theName << "\"." << endmsg;
        return status;
    }

  // Construct the transient CDB API object

    thePtr = new CdbSQLApiOrigin( CdbDatabasePtr( this->clone( )),
                                  originPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findOrigin( CdbOriginPtr&  thePtr,
                               unsigned short theId )
{
    const char* errorStr = "CdbSQLApiDatabase::findOrigin(id) -- ERROR" ;

    CdbStatus status = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Find the corresponding persistent origin

    CdbCPtr<CdbSQLOrigin> originPtr;
    if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                           theId ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to find the specified origin." << endl
                      << "        ORIGIN ID : " << theId << endmsg;
        return status;
    }

  // Construct the transient CDB API object

    thePtr = new CdbSQLApiOrigin( CdbDatabasePtr( this->clone( )),
                                  originPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findOriginObject( CdbCPtr<CdbSQLOrigin>& thePtr,
                                     const std::string&     theName )
{
    assert( _isValid );
    assert( _isOpen );
    assert( !theName.empty( ));

  // A little optimization to use already found and cached MASTER and local
  // origin objects in case if one of them gets requested.
 
    CdbCPtr<CdbSQLOrigin> originPtr;

    if(      theName == _myMasterSQLOriginPtr->name( )) originPtr = _myMasterSQLOriginPtr;
    else if( theName == _myLocalSQLOriginPtr->name( ))  originPtr = _myLocalSQLOriginPtr;
    else if( theName == "<master>" )                    originPtr = _myMasterSQLOriginPtr;
    else if( theName == "<local>"  )                    originPtr = _myLocalSQLOriginPtr;
    else {

        CdbStatus status = _mySQLPtr->find_origin( originPtr, theName );
        if( CdbStatus::Success != status ) return status;
    }

  // Done

    thePtr = originPtr;

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiDatabase::findOriginObject( CdbCPtr<CdbSQLOrigin>& thePtr,
                                     unsigned short         theId )
{
    assert( _isValid );
    assert( _isOpen );

  // A little optimization to use already found and cached MASTER and local
  // origin objects in case if one of them gets requested.
 
    CdbCPtr<CdbSQLOrigin> originPtr;

    if(      theId == _myMasterSQLOriginPtr->id( )) originPtr = _myMasterSQLOriginPtr;
    else if( theId == _myLocalSQLOriginPtr->id( ))  originPtr = _myLocalSQLOriginPtr;
    else {

        CdbStatus status = _mySQLPtr->find_origin( originPtr, theId );
        if( CdbStatus::Success != status ) return status;
    }

  // Done

    thePtr = originPtr;

    return CdbStatus::Success;
}

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

---