---

CdbSQLApiCondition.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbSQLApiCondition.cc,v 1.3 2005/09/22 00:01:56 gapon Exp $

/// The implementation of the CdbSQLApiCondition class.
/**
  * @see CdbSQLApiCondition
  */
#include "CdbSQL/CdbSQLApi.hh"
#include "CdbSQL/CdbSQLApiCondition.hh"
#include "CdbSQL/CdbSQLApiRevision.hh"
#include "CdbSQL/CdbSQLOrigin.hh"
#include "CdbSQL/CdbSQLPartition.hh"
#include "CdbSQL/CdbSQLCondition.hh"
#include "CdbSQL/CdbSQLRevision.hh"
#include "CdbSQL/CdbSQLView.hh"
#include "CdbSQL/CdbSQLFolder.hh"
#include "CdbSQL/CdbSQLConditionAtFolder.hh"
#include "CdbSQL/CdbSQLVisibleObject.hh"
#include "CdbSQL/CdbSQLOriginalObject.hh"

#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbRevision.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbConfigElement.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbObjectFactoryBase.hh"
#include "CdbBase/CdbItr.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbTimeUtils.hh"
#include "CdbBase/CdbDebugStream.hh"
#include "CdbBase/CdbVectorAdapterItr.hh"
#include "CdbBase/CdbSimpleVectorAdapterItr.hh"
#include "CdbBase/CdbCompositeItr.hh"
#include "CdbBase/CdbAdapterItr.hh"
#include "CdbBase/CdbEmptyItr.hh"

#include "BdbTime/BdbTime.hh"

#include "ErrLogger/ErrLog.hh"

#include <stdio.h>
#include <assert.h>

#include <vector>
#include <stack>

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

namespace {

  ///////////////////////////////
  // Class: RevisionIdIterator //
  ///////////////////////////////

    class RevisionIdIterator : public CdbVectorAdapterItr< BdbTime, CdbCPtr<CdbSQLRevision> > {

    private:

        RevisionIdIterator( );

        RevisionIdIterator& operator=( const RevisionIdIterator& theItr );

    protected:

        RevisionIdIterator( const RevisionIdIterator& theItr ) :
            CdbVectorAdapterItr< BdbTime, CdbCPtr<CdbSQLRevision> >( theItr )
        { }

    public:

        RevisionIdIterator( const std::vector< CdbCPtr<CdbSQLRevision> >& theVectorOfRevisions ) :
            CdbVectorAdapterItr< BdbTime, CdbCPtr<CdbSQLRevision> >( theVectorOfRevisions )
        { }

        virtual ~RevisionIdIterator( )
        { }

        virtual CdbIItr< BdbTime >* clone( ) const
        {
            return new RevisionIdIterator( *this );
        }

    protected:

      /// User defined translation for the currently reffered value.
      /**
        * Implement the corresponding method defined in a base clas or an interface.
        *
        * @see class CdbVectorAdapterItr
        */
        virtual BdbTime toValue( const CdbCPtr<CdbSQLRevision>& theRevisionPtr ) const
        {
            return theRevisionPtr->id( );
        }
    };

  /////////////////////////////////
  // Class: RevisionNameIterator //
  /////////////////////////////////

    class RevisionNameIterator : public CdbVectorAdapterItr< const char*, CdbCPtr<CdbSQLRevision> > {

    private:

        RevisionNameIterator( );

        RevisionNameIterator& operator=( const RevisionNameIterator& theItr );

    protected:

        RevisionNameIterator( const RevisionNameIterator& theItr ) :
            CdbVectorAdapterItr< const char*, CdbCPtr<CdbSQLRevision> >( theItr ),
            _value(theItr._value)
        { }

    public:

        RevisionNameIterator( const std::vector< CdbCPtr<CdbSQLRevision> >& theVectorOfRevisions ) :
            CdbVectorAdapterItr< const char*, CdbCPtr<CdbSQLRevision> >( theVectorOfRevisions ),
            _value("")
        { }

        virtual ~RevisionNameIterator( )
        { }

      // Need to implement this operation since we have locally defined data members

        virtual CdbIItr< const char* >* clone( ) const
        {
            return new RevisionNameIterator( *this );
        }

    protected:

      /// User defined translation for the currently reffered value.
      /**
        * Implement the corresponding method defined in a base clas or an interface.
        *
        * @see class CdbVectorAdapterItr
        */
        virtual const char* toValue( const CdbCPtr<CdbSQLRevision>& theRevisionPtr ) const
        {
            _value = theRevisionPtr->name( );
            return _value.c_str( );
        }

    private:

      // Current value
      //
      // DESIGN NOTE: We must to have the one since the current iterator
      //              is supposed to return plain C string pointers. These pointers
      //              can't be obtained from temporary objects.

        mutable std::string _value; 
    };

  /////////////////////////////////////////////////
  // Class: PersistentToTransientIteratorAdapter //
  /////////////////////////////////////////////////
  //
  // Retranslate persistent visible objects into the transient CDB API ones
    
    class PersistentToTransientIteratorAdapter : public CdbAdapterItr< CdbObjectPtr,
                                                                       CdbCPtr<CdbSQLVisibleObject> > {
    private:

        PersistentToTransientIteratorAdapter( );

        PersistentToTransientIteratorAdapter& operator=( const PersistentToTransientIteratorAdapter& theItr );

    protected:

        PersistentToTransientIteratorAdapter( const PersistentToTransientIteratorAdapter& theItr ) :
            CdbAdapterItr< CdbObjectPtr,
                           CdbCPtr<CdbSQLVisibleObject> >( theItr ),
            _myParentPtr(theItr._myParentPtr)
        { }

    public:

      /// Normal constructor


        PersistentToTransientIteratorAdapter( CdbIItr< CdbCPtr<CdbSQLVisibleObject> >* theInputItrPtr,
                                              const CdbConditionPtr&                   theParentPtr ) :
            CdbAdapterItr< CdbObjectPtr,
                           CdbCPtr<CdbSQLVisibleObject> >( theInputItrPtr ),
            _myParentPtr(theParentPtr)
        { }

        virtual ~PersistentToTransientIteratorAdapter( )
        { }

        virtual CdbIItr< CdbObjectPtr >* clone( ) const
        {
            return new PersistentToTransientIteratorAdapter( *this );
        }

    protected:

        virtual CdbObjectPtr toValue( const CdbCPtr<CdbSQLVisibleObject>& thePersistentObjectPtr ) const
        {
            const char* fatalStr = "CdbSQLApiCondition::<anonymous>::PersistentToTransientIteratorAdapter::toValue() -- FATAL ERROR.";

            assert( !thePersistentObjectPtr.isNull( ));

          // Get to the top CDB API object at a level of CdbSQLApi. We need this object
          // in order to invoke the final object creator.
          //
          // @see CdbSQLApi::createObject()

            CdbCPtr<CdbSQLApi> ptr = (const CdbCPtr<CdbSQLApi>&)_myParentPtr->parentDatabase( )->parent( );

          // Construct the current value of the iterator and return with success.

            CdbObjectPtr result;
            CdbStatus status = ptr->createObject( result,
                                                  _myParentPtr,
                                                  thePersistentObjectPtr->begin( ),     // original validity begin
                                                  thePersistentObjectPtr->end( ),       // original validity end
                                                  thePersistentObjectPtr->begin( ),     // visible validity begin
                                                  thePersistentObjectPtr->end( ),       // visible validity end
                                                  thePersistentObjectPtr->stored( ),    // begin of the "duration" period
                                                  BdbTime::plusInfinity,                // end   of the "duration" period
                                                  thePersistentObjectPtr->stored( ),
                                                  thePersistentObjectPtr->id( ));
            if( CdbStatus::Success != status ) {
                ErrMsg(fatal) << fatalStr << endl
                              << "    Failed to produce a metadata object for the found persistent object because" << endl
                              << "    of the following status: " << status << " returned by an object creator." << endmsg;
            }
            return result;
        }

        virtual bool isAccepted( const CdbCPtr<CdbSQLVisibleObject>& thePersistentObjectPtr ) const
        {
            assert( !thePersistentObjectPtr.isNull( ));

          // Skip non-valid objects

            return thePersistentObjectPtr->isValid( );
        }

    private:

        CdbConditionPtr _myParentPtr;
    };

  ////////////////////////////////////////
  // Class: VisibleObjectIteratorAdapter //
  ////////////////////////////////////////
  //
  // This class translate configuration elements of an input iterator into iterators
  // of visible objects. Each configuration elements maps into one output iterator.

