---

CdbSQLApiView.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbSQLApiView.cc,v 1.2 2005/10/19 18:54:26 gapon Exp $

/// The implementation of the CdbSQLApiView class.
/**
  * @see CdbSQLApiView
  */
#include "BaBar/BaBar.hh"

#include "CdbSQL/CdbSQLApiView.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbVectorAdapterItr.hh"
#include "CdbBase/CdbSimpleVectorAdapterItr.hh"

#include "CdbSQL/CdbSQLOrigin.hh"
#include "CdbSQL/CdbSQLPartition.hh"
#include "CdbSQL/CdbSQLView.hh"
#include "CdbSQL/CdbSQLFolder.hh"
#include "CdbSQL/CdbSQLConditionAtFolder.hh"
#include "CdbSQL/CdbSQLApiFolder.hh"

#include <assert.h>

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

namespace {

  /////////////////////////////
  // Class IteratorOfFolders //
  /////////////////////////////

    class IteratorOfFolders : public CdbVectorAdapterItr< const char*, CdbCPtr<CdbSQLFolder> > {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        IteratorOfFolders( );

      /// The assignment operator (NOT IMPLEMENTED)

        IteratorOfFolders& operator=( const IteratorOfFolders& );

    protected:

      /// The copy constructor

        IteratorOfFolders( const IteratorOfFolders& theItr ) :
            CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLFolder> >( theItr )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        IteratorOfFolders( const std::vector< CdbCPtr<CdbSQLFolder> >& theList ) :
            CdbVectorAdapterItr< const char*, CdbCPtr<CdbSQLFolder> >( theList )
        { }

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

    protected:

      /// User defined translation for the currently reffered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual const char* toValue( const CdbCPtr<CdbSQLFolder>& thePtr ) const
        {
            return thePtr->name( ).c_str( );
        }
    };
}

//////////////////////////////
// Class: CdbSQLApiView //
//////////////////////////////

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

    CdbSQLApiView* mySelf = const_cast<CdbSQLApiView*>( this );
    return new CdbSQLApiView( mySelf->parent( ),
                              mySelf->name( ),
                              mySelf->id( ),
                              _mySQLViewPtr,
                              _myMasterSQLOriginPtr,
                              _myLocalSQLOriginPtr );
}

CdbSQLApiView::CdbSQLApiView( const CdbDatabasePtr&        thePtr,
                              const char*                  theName,
                              const CdbId&                 theId,
                              const CdbCPtr<CdbSQLView>&   theViewPtr,
                              const CdbCPtr<CdbSQLOrigin>& theMasterOriginPtr,
                              const CdbCPtr<CdbSQLOrigin>& theLocalOriginPtr ) :
    CdbView( thePtr,
             theName,
             theId ),
    _mySQLViewPtr        (theViewPtr),
    _myMasterSQLOriginPtr(theMasterOriginPtr),
    _myLocalSQLOriginPtr (theLocalOriginPtr)
{
    assert( !_mySQLViewPtr.isNull( ));
    assert( !_myMasterSQLOriginPtr.isNull( ));
    assert( !_myLocalSQLOriginPtr.isNull( ));
}

CdbSQLApiView::~CdbSQLApiView( )
{ }

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

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

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

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

BdbTime
CdbSQLApiView::minValidity( ) const
{
    return _mySQLViewPtr->begin( );
}

BdbTime
CdbSQLApiView::maxValidity( ) const
{
    return _mySQLViewPtr->end( );
}

BdbTime
CdbSQLApiView::created( ) const
{
    return _mySQLViewPtr->created( );
}

std::string
CdbSQLApiView::description( ) const
{
    return _mySQLViewPtr->description( );
}

bool
CdbSQLApiView::hasDefaultConfig( ) const
{
    return _mySQLViewPtr->hasDefaultConfig( );
}

bool
CdbSQLApiView::isLocal( ) const
{
    return id( ).origin == _myLocalSQLOriginPtr->id( );
}

bool 
CdbSQLApiView::isFrozen( ) const
{
    return _mySQLViewPtr->isFrozen( );
}

