---

CdbBdbSSimpleClusterP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSSimpleClusterP.cc,v 1.5 2004/08/06 05:54:25 bartoldu Exp $

/// Implementation file for the CdbBdbSSimpleClusterP class
/**
  * @see CdbBdbSSimpleClusterP
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSSimpleClusterP.hh"
#include "CdbBdbShared/CdbBdbSUtils.hh"
#include "CdbBdbShared/CdbBdbSMetaDataP.hh"
#include "CdbBdbShared/CdbBdbSConditionP.hh"

#include "BdbClustering/BdbCondIndexClusteringHint.hh"

#include <stdio.h>
#include <iostream>

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

CdbBdbSSimpleClusterP::CdbBdbSSimpleClusterP( const char*    theName,
                                              d_UShort       theId,
                                              const char*    theDescription,
                                              const BdbTime& theCreationTime ) :
    CdbBdbSClusterP( theName,
                     theId,
                     theDescription,
                     theCreationTime )
{ }

CdbBdbSSimpleClusterP::~CdbBdbSSimpleClusterP( ) 
{ }

d_UShort
CdbBdbSSimpleClusterP::numIncrements( ) const
{
    return _increments.numIncrements( );
}

CdbStatus
CdbBdbSSimpleClusterP::increment( d_UShort          theNumber,
                                  CdbBdbSIncrement& theIncrement ) const
{
    return _increments.increment( theNumber,
                                  theIncrement );
}

CdbStatus
CdbBdbSSimpleClusterP::createIncrement( const BdbTime& theSplitTime )
{
    const char* errorStr = "CdbBdbSSimpleClusterP::createIncrement() -- ERROR";

    ooUpdate( );

    CdbStatus result = CdbStatus::Error;
    do {

      // Locate the highest old increment number

        d_UShort oldIncrementNumber = 0;
        {
            d_UShort num = _increments.numIncrements( );

            assert( num >= 1 );      // FATAL ERROR: There must be at least 1 increment
                                     //              in the cluster.
            oldIncrementNumber = num - 1;
        }

      // Create new increment number

        if( CdbStatus::Success != _increments.createIncrement( theSplitTime )) {
            cout << errorStr << endl
                 << "    Failed to create the new cluster increment." << endl;
            break;
        }

      // Locate the highest new increment number

        d_UShort newIncrementNumber = 0;
        {
            d_UShort num = _increments.numIncrements( );

            assert( num >= 2 );      // FATAL ERROR: There must be at least 1+1 increment
                                     //              in the cluster (the last one we've just
                                     //              created)
            newIncrementNumber = num - 1;
        }

      // Build the name of the new database for the increment

        std::string localRangeName;
        {
            CdbStatus returnStatus = CdbBdbSUtils::getLocalDbIdRange( localRangeName );
            assert( CdbStatus::Success == returnStatus );
        }
        std::string newDatabaseSuffix;
        {
            char clusterIdStr[12];
            char clusterNewIncrementStr[12];

            sprintf( clusterIdStr, "%u", id( ));
            sprintf( clusterNewIncrementStr, "%u", newIncrementNumber );

            newDatabaseSuffix = std::string( "c" )  + std::string( clusterIdStr ) +
                                std::string( "_i" ) + std::string( clusterNewIncrementStr );

            newDatabaseSuffix = newDatabaseSuffix +
                                std::string( "_" ) +
                                localRangeName;
        }

      // Create the new database by asking to create the "System" container
      // in it.

        BdbCondIndexClusteringHint systemHint( "cdb",
                                               "System",
                                               newDatabaseSuffix.c_str( ));

        BdbHandle(BdbContObj) systemContH;
        systemContH = systemHint.updatedHint( );

        assert( ! BdbIsNull(systemContH));
        assert( systemHint.newContainerCreated( ));

      // For each condition in this cluster

        CdbItr< BdbRef(CdbBdbSConditionP) > itr;
        if( CdbStatus::Success != iterator( itr )) {
            cout << errorStr << endl
                 << "    Failed to obtain the conditions - members of the cluster." << endl;
            break;
        }

        bool failed = false;

        while( itr.next( )) {

          // Locate condition

            BdbRef(CdbBdbSConditionP) conditionRef = itr.value( );
            assert( !BdbIsNull(conditionRef));

            d_UShort conditionId = conditionRef->id( );

          // Locate topmost metadata of the old increment

            BdbRef(CdbBdbSMetaDataP) oldMetaDataRef;
            if( CdbStatus::Success != CdbBdbSUtils::findMetaData( oldMetaDataRef,
                                                                  conditionId,
                                                                  false,        // non-partitionable
                                                                  0,            // partition identifier
                                                                  id( ),        // current cluster identifier
                                                                  oldIncrementNumber,
                                                                  localRangeName )) {

                cout << errorStr << endl
                     << "    Failed to find MetaData object for increment #" << oldIncrementNumber << endl;

                failed = true;
                break;
            }

          // Close  the found metadata object.
          //
          // NOTE: The closure procedure will also create a final revision in
          //       in the metadata container at the most recent modification
          //       time of that metadata container.

            BdbTime modificationTime = oldMetaDataRef->modified( );
            char finalRevisionNameStr[32];

            sprintf( finalRevisionNameStr,
                     "final_%u.%u",
                     modificationTime.getGmtSec( ),
                     modificationTime.getGmtNsec( ));

            if( CdbStatus::Success != oldMetaDataRef->close( theSplitTime,
                                                             finalRevisionNameStr,
                                                             theSplitTime,
                                                             "automatically created by the increment creation procedure" )) {
                cout << errorStr << endl
                     << "    Failed to close the old MetaData object." << endl;

                failed = true;
                break;
            }

          // Create new metadata object for this condition in the new database
          //
          //   NOTE: We need to extend the API of MetaData object to pass it a reference onto
          //         the previous metadata object to be initialized from.

            char conditionIdStr[12];
            sprintf( conditionIdStr, "%u", conditionId );

            std::string mdContainerName = std::string( "MetaData." ) + std::string( conditionIdStr );
            std::string obContainerName = std::string( "Objects."  ) + std::string( conditionIdStr );

          // Create containers for metadata and condition objects at specified
          // database.

            BdbCondIndexClusteringHint mdHint( "cdb",
                                               mdContainerName.c_str( ),
                                               newDatabaseSuffix.c_str( ));

            BdbHandle(BdbContObj) mdContH;
            mdContH = mdHint.updatedHint( );

            assert( ! BdbIsNull(mdContH));
            assert( mdHint.newContainerCreated( ));

            BdbCondIndexClusteringHint obHint( "cdb",
                                               obContainerName.c_str( ),
                                               newDatabaseSuffix.c_str( ));

            BdbHandle(BdbContObj) obContH;
            obContH = obHint.updatedHint( );

            assert( ! BdbIsNull(obContH));
            assert( obHint.newContainerCreated( ));

          // Create initial infrastructure in the newely created
          // container for metadata. The new medatada will have the same validity interval
          // as the old, and its begin insertion time will be where the old one ends.
          //
          // NOTE: Remember, that intervals collections of the new metadata object
          //       will be incomplete since they will not include intervals from previous
          //       increments. It's up to the intervals locator algorithm running on the top
          //       of metadata objects to resolve this issue.

            BdbHandle(CdbBdbSMetaDataP) newMetaDataH;
            newMetaDataH = new( mdContH ) CdbBdbSMetaDataP( oldMetaDataRef->minValidity( ), // begin of the validity
                                                            oldMetaDataRef->maxValidity( ), // end   of the validity
                                                            theSplitTime );
            assert( ! BdbIsNull(newMetaDataH));

          //  Name the metadata structure to be able to discover it later.

            BdbStatus status;
            status = newMetaDataH.nameObj( mdContH,
                                          "MetaData" );
            assert( BdbcSuccess == status );
        }
        if( failed ) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---