    class VisibleObjectIteratorAdapter : public CdbAdapterItr< CdbObjectItr,
                                                               CdbConfigElement > {
    private:

        VisibleObjectIteratorAdapter( );

        VisibleObjectIteratorAdapter& operator=( const VisibleObjectIteratorAdapter& theItr );

    protected:

        VisibleObjectIteratorAdapter( const VisibleObjectIteratorAdapter& theItr ) :
            CdbAdapterItr< CdbObjectItr,
                           CdbConfigElement >( theItr ),
            _myConditionPtr(theItr._myConditionPtr),
            _myParentPtr   (theItr._myParentPtr),
            _beginTime     (theItr._beginTime),
            _endTime       (theItr._endTime)
        { }

    public:

      /// Normal constructor


        VisibleObjectIteratorAdapter( CdbIItr<CdbConfigElement>*      theInputItrPtr,
                                      const CdbCPtr<CdbSQLCondition>& theConditionPtr,
                                      const CdbConditionPtr&          theParentPtr,
                                      const BdbTime&                  theBeginTime = BdbTime::minusInfinity,
                                      const BdbTime&                  theEndTime   = BdbTime::plusInfinity ) :
            CdbAdapterItr< CdbObjectItr,
                           CdbConfigElement >( theInputItrPtr ),
            _myConditionPtr(theConditionPtr),
            _myParentPtr   (theParentPtr),
            _beginTime     (theBeginTime),
            _endTime       (theEndTime)
        { }

        virtual ~VisibleObjectIteratorAdapter( )
        { }

      // Need to implement this operation since we have locally defined data members

        virtual CdbIItr< CdbObjectItr >* clone( ) const
        {
            return new VisibleObjectIteratorAdapter( *this );
        }

    protected:

      /// User defined translation for the currently referred value.
      /**
        * This implements the corresponding method of the base class.
        *
        * IMPLEMENTATION NOTES:
        *
        *   - This method will use an input configuration element to find visible objects
        *   in a scope of the cached condition and produce an iterator of visible CDB API
        *   objects out of the found seqeunce.
        *
        *   - The cached [begin,end) validity timeline limits will also be taken into
        *   and account as follows:
        *
        *     o If the validity limit of the configuration elements is falling of the cached
        *     limits then an empty iterator will be returned.
        *
        *     o The visible validity limits of the output objects would also be properly
        *     adjusted should they cross either border.
        *
        *   - IMPORTANT: Since we're not allowed (according to teh current BaBar Computing/Programming
        *     policy) to use exceptions and since we have no mechanism to return a error
        *     status value up to a caller then the method will abort an application
        *     in case of any failure inside the method. This will also apply to an unsupported
        *     configuration passed as the method's parameter.
        *
        * @see CdbAdapterItr::toValue()
        */
        virtual CdbObjectItr toValue( const CdbConfigElement& theConfigElement ) const
        {
            const char* fatalStr = "<anonymous>::VisibleObjectIteratorAdapter::toValue() -- FATAL ERROR";

          // IMPLEMENTATION RESTRICTION:
          //
          //   The current implementation of the iterator does not allow browsing intervals
          //   based on the "do not use revision" revision policy. In fact, thsi type of access
          //   is not fully supported in the present implementation of CDB.

            if( !theConfigElement.policy.useRevision( ))
                ErrMsg(fatal) << fatalStr << endl
                              << "    Unsupported revision policy has been detected in the current configuration" << endl
                              << "    of the condition." << endl
                              << "        CONDITION PATH: \"" << CdbCondition::fullPathName( _myParentPtr ) << "\"" << endmsg;

          // Check if we the element is outside the limits or if accessing a validity
          // interval covered by the configuration is allowed. If so then return an empty
          // iterator.

            if( !theConfigElement.accessIsAllowed  ||       // the view (at the configured interval) prohibits accessing objects
                theConfigElement.begin >= _endTime ||       // the configuration interval begins after the desired period ends
                theConfigElement.end   <= _beginTime ) {    // the configuration interval ends before the desired period begins

                return CdbObjectItr( new CdbEmptyItr< CdbObjectPtr >( ));
            }

          // Find an overlapping interval between the desired validity interval and the one
          // in the passed configuration element.

            const BdbTime adjustedBeginTime = ( theConfigElement.begin > _beginTime ? theConfigElement.begin : _beginTime );
            const BdbTime adjustedEndTime   = ( theConfigElement.end   < _endTime   ? theConfigElement.end   : _endTime   );

            assert( adjustedBeginTime != adjustedEndTime ); // in case if we're having an implementation bug

          // Make a database query to get a list of persistent visible intervals for
          // the above determined "adjusted" period of the validity time.

            std::vector< CdbCPtr<CdbSQLVisibleObject> > objects;

            if( CdbStatus::Success != _myConditionPtr->visible_objects( objects,
                                                                        theConfigElement.policy.partitionId( ),
                                                                        theConfigElement.policy.revisionId( ),
                                                                        adjustedBeginTime,
                                                                        adjustedEndTime ))
                ErrMsg(fatal) << fatalStr << endl
                              << "    Failed to obtain a list of visible object from the condition." << endl
                              << "        CONDITION PATH: \"" << CdbCondition::fullPathName( _myParentPtr ) << "\"" << endl
                              << "        PARTITION     : "   << theConfigElement.policy.partitionId( ) << endl
                              << "        REVISION      : "   << CdbTimeUtils::time2string( theConfigElement.policy.revisionId( )) << " : " << theConfigElement.policy.revisionId( ) << endl
                              << "        BEGIN TIME    : "   << CdbTimeUtils::time2string( adjustedBeginTime                    ) << " : " << adjustedBeginTime << endl
                              << "        END  TIME     : "   << CdbTimeUtils::time2string( adjustedEndTime                      ) << " : " << adjustedEndTime << endmsg;

          // Turn the found vector into an iterator of the same type of elements, then feed
          // the resulting iterator itself into an adapter for retranslation from visible
          // "persistent" objects into the "transient" ones.
          //
          // NOTE: We'll also sending the cached pointer onto the CDB API "owner" object which
          //       is needed to construct the transient CDB API objects.

            return CdbObjectItr( new PersistentToTransientIteratorAdapter( new CdbSimpleVectorAdapterItr< CdbCPtr<CdbSQLVisibleObject> >( objects ),
                                                                           _myParentPtr ));
        }

    private:

        CdbCPtr<CdbSQLCondition> _myConditionPtr;
        CdbConditionPtr          _myParentPtr;

        BdbTime _beginTime;
        BdbTime _endTime;
    };

  ///////////////////////////////////
  // Class: OriginalObjectIterator //
  ///////////////////////////////////
  //
  // Retranslate persistent original objects into the transient CDB API ones

    class OriginalObjectIterator : public CdbAdapterItr< CdbObjectPtr,
                                                         CdbCPtr<CdbSQLOriginalObject> > {
    private:

        OriginalObjectIterator( );

        OriginalObjectIterator& operator=( const OriginalObjectIterator& theItr );

    protected:

        OriginalObjectIterator( const OriginalObjectIterator& theItr ) :
            CdbAdapterItr< CdbObjectPtr,
                           CdbCPtr<CdbSQLOriginalObject> >( theItr ),
            _myParentPtr(theItr._myParentPtr)
        { }

    public:

      /// Normal constructor

        OriginalObjectIterator( CdbIItr< CdbCPtr<CdbSQLOriginalObject> >* theInputItrPtr,
                                const CdbConditionPtr&                    theParentPtr ) :
            CdbAdapterItr< CdbObjectPtr,
                           CdbCPtr<CdbSQLOriginalObject> >( theInputItrPtr ),
            _myParentPtr(theParentPtr)
        { }

        virtual ~OriginalObjectIterator( )
        { }

        virtual CdbIItr< CdbObjectPtr >* clone( ) const
        {
            return new OriginalObjectIterator( *this );
        }

    protected:

        virtual CdbObjectPtr toValue( const CdbCPtr<CdbSQLOriginalObject>& thePersistentObjectPtr ) const
        {
            const char* fatalStr = "CdbSQLApiCondition::<anonymous>::OriginalObjectIterator::toValue() -- FATAL ERROR.";

            assert( !thePersistentObjectPtr.isNull( ));

          // Get to the top CDB API object at a level of CdbSQLApi. We need this object
          // in order to invoke the final object creator.
          //
          // @see CdbSQLApi::createObject()

            CdbCPtr<CdbSQLApi> ptr = (const CdbCPtr<CdbSQLApi>&)_myParentPtr->parentDatabase( )->parent( );

          // Construct the current value of the iterator and return with success.

            CdbObjectPtr result;
            CdbStatus status = ptr->createObject( result,
                                                  _myParentPtr,
                                                  thePersistentObjectPtr->begin( ),     // original validity begin
                                                  thePersistentObjectPtr->end( ),       // original validity end
                                                  thePersistentObjectPtr->begin( ),     // visible validity begin
                                                  thePersistentObjectPtr->end( ),       // visible validity end
                                                  thePersistentObjectPtr->stored( ),    // begin of the "duration" period
                                                  BdbTime::plusInfinity,                // end   of the "duration" period
                                                  thePersistentObjectPtr->stored( ),
                                                  thePersistentObjectPtr->id( ));
            if( CdbStatus::Success != status ) {
                ErrMsg(fatal) << fatalStr << endl
                              << "    Failed to produce a metadata object for the found persistent object because" << endl
                              << "    of the following status: " << status << " returned by an object creator." << endmsg;
            }
            return result;
        }

    private:

        CdbConditionPtr _myParentPtr;
    };    
}

////////////////////////////////////
/// Class: CdbSQLApiCondition //
////////////////////////////////////

CdbCondition*
CdbSQLApiCondition::clone( ) const
{
    return new CdbSQLApiCondition( *this );
}

CdbSQLApiCondition::CdbSQLApiCondition( const CdbFolderPtr&                     theFolderPtr,
                                        const CdbDatabasePtr&                   theDatabasePtr,
                                        const char*                             theName,
                                        const CdbCPtr<CdbSQLConditionAtFolder>& theConditionAtFolderPtr,
                                        const CdbCPtr<CdbSQLCondition>&         theConditionPtr,
                                        const CdbCPtr<CdbSQLOrigin>&            theMasterOriginPtr,
                                        const CdbCPtr<CdbSQLOrigin>&            theLocalOriginPtr ) :
    CdbCondition( theFolderPtr,
                  theDatabasePtr,
                  theName ),
    _myConditionAtFolderPtr(theConditionAtFolderPtr),
    _myConditionPtr        (theConditionPtr),
    _myMasterSQLOriginPtr  (theMasterOriginPtr),
    _myLocalSQLOriginPtr   (theLocalOriginPtr)
{
    const char* fatalStr = "CdbSQLApiCondition::CdbSQLApiCondition() -- FATAL ERROR IN THE CONSTRUCTOR";

    if( theConditionPtr.isNull( ))
        ErrMsg(fatal) << fatalStr << endl
                      << "    A null pointer onto 'physical' condition object passed as a paremeter." << endmsg;

    if( theMasterOriginPtr.isNull( ))
        ErrMsg(fatal) << fatalStr << endl
                      << "    A null pointer onto the MASTER origin object passed as a paremeter." << endmsg;

    if( theLocalOriginPtr.isNull( ))
        ErrMsg(fatal) << fatalStr << endl
                      << "    A null pointer onto the local origin object passed as a paremeter." << endmsg;
}