CdbStatus
CdbSQLApiView::findFolder( CdbFolderPtr& thePtr,
                               const char*   theName )
{
    CdbStatus status = CdbStatus::Error;

  // Only the "root" folder is allowed

    if( std::string( theName ) != CdbPathName::separator( )) {

        cout << "CdbSQLApiView::findFolder() -- ERROR" << endl
             << "    No such folder in this implementation: \"" << theName                   << "\"" << endl
             << "    The only name allowed is the rood one: \"" << CdbPathName::separator( ) << "\"" << endl;

        return CdbStatus::Error;
    }

  // Find out persistent folder for specified name

    CdbCPtr<CdbSQLFolder> folderPtr;
    if( CdbStatus::Success != ( status = _mySQLViewPtr->find_folder( folderPtr,
                                                                     std::string( theName )))) {
        return status;
    }

  // Construct a transient CDB API object

    CdbFolderPtr parentFolderPtr = 0;       // the root folder is not supposed to have a parent

    thePtr = new CdbSQLApiFolder( CdbViewPtr( this->clone( )),
                                  parentFolderPtr,
                                  theName,
                                  folderPtr,
                                  _myMasterSQLOriginPtr,
                                  _myLocalSQLOriginPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiView::folderIterator( CdbFolderItr& theItr )
{
    const char* errorStr = "CdbSQLApiView::folderIterator() -- ERROR.";

    CdbStatus status = CdbStatus::Error;

  // Find all folders in the scope of the pesistent view

    std::vector< CdbCPtr<CdbSQLFolder> > folders;
    if( CdbStatus::Success != ( status = _mySQLViewPtr->folders( folders ))) {
        cout << errorStr << endl
             << "    Failed to obtain a list of folders at the view." << endl
             << "        VIEW NAME : \"" << name( ) << "\"." << endl;
        return status;
    }
    theItr = CdbFolderItr( new IteratorOfFolders( folders ));

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiView::getDefault( const BdbTime&    theValidityTime,
                               CdbConfigElement& theConfigElement ) const
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbSQLApiView::defaultConfigIterator( CdbItr<CdbConfigElement>& theItr ) const
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbSQLApiView::get( const char*       theName,
                    const BdbTime&    theValidityTime,
                    CdbConfigElement& theConfigElement ) const
{
    const char* errorStr = "CdbSQLApiView::get() -- ERROR.";

    CdbStatus status = CdbStatus::Error;

  // Verify the condition path name.

    if( 0 == theName ) {
        cout << errorStr << endl
             << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
        return CdbStatus::IllegalParameters;
    }

    CdbPathName fullPath( theName );

    if( ! ( fullPath.isValid( ) &&
            fullPath.isAbsolute( ) &&
            fullPath.isComposite( ))) {

        cout << errorStr << endl
             << "    Unsupported format of the condition name. Fully qualified" << endl
             << "    condition name including its folder path was expected." << endl
             << "        Passed condition name: \"" << theName << "\"" << endl;
        return CdbStatus::IllegalParameters;
    }

  // Check if specified time fits into the validity interval covered by
  // the current view.

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

        cout << errorStr << endl
             << "    The pased validity time is out of the validity interval covered" << endl
             << "    by the current view." << endl
             << "        Passed  validity time: " << theValidityTime << endl
             << "        Minimum validity time: " << _mySQLViewPtr->begin( ) << endl
             << "        Maximum validity time: " << _mySQLViewPtr->end( ) << endl;
        return CdbStatus::IllegalParameters;
    }

  // First we're going to see if specified condition has its own revision
  // configuration. This always superseeds the default configuration at
  // the level of the view.

    CdbConfigElement configElement;
    {
        std::string folderName    = fullPath.beforeLast( ).toString( );
        std::string conditionName = fullPath.last( ).toString( );

      // Find the parent folder first

        CdbCPtr<CdbSQLFolder> folderPtr;
        if( CdbStatus::Success != ( status = _mySQLViewPtr->find_folder( folderPtr,
                                                                         folderName ))) {
            return status;
        }

      // Then find the condition

        CdbCPtr<CdbSQLConditionAtFolder> conditionPtr;
        if( CdbStatus::Success != ( status = folderPtr->find_condition( conditionPtr,
                                                                        conditionName ))) {
            return status;
        }

      // Proceed to the configuration element

        status = conditionPtr->find_config_element( configElement,
                                                    theValidityTime );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) {

              // No configuration found at the conditin level. Get the default
              // configuration at the view level then.

                if( CdbStatus::Success != _mySQLViewPtr->find_config_element( configElement,
                                                                              theValidityTime )) {
                    cout << errorStr << endl
                         << "    The current view is inproperly configured for specified condition." << endl
                         << "    No configuration found both at specified condition scope and" << endl
                         << "    at the view level." << endl
                         << "        Current view name:     \"" << name( ) << "\"" << endl
                         << "        Passed condition name: \"" << theName << "\"" << endl;
                    return status;
                }

            } else {
                cout << errorStr << endl
                     << "    A problem occured while attempting to get a configuration." << endl
                     << "    No configuration found both at specified condition scope and" << endl
                     << "    at the view level." << endl
                     << "        Current view name:     \"" << name( ) << "\"" << endl
                     << "        Passed condition name: \"" << theName << "\"" << endl;
                return status;
            }
        }
    }
    theConfigElement = configElement;

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiView::configIterator( const char*               theName,
                               CdbItr<CdbConfigElement>& theItr ) const
{
    const char* errorStr = "CdbSQLApiView::configIterator() -- ERROR.";

    CdbStatus status = CdbStatus::Error;

  // Verify the condition path name.

    if( 0 == theName ) {
        cout << errorStr << endl
             << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
        return CdbStatus::IllegalParameters;
    }

    CdbPathName fullPath( theName );

    if( ! ( fullPath.isValid( ) &&
            fullPath.isAbsolute( ) &&
            fullPath.isComposite( ))) {

        cout << errorStr << endl
             << "    Unsupported format of the condition name. Fully qualified" << endl
             << "    condition name including its folder path was expected." << endl
             << "        Passed condition name: \"" << theName << "\"" << endl;
        return CdbStatus::IllegalParameters;
    }

  // First we're going to see if specified condition has  its own revision
  // configuration. This always superseeds the default configuration at
  // the level of the view.

    std::vector<CdbConfigElement> config_elements;
    {
        std::string folderName    = fullPath.beforeLast( ).toString( );
        std::string conditionName = fullPath.last( ).toString( );

      // Find the parent folder first

        CdbCPtr<CdbSQLFolder> folderPtr;
        if( CdbStatus::Success != ( status = _mySQLViewPtr->find_folder( folderPtr,
                                                                         folderName ))) {
            return status;
        }

      // Then find the condition

        CdbCPtr<CdbSQLConditionAtFolder> conditionPtr;
        if( CdbStatus::Success != ( status = folderPtr->find_condition( conditionPtr,
                                                                        conditionName ))) {
            return status;
        }

      // Then proceed to configuration elements

        status = conditionPtr->config_elements( config_elements );

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

              // No configuration found at the conditin level. Get the default
              // configuration at the view level then.

                if( CdbStatus::Success != ( status = _mySQLViewPtr->config_elements( config_elements ))) {
                    cout << errorStr << endl
                         << "    The current view is inproperly configured for specified condition." << endl
                         << "    No configuration found both at specified condition scope and" << endl
                         << "    at the view level." << endl
                         << "        Current view name:     \"" << name( ) << "\"" << endl
                         << "        Passed condition name: \"" << theName << "\"" << endl;
                    return status;
                }

            } else {
                cout << errorStr << endl
                     << "    A problem occured while attempting to get a configuration." << endl
                     << "    No configuration found both at specified condition scope and" << endl
                     << "    at the view level." << endl
                     << "        Current view name:     \"" << name( ) << "\"" << endl
                     << "        Passed condition name: \"" << theName << "\"" << endl;
                return status;
            }
        }
    }

  // Fill up 'holes' in the validity timeline if the above found list doesn't cover
  // the whole timeline.

    std::vector<CdbConfigElement> adjusted_config_elements;
    {
        BdbTime prevEnd = BdbTime::minusInfinity;

        for( std::vector<CdbConfigElement>::const_iterator itr = config_elements.begin();
                                                           itr != config_elements.end();
                                                         ++itr ) {
            if( prevEnd < itr->begin )
                adjusted_config_elements.push_back( CdbConfigElement( prevEnd,
                                                                      itr->begin ));
            adjusted_config_elements.push_back( *itr );
            prevEnd = itr->end;
        }
        if( prevEnd < BdbTime::plusInfinity )
            adjusted_config_elements.push_back( CdbConfigElement( prevEnd,
                                                                  BdbTime::plusInfinity ));
    }
    theItr = CdbItr<CdbConfigElement>( new CdbSimpleVectorAdapterItr<CdbConfigElement>( adjusted_config_elements ));

    return CdbStatus::Success;
}