CdbSQLApiCondition::CdbSQLApiCondition( const CdbSQLApiCondition& theCondition ) :
    CdbCondition( theCondition ),
    _myConditionAtFolderPtr(theCondition._myConditionAtFolderPtr),
    _myConditionPtr        (theCondition._myConditionPtr),
    _myMasterSQLOriginPtr  (theCondition._myMasterSQLOriginPtr),
    _myLocalSQLOriginPtr   (theCondition._myLocalSQLOriginPtr)
{ }

CdbSQLApiCondition::~CdbSQLApiCondition( )
{ }

std::string
CdbSQLApiCondition::description( ) const
{
    if( _myConditionAtFolderPtr.isNull( )) return _myConditionPtr->description( );
    return _myConditionAtFolderPtr->description( );
}

bool
CdbSQLApiCondition::isPartitionable( ) const
{
    return _myConditionPtr->isPartitionable( );
}

CdbCompositeName
CdbSQLApiCondition::physicalName( ) const
{
    return CdbCompositeName( _myConditionPtr->parent( )->name( ).c_str( ),
                             _myConditionPtr->name( ).c_str( ));
}

CdbId
CdbSQLApiCondition::physicalId( ) const
{
    return CdbId( _myConditionPtr->parent( )->id( ),
                  _myConditionPtr->id( ));
}

BdbTime
CdbSQLApiCondition::created( ) const
{
    return _myConditionPtr->created( );
}

BdbTime
CdbSQLApiCondition::registered( ) const
{
    if( _myConditionAtFolderPtr.isNull( )) return _myConditionPtr->created( );
    return _myConditionAtFolderPtr->created( );
}

BdbTime
CdbSQLApiCondition::modified( ) const
{
    const char* errorStr = "CdbSQLApiCondition::modified() -- ERROR";

    BdbTime result = BdbTime::minusInfinity;    // this default value means a failure of the algorithm

    do {

      /*
       * =================
       * EXECUTION PATH I: 'physical address' conditions only
       * =================
       *
       * This path is not currently implemented. A complicated algorithm to iterate
       * over a validity timeline of the "topmost" partitions would be needed for
       * PARTITIONABLE conditions. Things are trivial for REGULAR conditions though.
       * However to avoid an incomplete implementation of this part of the code let's just
       * postpone it as a whole.
       *
       * AN IDEA: Having a super-iterator composed of elementary iterators for individual
       *          "topmost" partitions would be a good idea. That would require to extend
       *          the API of P-Layout to deliver an iterator of "topmost" partitions. The
       *          one currently available does not respect non-instantiated partitions.
       */

        if( _myConditionAtFolderPtr.isNull( )) break;

      /*
       * ==================
       * EXECUTION PATH II: 'view/folder/config' conditions only
       * ==================
       *
       * HOW THIS ALGORITHM IS IMPLEMENTED:
       *
       *   The code below will iterate through the configuration intervals and depending
       *   on a configuration of an interval will either use the timestamp of the specified
       *   revision (for non-topmost revisions) or directly scan the condition/partition.
       *
       *   IMPORTANT:
       *
       *     The result delivered by the algorithm will depend on a particular configuration
       *     of the condition. In other words, in the current model of conditions, a value
       *     of the "modification timestamp" should be read in the context of "...from
       *     the point of view of the specified view...".
       */

        std::vector<CdbConfigElement> config_elements;
        if( CdbStatus::Success != _myConditionAtFolderPtr->config_elements( config_elements )) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to get a list of configuration elements for the current condition." << endl
                          << "        CONDITION NAME : \"" << _myConditionAtFolderPtr->name( ) << "\"." << endmsg;
            break;
        }
        unsigned int nElements = config_elements.size( );

        for( unsigned int iElement = 0; iElement < nElements; ++iElement ) {

            CdbConfigElement configElement = config_elements[iElement];
/*
cout << "CdbSQLApiCondition::modified( ) - CONFIG ELEMENT - " << iElement << "/" << nElements << " {" << endl
     << "  accessIsAllowed    : " << configElement.accessIsAllowed << endl
     << "  policy.useRevision : " << configElement.policy.useRevision( ) << endl
     << "  policy.revisionId  : " << CdbTimeUtils::time2string( configElement.policy.revisionId( )) << endl
     << "  policy.partitionId : " << configElement.policy.partitionId( ) << endl
     << "  begin              : " << CdbTimeUtils::time2string( configElement.begin ) << endl
     << "  end                : " << CdbTimeUtils::time2string( configElement.end ) << endl
     << "}" << endl;
*/
          // Skeep the found element if it tells us that the corresponding range of the validity
          // timeline is not accessible for the current application.

            if( !configElement.accessIsAllowed ) continue;

          // If we're supposed to use revisions and if this is not the 'topmost' one
          // then then we use that revision ID as the modification time.

            BdbTime modificationTime = BdbTime::minusInfinity;
            if( configElement.policy.useRevision( ) && ( BdbTime::plusInfinity != configElement.policy.revisionId( ))) {
                modificationTime = configElement.policy.revisionId( );
            } else {

              // Otherwise we use the modification time of the condition at
              // the specified partition.

                if( CdbStatus::Success != _myConditionPtr->modified( modificationTime,
                                                                     configElement.policy.partitionId( ))) {

                    ErrMsg(error) << errorStr << endl
                                  << "    Failed to get the modification of configuration elements for the current condition/partition." << endl
                                  << "        CONDITION NAME : \"" << _myConditionAtFolderPtr->name( ) << "\"" << endl
                                  << "        PARTITION      : " << configElement.policy.partitionId( ) << "." << endmsg;
                    break;
                }
            }
            assert( BdbTime::minusInfinity != modificationTime );   // something is broken in the algorithm above
            assert( BdbTime::plusInfinity  != modificationTime );   // something is broken in the algorithm above

          // Check if the found time is newer than the one we have now.

            if( modificationTime > result ) result = modificationTime;
        }

      // Done.

    } while( false );

    return result;

}

CdbStatus
CdbSQLApiCondition::findObject( CdbObjectPtr&  theObjectPtr,
                                const BdbTime& theValidityTime,
                                const BdbTime& theInsertionTime )
{
    const char* errorStr = "CdbSQLApiCondition::findObject(validity,insertion) -- ERROR";

  /*
   * =================
   * EXECUTION PATH I: 'physical address' conditions only
   * =================
   *
   * If the condition is available by its 'physical address' only
   * then we don't have any asociation with views & folders, therefore no such things
   * as condition configurations are available. The "insertion" time will play a role
   * of the secondary (in addition to the validity time) key. Here are the rules
   * for different values of the insertion time and condition types
   *
   *   o if the insertion time is +Infinity then:
   *
   *     REGULAR       : the TOPMOST revision will always be used
   *
   *     PARTITIONABLE : the most recent revision of the "topmost" (at given validity time)
   *                     partition will be used. In case if this is an "open" partition
   *                     then its TOPMOST revision will be used.
   *
   *   o for any other values of the insertion time:
   *
   *     REGULAR       : the specified insertion time would be used
   *
   *     PARTITIONABLE : the specified insertion time would be used
   */

    if( _myConditionAtFolderPtr.isNull( )) {

      // The default constructor of the policy would assume that we're going
      // to use the actual insertion time rather than any explicitly found revision.

        CdbRevisionPolicy rPolicy;

        if( BdbTime::plusInfinity == theInsertionTime ) {

          // Okay, we need to find the most recent partition & revision

            if( _myConditionPtr->isPartitionable( )) {

              // Find an appropriate partition for the specified validity and insertion
              // timestamps.
              //
              // @see CdbSQLApiCondition::findInitialPartition()

                CdbCPtr<CdbSQLPartition> partitionPtr;

                if( CdbStatus::Success != findInitialPartition( partitionPtr,
                                                                theValidityTime,
                                                                theInsertionTime )) {

                    ErrMsg(error) << errorStr << endl
                                  << "    Failed to find an initial partition for the specified validity and insertion" << endl
                                  << "    for a condition found by its 'physical address'." << endl
                                  << "        PHYSICAL CONDITION ADDRESS : " << physicalId( ) << endl
                                  << "        VALIDITY TIME              : " << CdbTimeUtils::time2string( theValidityTime )  << " : " << theValidityTime  << endl
                                  << "        INSERTION TIME             : " << CdbTimeUtils::time2string( theInsertionTime ) << " : " << theInsertionTime << endmsg;

                    return CdbStatus::Error;
                }

              // Find the most recent (can be "<topmost>" if the partition is in the "open"
              // state) revision in the partition.

                BdbTime rId = BdbTime::minusInfinity;

                if( CdbStatus::Success != _myConditionPtr->topmost_revision_id( rId,
                                                                                partitionPtr->id( ))) {

                    ErrMsg(error) << errorStr << endl
                                  << "    Failed to find a topmost revision in the partition #" << partitionPtr->id( ) << " for a condition" << endl
                                  << "    found by its 'physical address'." << endl
                                  << "        PHYSICAL CONDITION ADDRESS : " << physicalId( ) << endmsg;

                    return CdbStatus::Error;
                }
                assert( BdbTime::minusInfinity != rId );    // check for a bug in the API

              // Use the just found revision and partition ids for PARTITIONABLE conditions.

                rPolicy = CdbRevisionPolicy( rId, partitionPtr->id( ));

            } else {

              // Just use TOPMOST revision for REGULAR conditions.

                rPolicy = CdbRevisionPolicy( BdbTime::plusInfinity, 0 );
            }
        }

      // Proceed with the policy driven search.

        return findObject( theObjectPtr,
                           rPolicy,
                           theValidityTime,
                           theInsertionTime );
    }

  /*
   * ==================
   * EXECUTION PATH II: 'view/folder/config' conditions only
   * ==================
   */

    CDB_DEBUG_STREAM
        << "CDB_FIND_OBJECT_1: condition=" << name( )
        << " validity_time=" << theValidityTime.getGmtSec( ) << "." << theValidityTime.getGmtNsec( )
        << " insertion_time=" << theInsertionTime.getGmtSec( ) << "." << theInsertionTime.getGmtNsec( ) << endl;

    theObjectPtr = 0;

    CdbStatus result = CdbStatus::Error;

    do {

      // Check if specified validity time is covered by the validity
      // interval of the current view.

        CdbCPtr<CdbSQLView> viewPtr = _myConditionAtFolderPtr->parent( )->parentView( );
        assert( !viewPtr.isNull( ));

        if(( theValidityTime <  viewPtr->begin( )) ||
           ( theValidityTime >= viewPtr->end  ( ))) {

            ErrMsg(error) << errorStr << endl
                          << "    Specified validity time does not fit into the validity range" << endl
                          << "    of the current view." << endl
                          << "        VIEW NAME:   \"" << viewPtr->name( ) << "\"" << endl
                          << "        PASSED TIME: " << theValidityTime << endmsg;
            break;
        }

      // All we need to do is to find out a revision policy ("configuration element")
      // for the condition.

        CdbConfigElement rConfigElement;

        if( CdbStatus::Success != _myConditionAtFolderPtr->find_config_element( rConfigElement,
                                                                                theValidityTime )) {

            ErrMsg(error) << errorStr << endl
                          << "    Failed to find revision policy information for specified validity time" << endl
                          << "    at the condition description of the  the current view." << endl
                          << "    The view may be inproperly configured." << endl
                          << "        PASSED TIME:    " << theValidityTime << endl
                          << "        CONDITION NAME: \"" << name( ) << "\"" << endl
                          << "        VIEW NAME:      \"" << viewPtr->name( ) << "\"" << endmsg;
            break;
        }
        if( ! rConfigElement.accessIsAllowed ) {
            ErrMsg(error) << errorStr << endl
                          << "    The current view prohibits accessing conditions at specified" << endl
                          << "    point of the validity timeline." << endl
                          << "        VIEW NAME:   \"" << viewPtr->name( ) << "\"" << endl
                          << "        PASSED TIME: " << theValidityTime << endmsg;
            break;
        }

      // Given the found policy, propagate the call down to the next
      // method requiring explicit policy to be specified among
      // the method's parameters.

        CdbCPtr<CdbSQLVisibleObject> visibleObjectPtr;

        BdbTime beginOfVisiblePeriod  = BdbTime::plusInfinity;  // initially this value will be calculated by the doFindObject* methods
        BdbTime endOfVisiblePeriod    = BdbTime::plusInfinity;  // -/-

        BdbTime beginOfDurationPeriod = BdbTime::minusInfinity;
        BdbTime endOfDurationPeriod   = BdbTime::minusInfinity;

        if( _myConditionPtr->isPartitionable( )) {

            if( CdbStatus::Success != doFindObjectAtPartition( rConfigElement.policy,
                                                               theValidityTime,
                                                               theInsertionTime,
                                                               visibleObjectPtr, 
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod )) break;

        } else {

            if( CdbStatus::Success != doFindObject( rConfigElement.policy,
                                                    theValidityTime,
                                                    theInsertionTime,
                                                    visibleObjectPtr, 
                                                    beginOfVisiblePeriod,
                                                    endOfVisiblePeriod,
                                                    beginOfDurationPeriod,
                                                    endOfDurationPeriod )) break;
        }

      // Now we should check if the found visible validity interval must be
      // narrowed down to the limits enforced by the current policy interval.

        if( rConfigElement.begin > beginOfVisiblePeriod ) beginOfVisiblePeriod = rConfigElement.begin;
        if( rConfigElement.end   < endOfVisiblePeriod   ) endOfVisiblePeriod   = rConfigElement.end;

      // Create a transient object.

        CdbObjectPtr transientObjectPtr;
        {
          // Get to the top CDB API object at a level of CdbSQLApi. We need this object
          // in order to invoke the final object creator.
          //
          // @see CdbSQLApi::createObject()

            CdbCPtr<CdbSQLApi> ptr = (const CdbCPtr<CdbSQLApi>&)parentDatabase( )->parent( );

          // Construct the current value of the iterator and return with success.

            if( CdbStatus::Success != ptr->createObject( transientObjectPtr,
                                                         CdbConditionPtr( this->clone( )),
                                                         visibleObjectPtr->original_begin( ),
                                                         visibleObjectPtr->original_end( ),
                                                         beginOfVisiblePeriod,
                                                         endOfVisiblePeriod,
                                                         beginOfDurationPeriod,
                                                         endOfDurationPeriod,
                                                         visibleObjectPtr->stored( ),
                                                         visibleObjectPtr->id( ))) {
                ErrMsg(error) << errorStr << endl
                              << "    Failed to produce a metadata object for the found persistent object." << endmsg;
                break;
            }
        }
        theObjectPtr = transientObjectPtr;

     // Done

       result = CdbStatus::Success;

    } while( false );

    CDB_DEBUG_STREAM << "CDB_FIND_OBJECT_1: " << (theObjectPtr.isNull( ) ? "" : theObjectPtr->id( )) << endl;

    return result;
}

CdbStatus
CdbSQLApiCondition::findObject( CdbObjectPtr&            theObjectPtr,
                                const CdbRevisionPolicy& thePolicy,
                                const BdbTime&           theValidityTime,
                                const BdbTime&           theInsertionTime )
{
    const char* errorStr = "CdbSQLApiCondition::findObject(policy,validity,insertion) -- ERROR";

    theObjectPtr = 0;

    CDB_DEBUG_STREAM
        << "CDB_FIND_OBJECT_2: condition=" << name( ) 
        << " validity_time=" << theValidityTime.getGmtSec( ) << "." << theValidityTime.getGmtNsec( ) 
        << " insertion_time=" << theInsertionTime.getGmtSec( ) << "." << theInsertionTime.getGmtNsec( ) << endl;

    CdbStatus result = CdbStatus::Error;

    do {

      // Given the found policy, propagate the call down to the next
      // method requiring explicit policy to be specified among
      // the method's parameters.

        CdbCPtr<CdbSQLVisibleObject> visibleObjectPtr;

        BdbTime beginOfVisiblePeriod  = BdbTime::plusInfinity;  // initially this value will be calculated by the doFindObject* methods
        BdbTime endOfVisiblePeriod    = BdbTime::plusInfinity;  // -/-

        BdbTime beginOfDurationPeriod = BdbTime::minusInfinity;
        BdbTime endOfDurationPeriod   = BdbTime::minusInfinity;

        if( _myConditionPtr->isPartitionable( )) {

            if( CdbStatus::Success != doFindObjectAtPartition( thePolicy,
                                                               theValidityTime,
                                                               theInsertionTime,
                                                               visibleObjectPtr,
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod )) break;

        } else {

            if( CdbStatus::Success != doFindObject( thePolicy,
                                                    theValidityTime,
                                                    theInsertionTime,
                                                    visibleObjectPtr, 
                                                    beginOfVisiblePeriod,
                                                    endOfVisiblePeriod,
                                                    beginOfDurationPeriod,
                                                    endOfDurationPeriod )) break;
        }

      // Note, in this case we're not going to narrow a visibility of the found object since
      // we're using an explicit (rather then the default, found at a view) one. It's up to
      // our client to interpret the found validity interval.

        ;

      // Create a transient object through the creator factory.

        CdbObjectPtr transientObjectPtr;
        {
          // Get to the top CDB API object at a level of CdbSQLApi. We need this object
          // in order to invoke the final object creator.
          //
          // @see CdbSQLApi::createObject()

            CdbCPtr<CdbSQLApi> ptr = (const CdbCPtr<CdbSQLApi>&)parentDatabase( )->parent( );

          // Construct the current value of the iterator and return with success.

            if( CdbStatus::Success != ptr->createObject( transientObjectPtr,
                                                         CdbConditionPtr( this->clone( )),
                                                         visibleObjectPtr->original_begin( ),
                                                         visibleObjectPtr->original_end( ),
                                                         beginOfVisiblePeriod,
                                                         endOfVisiblePeriod,
                                                         beginOfDurationPeriod,
                                                         endOfDurationPeriod,
                                                         visibleObjectPtr->stored( ),
                                                         visibleObjectPtr->id( ))) {
                ErrMsg(error) << errorStr << endl
                              << "    Failed to produce a metadata object for the found persistent object." << endmsg;
                break;
            }
        }
        theObjectPtr = transientObjectPtr;

     // Done
 
       result = CdbStatus::Success;
 
    } while( false );
 
    CDB_DEBUG_STREAM << "CDB_FIND_OBJECT_2: " << (theObjectPtr.isNull( ) ? "" : theObjectPtr->id( )) << endl;

    return result;
}