CdbStateId
CdbSQLApiView::currentStateId( const BdbTime& theValidityTime ) const
{
    const char* errorStr = "CdbSQLApiView::currentStateId() -- ERROR.";

    CdbStateId result;  // REMEMBER: default value of the State ID is invalid
    do {

      // _________________________________________________________________________________
      // The algorithm desctiption below has been copied from its original implementation
      // in the "Shared" implementation of the "Bdb" technology. See the implementation of
      // the correponding method for more details.
      //
      // @see CdbBdbSView::currentStateId()
      //
      // _______________________________________________________________________
      // Find out a 'topmost' partition corresponding to specified validity time
      // and obtain its modification time.
      //
      // NOTE: The logic implemented by the current code is slightly different from
      //       the one found in previous implementations. Here are the differences:
      //
      //       (1) The previous implementations used _current_ wall-clock time if
      //           a 'closed' partition was found. The new logic will always use
      //           the modification time.
      //
      //           [ That older logic didn't seem right from the optimization point of view
      //             since the actual _meaning_ of StateId-s does not change with wall-clock
      //             time for closed partition. In this case an identifier of a views
      //             alone stored as a part of the StateId provides full description of
      //             the same state of CDB. ]
      //
      //       (2) Another tiny change in the logic is related to so called "non-instantiated"
      //           partition not owned by the current CDB. This transitional scenario is quite
      //           normal in a distributed CDB when a remote origin has not delivered its
      //           instance of a known to MASTER partition (unless this instance is supposed
      //           to belong to the current 'origin'. Having a non-instantiated partition
      //           belonging to  the current 'origin' is supposed to be a CDB initialization
      //           error.). When this transition scenario is detected the creation time of the
      //           partition (in fact - the 'bottom' of the partition in the modification
      //           time dimension) will be put into the StateID.
      //
      //       (3) The current wall-clock time will only be used if no partition will be
      //           found for the specified validity time. It's quite an unusual situation
      //           meaning that 'partitionable' conditions are not in use at all.
      //
      // If the found partition is still not 'closed' (is 'under construction')
      // and if the current database is not the MASTER one and (finally :-)) if found
      // partition belongs to the local database then we should switch to the local
      // partition object. Then we'll have the most 'up-to-date' information about
      // the modification time of that partition.
      //
      // This kind of logic will not only provide us with the 'up-to-date' modification
      // time of a partition in its owner database, but will also ensure the correctness
      // of its ('modification time') in other databases.
      //
      // NOTE: The modification time as a way to refine the current state of the database
      //       _ONLY_ makes sense for the 'partitionable' conditions. In case of 'regular'
      //       conditions one should rely on the regular revisions mechanizm (sufficiently 
      //       supported by views)  to acheive the reproducability of the database contents.

        BdbTime partitionModificationTime( BdbTime::now( ));    // _current_ time by default
        {
          // NOTE: The following operation will look for an 'topmost' partition at
          //       at the MASTER registry.

            CdbCPtr<CdbSQLPartition> partitionPtr;
            if( CdbStatus::Success == _myMasterSQLOriginPtr->find_topmost_partition( partitionPtr,
                                                                                     theValidityTime )) {

              // Refine which partition object to use

                if( !partitionPtr->isClosed( )) {

                  // Switch from the MASTER partition to the local one if needed, which
                  // is going to happen in a case when the found partition belongs to
                  // the local 'origin'.

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

                          // Since we're switching to the final partition then we have one extra requirement
                          // to this partition - it must exist.
                          //
                          // NOTE: Unlike the previous step when we're looking for the preliminary information
                          //       about the partition now we also need to find 'closed' partitions
                          //       This is why we're looking this partition by it's ID, not requering
                          //       its "openness".

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

              // Check one more time if that partition is in the 'open' state because
              // the previous step was switch us to the final partition owned
              // by the current SLAVE database. Therefore the information we're looking
              // for must be 'up-to-date'.

                if( partitionPtr->isClosed( )) {

                  // Get the modification time of the 'closed' partition. It will correspond
                  // to the time when the partition was closed.

                    partitionModificationTime = partitionPtr->modified( );

                } else {

                  // The non-local partition is allowed to be not instantiated since
                  // its owner database may not have delivered the corresponding updated version of it.
                  //
                  // Otherwise we treat the non-instantiated partition as a database inconsistency problem...

                    if( partitionPtr->isInstantiated( )) {
                        partitionModificationTime = partitionPtr->modified( );
                    } else {
                        if( _myLocalSQLOriginPtr->id( ) == partitionPtr->originId( )) {
                            cout << errorStr << endl
                                 << "    The partition with ID=" << partitionPtr->id( ) << " corresponding to the following" << endl
                                 << "    validity time: " << theValidityTime << endl
                                 << "    belonging to the local database is not properly instantiated." << endl
                                 << "    The local database may not be properly initialized/loaded." << endl;
                            break;

                        } else {

                          // This is pretty normal 'transitional' situation - a remote database has
                          // not delivered its instantiated partition yet. Therefore we don't know yet
                          // when the partition was modified. So we just go along with 'creation' time
                          // of the partition. This 'creation' time represents the 'bottom' of the partition
                          // in the modification timeline. It will guarantee that we'll be relying on
                          // the values of 'partitionable' conditions stored _before_ the found partition.

                            partitionModificationTime = partitionPtr->created( );
                        }
                    }
                }
            }
        }

      // Build the valid state identifier

        result = CdbStateId( id( ), partitionModificationTime );

    } while( false );

    return result;
}

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

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

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

---