CdbStatus
CdbSQLApiCondition::objectIterator( CdbObjectItr&  theItr,
                                    const BdbTime& theBeginValidity,
                                    const BdbTime& theEndValidity )
{
    const char* errorStr = "CdbSQLApiCondition::objectIterator() -- ERROR";

  /*
   * =================
   * EXECUTION PATH I: 'physical address' conditions only
   * =================
   *
   * This path is not currently implemented. A complicated algorithm to iterate
   * over a validity timeline of the "topmost" partitions would be needed for
   * PARTITIONABLE conditions. Things are trivial for REGULAR conditions though.
   * However to avoid an incomplete implementation of this part of the code let's just
   * postpone it as a whole.
   *
   * AN IDEA: Having a super-iterator composed of elementary iterators for individual
   *          "topmost" partitions would be a good idea. That would require to extend
   *          the API of P-Layout to deliver an iterator of "topmost" partitions. The
   *          one currently available does not respect non-instantiated partitions.
   */

    if( _myConditionAtFolderPtr.isNull( )) return CdbStatus::NotImplemented;

  /*
   * ==================
   * EXECUTION PATH II: 'view/folder/config' conditions only
   * ==================
   */

    CdbStatus result = CdbStatus::Error;

  // Verify parameters

    if( theEndValidity <= theBeginValidity ) {

        ErrMsg(error) << errorStr << endl
                      << "    Invalid validity interval range passed to the method." << endl
                      << "    The end time should be greater or equal than the begin one." << endl
                      << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                      << "        PASSED END   TIME : " << theEndValidity << endl
                      << "        CONDITION         : \"" << name( ) << "\"" << endmsg;

        return CdbStatus::IllegalParameters;
    }

    CdbCPtr<CdbSQLView> viewPtr = _myConditionAtFolderPtr->parent( )->parentView( );

    BdbTime minValidity = viewPtr->begin( );
    BdbTime maxValidity = viewPtr->end( );

    if(( theBeginValidity >= maxValidity ) || ( theEndValidity <= minValidity )) {

        ErrMsg(error) << errorStr << endl
                      << "    Invalid validity interval range passed to the method." << endl
                      << "    This interval does not fit into the validity range" << endl
                      << "    allowed by the current view." << endl
                      << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                      << "        PASSED END   TIME : " << theEndValidity << endl
                      << "        VIEW'S BEGIN TIME : " << minValidity << endl
                      << "        VIEW'S END   TIME : " << maxValidity << endl
                      << "        VIEW              : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                      << "        CONDITION         : \"" << name( ) << "\"" << endmsg;

        return CdbStatus::IllegalParameters;
    }

  // Make adjustments to the validity limits to narrow the interval if needed.
  // The resulting interval will be passed to the iterator

    if( theBeginValidity > minValidity ) minValidity = theBeginValidity;
    if( theEndValidity   < maxValidity ) maxValidity = theEndValidity;

  // Prepare a right configuration collection. This is going to be either
  // specific collection at the level of the condition, or the default one
  // at the level of the view.
  //
  // @see method CdbSQLConditionAtFolder::config_elements()

    std::vector<CdbConfigElement> configElements;

    if( CdbStatus::Success == ( result = _myConditionAtFolderPtr->config_elements( configElements ))) {

      // Okay, there is a local configuration for the condition

        ;

    } else  if( CdbStatus::NotFound == result ) {

      // Try the default one

        if( !viewPtr->hasDefaultConfig( )) {

            ErrMsg(error) << errorStr << endl
                          << "    No default configuration collection in the view." << endl
                          << "        VIEW              : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                          << "        CONDITION         : \"" << name( ) << "\"" << endmsg;

            return CdbStatus::Error;

        }
        if( CdbStatus::Success != ( result = viewPtr->config_elements( configElements ))) {

            ErrMsg(error) << errorStr << endl
                          << "    Failed to get the default configuration collection from the view." << endl
                          << "        VIEW              : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                          << "        CONDITION         : \"" << name( ) << "\"" << endmsg;

            return CdbStatus::Error;
        }

    } else {

        ErrMsg(error) << errorStr << endl
                      << "    Failed to get a local configuration collection for the condition in the view." << endl
                      << "        VIEW      : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                      << "        CONDITION : \"" << name( ) << "\"" << endmsg;

        return CdbStatus::Error;
    }

  // Now construct the desired iterator using an iterator adapter retranslating
  // configuration elements into an iterator of transient CDB API object.

    theItr = CdbObjectItr( new CdbCompositeItr< CdbObjectItr::ValueType >( new VisibleObjectIteratorAdapter( new CdbSimpleVectorAdapterItr<CdbConfigElement>( configElements ),
                                                                                                             _myConditionPtr,
                                                                                                             CdbConditionPtr( this->clone( )),
                                                                                                             minValidity,
                                                                                                             maxValidity )));
  // Done
 
   return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::objectIterator( CdbObjectItr&            theItr,
                                    const CdbRevisionPolicy& thePolicy,
                                    const BdbTime&           theBeginValidity,
                                    const BdbTime&           theEndValidity )
{
    const char* errorStr = "CdbSQLApiCondition::objectIterator(policy) -- ERROR";

  // Verify parameters

    if( theEndValidity <= theBeginValidity ) {

        ErrMsg(error) << errorStr << endl
                      << "    Invalid validity interval range passed to the method." << endl
                      << "    The end time should be greater or equal than the begin one." << endl
                      << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                      << "        PASSED END   TIME : " << theEndValidity << endl
                      << "        CONDITION         : \"" << name( ) << "\"" << endmsg;

        return CdbStatus::IllegalParameters;
    }

  // Prepare a collection of configuration elements made of a single record
  // constructed from the input policy and the validity limits.

    std::vector<CdbConfigElement> configElements;

    configElements.push_back( CdbConfigElement( thePolicy,
                                                theBeginValidity,
                                                theEndValidity ));

  // Now construct the desired iterator using an iterator adapter retranslating
  // configuration elements into an iterator of transient CDB API object.

    theItr = CdbObjectItr( new CdbCompositeItr< CdbObjectItr::ValueType >( new VisibleObjectIteratorAdapter( new CdbSimpleVectorAdapterItr<CdbConfigElement>( configElements ),
                                                                                                             _myConditionPtr,
                                                                                                             CdbConditionPtr( this->clone( )),
                                                                                                             theBeginValidity,
                                                                                                             theEndValidity )));
  // Done
 
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::originalObjectIterator( CdbObjectItr&        theItr,
                                            const BdbTime&       theBeginInsertion,
                                            const BdbTime&       theEndInsertion,
                                            const unsigned short thePartitionId )
{
    const char* errorStr = "CdbSQLApiCondition::originalObjectIterator() -- ERROR";

  // Verify parameters

    if( theBeginInsertion >= theEndInsertion ) {

        ErrMsg(error) << errorStr << endl
                      << "    Invalid 'insertion' interval range passed to the method." << endl
                      << "    The end time should be greater or equal than the begin one." << endl
                      << "        VIEW                : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                      << "        CONDITION           : \"" << name( ) << "\"" << endl
                      << "        PARTITION           : " << thePartitionId << endl
                      << "        BEGIN INSERTIN TIME : " << CdbTimeUtils::time2string( theBeginInsertion ) << " : " << theBeginInsertion << endl
                      << "        END   INSERTIONTIME : " << CdbTimeUtils::time2string( theEndInsertion )   << " : " << theEndInsertion   << endmsg;

        return CdbStatus::IllegalParameters;
    }

  // Get a list of original objects in the specified scope

    std::vector< CdbCPtr<CdbSQLOriginalObject> > originalObjects;

    if( CdbStatus::Success != _myConditionPtr->original_objects( originalObjects,
                                                                 thePartitionId,
                                                                 theBeginInsertion,
                                                                 theEndInsertion )) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to get a list of original persistent objects for the condition in the view." << endl
                      << "        VIEW                : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                      << "        CONDITION           : \"" << name( ) << "\"" << endl
                      << "        PARTITION           : " << thePartitionId << endl
                      << "        BEGIN INSERTIN TIME : " << CdbTimeUtils::time2string( theBeginInsertion ) << " : " << theBeginInsertion << endl
                      << "        END   INSERTIONTIME : " << CdbTimeUtils::time2string( theEndInsertion )   << " : " << theEndInsertion   << endmsg;
        return CdbStatus::Error;
    }

  // Now pick up the right iterator and let it to do the rest...

    theItr = CdbObjectItr( new OriginalObjectIterator( new CdbSimpleVectorAdapterItr< CdbCPtr<CdbSQLOriginalObject> >( originalObjects ),
                                                       CdbConditionPtr( this->clone( ))));

  // Done

   return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::storeObject( CdbObjectFactoryBase& theObjectFactory,
                                 const BdbTime&        theBegin,
                                 const BdbTime&        theEnd,
                                 CdbObjectPtr&         theObjectPtr )
{
    const char* errorStr = "CdbSQLApiCondition::storeObject() -- ERROR";

    CDB_DEBUG_STREAM
        << "CDB_STORE_OBJECT_1: condition=" << name( )
        << " begin_time=" << CdbTimeUtils::time2string( theBegin )
        << " end_time=" << CdbTimeUtils::time2string( theEnd ) << endl;

    CdbStatus result = CdbStatus::Error;

    theObjectPtr = 0;

    do {

      // Truncated end validity time for the new object.
      //
      // NOTES:
      //
      //    (1) This time can be truncated to the end of the current partition if this
      //        is a partitionable condition and if the end time does not fit into the
      //        same partition the begin time falls into.
      //
      //    (2) This time can be further truncated if the "truncate" parameter delivered
      //        by by CdbEnvironment is less than the adjusted end time. This rule applies
      //        for both 'regular' and 'partitionable' conditions.
      //
      //        NOTE: The resulting truncate time should not be less or equal to the begin
      //              time. Otherwise the current operation would fail.

        BdbTime truncatedEnd = theEnd;

      // Find & verify the partition if the current condition is the partitionable one.
      // We may also truncate the end time of the partition if required.

        CdbCPtr<CdbSQLPartition> partitionPtr;

        if( _myConditionPtr->isPartitionable( )) {

          // Find the partition

            if( CdbStatus::Success != _myLocalSQLOriginPtr->find_topmost_partition( partitionPtr, 
                                                                                    theBegin )) {
                ErrMsg(error) << errorStr << "\n"
                              << "    Failed to locate an open partition for the begin time\n"
                              << "        BEGIN VALIDITY TIME: " << CdbTimeUtils::time2string( theBegin ) << " : " << theBegin << "\n"
                              << "        CONDITION NAME:      \"" << name( ) << "\"" << endmsg;
                break;
            }

          // Verify the partition

            if( partitionPtr->isClosed( )) {
                ErrMsg(error) << errorStr << "\n"
                              << "    The partition is closed for modifications.\n"
                              << "    Storing new objects in the closed partition is not allowed.\n"
                              << "        PARTITION ID:   " << partitionPtr->id( ) << "\n"
                              << "        CONDITION NAME: \"" << name( ) << "\"" << endmsg;
                break;
            }
            if( !partitionPtr->isInstantiated( )) {
                ErrMsg(error) << errorStr << "\n"
                              << "    The partition is not instantiated yet.\n"
                              << "    Storing new objects into a partition in this state is not allowed.\n"
                              << "        PARTITION ID:   " << partitionPtr->id( ) << "\n"
                              << "        CONDITION NAME: \"" << name( ) << "\"" << endmsg;
                break;
            }

          // Truncate the end time if needed.

            CdbSQLCell cell = partitionPtr->cell( );
            if( truncatedEnd > cell.endValidity ) truncatedEnd = cell.endValidity;
        }

      // Now make another adjustment (for both 'regular' and 'partitionable' conditions)
      // to the end time if the corresponding restriction is required by CdbEnvironment.

        {
            BdbTime truncateTime = CdbEnvironment::getTruncateTime( );
            if( truncateTime  < truncatedEnd ) {

                if( truncateTime <= theBegin ) {
                    ErrMsg(error) << errorStr << "\n"
                                  << "    Wrong value of the truncate time found in the job's environment.\n"
                                  << "    This time is not allwed to be less or equal to the begin time\n"
                                  << "    of stored objects. The job may be inproperly configured.\n"
                                  << "        TRUNCATE TIME: " << CdbTimeUtils::time2string( truncatedEnd ) << " : " << truncatedEnd << endmsg;
                    break;
                }
                truncatedEnd = truncateTime;

                CDB_DEBUG_STREAM << "CDB_STORE_OBJECT_1: truncated_end_time=" << CdbTimeUtils::time2string( truncatedEnd ) << endl;
            }
        }

      // Check if the condition can be modified localy.

        if( _myConditionPtr->isPartitionable( )) {
            if( _myLocalSQLOriginPtr->id( ) != partitionPtr->originId( )) {
                ErrMsg(error) << errorStr << "\n"
                              << "    The partition does not belong to current database. Therefore it can't\n"
                              << "    be used to store new objects locally.\n"
                              << "        PARTITION ID:   " << partitionPtr->id( ) << "\n"
                              << "        CONDITION NAME: \"" << name( ) << "\"" << endmsg;
                break;
            }
        } else {
            if( _myLocalSQLOriginPtr->id( ) != _myConditionPtr->parent( )->id( )) {
                ErrMsg(error) << errorStr << "\n"
                              << "    The condition does not belong to current database. Therefore it can't\n"
                              << "    be used to store new objects locally.\n"
                              << "        CONDITION NAME: \"" << name( ) << "\"" << endmsg;
                break;
            }
        }

      // Get to the Top-Level API component and delegate the object creation and storing
      // to a specific implementation of that API component.
      //
      // NOTE: We're using the above calculated "truncated" end time.

        CdbSQLApi* topLevelApiPtr = dynamic_cast< CdbSQLApi* >( parentDatabase( )->parent( ).get( ));
        assert( 0 != topLevelApiPtr );

        if( CdbStatus::Success != topLevelApiPtr->storeObject( theObjectPtr,
                                                               theObjectFactory,
                                                               _myConditionPtr,
                                                               partitionPtr,
                                                               CdbConditionPtr( this->clone( )),
                                                               theBegin,
                                                               truncatedEnd )) break;
        assert( !theObjectPtr.isNull( ));

        CDB_DEBUG_STREAM << "CDB_STORE_OBJECT_1: " << theObjectPtr->id( ) << endl; 

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbSQLApiCondition::storeAndTruncateObject( CdbObjectFactoryBase& theObjectFactory,
                                            const BdbTime&        theStoreTime,
                                            const BdbTime&        theTruncateTime,
                                            CdbObjectPtr&         theObjectPtr )
{
    return storeObject( theObjectFactory,
                        theStoreTime,
                        BdbTime::plusInfinity,
                        theObjectPtr );
}

CdbStatus
CdbSQLApiCondition::split( const BdbTime& theTime )
{
    ErrMsg(warning) << "CdbSQLApiCondition::split() -- WARNING.\n"
                    << "    The 'split interval' is the 'noop' operations in this\n"
                    << "    implementation of the API. This operation is only provided for backward\n"
                    << "    compatibility with the old condition database. Eventually it will be phased out." << endmsg;

    return CdbStatus::Success;
}

bool
CdbSQLApiCondition::isValid( )
{
    return true;
}

bool
CdbSQLApiCondition::isOpen( )
{
    return true;
}

CdbStatus
CdbSQLApiCondition::open( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::close( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::findRevision( CdbRevisionPtr& thePtr,
                                  const BdbTime&  theId,
                                  unsigned short  thePartitionId )
{
    CdbStatus result = CdbStatus::Error;

  // Find the persistent revision objects in a scope of the current condition/partition.

    CdbCPtr<CdbSQLRevision> persistentRevisionPtr;

    if( CdbStatus::Success != ( result = _myConditionPtr->find_revision( persistentRevisionPtr,
                                                                         theId,
                                                                         thePartitionId ))) {
        return result;
    }

  // Construct the transient revision object.

    thePtr = new CdbSQLApiRevision( CdbConditionPtr( this->clone( )),
                                    persistentRevisionPtr );

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::findRevision( CdbRevisionPtr& thePtr,
                                  const char*     theName,
                                  unsigned short  thePartitionId )
{
    CdbStatus result = CdbStatus::Error;

  // Find the persistent revision objects in a scope of the current condition/partition.

    CdbCPtr<CdbSQLRevision> persistentRevisionPtr;

    if( CdbStatus::Success != ( result = _myConditionPtr->find_revision( persistentRevisionPtr,
                                                                         theName,
                                                                         thePartitionId ))) {
        return result;
    }

  // Construct the transient revision object.

    thePtr = new CdbSQLApiRevision( CdbConditionPtr( this->clone( )),
                                    persistentRevisionPtr );

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::revisionIdIterator( CdbItr<BdbTime>& theItr,
                                        unsigned short   thePartitionId )
{
    const char* errorStr = "CdbSQLApiCondition::revisionIdIterator() -- ERROR";

    CdbStatus result = CdbStatus::Error;

  // Find all revision objects corresponding to current condition/partition.

    std::vector< CdbCPtr<CdbSQLRevision> > vectorOfRevisions;

    if( CdbStatus::Success != ( result = _myConditionPtr->revisions( vectorOfRevisions,
                                                                     thePartitionId ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to locate the MetaData objects for the current condition/partition." << endmsg;
        return result;
    }

  // Create the iterator out of the list.

    theItr = CdbItr<BdbTime>( new RevisionIdIterator( vectorOfRevisions ));

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::revisionNameIterator( CdbItr<const char*>& theItr,
                                          unsigned short       thePartitionId )
{
    const char* errorStr = "CdbSQLApiCondition::revisionNameIterator() -- ERROR";

    CdbStatus result = CdbStatus::Error;

  // Find all revision objects corresponding to current condition/partition.

    std::vector< CdbCPtr<CdbSQLRevision> > vectorOfRevisions;

    if( CdbStatus::Success != ( result = _myConditionPtr->revisions( vectorOfRevisions,
                                                                     thePartitionId ))) {
        ErrMsg(error) << errorStr << endl
                      << "    Failed to locate the MetaData objects for the current condition/partition." << endmsg;
        return result;
    }

  // Create the iterator out of the list.

    theItr = CdbItr<const char*>( new RevisionNameIterator( vectorOfRevisions ));

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::createRevision( CdbRevisionPtr& thePtr,
                                    const BdbTime&  theId,
                                    const char*     theName,
                                    const char*     theDescription,
                                    unsigned short  thePartitionId )
{
    return CdbStatus::NotImplemented;
}

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

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

CdbStatus
CdbSQLApiCondition::findInitialPartition( CdbCPtr<CdbSQLPartition>& thePartitionPtr,
                                          const BdbTime&            theValidityTime,
                                          const BdbTime&            theInsertionTime ) const
{
    const char* errorStr = "CdbSQLApiCondition::findInitialPartition() -- ERROR";

    CdbStatus result = CdbStatus::Error;

  // The partition location can be a two-stage process, First we look for general
  // partition information at the MASTER origin.

    if( BdbTime::plusInfinity == theInsertionTime ) {

        if( CdbStatus::Success != ( result = _myMasterSQLOriginPtr->find_topmost_partition( thePartitionPtr,
                                                                                            theValidityTime ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find a 'topmost' partition for specified validity time" << endl
                          << "    at the master origin." << endl
                          << "        VALIDITY TIME: " << theValidityTime << endmsg;
            return result;
        }

    } else {

        if( CdbStatus::Success != ( result = _myMasterSQLOriginPtr->find_partition( thePartitionPtr,
                                                                                    theValidityTime,
                                                                                    theInsertionTime ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find a partition at specified point of 2-D timespace" << endl
                          << "    at the master origin." << endl
                          << "        VALIDITY  TIME: " << theValidityTime << endl
                          << "        INSERTION TIME: " << theInsertionTime << endmsg;
            return result;
        }
    }

  // Then we need to verify if the found partition belongs to the local origin.
  // If so then we reload partition information from the local registry since this partition
  // is supposed to be modified locally.

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

        unsigned short partitionId = thePartitionPtr->id( );

        if( CdbStatus::Success != ( result = _myLocalSQLOriginPtr->find_partition( thePartitionPtr,
                                                                                   partitionId ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to locate a final partition with ID=" << partitionId << endl
                          << "    at the local database where it's supposed to belong to." << endl
                          << "    The local database may not be properly initialized/loaded." << endmsg;
            return result;
        }
    }

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::findNextPartition( CdbCPtr<CdbSQLPartition>& thePartitionPtr,
                                       const BdbTime&            theValidityTime ) const
{
    const char* fatalStr = "CdbSQLApiCondition::findNextPartition() -- FATAL ERROR";
    const char* errorStr = "CdbSQLApiCondition::findNextPartition() -- ERROR";

  // Verify critical parameters

    if( thePartitionPtr.isNull( )) {

        ErrMsg(fatal) << fatalStr << endl
                      << "    Null pointer passed into the method where a valid partition" << endl
                      << "    object was expected. This is a fatal internal error indicating" << endl
                      << "    either a memory corruption or an inconsistency in a database." << endmsg;

        return CdbStatus::IllegalParameters;
    }

  // Proceed with the normal flow of the algorithm

    CdbStatus result = CdbStatus::Error;

  // The partition location can be a two-stage process, First we're trying
  // to locate the information about the next partition from the master registry.

    unsigned short prevPartitionId = thePartitionPtr->id( );

    if( CdbStatus::Success != ( result = _myMasterSQLOriginPtr->find_next_partition( thePartitionPtr,
                                                                                     theValidityTime ))) {
      // Issue a complain only if a real error (otehr than CdbStatus::NotFound)
      // has been met.

        if( CdbStatus::NotFound != result ) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find a 'next' partition for specified validity time" << endl
                          << "    at the master registry." << endl
                          << "        VALIDITY TIME:       " << theValidityTime << endl
                          << "        PREVIOUS PARTITION: #" << prevPartitionId << endmsg;
        }

      // Quit anyway. Note, that the CdbStatus::NotFound status should be returned
      // to a caller unchanged.

        return result;
    }

  // Then we need to verify if the found partition belongs to the local registry.
  // If so then we reload partition information from the local registry since this partition
  // is supposed to be modified locally.

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

        unsigned short nextPartitionId = thePartitionPtr->id( );

        if( CdbStatus::Success != ( result = _myLocalSQLOriginPtr->find_partition( thePartitionPtr,
                                                                                   nextPartitionId ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find a partition #" << nextPartitionId << " at the local registry." << endmsg;
            return result;
        }
    }

  // Done

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiCondition::doFindObjectAtPartition( const CdbRevisionPolicy&      thePolicy,
                                             const BdbTime&                theValidityTime,
                                             const BdbTime&                theInsertionTime,
                                             CdbCPtr<CdbSQLVisibleObject>& theVisibleObjectPtr,
                                             BdbTime&                      theBeginOfVisiblePeriod,
                                             BdbTime&                      theEndOfVisiblePeriod,
                                             BdbTime&                      theBeginOfDurationPeriod,
                                             BdbTime&                      theEndOfDurationPeriod ) const
{
    const char* debugStr = "CdbSQLApiCondition::doFindObjectAtPartition()";
    const char* errorStr = "CdbSQLApiCondition::doFindObjectAtPartition() -- ERROR";
    const char* fatalStr = "CdbSQLApiCondition::doFindObjectAtPartition() -- FATAL ERROR";

    CdbStatus status = CdbStatus::Error;

  // Make sure this is a proper use of the algorithm. Just in case...

    assert( _myConditionPtr->isPartitionable( ));

  // Verify parameters and extract revision to begin with

    bool    useRevisions = thePolicy.useRevision( );
    BdbTime rId          = thePolicy.revisionId( );

    if( useRevisions ) {

        ;   // Nothing more to say

    } else if( BdbTime::plusInfinity == theInsertionTime ) {

        useRevisions = true;                    // Need this for the topmost revision
        rId          = BdbTime::plusInfinity;   // TOPMOST revision

    } else {

        rId = theInsertionTime;     // Still, no revisions
    }

  // Get the condition creation time. We would need this information to skip
  // partitions closed before that time.

    BdbTime creationTime = _myConditionPtr->created( );

    if( rId < creationTime ) {
        ErrMsg(error) << errorStr << endl
                      << "    Specified revision identifier / insertion time is older" << endl
                      << "    than the time when the condition was created." << endl
                      << "    The current view may be inproperly configured for the condition." << endl
                      << "        REVISION ID / INSERTION TIME : " << rId << endl
                      << "        CONDITION CREATION TIME      : " << creationTime << endl
                      << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                      << "        PARENT FOLDER NAME           : \"" << parent( )->name( ) << "\"" << endl
                      << "        VIEW NAME                    : \"" << parent( )->parentView( )->name( ) << "\"" << endmsg;

        return CdbStatus::Error;
    }

  // Find the initial <partition> to begin with.
  //
  // NOTE: We're going to check if the partion is closed. If so then its
  //       upper "insertion" time boundry is strictly above the condition
  //       creation time. Otherwise we just quit here since no intervals
  //       for the recently created condition should exist in his partition.

    CdbCPtr<CdbSQLPartition> partitionPtr;

    if( CdbStatus::Success != ( status = findInitialPartition( partitionPtr,
                                                               theValidityTime,
                                                               rId ))) {
        return status;
    }

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found initial partition ID=" << partitionPtr->id( ) << endl
         << "}" << endl;
/******************************************************************/

    if( partitionPtr->isClosed( )) {
        if( partitionPtr->endInsertion( ) <= creationTime ) {

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
cout << debugStr << endl
 << "{" << endl
 << "    The just found partition is already 'closed' and its upper 'insertion'" << endl
 << "    time limit is older than the creation time of the current condition." << endl
 << "    So no object has been found." << endl
 << "        creationTime                  : " << creationTime << endl
 << "        partitionPtr->endInsertion( ) : " << partitionPtr->endInsertion( ) << endl
 << "}" << endl;
/***************************************************************/

            return CdbStatus::NotFound;
        }
    }

  // Now we're ready to begin seraching for condition objects through
  // the sequence of partitions.
  //
  // == ALGORITHM DESCRIPTION ==
  //
  //  (1) The search algorithm begins with the specified revision/insertion time
  //      of the initially found partition and it will proceed down
  //      to final revisions of previously created ("next") partitions until
  //      either the desired interval is found or the bottom of the partitions
  //      stack is met. The bottom is defined as the lowest partition including
  //      the condition's creation time.
  //
  //  (2) If the bottom of the initial partition is met and desired interval
  //      is still not found then we switch to the next partition below
  //      the initial one and proceed with the search begining with the final
  //      revision of that partition.
  //
  //  (3) We proceed with step (2) until either we find desired interval or
  //      we reach the bottom of the condition. Note, that definition of
  //      the "bottom" given at (1) above.
  //
  // This algorithm is used for both states of the "useRevisions" flag
  // calculated above. The only difference is that in case of "!useRevisions"
  // we're only given one chance to try the above calculated initial partition
  // where the answer for specified insertionTime should be.
  //
  // Here is a pseudo-graphical representation of this process:
  //
  //           <validity time>
  //                   |
  //                   |
  // ..................|............................................
  // :Partition M      |                                           :
  // :                 |                              ============ :
  // :                 |                         ================= :
  // + + + + + + + + + X + + + + + + + + + + + + + + + + + + + + + +  Rev.M/insertion time
  // :                 |                   ======================= :
  // :                 |              ============================ :
  // :                 |        ================================== :
  // ..................|............................................
  //                   |
  // ..................|..........................
  // :Partition L      |                         :
  // :                 |                         :
  // + + + + + + + + + X + + + + + + + + + + + + +  Rev.Final
  // :                 |     =================== :
  // :                 | ======================= :
  // :                 X======================== :
  // :           =============================== :
  // .............................................
  //
  // == CALCULATING THE VISIBLE VALIDITY INTERVAL OF FOUND OBJECT ==
  //
  // The basic idea is that the visible validity interval is the shortest interval
  // of any of the following validity intervals met by the above described
  // algorithm:
  //
  // - the validity range of any partition explored
  // - the validity range of any failed as CdbStatus::NotFound attempts
  //   to find desired object at any MetaData object of partitions & increments explored
  // - the visibke validity for a successfully found object
  //
  // IMPORTANT: This algorithm needs thorough testing before deploying it.

  // Set up initial visible validity limits to the partition's borders. The limits
  // may be adjusted by the object lookup algorithm.

    theBeginOfVisiblePeriod = partitionPtr->beginValidity( );
    theEndOfVisiblePeriod   = partitionPtr->endValidity( );

    assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );

  // Begin the algorithm...

    bool isFirstPath = true;    // At first path we don't need to look for the 'topmost' revision
                                // of an initial partition. The correct revisions is supposed
                                // to be found above.
    do {

/**************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    isFirstPath : " << ( isFirstPath ? "Yes" : "No" ) << endl
         << "}" << endl;
/**************************************************************************/

        if( !isFirstPath ) {

          // Reload <partition>
          //
          // NOTE: We're going to check if the partion is closed. If so if its
          //       upper "insertion" time boundry is strictly above the condition
          //       creation time. Otherwise we just quit here since no intervals
          //       for the recently created condition should exist in his partition.

            if( CdbStatus::Success != ( status = findNextPartition( partitionPtr,
                                                                    theValidityTime ))) {
                return status;
            }

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found next partition ID=" << partitionPtr->id( ) << endl
         << "}" << endl;
/***************************************************************/

            if( partitionPtr->isClosed( )) {
                if( partitionPtr->endInsertion( ) <= creationTime ) {

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    The just found partition is already 'closed' and its upper 'insertion'" << endl
         << "    time limit is older than the creation time of the current condition." << endl
         << "    So no object has been found." << endl
         << "        creationTime                  : " << creationTime << endl
         << "        partitionPtr->endInsertion( ) : " << partitionPtr->endInsertion( ) << endl
         << "}" << endl;
/***************************************************************/

                    return CdbStatus::NotFound;
                }
            }

          // Narrow down the visible interval to the partition limits

            if( partitionPtr->beginValidity( ) > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = partitionPtr->beginValidity( );
            if( partitionPtr->endValidity( )   < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = partitionPtr->endValidity( );

            assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );
        }

      // If this is not the very first step in the <partition> loop
      // then we need to switch to the "topmost" revision of the just switched partition.
      //
      // NOTES:
      //
      //   1.The 'topmost' means a revision with highest numeric identifier in
      //   the scope of the partition.
      //
      //   2.That for closed partitions of partitionable conditions the returned
      //     identifier can not be equal to +Infinity.

        if( isFirstPath ) {
            ;
        } else {
            if( CdbStatus::Success != ( status = _myConditionPtr->topmost_revision_id( rId,
                                                                                       partitionPtr->id( )))) {
                ErrMsg(error) << errorStr << endl
                              << "    Failed to find the 'topmost' revision in a scope of the partition." << endl
                              << "        CONDITION NAME     : \"" << name( ) << "\"" << endl
                              << "        PARENT FOLDER NAME : \"" << parent( )->name( ) << "\"" << endl
                              << "        VIEW NAME          : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                              << "        PARTITION ID       : "   << partitionPtr->id( ) << endmsg;

                return status;
            }
        }

      // Try finding the persistent object in the current partition using
      // the requested method.

        if( useRevisions ) {

/*************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Find by revision" << endl
         << "       next    curent partition number : " << partitionPtr->id( ) << endl
         << "               rId                     : " << rId << endl
         << "               theValidityTime         : " << CdbTimeUtils::time2string( theValidityTime) << " : " << theValidityTime << endl
         << "}" << endl;
/*************************************************************************************************/

          // Find a visible validity interval in a scope of the current partition
          // using the current revision.
          //
          // IMPORTANT NOTE:
          //
          //   If the operation returns CdbStatus::NotFound then it still carries
          //   an important information about a "hole" corresponidng to non-found object.
          //   We may need to use this information to narrow down the further search in
          //   in the "next" (if any) partition.

            status = _myConditionPtr->find_visible_object( theVisibleObjectPtr,
                                                           theValidityTime,
                                                           partitionPtr->id( ),
                                                           rId );

/************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    status = _myConditionPtr->find_visible_object() : " << status << endl
         << "}" << endl;
/************************************************/

            if(( CdbStatus::Success  == status ) ||
               ( CdbStatus::NotFound == status )) {

              // Must readjust the validity limits even if the object has not been found.
              // The search may proceed down to the "next" (old) partition within limits of
              // the "validity hole".

                if( theVisibleObjectPtr->begin( ) > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = theVisibleObjectPtr->begin( );
                if( theVisibleObjectPtr->end( )   < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = theVisibleObjectPtr->end( );

                assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );

                if( CdbStatus::Success == status ) {

                  // The duration of this object begins with its insertion time up
                  // to +Infinity

                    theBeginOfDurationPeriod = theVisibleObjectPtr->stored( );
                    theEndOfDurationPeriod   = BdbTime::plusInfinity;

                    return CdbStatus::Success;
                }

            } else {

                ErrMsg(error) << errorStr << endl
                              << "    Failed to find an object by a revision." << endl
                              << "        CONDITION NAME     : \"" << name( ) << "\"" << endl
                              << "        PARENT FOLDER NAME : \"" << parent( )->name( ) << "\"" << endl
                              << "        VIEW NAME          : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                              << "        PARTITION ID       : "   << partitionPtr->id( ) << endl
                              << "        VALIDITY TIME      : "   << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl
                              << "        REVISION ID        : "   << CdbTimeUtils::time2string( rId )             << " : " << rId << endmsg;
                return status;
            }

        } else {

            ErrMsg(fatal) << fatalStr << endl
                          << "    Finding objects by an insertion time is not presently implemented." << endl
                          << "    Make sure that you're using an explicitly specified revision in a configuration" << endl
                          << "    of this condition." << endl
                          << "        CONDITION NAME     : \"" << name( ) << "\"" << endl
                          << "        PARENT FOLDER NAME : \"" << parent( )->name( ) << "\"" << endl
                          << "        VIEW NAME          : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                          << "        PARTITION ID       : "   << partitionPtr->id( ) << endl
                          << "        INSERTION TIME     : "   << CdbTimeUtils::time2string( rId ) << " : " << rId << endmsg;

            return CdbStatus::Error;
        }
        isFirstPath = false;

    } while( true );    // Should be broken by the logic above.

    return CdbStatus::Error;
}

CdbStatus
CdbSQLApiCondition::doFindObject( const CdbRevisionPolicy&      thePolicy,
                                  const BdbTime&                theValidityTime,
                                  const BdbTime&                theInsertionTime,
                                  CdbCPtr<CdbSQLVisibleObject>& theVisibleObjectPtr, 
                                  BdbTime&                      theBeginOfVisiblePeriod,
                                  BdbTime&                      theEndOfVisiblePeriod,
                                  BdbTime&                      theBeginOfDurationPeriod,
                                  BdbTime&                      theEndOfDurationPeriod ) const
{
    const char* debugStr = "CdbSQLApiCondition::doFindObject()";
    const char* errorStr = "CdbSQLApiCondition::doFindObject() -- ERROR";
    const char* fatalStr = "CdbSQLApiCondition::doFindObject() -- FATAL ERROR";

    CdbStatus status = CdbStatus::Error;

  // Make sure this is a proper use of the algorithm. Just in case...

    assert( !_myConditionPtr->isPartitionable( ));

  // Verify parameters and extract revision to begin with

    bool    useRevisions = thePolicy.useRevision( );
    BdbTime rId          = thePolicy.revisionId( );

    if( useRevisions ) {

        ;   // Nothing more to say

    } else if( BdbTime::plusInfinity == theInsertionTime ) {

        useRevisions = true;                    // Need this for the topmost revision
        rId          = BdbTime::plusInfinity;   // TOPMOST revision

    } else {

        rId = theInsertionTime;     // Still, no revisions
    }

  // Set up some initial "visible" validity period. This window will be corrected
  // by the condition lookup algorithm.

    theBeginOfVisiblePeriod = BdbTime::minusInfinity;
    theEndOfVisiblePeriod   = BdbTime::plusInfinity;

  // Try finding the persistent object in the current partition using
  // the requested method.

    if( useRevisions ) {

/*************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Find by revision" << endl
         << "               rId                     : " << rId << endl
         << "               theValidityTime         : " << CdbTimeUtils::time2string( theValidityTime) << " : " << theValidityTime << endl
         << "}" << endl;
/*************************************************************************************************/

      // Find a visible validity interval using the current revision.

        if( CdbStatus::Success != ( status = _myConditionPtr->find_visible_object( theVisibleObjectPtr,
                                                                                   theValidityTime,
                                                                                   0,
                                                                                   rId ))) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to find an object by a revision." << endl
                          << "        CONDITION NAME     : \"" << name( ) << "\"" << endl
                          << "        PARENT FOLDER NAME : \"" << parent( )->name( ) << "\"" << endl
                          << "        VIEW NAME          : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                          << "        VALIDITY TIME      : "   << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl
                          << "        REVISION ID        : "   << CdbTimeUtils::time2string( rId )             << " : " << rId << endmsg;
            return status;
        }

      // Must readjust the validity limits.

        if( theVisibleObjectPtr->begin( ) > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = theVisibleObjectPtr->begin( );
        if( theVisibleObjectPtr->end( )   < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = theVisibleObjectPtr->end( );

        assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );

      // The duration of this object begins with its insertion time up
      // to +Infinity

        theBeginOfDurationPeriod = theVisibleObjectPtr->stored( );
        theEndOfDurationPeriod   = BdbTime::plusInfinity;

        return CdbStatus::Success;
            
    } else {

        ErrMsg(fatal) << fatalStr << endl
                      << "    Finding objects by an insertion time is not presently implemented." << endl
                      << "    Make sure that you're using an explicitly specified revision in a configuration" << endl
                      << "    of this condition." << endl
                      << "        CONDITION NAME     : \"" << name( ) << "\"" << endl
                      << "        PARENT FOLDER NAME : \"" << parent( )->name( ) << "\"" << endl
                      << "        VIEW NAME          : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                      << "        INSERTION TIME     : "   << CdbTimeUtils::time2string( rId ) << " : " << rId << endmsg;

        return CdbStatus::Error;
    }
    return CdbStatus::Error;
}

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

---