---

CdbBdb2MySQLConversionTool.cc

Go to the documentation of this file.

// A conversion tool to convert the contents of an Objectivity/DD base
// CDB installation into the MySQL based one.

#include "BaBar/BaBar.hh"

#include "BdbUtil/Bdb.hh"

#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbTimeUtils.hh"
#include "CdbBase/CdbTransaction.hh"

#include "CdbBdbShared/CdbBdbShared.hh"
#include "CdbBdbShared/CdbBdbSRegistryP.hh"
#include "CdbBdbShared/CdbBdbSOriginCollectionP.hh"
#include "CdbBdbShared/CdbBdbSOriginP.hh"
#include "CdbBdbShared/CdbBdbSConditionCollectionP.hh"
#include "CdbBdbShared/CdbBdbSConditionP.hh"
#include "CdbBdbShared/CdbBdbSViewCollectionP.hh"
#include "CdbBdbShared/CdbBdbSViewP.hh"
#include "CdbBdbShared/CdbBdbSConfigCollectionP.hh"
#include "CdbBdbShared/CdbBdbSConfigInterval.hh"
#include "CdbBdbShared/CdbBdbSClusterCollectionP.hh"
#include "CdbBdbShared/CdbBdbSClusterP.hh"
#include "CdbBdbShared/CdbBdbSSimpleClusterP.hh"
#include "CdbBdbShared/CdbBdbSIncrement.hh"
#include "CdbBdbShared/CdbBdbSPartitionsLayoutP.hh"
#include "CdbBdbShared/CdbBdbSPartitionP.hh"
#include "CdbBdbShared/CdbBdbSMetaDataP.hh"
#include "CdbBdbShared/CdbBdbSUtils.hh"
#include "CdbBdbShared/CdbBdbSOiCollectionP.hh"
#include "CdbBdbShared/CdbBdbSRevisionP.hh"
#include "CdbBdbShared/CdbBdbSViCollectionP.hh"

#include "CdbMySQL/CdbMySQLConnection.hh"
#include "CdbMySQL/CdbMySQLQueryUtils.hh"

#include "RdbMySQL/RdbMySQLResult.hh"

#include <assert.h>
#include <stdio.h>
#include <string.h>     // strlen()

#include <string>
#include <vector>
#include <map>

#include <sstream>
using std::ostringstream;

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

namespace {

    bool verboseModeFlag          = false;
    bool excludeRegularFlag       = false;
    bool excludePartitionableFlag = false;

    CdbCPtr<CdbMySQLConnection> myConnectionPtr;

    bool
    translate_uint( unsigned int&      theValue,
                    const std::string& theString )
    {
        unsigned v;

        if( 1 == sscanf( theString.c_str( ), "%u", &v )) {
            theValue = v;
            return true;
        }
        return false;
    }

    bool
    execute_sql_query( const std::string& theQuery )
    {
        const char* context = "Bdb2MySQLConversionTool::execute_sql_query()";

        if( verboseModeFlag )
            cout << theQuery << endl;

        CdbCPtr<RdbMySQLResult> resultPtr;
        if( CdbStatus::Success != CdbMySQLQueryUtils::execute_query( resultPtr,
                                                                     myConnectionPtr,
                                                                     theQuery,
                                                                     context )) return false;
        return true;
    }
    
    CdbStatus convertOrigins( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH );

    CdbStatus convertClusters( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH );

    CdbStatus convertPartitionsLayout( const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH,
                                       const BdbHandle(CdbBdbSRegistryP)& theInRegistryH );

    CdbStatus convertPhysicalConditions( const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH,
                                         const BdbHandle(CdbBdbSRegistryP)& theInRegistryH );

    CdbStatus convertViews( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH );

    CdbStatus convertFoldersAndConditions( const std::string&               theFoldersConditionsTableName,
                                           const std::string&               theConditionsConfigsTableName,
                                           const BdbHandle(CdbBdbSViewP)&   theInViewH,
                                           const BdbHandle(CdbBdbSFolderP)& theInFolderH,
                                           const CdbPathName&               theCurrentPathName );

    CdbStatus convertConfigCollection( const std::string&                      theConditionsConfigsTableName,
                                       const BdbRef(CdbBdbSConfigCollectionP)& theInputConfigCollectionRef );

    CdbStatus testMetaDataConversion( ) { return CdbStatus::NotImplemented; }

    CdbStatus convertMetaDataOfRegularCondition( const BdbHandle(CdbBdbSConditionP)& theConditionH,
                                                 const BdbHandle(CdbBdbSRegistryP)&  theMasterRegistryH,
                                                 d_UShort                            theOwnerOriginId );

    CdbStatus convertMetaDataOfPartitionableCondition( const BdbHandle(CdbBdbSConditionP)& theConditionH,
                                                       const BdbHandle(CdbBdbSRegistryP)&  theMasterRegistryH );

    CdbStatus convertMetaData( const BdbHandle(CdbBdbSMetaDataP)& theInMetaDataH,
                               d_UShort                           theOriginId,
                               d_UShort                           theConditionId,
                               d_UShort                           theClusterId,
                               bool                               isPartitionableFlag,
                               d_UShort                           thePartitionId,
                               d_UShort                           theIncrementId );

    CdbStatus printPersistentClasses( );

    CdbStatus printPersistentConditions( );
}

static
void
usage( )
{
    cerr << "Usage: [-h <host>] [-u <user>] [-port <number>] [-db <database>] <command> [<parameters>]" << endl
         << "       help" << endl
         << "       conversion [-noregular] [-nopartitionable] [-verbose]" << endl
         << "       testing                                    [-verbose]" << endl
         << "       classes    [-noregular] [-nopartitionable] [-verbose]" << endl
         << "       conditions [-noregular] [-nopartitionable] [-verbose]" << endl;
}

int
main( int argc, char* argv[] )
{
  // Parameters of a MySQL connection

    std::string  myHost     = "yakut01";
    std::string  myUser     = "gapon";
    std::string  myPassword = "";       // no password
    unsigned int myPort     = 0;        // default port in the current MySQL installation
    std::string  myDatabase = "cdb";

  // Get the command name

    enum CommandType {
        CMD_CONVERSION = 0,
        CMD_TESTING,
        CMD_CLASSES,
        CMD_CONDITIONS
    };
    CommandType command = CMD_CONVERSION;

    int numArgs = argc - 1;
    int nextArg = 1;

    if( numArgs >= 2 ) {
        if( std::string( "-h" ) == argv[nextArg] ) {
            myHost = argv[nextArg+1];
            nextArg += 2;
            numArgs -= 2;
        }
    }
    if( numArgs >= 2 ) {
        if( std::string( "-u" ) == argv[nextArg] ) {
            myUser = argv[nextArg+1];
            nextArg += 2;
            numArgs -= 2;
        }
    }
    if( numArgs >= 2 ) {
        if( std::string( "-port" ) == argv[nextArg] ) {
            if( !translate_uint( myPort,
                                 argv[nextArg+1] )) {
                cerr << "failed to translate the port number." << endl;
                usage( );
                return 1;
            }
            nextArg += 2;
            numArgs -= 2;
        }
    }
    if( numArgs >= 2 ) {
        if( std::string( "-db" ) == argv[nextArg] ) {
            myDatabase = argv[nextArg+1];
            nextArg += 2;
            numArgs -= 2;
        }
    }
    if( 0 == numArgs ) {
        usage( );
        return 1;
    }
    if( numArgs > 0 ) {

        const std::string commandName = argv[nextArg];

        if( commandName == "help" ) {

            usage( );

            return 1;

        } else if( commandName == "conversion" ) {

            command = CMD_CONVERSION;

            numArgs --;
            nextArg ++;

        } else if( commandName == "testing" ) {

            command = CMD_TESTING;

            numArgs --;
            nextArg ++;

        } else if( commandName == "classes" ) {

            command = CMD_CLASSES;

            numArgs --;
            nextArg ++;

        } else if( commandName == "conditions" ) {

            command = CMD_CONDITIONS;

            numArgs --;
            nextArg ++;

        } else {

            cerr << "unknown command: \"" << commandName << "\"." << endl;
            usage( );
            return 1;
        }
    }
    if( numArgs > 0 ) {
        if( argv[nextArg] == std::string( "-noregular" )) {

            excludeRegularFlag = true;

            numArgs --;
            nextArg ++;
        }
    }
    if( numArgs > 0 ) {
        if( argv[nextArg] == std::string( "-nopartitionable" )) {

            excludePartitionableFlag = true;

            numArgs --;
            nextArg ++;
        }
    }
    if( numArgs > 0 ) {
        if( std::string( "-verbose" ) == argv[nextArg] ) {

            verboseModeFlag = true;

            numArgs --;
            nextArg ++;

        } else {
            cerr << "unknown command option or parameter: \"" << argv[nextArg] << "\"." << endl;
            usage( );
            return 1;
        }
    }

   // Initialize Ojectivity/DB base CDB API context

    CdbBdbShared::forceLoad( );

    CdbTransaction readOnlyTransaction( CdbBdbShared::technology( ),
                                        CdbBdbShared::implementation( ));

  // Open a connection with the database. The connection object is made
  // visible in this file scope.

    const bool notExistingDatabaseFlag = true;

    myConnectionPtr = new CdbMySQLConnection( myHost,
                                              myUser,
                                              myPassword,
                                              notExistingDatabaseFlag,
                                              myDatabase,
                                              myPort );

  // Proceed directly to the simple tests if required.

    switch( command ) {
    case CMD_TESTING   : return ( CdbStatus::Success == ::testMetaDataConversion   ( ) ? 0 : 1 );
    case CMD_CLASSES   : return ( CdbStatus::Success == ::printPersistentClasses   ( ) ? 0 : 1 );
    case CMD_CONDITIONS: return ( CdbStatus::Success == ::printPersistentConditions( ) ? 0 : 1 );
    default:
        break;
    }

  // Recreate the output database

    cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << endl;

    if( !execute_sql_query( "DROP DATABASE IF EXISTS " + myDatabase )) return 1;
    if( !execute_sql_query( "CREATE DATABASE " + myDatabase )) return 1;

  // Create a table with the informaton about the "local" origin and default
  // view of the current database installation.

    {
        std::string localTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".local";
            localTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + localTableName )) return 1;
        {
            const std::string query =
                "CREATE TABLE " + localTableName + " ( " +
                "origin_id SMALLINT UNSIGNED, " +
                "origin_name VARCHAR(32), " +
                "default_view TEXT " +
                ") COMMENT = 'This table describes local identity and some other information in this CDB installation. " +
                "There may be just one, instance of the table in the CDB. Each CDB installation has its own local copy of this table.'";

            if( !execute_sql_query( query )) return 1;
        }
        {
            const std::string query =
                "INSERT INTO " + localTableName + " (origin_id,origin_name,default_view) VALUES ( " +
                "0, " +
                "'MASTER', " +
                "'<local>::<recent>' )";
            if( !execute_sql_query( query )) return 1;
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << localTableName << endl;
    }

  // Get the MASTER registry and the collection of origins, which we'll
  // be using for a few things below.

    BdbHandle(CdbBdbSRegistryP) masterRegistryH;
    CdbStatus result = CdbBdbSRegistryP::findMaster( masterRegistryH );
    if( CdbStatus::Success != result ) {
        cerr << "failed to find the MASTER registry." << endl;
        return 1;
    }
    assert( masterRegistryH->isMaster( ));

    BdbHandle(CdbBdbSOriginCollectionP) originCollectionH = masterRegistryH->originCollection( );
    assert( !BdbIsNull(originCollectionH));

  // Convert the collection of origins which belongs to MASTER.

    if( CdbStatus::Success != ( result = convertOrigins( masterRegistryH ))) {
        cerr << "failed to convert the collection of origins." << endl;
        return 1;
    }

  // Iterate over known registries and convert them one-by-one if the corresponding origins
  // are instantiated in the input database.

    CdbBdbSOriginCollectionP::IteratorOfIdentifiers itr = originCollectionH->iterator_identifiers( );
    while( itr.next( )) {

        d_UShort originId = itr.value( );

      // Try to get the corresponding registry. If it doesn't exist (not instantiated) then we
      // will _NOT_ create the output data structures for that registry.

        BdbHandle(CdbBdbSRegistryP) registryH;
        {
            CdbStatus result = CdbBdbSRegistryP::findByOrigin( registryH,
                                                               originId );
            if( CdbStatus::Success != result ) {
                if( CdbStatus::NotFound == result ) {

                  // The origin is not currently instantiated in the input database. This may happen
                  // when the origin's data are yet to be imported.

                    continue;

                } else {
                    cerr << "failed to find a registry for origin ID = " << originId << "." << endl;
                    return 1;
                }
            }
        }

      // MASTER & SLAVE collections only

        if( !BdbIsNull( registryH->partitionsLayout( ))) {

            if( CdbStatus::Success != ( result = ::convertPartitionsLayout( masterRegistryH,
                                                                            registryH ))) {
                cerr << "Failed to convert Partitions Layout." << endl
                     << "for origin ID = " << originId << endl;
                return 1;
            }
        }

      // Convert and store some local collections

        if( registryH->hasLocalCollections( )) {

            if( CdbStatus::Success != ( result = ::convertClusters( registryH ))) {

                cerr << "Failed to convert a collection of condition clusters." << endl
                     << "for origin ID = " << originId << endl;
                return 1;
            }
            if( CdbStatus::Success != ( result = ::convertViews( registryH ))) {

                cerr << "Failed to convert a collection of views." << endl
                     << "for origin ID = " << originId << endl;
                return 1;
            }
        }
    }
    cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << endl;

  // Proceed to local collections
  //
  // NOTE: A reason why we're doing this in a separate loop is that the prebvious loop
  //       over origins should create the tables for 'physical conditions'

    itr.reset( );

    while( itr.next( )) {

        d_UShort originId = itr.value( );

      // Try to get the corresponding registry. If it doesn't exist (not instantiated) then we
      // will _NOT_ create the output data structures for that registry.

        BdbHandle(CdbBdbSRegistryP) registryH;
        {
            CdbStatus result = CdbBdbSRegistryP::findByOrigin( registryH,
                                                               originId );
            if( CdbStatus::Success != result ) {
                if( CdbStatus::NotFound == result ) {

                  // The origin is not currently instantiated in the input database. This may happen
                  // when the origin's data are yet to be imported.

                    continue;

                } else {
                    cerr << "failed to find a registry for origin ID = " << originId << "." << endl;
                    return 1;
                }
            }
        }

      // Convert and store remaining local collections

        if( registryH->hasLocalCollections( )) {

            if( CdbStatus::Success != ( result = ::convertPhysicalConditions( masterRegistryH,
                                                                              registryH ))) {

                cerr << "Failed to convert a collection of 'physical' conditions." << endl
                     << "for origin ID = " << originId << endl;
                return 1;
            }
        }
    }
    cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << endl;

  // Done.

    return 0;
}

/////////////
// Helpers //
/////////////

namespace {

    CdbStatus
    convertOrigins( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH )
    {
        const char* errorStr = "::convertOrigins() - ERROR.";

        assert( !BdbIsNull(theInRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Recreate the table

        std::string tableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_origins";
            tableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + tableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + tableName + " ( " +
                "id SMALLINT UNSIGNED, " +
                "name VARCHAR(32), " +
                "type ENUM('M','S', 'T', 'R'), " +
                "created BIGINT UNSIGNED, " +
                "description TEXT, " +
                "is_instantiated ENUM('Y','N') " +
                ") COMMENT = 'This table describes known origins in CDB." +
                "There may be just one, MASTER owned, instance of the table in CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }

      // Convert origins from the input collection and put them into the table

        BdbHandle(CdbBdbSOriginCollectionP) originCollectionH = theInRegistryH->originCollection( );
        assert( !BdbIsNull(originCollectionH));

        CdbBdbSOriginCollectionP::IteratorOfIdentifiers itr = originCollectionH->iterator_identifiers( );
        while( itr.next( )) {

          // Get the input condition

            d_UShort originId = itr.value( );

            BdbHandle(CdbBdbSOriginP) originH;
            {
                BdbRef(CdbBdbSOriginP) originRef;
                if( CdbStatus::Success != ( result = originCollectionH->find( originId,
                                                                              originRef ))) {
                    cerr << errorStr << endl
                         << "    An origin with ID = " << originId << " was not found." << endl;
                    return result;
                }
                originH = originRef;
            }

          // Remap the origin type

            char originType = 'M';

            switch( originH->type( )) {

            case CdbBdbSOriginP::MASTER  : originType = 'M'; break;
            case CdbBdbSOriginP::SLAVE   : originType = 'S'; break;
            case CdbBdbSOriginP::REPLICA : originType = 'R'; break;
            case CdbBdbSOriginP::TEST    : originType = 'T'; break;

            default:

                cerr << errorStr << endl
                     << "    An unknown (to the current algorithm) origin type: " << originH->type( ) << endl;
                return CdbStatus::Error;
            }

          // Try to find the corresponding registry to see if it's instantaited or not
          // in the current database installation.

            bool originIsInstantiatedFlag = false;
            {
                BdbHandle(CdbBdbSRegistryP) registryHandle;
                originIsInstantiatedFlag = CdbStatus::Success == CdbBdbSRegistryP::findByOrigin( registryHandle, originH->id( ));

            }

          // Create the output one and put into the collection

            std::string query;
            {
                ostringstream s;

                s << "INSERT INTO " << tableName << " "
                  << "(id,name,type,created,description,is_instantiated) VALUES ("
                  << originH->id( ) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( originH->name( ).head( )) << "',"
                  << "'" << originType << "',"
                  << CdbTimeUtils::to_nsec( originH->created( )) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( originH->description( ).head( )) << "',"
                  << "'" << (originIsInstantiatedFlag ? 'Y' : 'N' ) << "')";

                query = s.str( );
            }
            if(!execute_sql_query( query )) return CdbStatus::Error;
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << tableName << endl;

        return CdbStatus::Success;
    }

    CdbStatus
    convertPhysicalConditions( const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH,
                               const BdbHandle(CdbBdbSRegistryP)& theInRegistryH )
    {
        const char* errorStr = "::convertPhysicalConditions() - ERROR.";

        assert( !BdbIsNull(theInRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Recreate the table

        std::string tableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_physical_conditions";
            tableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + tableName  )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + tableName + " ( " +
                "id SMALLINT UNSIGNED, " +
                "name VARCHAR(255), " +
                "type ENUM('P','R'), " +
                "cluster SMALLINT UNSIGNED, " +
                "created BIGINT UNSIGNED, " +
                "description TEXT " +
                ") COMMENT = 'This table describes known physical conditions in this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }

      // Convert conditions from the input collection and put them into the table

        BdbHandle(CdbBdbSConditionCollectionP) conditionCollectionH = theInRegistryH->conditionCollection( );

        CdbBdbSConditionCollectionP::IteratorOfIdentifiers itr = conditionCollectionH->iterator_identifiers( );
        while( itr.next( )) {

          // Get the input condition

            d_UShort conditionId = itr.value( );

            BdbHandle(CdbBdbSConditionP) conditionH;
            {
                BdbRef(CdbBdbSConditionP) conditionRef;
                if( CdbStatus::Success != ( result = conditionCollectionH->find( conditionId,
                                                                                 conditionRef ))) {
                    cerr << errorStr << endl
                         << "    A condition with ID = " << conditionId << " was not found." << endl;
                    return result;
                }
                conditionH = conditionRef;
            }

          // See if we need to exclude it

            if( conditionH->isPartitionable( )) {
                if( excludePartitionableFlag ) continue;
            } else {
                if( excludeRegularFlag ) continue;
            }

            char conditionType = ( conditionH->isPartitionable( ) ? 'P' : 'R' );

          // Create the output one and put into the collection

            std::string query;
            {
                ostringstream s;

                s << "INSERT INTO " << tableName << " "
                  << "(id,name,type,cluster,created,description) VALUES ("
                  << conditionH->id( ) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( conditionH->name( ).head( )) << "',"
                  << "'" << conditionType << "',"
                  << conditionH->cluster( )->id( ) << ","
                  << CdbTimeUtils::to_nsec( conditionH->created( )) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( conditionH->description( ).head( )) << "')";

                query = s.str( );
            }
            if(!execute_sql_query( query )) return CdbStatus::Error;

          // Find all relevant MetaData objects and convert them too

            if( !conditionH->isPartitionable( )) {

                if( CdbStatus::Success != ( result = ::convertMetaDataOfRegularCondition( conditionH,
                                                                                          theMasterRegistryH,
                                                                                          theInRegistryH->originId( )))) {
                    cerr << errorStr << endl
                         << "    Failed to convert MetaDaa of a 'regular' condition with ID = " << conditionId << "." << endl;
                    return result;
                }

            } else {

                if( CdbStatus::Success != ( result = ::convertMetaDataOfPartitionableCondition( conditionH,
                                                                                                theMasterRegistryH ))) {
                    cerr << errorStr << endl
                         << "    Failed to convert MetaData of a 'partitionable' condition with ID = " << conditionId << "." << endl;
                    return result;
                }
            }
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << tableName << endl;

        return CdbStatus::Success;
    }

    CdbStatus
    convertClusters( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH )
    {
        const char* errorStr = "::convertClusters() - ERROR.";

        assert( !BdbIsNull(theInRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Recreate the tables

        std::string clustersTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_clusters";
            clustersTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + clustersTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + clustersTableName + " ( " +
                "id SMALLINT UNSIGNED," +
                "name VARCHAR(255), " +
                "type ENUM( 'R', 'P' ), " +
                "created BIGINT UNSIGNED, " +
                "description TEXT " +
                ") COMMENT = 'This table describes clusters in this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }
        std::string rIncrementsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_cluster_increments";
            rIncrementsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + rIncrementsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + rIncrementsTableName + " ( " +
                "cluster_id SMALLINT UNSIGNED," +
                "id SMALLINT UNSIGNED, " +
                "begin BIGINT UNSIGNED, " +
                "end BIGINT UNSIGNED " +
                ") COMMENT = 'This table describes increments of REGULAR clusters in this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }

      // Convert 'partitionable' clusters if they're defined for the specifid registry.

        {
            BdbHandle(CdbBdbSClusterCollectionP) clusterCollectionH = theInRegistryH->pClusterCollection( );
            if( !BdbIsNull(clusterCollectionH)) {

                CdbBdbSClusterCollectionP::IteratorOfIdentifiers itr = clusterCollectionH->iterator_identifiers( );
                while( itr.next( )) {

                  // Get the input cluster

                    d_UShort clusterId = itr.value( );

                    BdbHandle(CdbBdbSClusterP) clusterH;
                    {
                        BdbRef(CdbBdbSClusterP) clusterRef;
                        if( CdbStatus::Success != ( result = clusterCollectionH->find( clusterId,
                                                                                       clusterRef ))) {
                            cerr << errorStr << endl
                                 << "    A 'partitionable' cluster with ID = " << clusterId << " was not found." << endl;
                            return result;
                        }
                        clusterH = clusterRef;
                    }
                    const char clusterTypeFlag = 'P';

                  // Create the output cluster and store it in the collection

                    {
                        std::string query;

                        ostringstream s;

                        s << "INSERT INTO " << clustersTableName << " "
                          << "(id,name,type,created,description) VALUES ("
                          << clusterH->id( ) << ","
                          << "'" << myConnectionPtr->translate_string_to_escaped( clusterH->name( ).head( )) << "',"
                          << "'" << clusterTypeFlag << "',"
                          << CdbTimeUtils::to_nsec( clusterH->created( )) << ","
                          << "'" << myConnectionPtr->translate_string_to_escaped( clusterH->description( ).head( )) << "')";

                        query = s.str( );

                        if(!execute_sql_query( query )) return CdbStatus::Error;
                    }
                }
            }
        }

      // Convert 'regular' clusters if they're defined for the specifid registry.
      // Also put the information about increments into a separate table.

        {
            BdbHandle(CdbBdbSClusterCollectionP) clusterCollectionH = theInRegistryH->clusterCollection( );
            if( !BdbIsNull(clusterCollectionH)) {

                CdbBdbSClusterCollectionP::IteratorOfIdentifiers itr = clusterCollectionH->iterator_identifiers( );
                while( itr.next( )) {

                  // Get the input cluster

                    d_UShort clusterId = itr.value( );

                    BdbHandle(CdbBdbSSimpleClusterP) clusterH;
                    {
                        BdbRef(CdbBdbSSimpleClusterP) clusterRef;
                        if( CdbStatus::Success != ( result = clusterCollectionH->find( clusterId,
                                                                                       clusterRef ))) {
                            cerr << errorStr << endl
                                 << "    A 'regular' cluster with ID = " << clusterId << " was not found." << endl;
                            return result;
                        }
                        clusterH = clusterRef;
                    }
                    const char clusterTypeFlag = 'R';

                  // Create the output cluster and store it in the collection

                    {
                        std::string query;

                        ostringstream s;

                        s << "INSERT INTO " << clustersTableName << " "
                          << "(id,name,type,created,description) VALUES ("
                          << clusterH->id( ) << ","
                          << "'" << myConnectionPtr->translate_string_to_escaped( clusterH->name( ).head( )) << "',"
                          << "'" << clusterTypeFlag << "',"
                          << CdbTimeUtils::to_nsec( clusterH->created( )) << ","
                          << "'" << myConnectionPtr->translate_string_to_escaped( clusterH->description( ).head( )) << "')";

                        query = s.str( );

                        if(!execute_sql_query( query )) return CdbStatus::Error;
                    }

                  // Prepare a vector with increments converted from the input cluster

                    d_UShort numIncrements = clusterH->numIncrements( );
                    for( d_UShort incrementId = 0; incrementId < numIncrements; ++incrementId ) {

                        CdbBdbSIncrement inputIncrement;

                        if( CdbStatus::Success != ( result = clusterH->increment( incrementId,
                                                                                  inputIncrement ))) {
                            cerr << errorStr << endl
                                 << "    An increment with ID = " << incrementId << " was not found in a cluster with ID = " << clusterId << endl;
                            return result;
                        }

                      // Create the output increments and put them into the collection

                        {
                            std::string query;

                            ostringstream s;

                            s << "INSERT INTO " << rIncrementsTableName << " "
                              << "(cluster_id,id,begin,end) VALUES ("
                              << clusterH->id( ) << ","
                              << incrementId << ","
                              << CdbTimeUtils::to_nsec( inputIncrement.begin ) << ","
                              << CdbTimeUtils::to_nsec( inputIncrement.end ) << ")";

                            query = s.str( );

                            if(!execute_sql_query( query )) return CdbStatus::Error;
                        }

                      // Also create tables for metadata of regular conditions

                        std::string baseTableName;
                        {
                            ostringstream s;
                            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( )
                              << "_c" << clusterId
                              << "_i" << incrementId
                              << "_";
                            baseTableName = s.str( );
                        }
                        const std::string payloadObjectsTableName    = baseTableName + "payload";
                        const std::string originalIntervalsTableName = baseTableName + "original";
                        const std::string revisionsTableName         = baseTableName + "revisions";
                        const std::string visibleIntervalsTableName  = baseTableName + "visible";

                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + payloadObjectsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + payloadObjectsTableName + " ( " +
                                "id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY, " +    // PRIMARY
                                "legacy_id TEXT, " +
                                "type TEXT, " +
                                "size INT UNSIGNED, " +
                                "value MEDIUMBLOB " +
                                ") COMMENT = 'This table represents PAYLOAD objects for REGULAR conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + originalIntervalsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + originalIntervalsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +                // COMPOSITE PRIMARY, ALSO FOREIGN -> "physical_conditions" @ MASTER origin
                                "stored BIGINT UNSIGNED," +                         // COMPOSITE PRIMARY
                                "begin BIGINT UNSIGNED, " +
                                "end BIGINT UNSIGNED, " +
                                "object_id INTEGER UNSIGNED " +                     // FOREIGN -> "payload" objects within the same scope
                                ") COMMENT = 'This table represents ORIGINAL objects for REGULAR conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + revisionsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + revisionsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +    // COMPOSITE PRIMARY, ALSO FOREIGN -> "physical_conditions" @ MASTER origin
                                "id BIGINT UNSIGNED, " +                // COMPOSITE PRIMARY
                                "name TEXT, " + 
                                "created BIGINT UNSIGNED, " +
                                "description TEXT " +
                                ") COMMENT = 'This table represents REVISIONS for REGULAR conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + visibleIntervalsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + visibleIntervalsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +    // COMPOSITE PRIMARY, FOREIGN -> "physical_conditions" @ MASTER origin
                                "revision_id BIGINT UNSIGNED, " +       // COMPOSITE PRIMARY, FOREIGN -> "revisions"
                                "begin BIGINT UNSIGNED, " +             // COMPOSITE PRIMARY
                                "end BIGINT UNSIGNED, " +               // COMPOSITE PRIMARY
                                "original_stored BIGINT UNSIGNED " +    // FOREIGN KEY -> "original"
                                ") COMMENT = 'This table represents VISIBLE objects for REGULAR conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << payloadObjectsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << originalIntervalsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << revisionsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << visibleIntervalsTableName << endl;
                    }
                }
            }
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << clustersTableName << endl;
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << rIncrementsTableName << endl;

        return CdbStatus::Success;
    }

    CdbStatus
    convertPartitionsLayout( const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH,
                             const BdbHandle(CdbBdbSRegistryP)& theInRegistryH )
    {
        const char* errorStr = "::convertPartitionsLayout() - ERROR.";

        assert( !BdbIsNull(theInRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Recreate the tables

        std::string pLayoutTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_partitions";
            pLayoutTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + pLayoutTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + pLayoutTableName + " ( " +
                "id SMALLINT UNSIGNED," +
                "origin_id SMALLINT UNSIGNED, " +
                "is_instantiated  ENUM( 'Y', 'N' ), " +
                "is_closed ENUM( 'Y', 'N' ), " +
                "created BIGINT UNSIGNED, " +
                "modified BIGINT UNSIGNED, " +
                "v_begin BIGINT UNSIGNED, " +
                "v_end BIGINT UNSIGNED, " +
                "i_begin BIGINT UNSIGNED, " +
                "i_end BIGINT UNSIGNED, " +
                "description TEXT " +
                ") COMMENT = 'This table describes the Partitions Layout of this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }
        std::string pIncrementsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_partition_increments";
            pIncrementsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + pIncrementsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + pIncrementsTableName + " ( " +
                "partition_id SMALLINT UNSIGNED," +
                "id SMALLINT UNSIGNED, " +
                "begin BIGINT UNSIGNED, " +
                "end BIGINT UNSIGNED " +
                ") COMMENT = 'This table describes increments of PARTITIONS in this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }

      // Get a number of partitionable clusters from the Master registry. We'll need
      // this information to create tables for partitionable conditions.
      //
      // NOTES:
      //
      //   - We're asuming that partitionable clusters (as well as conditions themselves)
      //   can only created in MASTER CDB. At least at the current implementation of CDB.

        BdbHandle(CdbBdbSClusterCollectionP) pClusterCollectionH = theMasterRegistryH->clusterCollection( );
        assert( !BdbIsNull(pClusterCollectionH));

        CdbBdbSClusterCollectionP::IteratorOfIdentifiers pClusterItr = pClusterCollectionH->iterator_identifiers( );

      // Convert partitions from the input collection and put them into the table.
      // Also put the information about increments into a separet table.

        BdbHandle(CdbBdbSPartitionsLayoutP) partitionsLayoutH = theInRegistryH->partitionsLayout( );
        assert( !BdbIsNull(partitionsLayoutH));

        CdbItr<d_UShort> itr = partitionsLayoutH->iterator( );
        while( itr.next( )) {

            d_UShort partitionId = itr.value( );

          // Get the input partition

            BdbHandle(CdbBdbSPartitionP) partitionH;
            {
                BdbRef(CdbBdbSPartitionP) partitionRef;
                if( CdbStatus::Success != ( result = partitionsLayoutH->find( partitionId,
                                                                              partitionRef ))) {
                    cerr << errorStr << endl
                         << "    A partition with ID = " << partitionId << " was not found." << endl;
                    return result;
                }
                partitionH = partitionRef;
            }

            char isInstantiatedFlag = ( partitionH->isInstantiated( ) ? 'Y' : 'N' );
            char isClosedFlag       = ( partitionH->isClosed( )       ? 'Y' : 'N' );

          // Create the output partition and put into the collection

            {
                std::string query;

                ostringstream s;

                s << "INSERT INTO " << pLayoutTableName << " "
                  << "(id,origin_id,is_instantiated,is_closed,created,modified,v_begin,v_end,i_begin,i_end,description) VALUES ("
                  << partitionH->id( ) << ","
                  << partitionH->originId( ) << ","
                  << "'" << isInstantiatedFlag << "',"
                  << "'" << isClosedFlag << "',"
                  << CdbTimeUtils::to_nsec( partitionH->created( )) << ","
                  << CdbTimeUtils::to_nsec( partitionH->modified( )) << ","
                  << CdbTimeUtils::to_nsec( partitionH->cell( ).beginValidity ) << ","
                  << CdbTimeUtils::to_nsec( partitionH->cell( ).endValidity) << ","
                  << CdbTimeUtils::to_nsec( partitionH->cell( ).beginInsertion) << ","
                  << CdbTimeUtils::to_nsec( partitionH->cell( ).endInsertion) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( partitionH->description( ).head( )) << "')";

                query = s.str( );

                if(!execute_sql_query( query )) return CdbStatus::Error;
            }

          // Convert a collection of increments

            d_UShort numIncrements = partitionH->numIncrements( );
            for( d_UShort incrementId = 0; incrementId < numIncrements; ++incrementId ) {

                CdbBdbSIncrement inputIncrement;

                if( CdbStatus::Success != ( result = partitionH->increment( incrementId,
                                                                            inputIncrement ))) {
                    cerr << errorStr << endl
                         << "    An increment with ID = " << incrementId << " was not found in a partition with ID = " << partitionId << endl;
                    return result;
                }

              // Create the output increments and put them into the collection

                {
                    std::string query;

                    ostringstream s;

                    s << "INSERT INTO " << pIncrementsTableName << " "
                      << "(partition_id,id,begin,end) VALUES ("
                      << partitionH->id( ) << ","
                      << incrementId << ","
                      << CdbTimeUtils::to_nsec( inputIncrement.begin ) << ","
                      << CdbTimeUtils::to_nsec( inputIncrement.end ) << ")";

                    query = s.str( );

                    if(!execute_sql_query( query )) return CdbStatus::Error;
                }

              // Get identifiers of all partitionable clusters and create tables for methadata
              // of partitionable conditions.
              //
              // NOTES:
              //
              //   - Tables will only be created for partitions owned by the local origin (the one passed
              //   as a parameter)

                if( theInRegistryH->originId( ) == partitionH->originId( )) {

                    pClusterItr.reset( );

                    while( pClusterItr.next( )) {

                        d_UShort clusterId = pClusterItr.value( );

                        std::string baseTableName;
                        {
                            ostringstream s;
                            s << myConnectionPtr->database( ) << ".o" << partitionH->originId( )
                              << "_p" << partitionH->id( )
                              << "_c" << clusterId
                              << "_i" << incrementId
                              << "_";
                            baseTableName = s.str( );
                        }
                        const std::string payloadObjectsTableName    = baseTableName + "payload";
                        const std::string originalIntervalsTableName = baseTableName + "original";
                        const std::string revisionsTableName         = baseTableName + "revisions";
                        const std::string visibleIntervalsTableName  = baseTableName + "visible";

                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + payloadObjectsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + payloadObjectsTableName + " ( " +
                                "id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY, " +    // PRIMARY
                                "legacy_id TEXT, " +
                                "type TEXT, " +
                                "size INT UNSIGNED, " +
                                "value MEDIUMBLOB " +
                                ") COMMENT = 'This table represents PAYLOAD objects for PARTITIONABLE conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + originalIntervalsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + originalIntervalsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +        // COMPOSITE PRIMARY, ALSO FOREIGN -> "physical_conditions" @ MASTER origin
                                "stored BIGINT UNSIGNED," +                 // COMPOSITE PRIMARY
                                "begin BIGINT UNSIGNED, " +
                                "end BIGINT UNSIGNED, " +
                                "object_id INTEGER UNSIGNED NOT NULL " +    // FOREIGN -> "payload" objects within the same scope
                                ") COMMENT = 'This table represents ORIGINAL objects for PARTITIONABLE conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + revisionsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + revisionsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +    // COMPOSITE PRIMARY, ALSO FOREIGN -> "physical_conditions" @ MASTER origin
                                "id BIGINT UNSIGNED, " +                // COMPOSITE PRIMARY
                                "name TEXT, " + 
                                "created BIGINT UNSIGNED, " +
                                "description TEXT " +
                                ") COMMENT = 'This table represents REVISIONS for PARTITIONABLE conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        if(!execute_sql_query( "DROP TABLE IF EXISTS " + visibleIntervalsTableName )) return CdbStatus::Error;
                        {
                            const std::string query =
                                "CREATE TABLE " + visibleIntervalsTableName + " ( " +
                                "condition_id SMALLINT UNSIGNED, " +    // COMPOSITE PRIMARY, FOREIGN -> "physical_conditions" @ MASTER origin
                                "revision_id BIGINT UNSIGNED, " +       // COMPOSITE PRIMARY, FOREIGN -> "revisions"
                                "begin BIGINT UNSIGNED, " +             // COMPOSITE PRIMARY
                                "end BIGINT UNSIGNED, " +               // COMPOSITE PRIMARY
                                "original_stored BIGINT UNSIGNED " +    // FOREIGN KEY -> "original"
                                ") COMMENT = 'This table represents VISIBLE objects for PARTITIONABLE conditions in a scope of this PARTITION, CLUSTER and an INCREMENT.'";

                            if( !execute_sql_query( query )) return CdbStatus::Error;
                        }
                        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << payloadObjectsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << originalIntervalsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << revisionsTableName << "\n"
                             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << visibleIntervalsTableName << endl;
                    }
                }
            }
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << pLayoutTableName << "\n"
             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << pIncrementsTableName << endl;

        return CdbStatus::Success;
    }

    CdbStatus
    convertViews( const BdbHandle(CdbBdbSRegistryP)& theInRegistryH )
    {
        const char* errorStr = "::convertViews() - ERROR.";

        assert( !BdbIsNull(theInRegistryH));

        CdbStatus result = CdbStatus::Error;

     // Recreate the tables

        std::string viewsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_views";
            viewsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + viewsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + viewsTableName + " ( " +
                "id SMALLINT UNSIGNED," +
                "name VARCHAR(255), " +
                "has_default_config ENUM( 'Y', 'N' ), " +
                "is_frozen ENUM( 'Y', 'N' ), " +
                "created BIGINT UNSIGNED, " +
                "min_validity BIGINT UNSIGNED, " +
                "max_validity BIGINT UNSIGNED, " +
                "description TEXT " +
                ") COMMENT = 'This table describes the Views of this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }
        std::string foldersConditionsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_folders_conditions";
            foldersConditionsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + foldersConditionsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + foldersConditionsTableName + " ( " +
                "id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE, " +
                "view_id SMALLINT UNSIGNED, " +
                "path TEXT, " +
                "entry_type ENUM('F','C'), " +
                "created BIGINT UNSIGNED, " +
                "description TEXT, " +
                "pcond_origin_id SMALLINT UNSIGNED, " +
                "pcond_local_id  SMALLINT UNSIGNED " +
                ") COMMENT = 'This table describes Folders and Conditions in each View of this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }
        std::string defaultConfigsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_default_configs";
            defaultConfigsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + defaultConfigsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + defaultConfigsTableName + " ( " +
                "view_id SMALLINT UNSIGNED, " +
                "begin BIGINT UNSIGNED, " +
                "end BIGINT UNSIGNED, " +
                "use_revision ENUM('Y','N'), " +
                "partition_id SMALLINT UNSIGNED, " +
                "revision BIGINT UNSIGNED " +
                ") COMMENT = 'This table describes default Configuratins of Conditions in each View of this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }
        std::string conditionsConfigsTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theInRegistryH->originId( ) << "_conditions_configs";
            conditionsConfigsTableName = s.str( );
        }
        if(!execute_sql_query( "DROP TABLE IF EXISTS " + conditionsConfigsTableName )) return CdbStatus::Error;
        {
            const std::string query =
                "CREATE TABLE " + conditionsConfigsTableName + " ( " +
                "entry_id INTEGER UNSIGNED, " +
                "begin BIGINT UNSIGNED, " +
                "end BIGINT UNSIGNED, " +
                "use_revision ENUM('Y','N'), " +
                "partition_id SMALLINT UNSIGNED, " +
                "revision BIGINT UNSIGNED " +
                ") COMMENT = 'This table describes local Configuratins of Conditions in each View of this origin of CDB.'";

            if( !execute_sql_query( query )) return CdbStatus::Error;
        }

      // Convert views from the input collection and put them into the tables.

        BdbHandle(CdbBdbSViewCollectionP) viewCollectionH = theInRegistryH->viewCollection( );
        assert( !BdbIsNull(viewCollectionH));

        CdbBdbSViewCollectionP::IteratorOfIdentifiers itr = viewCollectionH->iterator_identifiers( );
        while( itr.next( )) {

          // Get the input view

            d_UShort viewId = itr.value( );

            BdbHandle(CdbBdbSViewP) viewH;
            {
                BdbRef(CdbBdbSViewP) viewRef;
                if( CdbStatus::Success != ( result = viewCollectionH->find( viewId,
                                                                            viewRef ))) {
                    cerr << errorStr << endl
                         << "    A view with ID = " << viewId << " was not found." << endl;
                    return result;
                }
                viewH = viewRef;
            }

          // Check if the view has the default configuration

            const char hasDefaultConfigFlag = ( !BdbIsNull( viewH->defaultConfig( )) ? 'Y' : 'N' );
            const char isFrozenFlag         = ( viewH->isFrozen( )                   ? 'Y' : 'N' );

          // Store the view

            {
                std::string query;

                ostringstream s;

                s << "INSERT INTO " << viewsTableName << " "
                  << "(id,name,has_default_config,is_frozen,created,min_validity,max_validity,description) VALUES ("
                  << viewH->id( ) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( viewH->name( ).head( )) << "',"
                  << "'" << hasDefaultConfigFlag << "',"
                  << "'" << isFrozenFlag << "',"
                  << CdbTimeUtils::to_nsec( viewH->created( )) << ","
                  << CdbTimeUtils::to_nsec( viewH->minValidity( )) << ","
                  << CdbTimeUtils::to_nsec( viewH->maxValidity( )) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( viewH->description( ).head( )) << "')";

                query = s.str( );

                if(!execute_sql_query( query )) return CdbStatus::Error;
            }

          // If the view has a default configuration then store it too

            BdbHandle(CdbBdbSConfigCollectionP) configCollectionH = viewH->defaultConfig( );

            if( !BdbIsNull(configCollectionH)) {

                CdbBdbSConfigCollectionP::IteratorOfIntervals itr = configCollectionH->iterator( );
                while( itr.next( )) {

                    CdbBdbSConfigInterval iVal = itr.value( );

                    const char userRevisionFlag = ( iVal.value.useRevision ? 'Y' : 'N' );
                    {
                        std::string query;

                        ostringstream s;

                        s << "INSERT INTO " << defaultConfigsTableName << " "
                          << "(view_id,begin,end,use_revision,partition_id,revision) VALUES ("
                          << viewH->id( ) << ","
                          << CdbTimeUtils::to_nsec( iVal.begin ) << ","
                          << CdbTimeUtils::to_nsec( iVal.end ) << ","
                          << "'" << userRevisionFlag << "',"
                          << iVal.value.partition << ","
                          << CdbTimeUtils::to_nsec( iVal.value.revision ) << ")";

                        query = s.str( );

                        if(!execute_sql_query( query )) return CdbStatus::Error;
                    }
                }
            }

          // Proceed down to folders
          //
          // NOTES:
          //
          //   (1) The "/" folder must already exist in the output collection as it's created
          //       automatically at the same time the view gets created.
          //
          //   (2) The path name would be automatically extended as the recursive copying
          //       procedure of folders and conditions will keep going.

            BdbHandle(CdbBdbSFolderP) rootFolderH = viewH->rootFolder( );
            assert( !BdbIsNull(rootFolderH));

            if( CdbStatus::Success != ( result = ::convertFoldersAndConditions( foldersConditionsTableName,
                                                                                conditionsConfigsTableName,
                                                                                viewH,
                                                                                rootFolderH,
                                                                                CdbPathName( rootFolderH->name( ).head( ))))) {
                cerr << errorStr << endl
                     << "    Failed to convert folders starting from \"/\"" << endl
                     << "    when copying view \"" << viewH->name( ).head( ) << "\"" << endl;
                return result;
            }
        }
        cerr << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << viewsTableName << "\n"
             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << foldersConditionsTableName << "\n"
             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << defaultConfigsTableName << "\n"
             << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << conditionsConfigsTableName << endl;

        return CdbStatus::Success;
    }

    CdbStatus
    convertFoldersAndConditions( const std::string&               theFoldersConditionsTableName,
                                 const std::string&               theConditionsConfigsTableName,
                                 const BdbHandle(CdbBdbSViewP)&   theInViewH,
                                 const BdbHandle(CdbBdbSFolderP)& theFolderH,
                                 const CdbPathName&               theCurrentPathName )
    {
        const char* errorStr = "::convertFoldersAndConditions() - ERROR.";

        assert( !BdbIsNull(theInViewH));
        assert( !BdbIsNull(theFolderH));

        CdbStatus result = CdbStatus::Error;

      // Save the current folder first

        {
            std::string query;

            ostringstream s;

            s << "INSERT INTO " << theFoldersConditionsTableName << " "
              << "(view_id,path,entry_type,created,description) VALUES ("
              << theInViewH->id( ) << ","
              << "'" << myConnectionPtr->translate_string_to_escaped( theCurrentPathName.toString( )) << "',"
              << "'F',"
              << CdbTimeUtils::to_nsec( theFolderH->created( )) << ","
              << "'" << myConnectionPtr->translate_string_to_escaped( theFolderH->description( ).head( )) << "')";

            query = s.str( );

            if(!execute_sql_query( query )) return CdbStatus::Error;
        }

      // Browse conditions in the input folder and copy them

        {
            CdbItr< const char* > itr;
            if( CdbStatus::Success != ( result = theFolderH->conditionIterator( itr ))) {
                cerr << errorStr << endl
                     << "    Failed to obtain an iterator of condition names." << endl
                     << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl;
                return result;
            }
            while( itr.next( )) {

              // Find the input condition objct

                BdbHandle(CdbBdbSConditionAtFolderP) conditionH;
                {
                    BdbRef(CdbBdbSConditionAtFolderP) conditionRef;
                    if( CdbStatus::Success != ( result = theFolderH->findCondition( CdbPathName( itr.value( )),
                                                                                    conditionRef ))) {
                        cerr << errorStr << endl
                             << "    Failed to find the condition in the current folder." << endl
                             << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl
                             << "        CONDITION:      \"" << itr.value( ) << "\"" << endl;
                        return result;
                    }
                    conditionH = conditionRef;
                }
                assert( !BdbIsNull(conditionH));

              // Save the condition

                CdbPathName conditionFullPathName = theCurrentPathName + CdbPathName( itr.value( ));
                {
                    std::string query;

                    ostringstream s;

                    s << "INSERT INTO " << theFoldersConditionsTableName << " "
                      << "(view_id,path,entry_type,created,description,pcond_origin_id,pcond_local_id) VALUES ("
                      << theInViewH->id( ) << ","
                      << "'" << myConnectionPtr->translate_string_to_escaped( conditionFullPathName.toString( )) << "',"
                      << "'C',"
                      << CdbTimeUtils::to_nsec( conditionH->created( )) << ","
                      << "'" << myConnectionPtr->translate_string_to_escaped( conditionH->description( ).head( )) << "',"
                      << conditionH->id( ).origin << ","
                      << conditionH->id( ).local << ")";

                    query = s.str( );

                    if(!execute_sql_query( query )) return CdbStatus::Error;
                }

              // Convert the configuration collection (if any)
              //
              // NOTE: The null input collection is considered a normal result since some conditions
              //       may be used through a default collection of their parent view.

                if( CdbStatus::Success != ( result = ::convertConfigCollection( theConditionsConfigsTableName,
                                                                                conditionH->config( )))) {
                    cerr << errorStr << endl
                         << "    Failed to convert the configuration collection of the condition in the current folder." << endl
                         << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl
                         << "        CONDITION:      \"" << itr.value( ) << "\"" << endl;
                    return result;
                }
            }
        }

        // Browse folders in the input folder and copy them

        {
            CdbItr< const char* > itr;
            if( CdbStatus::Success != ( result = theFolderH->folderIterator( itr ))) {
                cerr << errorStr << endl
                     << "    Failed to obtain an iterator of folder names." << endl
                     << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl;
                return result;
            }
            while( itr.next( )) {

              // Find the input folder objct

                BdbHandle(CdbBdbSFolderP) folderH;
                {
                    BdbRef(CdbBdbSFolderP) folderRef;
                    if( CdbStatus::Success != ( result = theFolderH->findFolder( CdbPathName( itr.value( )),
                                                                                 folderRef ))) {
                        cerr << errorStr << endl
                             << "    Failed to find the folder in the current folder." << endl
                             << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl
                             << "        FOLDER:         \"" << itr.value( ) << "\"" << endl;
                        return result;
                    }
                    folderH = folderRef;
                }
                assert( !BdbIsNull(folderH));

              // Proceed down to the found folder

                CdbPathName folderFullPathName = theCurrentPathName + itr.value( );

                if( CdbStatus::Success != ( result = ::convertFoldersAndConditions( theFoldersConditionsTableName,
                                                                                    theConditionsConfigsTableName,
                                                                                    theInViewH,
                                                                                    folderH,
                                                                                    folderFullPathName ))) {
                    cerr << errorStr << endl
                         << "    Failed to convert folders starting from the found one." << endl
                         << "        CURRENT FOLDER: \"" << theCurrentPathName << "\"" << endl
                         << "        FOLDER:         \"" << itr.value( ) << "\"" << endl;
                    return result;
                }
            }
        }
        return CdbStatus::Success;
    }

    CdbStatus
    convertConfigCollection( const std::string&                      theConditionsConfigsTableName,
                             const BdbRef(CdbBdbSConfigCollectionP)& theInputConfigCollectionRef )
    {
        if( BdbIsNull(theInputConfigCollectionRef)) return CdbStatus::Success;

        CdbBdbSConfigCollectionP::IteratorOfIntervals itr = theInputConfigCollectionRef->iterator( );
        while( itr.next( )) {

            CdbBdbSConfigInterval iVal = itr.value( );

            const char userRevisionFlag = ( iVal.value.useRevision ? 'Y' : 'N' );
            {
                std::string query;

                ostringstream s;

                s << "INSERT INTO " << theConditionsConfigsTableName << " "
                  << "(entry_id,begin,end,use_revision,partition_id,revision) VALUES ("
                  << "LAST_INSERT_ID(),"
                  << CdbTimeUtils::to_nsec( iVal.begin ) << ","
                  << CdbTimeUtils::to_nsec( iVal.end ) << ","
                  << "'" << userRevisionFlag << "',"
                  << iVal.value.partition << ","
                  << CdbTimeUtils::to_nsec( iVal.value.revision ) << ")";

                query = s.str( );

                if(!execute_sql_query( query )) return CdbStatus::Error;
            }
        }
        return CdbStatus::Success;
    }
/*
    CdbStatus
    testMetaDataConversion( )
    {
        const char* errorStr = "::testMetaDataConversion() - ERROR.";

        CdbStatus result = CdbStatus::Error;

      // Ask a user which collection to convert

        d_UShort originId = 0;

        cout << endl
             << "Please, enter the parameters of a condition." << endl
             << endl;

        d_UShort conditionId = 0xFFFF;
        {
            cout << "  Condition identifier : "; cin >> conditionId;
        }
        bool isPartitionableFlag = false;
        {
            int yesOrNo;
            cout << "Is partitionable [0/1] : "; cin >> yesOrNo;
            isPartitionableFlag = ( 0 != yesOrNo );
        }
        d_UShort partitionId = 0xFFFF;
        {
            cout << "  Partition identifier : "; cin >> partitionId;
        }
        d_UShort clusterId = 0xFFFF;
        {
            cout << "    Cluster identifier : "; cin >> clusterId;
        }
        d_UShort incrementNumber = 0xFFFF;
        {
            cout << "      Increment number : "; cin >> incrementNumber;
        }
        std::string dbIdRange = "";
        {
            cout << "       DBID Range Name : "; cin >> dbIdRange;
        }
        cout << endl
             << "Just for the record, you've entered the following parameters:" << endl
             << endl
             << "  Condition identifier : "   << conditionId << endl
             << "      Is partitionable : "   << ( isPartitionableFlag ? "Yes" : "No" ) << endl
             << "  Partition identifier : "   << partitionId << endl
             << "    Cluster identifier : "   << clusterId << endl
             << "      Increment number : "   << incrementNumber << endl
             << "       DBID Range Name : \"" << dbIdRange << "\"" << endl
             << endl;

      // Find the input metadata collection 

        BdbHandle(CdbBdbSMetaDataP) mdH;
        {
            BdbRef(CdbBdbSMetaDataP) mdRef;
            if( CdbStatus::Success != ( result = CdbBdbSUtils::findMetaData( mdRef,
                                                                             conditionId,
                                                                             isPartitionableFlag,
                                                                             partitionId,
                                                                             clusterId,
                                                                             incrementNumber,
                                                                             dbIdRange ))) {
                cerr << errorStr << endl
                     << "    Failed to locate the input MetaData object." << endl;
                return result;
            }
            mdH = mdRef;
        }

      // Create the output file

        TFile databaseFile( "con_cdb_test.root", "recreate" );
        if( databaseFile.IsZombie( )) {
            cerr << errorStr << endl
                 << "    Failed to (re-)create the file: \"" << databaseFile.GetName( ) << "\"." << endl;
            return CdbStatus::Error;
        }

      // Create a fake descriptor

        CdbRooRoRegistryDescriptorR registryDescriptor;

      // Proceed to the converion of the found MetaData object

        return ::convertMetaData( mdH,
                                  originId,
                                  conditionId,
                                  clusterId,
                                  isPartitionableFlag,
                                  partitionId,
                                  incrementNumber );
    }
*/
    CdbStatus
    convertMetaDataOfRegularCondition( const BdbHandle(CdbBdbSConditionP)& theConditionH,
                                       const BdbHandle(CdbBdbSRegistryP)&  theMasterRegistryH,
                                       d_UShort                            theOwnerOriginId )
    {
        const char* errorStr = "::convertMetaDataOfRegularCondition() - ERROR.";

        assert( !BdbIsNull(theConditionH));
        assert( !theConditionH->isPartitionable( ));
        assert( !BdbIsNull(theMasterRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Get the DBID range of the condition's origin.

        std::string dbidRangeName;
        {
            BdbRef(CdbBdbSOriginP) originRef;
            if( CdbStatus::Success != ( result = theMasterRegistryH->originCollection( )->find( theOwnerOriginId,
                                                                                                originRef ))) {
                cerr << errorStr << endl
                     << "    An origin with ID=" << theOwnerOriginId << " was not found." << endl;
                return result;
            }
            dbidRangeName = originRef->dbidrange( ).head( );
        }

      // Browse through increments of a cluster the condition is a member of. Select only
      // those increments the condition is participating in.
      //
      // NOTE: The condition might be creaed after certain increments were already
      //       closed. That's why we shoul skip those ones closed before.

        BdbHandle(CdbBdbSSimpleClusterP) clusterH = (const BdbRef(CdbBdbSSimpleClusterP)&)theConditionH->cluster( );

        d_ULong numIncrements = clusterH->numIncrements( );
        for( d_ULong incrementId = 0; incrementId < numIncrements; ++incrementId ) {

            if( verboseModeFlag ) {
                cout << "increment=" << incrementId << endl;
            }

            CdbBdbSIncrement increment;
            if( CdbStatus::Success != ( result = clusterH->increment( incrementId,
                                                                      increment ))) {
                cerr << errorStr << endl
                     << "    Failed to get increment " << incrementId << " from cluster " << clusterH->id( ) << endl
                     << "    of condition \"" << theConditionH->name( ) << "\"" << endl
                     << "    of the origin " << theOwnerOriginId << endl;
                return result;
            }

          // Skip increments closed at or before the condition creation time.
          // These increments are not supposed to know about this condition.

            if( increment.end <= theConditionH->created( )) {
                if( verboseModeFlag ) {
                    cout << "skipping the increment=" << incrementId << " since it was" << endl
                         << "    ended before the condition was created." << endl
                         << "    CONDITION CREATED: " << theConditionH->created( ) << endl
                         << "    PARTITION CLOSED : " << increment.end << endl;
                }
                continue;
            }

          // Find out the input "MetaData" object

            BdbHandle(CdbBdbSMetaDataP) mdH;
            {
                BdbRef(CdbBdbSMetaDataP) mdRef;
                if( CdbStatus::Success != ( result = CdbBdbSUtils::findMetaData( mdRef,
                                                                                 theConditionH->id( ),
                                                                                 theConditionH->isPartitionable( ),
                                                                                 0,
                                                                                 clusterH->id( ),
                                                                                 incrementId,
                                                                                 dbidRangeName.c_str( )))) {
                    cerr << errorStr << endl
                         << "    Failed to find the metadata object for condition \"" << theConditionH->name( ) << "\"." << endl
                         << "    See details above." << endl;
                    return result;
                }
                mdH = mdRef;
            }

          // Convert the object

            if( CdbStatus::Success != ( result = ::convertMetaData( mdH,
                                                                    theOwnerOriginId,
                                                                    theConditionH->id( ),
                                                                    clusterH->id( ),
                                                                    theConditionH->isPartitionable( ),
                                                                    0,
                                                                    incrementId ))) {
                cerr << errorStr << endl
                     << "    Failed to translate the metadata object for condition \"" << theConditionH->name( ) << "\"." << endl
                     << "    See details above." << endl;
                return result;
            }
        }
        return CdbStatus::Success;
    }

    CdbStatus
    convertMetaDataOfPartitionableCondition( const BdbHandle(CdbBdbSConditionP)& theConditionH,
                                             const BdbHandle(CdbBdbSRegistryP)&  theMasterRegistryH )
    {
        const char* errorStr = "::convertMetaDataOfPartitionableCondition() : ";

        assert( !BdbIsNull(theConditionH));
        assert( theConditionH->isPartitionable( ));
        assert( !BdbIsNull(theMasterRegistryH));

        CdbStatus result = CdbStatus::Error;

      // Get to the cluster.

        BdbHandle(CdbBdbSSimpleClusterP) clusterH = (const BdbRef(CdbBdbSSimpleClusterP)&)theConditionH->cluster( );

      // Get to the PartitinLayout at MASTER's Registry and iterate over
      // _instantiated_ partitions only.

        BdbHandle(CdbBdbSPartitionsLayoutP) pLayoutH = theMasterRegistryH->partitionsLayout( );

        CdbItr< d_UShort > pItr = pLayoutH->iterator( );
        while( pItr.next( )) {

            d_UShort partitionId = pItr.value( );

            if( verboseModeFlag ) {
                cout << "partition ID=" << partitionId << endl;
            }

            BdbHandle( CdbBdbSPartitionP ) partitionH;
            {
                BdbRef( CdbBdbSPartitionP ) partitionRef;
                if( CdbStatus::Success != ( result = pLayoutH->find( partitionId,
                                                                     partitionRef ))) {
                    cerr << errorStr << endl
                         << "   Failed to find the partition corresponding to ID=" << partitionId << endl;
                    return result;
                }
                partitionH = partitionRef;
            }

          // Skip this partition if it's not instantiated yet or if it's closed at the time
          // of before the current condition was created.

            if( !partitionH->isInstantiated( )) {
                if( verboseModeFlag ) {
                    cout << "skipping non-instantiated partition ID=" << partitionId << endl;
                }
                continue;
            }
            if( partitionH->isClosed( ) && ( partitionH->cell( ).endInsertion <= theConditionH->created( ))) {
                if( verboseModeFlag ) {
                    cout << "skipping closed partition ID=" << partitionId << " since it was" << endl
                         << "    closed before the condition was created." << endl
                         << "    CONDITION CREATED: " << theConditionH->created( ) << endl
                         << "    PARTITION CLOSED : " << partitionH->cell( ).endInsertion << endl;
                }
                continue;
            }

          // Get the DBID range of the partition's orgin.

            std::string dbidRangeName;
            {
                d_UShort originId = partitionH->originId( );

                BdbRef(CdbBdbSOriginP) originRef;
                if( CdbStatus::Success != ( result = theMasterRegistryH->originCollection( )->find( originId,
                                                                                                    originRef ))) {
                    cerr << errorStr << endl
                         << "    An origin with ID=" << originId << " was not found." << endl;
                    return result;
                }
                dbidRangeName = originRef->dbidrange( ).head( );
            }

          //  Browse through increments

            d_ULong numIncrements = partitionH->numIncrements( );
            for( d_ULong incrementId = 0; incrementId < numIncrements; ++incrementId ) {

                if( verboseModeFlag ) {
                    cout << "increment=" << incrementId << endl;
                }

                CdbBdbSIncrement increment;
                if( CdbStatus::Success != ( result = partitionH->increment( incrementId,
                                                                            increment ))) {
                    cerr << errorStr << endl
                         << "    Failed to get increment " << incrementId << " from partition " << partitionId << endl
                         << "    of condition \"" << theConditionH->name( ) << "\"" << endl;
                    return result;
                }

              // Skip increments closed at or before the condition creation time.
              // These increments are not supposed to know about this condition.

                if( increment.end <= theConditionH->created( )) {
                    if( verboseModeFlag ) {
                        cout << "skipping the increment=" << incrementId << " since it was" << endl
                         << "    ended before the condition was created." << endl
                         << "    CONDITION CREATED: " << theConditionH->created( ) << endl
                         << "    PARTITION CLOSED : " << increment.end << endl;
                    }
                    continue;
                }

              // Find out the input "MetaData" object

                BdbHandle(CdbBdbSMetaDataP) mdH;
                {
                    BdbRef(CdbBdbSMetaDataP) mdRef;
                    if( CdbStatus::Success != ( result = CdbBdbSUtils::findMetaData( mdRef,
                                                                                     theConditionH->id( ),
                                                                                     theConditionH->isPartitionable( ),
                                                                                     partitionId,
                                                                                     clusterH->id( ),
                                                                                     incrementId,
                                                                                     dbidRangeName ))) {
                        cerr << errorStr << endl
                             << "    Failed to find the metadata object for condition \"" << theConditionH->name( ) << "\"." << endl
                             << "    See details above." << endl;
                        return result;
                    }
                    mdH = mdRef;
                }

              // Convert the object

                if( CdbStatus::Success != ( result = ::convertMetaData( mdH,
                                                                        partitionH->originId( ),
                                                                        theConditionH->id( ),
                                                                        clusterH->id( ),
                                                                        theConditionH->isPartitionable( ),
                                                                        partitionId,
                                                                        incrementId ))) {
                    cerr << errorStr << endl
                         << "    Failed to translate the metadata object for condition \"" << theConditionH->name( ) << "\"." << endl
                         << "    See details above." << endl;
                    return result;
                }
            }
        }
        return CdbStatus::Success;
    }

    CdbStatus
    convertMetaData( const BdbHandle(CdbBdbSMetaDataP)& theInMetaDataH,
                     d_UShort                           theOriginId,
                     d_UShort                           theConditionId,
                     d_UShort                           theClusterId,
                     bool                               isPartitionableFlag,
                     d_UShort                           thePartitionId,
                     d_UShort                           theIncrementId )
    {
        const char* errorStr = "::convertMetaData() - ERROR.";

        assert( !BdbIsNull(theInMetaDataH));

        CdbStatus result = CdbStatus::Error;

      // Build the names of relevant tables

        std::string baseTableName;
        {
            ostringstream s;
            s << myConnectionPtr->database( ) << ".o" << theOriginId;
            if( isPartitionableFlag ) s << "_p" << thePartitionId;
            s << "_c" << theClusterId
              << "_i" << theIncrementId
              << "_";
            baseTableName = s.str( );
        }
        const std::string payloadObjectsTableName    = baseTableName + "payload";
        const std::string originalIntervalsTableName = baseTableName + "original";
        const std::string revisionsTableName         = baseTableName + "revisions";
        const std::string visibleIntervalsTableName  = baseTableName + "visible";

      // Translate the collection of 'original intervals
      //
      // NOTE; We'll also need 'stored' timestamps from this collection later when  
      //       translating 'visible' intervals. The timestamps will be used as a sort
      //       of 'foreign' keys for 'visible' intervals.
      //
      //       ATTENTION: This is based on an assumption that no two (or more) original
      //                  intervals will have the same 'stored' time. Actually we're
      //                  going to perform this check below when converting 'original'
      //                  intervals.
      //
      //       Indexes of the vector with 'stored' values to be filled below are used
      //       by "Bdb/Shared" implementation of CDB as a back link from 'visible'
      //       to 'original' intervals.

        std::vector<BdbTime> oiStoredTimestamps;
        {
            BdbHandle(CdbBdbSOiCollectionP) oiCollectionH = theInMetaDataH->originaIntervalsCollection( );
            d_ULong numOriginalElements = oiCollectionH->size( );
            assert( numOriginalElements > 0 );

          // Note, that it's very important that the 0 element had BdbTime::minusInfinity
          // as some 'visible' intervals representing 'holes' (no actual persistnet object behind)
          // would be using this below.

            oiStoredTimestamps.resize( numOriginalElements, BdbTime::minusInfinity );

            for( d_ULong idx = 1; idx < numOriginalElements; ++idx ) {

                CdbBdbSOi oi;

                BdbTime beginDuration;  // will be filled by the call, but we're not going to use it
                BdbTime endDuration;    // -//-

                if( CdbStatus::Success != ( result = oiCollectionH->find( idx,
                                                                          oi,
                                                                          beginDuration,
                                                                          endDuration ))) {
                    cerr << errorStr << endl
                         << "    Failed to obtain an 'original' interval with IDX = " << idx << " from the collection." << endl;
                    return result;
                }

              // Verify if the 'stored' time of the interval is _strictly_ more than the one
              // previously stored. This test is meant to ensure two things:
              //
              // 1. That there is no corruption in the collection.
              // 2. The collection doesn't have two (or more) intervals stored at exactly
              //    the same moment of time.

                if( oi.inserted <= oiStoredTimestamps[idx-1] ) {
                    cerr << errorStr << endl
                         << "    Found an 'original' interval with IDX = " << idx << " whose 'inserted' timestamp" << endl
                         << "    is not strictly newer than the previously stored one. The collection can be corrupted." << endl
                         << "        CONDITION ID:           " << theConditionId << endl
                         << "        DESTINATION TABLE NAME: \"" << originalIntervalsTableName << "\"" << endl
                         << "        PREVIOUS TIMESTAMP:     " << CdbTimeUtils::time2string( oiStoredTimestamps[idx-1] ) << " : " << oiStoredTimestamps[idx-1] << endl
                         << "        CURRENT  TIMESTAMP:     " << CdbTimeUtils::time2string( oi.inserted )               << " : " << oi.inserted << endl;
                    return CdbStatus::Error;
                }
                oiStoredTimestamps[idx] = oi.inserted;

              // Create an output "payload" object

                {
                    std::string query;

                    ostringstream s;

                    s << "INSERT INTO " << payloadObjectsTableName << " "
                      << "(legacy_id) VALUES ("
                      << "'" << oi.object.sprint( ) << "')";

                    query = s.str( );

                    if(!execute_sql_query( query )) return CdbStatus::Error;
                }

              // Create an output "original" object

                {
                    std::string query;

                    ostringstream s;

                    s << "INSERT INTO " << originalIntervalsTableName << " "
                      << "(condition_id,stored,begin,end,object_id) VALUES ("
                      << theConditionId << ","
                      << CdbTimeUtils::to_nsec( oi.inserted ) << ","
                      << CdbTimeUtils::to_nsec( oi.begin ) << ","
                      << CdbTimeUtils::to_nsec( oi.end ) << ","
                      << "LAST_INSERT_ID())";

                    query = s.str( );

                    if(!execute_sql_query( query )) return CdbStatus::Error;
                }
            }

          // Insert a special original object which will be reffered to by 'visible' intervals
          // representing 'holes' (no actaul 'original' object) in the validity timeline of
          // the local MetaData.
          //
          // NOTES:
          //
          //   1. There is just one special object of this type per conditions and per MetaData.
          //   2. This object has a special "stored/insertion" timestamp in the minus infinity.
          //   3. There won't be any "payload" entry for this object.

            {
                std::string query;

                ostringstream s;

                s << "INSERT INTO " << originalIntervalsTableName << " "
                  << "(condition_id,stored) VALUES ("
                  << theConditionId << ","
                  << CdbTimeUtils::to_nsec( BdbTime::minusInfinity ) << ")";

                query = s.str( );

                if(!execute_sql_query( query )) return CdbStatus::Error;
            }

            cout << CdbTimeUtils::time2string( BdbTime::now( )) << "::" << originalIntervalsTableName << " [" << theOriginId << "::" << theConditionId << "] " << numOriginalElements-1 << " objects" << endl;
        }

      // Iterate over known revisions and convert them

        CdbItr<BdbTime> itr;
        if( CdbStatus::Success != ( result = theInMetaDataH->revisionIdIterator( itr ))) {
            cerr << errorStr << endl
                 << "    Failed to set up an iterator of revision identifiers." << endl;
            return result;
        }
        while( itr.next( )) {

            BdbTime revisionId = itr.value( );

          // Find the input revision

            BdbHandle(CdbBdbSRevisionP) revisionH;
            {
                BdbRef(CdbBdbSRevisionP) revisionRef;
                if( CdbStatus::Success != ( result = theInMetaDataH->findRevision( revisionId,
                                                                                   revisionRef ))) {
                    cerr << errorStr << endl
                        << "    Failed to find a revision with ID = " << CdbTimeUtils::time2string( revisionId ) << endl;
                    return result;
                }
                revisionH = revisionRef;
            }

          // Create the output revision object

            {
                std::string query;

                ostringstream s;

                s << "INSERT INTO " << revisionsTableName << " "
                  << "(condition_id,id,name,created,description) VALUES ("
                  << theConditionId << ","
                  << CdbTimeUtils::to_nsec( revisionH->id( )) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( revisionH->name( ).head( )) << "',"
                  << CdbTimeUtils::to_nsec( revisionH->created( )) << ","
                  << "'" << myConnectionPtr->translate_string_to_escaped( revisionH->description( ).head( )) << "')";

                query = s.str( );

                if(!execute_sql_query( query )) return CdbStatus::Error;
            }

          // Iterate over 'visible' intervals and convert them

            BdbHandle(CdbBdbSViCollectionP) viCollectionH = revisionH->collection( );
            assert( !BdbIsNull(viCollectionH));

            CdbBdbSViCollectionP::IteratorOfIntervals viItr = viCollectionH->iterator( );
            while( viItr.next( )) {

                CdbBdbSVi iVal = viItr.value( );

              // Create an output "visible" object

                {
                    std::string query;

                    ostringstream s;

                    s << "INSERT INTO " << visibleIntervalsTableName << " "
                      << "(condition_id,revision_id,begin,end,original_stored) VALUES ("
                      << theConditionId << ","
                      << CdbTimeUtils::to_nsec( revisionH->id( )) << ","
                      << CdbTimeUtils::to_nsec( iVal.begin ) << ","
                      << CdbTimeUtils::to_nsec( iVal.end ) << ","
                      << CdbTimeUtils::to_nsec( oiStoredTimestamps[iVal.value] ) << ")";

                    query = s.str( );

                    if(!execute_sql_query( query )) return CdbStatus::Error;
                }
            }
        }
        return CdbStatus::Success;
    }

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

        CdbStatus result = CdbStatus::Error;

      // Get the MASTER registry.

        BdbHandle(CdbBdbSRegistryP) masterRegistryH;
        if( CdbStatus::Success != ( result = CdbBdbSRegistryP::findMaster( masterRegistryH ))) {
            cerr << errorStr << endl
                 << "    Failed to find the MASTER registry." << endl;
            return result;
        }

      // Iterate over known registries and analyses them one-by-one if the corresponding origins
      // are instantiated in the input database.

        BdbHandle(CdbBdbSOriginCollectionP) originCollectionH = masterRegistryH->originCollection( );

        CdbBdbSOriginCollectionP::IteratorOfIdentifiers itr = originCollectionH->iterator_identifiers( );
        while( itr.next( )) {

          // Get the persistent registry object

            d_UShort conditionOwnerOriginId = itr.value( );

            BdbHandle(CdbBdbSOriginP) originH;
            {
                BdbRef(CdbBdbSOriginP) originRef;
                if( CdbStatus::Success != ( result = originCollectionH->find( conditionOwnerOriginId,
                                                                              originRef ))) {

                    cerr << errorStr << endl
                         << "    Failed to find an origin with ID = " << conditionOwnerOriginId << "." << endl
                         << "    The input database may not be properly initialized." << endl;
                    return result;
                }
                originH = originRef;
            }

          // Try to get the corresponding registry. If it doesn't exist (not instantiated)
          // then we will skip that registry.

            BdbHandle(CdbBdbSRegistryP) registryH;
            {
                if( CdbStatus::Success != ( result = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                                     conditionOwnerOriginId ))) {
                    if( CdbStatus::NotFound == result ) {

                      // The origin is not currently instantiated in the input database. This may happen
                      // when the origin's data are yet to be imported.

                        continue;

                    } else {
                        cerr << errorStr << endl
                             << "    Failed to find a registry for origin ID = " << conditionOwnerOriginId << "." << endl;
                        return result;
                    }
                }
            }

          // Proceed to 'physical' conditions of the collection

            if( registryH->hasLocalCollections( )) {

                BdbHandle(CdbBdbSConditionCollectionP) conditionCollectionH = registryH->conditionCollection( );

                CdbBdbSConditionCollectionP::IteratorOfIdentifiers itr = conditionCollectionH->iterator_identifiers( );
                while( itr.next( )) {

                  // Get the input condition

                    d_UShort conditionId = itr.value( );

                    BdbHandle(CdbBdbSConditionP) conditionH;
                    {
                        BdbRef(CdbBdbSConditionP) conditionRef;
                        if( CdbStatus::Success != ( result = conditionCollectionH->find( conditionId,
                                                                                         conditionRef ))) {
                            cerr << errorStr << endl
                                 << "    A condition with ID = " << conditionId << " was not found." << endl;
                            return result;
                        }
                        conditionH = conditionRef;
                    }

                  // Find all relevant MetaData objects

                    if( conditionH->isPartitionable( )) {

                      // ** PARTITIONABLE **

                        if( excludePartitionableFlag ) continue;

                        BdbHandle(CdbBdbSSimpleClusterP) clusterH = (const BdbRef(CdbBdbSSimpleClusterP)&)conditionH->cluster( );

                      // Get to the PartitinLayout at MASTER's Registry and iterate over
                      // _instantiated_ partitions only.

                        BdbHandle(CdbBdbSPartitionsLayoutP) pLayoutH = masterRegistryH->partitionsLayout( );

                        CdbItr< d_UShort > pItr = pLayoutH->iterator( );
                        while( pItr.next( )) {

                            d_UShort partitionId = pItr.value( );

                            BdbHandle( CdbBdbSPartitionP ) partitionH;
                            {
                                BdbRef( CdbBdbSPartitionP ) partitionRef;
                                if( CdbStatus::Success != ( result = pLayoutH->find( partitionId,
                                                                                     partitionRef ))) {
                                    cerr << errorStr << endl
                                         << "   Failed to find the partition corresponding to ID=" << partitionId << endl;
                                    return result;
                                }
                                partitionH = partitionRef;
                            }

                          // Skip this partition if it's not instantiated yet or if it's closed at the time
                          // of before the current condition was created.

                            if( !partitionH->isInstantiated( )) continue;
                            if( partitionH->isClosed( ) && ( partitionH->cell( ).endInsertion <= conditionH->created( ))) continue;

                          // Get the DBID range of the partition's orgin.

                            std::string dbidRangeName;
                            {
                                BdbRef(CdbBdbSOriginP) originRef;
                                if( CdbStatus::Success != ( result = masterRegistryH->originCollection( )->find( partitionH->originId( ),
                                                                                                                 originRef ))) {
                                    cerr << errorStr << endl
                                         << "    An origin with ID=" << partitionH->originId( ) << " was not found." << endl;
                                    return result;
                                }
                                dbidRangeName = originRef->dbidrange( ).head( );
                            }

                          //  Browse through increments

                            d_ULong numIncrements = partitionH->numIncrements( );
                            for( d_ULong i = 0; i < numIncrements; ++i ) {

                                CdbBdbSIncrement increment;
                                if( CdbStatus::Success != ( result = partitionH->increment( i,
                                                                                            increment ))) {
                                    cerr << errorStr << endl
                                         << "    Failed to get increment " << i << " from partition " << partitionId << endl
                                         << "    of condition \"" << conditionH->name( ) << "\"" << endl;
                                    return result;
                                }

                              // Skip increments closed at or before the condition creation time.
                              // These increments are not supposed to know about this condition.

                                if( increment.end <= conditionH->created( )) continue;

                              // Find out the input "MetaData" object

                                BdbHandle(CdbBdbSMetaDataP) mdH;
                                {
                                    BdbRef(CdbBdbSMetaDataP) mdRef;
                                    if( CdbStatus::Success != ( result = CdbBdbSUtils::findMetaData( mdRef,
                                                                                                     conditionH->id( ),
                                                                                                     conditionH->isPartitionable( ),
                                                                                                     partitionId,
                                                                                                     clusterH->id( ),
                                                                                                     i,
                                                                                                     dbidRangeName ))) {
                                        cerr << errorStr << endl
                                             << "    Failed to find the metadata object for condition \"" << conditionH->name( ) << "\"." << endl
                                             << "    See details above." << endl;
                                        return result;
                                    }
                                    mdH = mdRef;
                                }

                              // Browse the 'original' collection

                                std::map<std::string,unsigned int> counters;

                                const BdbHandle(CdbBdbSOiCollectionP) collectionH = mdH->originaIntervalsCollection( );

                                d_ULong numOriginalElements = collectionH->size( );

                                for( d_ULong idx = 1; idx < numOriginalElements; ++idx ) {

                                    CdbBdbSOi oi;

                                    BdbTime beginDuration;  // will be filled by the call, but we're not going to use it
                                    BdbTime endDuration;    // -//-

                                    if( CdbStatus::Success != ( result = collectionH->find( idx,
                                                                                            oi,
                                                                                            beginDuration,
                                                                                            endDuration ))) {
                                        cerr << errorStr << endl
                                             << "    Failed to obtain an 'original' interval with IDX = " << idx << " from the collection." << endl;
                                        return result;
                                    }

                                    std::string typeName = oi.object.typeName( );

                                    unsigned int nObjectsOfThisClass = 0;
                                    if( 0 != counters.count( typeName )) nObjectsOfThisClass = counters[ typeName ];
                                    counters[ typeName ] = ++nObjectsOfThisClass;
                                }

                              // Print results

                                for( std::map<std::string,unsigned int>::const_iterator itr = counters.begin( );
                                                                                        itr != counters.end( );
                                                                                      ++itr ) {
                                    std::string typeName = (*itr).first;
                                    unsigned int nObjectsOfThisClass = (*itr).second;
                                    cout << conditionOwnerOriginId << "::" << conditionH->id( ) << " [" << partitionH->id( ) << "," << clusterH->id( ) << "," << i << "] \"" << typeName << "\" " << nObjectsOfThisClass << endl;
                                }
                            }
                        }

                    } else {

                      // ** REGULAR **

                        if( excludeRegularFlag ) continue;

                      // Get the DBID range of the condition's origin.

                        std::string dbidRangeName;
                        {
                            BdbRef(CdbBdbSOriginP) originRef;
                            if( CdbStatus::Success != ( result = masterRegistryH->originCollection( )->find( conditionOwnerOriginId,
                                                                                                             originRef ))) {
                                cerr << errorStr << endl
                                     << "    An origin with ID=" << conditionOwnerOriginId << " was not found." << endl;
                                return result;
                            }
                            dbidRangeName = originRef->dbidrange( ).head( );
                        }

                      // Browse through increments of a cluster the condition is a member of. Select only
                      // those increments the condition is participating in.
                      //
                      // NOTE: The condition might be creaed after certain increments were already
                      //       closed. That's why we shoul skip those ones closed before.

                        BdbHandle(CdbBdbSSimpleClusterP) clusterH = (const BdbRef(CdbBdbSSimpleClusterP)&)conditionH->cluster( );

                        d_ULong numIncrements = clusterH->numIncrements( );
                        for( d_ULong i = 0; i < numIncrements; ++i ) {

                            CdbBdbSIncrement increment;
                            if( CdbStatus::Success != ( result = clusterH->increment( i,
                                                                                      increment ))) {
                                cerr << errorStr << endl
                                     << "    Failed to get increment " << i << " from cluster " << clusterH->id( ) << endl
                                     << "    of condition \"" << conditionH->name( ) << "\"" << endl;
                                return result;
                            }

                          // Skip increments closed at or before the condition creation time.
                          // These increments are not supposed to know about this condition.

                            if( increment.end <= conditionH->created( )) continue;

                          // Find out the input "MetaData" object

                            BdbHandle(CdbBdbSMetaDataP) mdH;
                            {
                                BdbRef(CdbBdbSMetaDataP) mdRef;
                                if( CdbStatus::Success != ( result = CdbBdbSUtils::findMetaData( mdRef,
                                                                                                 conditionH->id( ),
                                                                                                 conditionH->isPartitionable( ),
                                                                                                 0,
                                                                                                 clusterH->id( ),
                                                                                                 i,
                                                                                                 dbidRangeName.c_str( )))) {
                                    cerr << errorStr << endl
                                         << "    Failed to find the metadata object for condition \"" << conditionH->name( ) << "\"." << endl
                                         << "    See details above." << endl;
                                    return result;
                                }
                                mdH = mdRef;
                            }

                          // Browse the 'original' collection

                            std::map<std::string,unsigned int> counters;

                            const BdbHandle(CdbBdbSOiCollectionP) collectionH = mdH->originaIntervalsCollection( );

                            d_ULong numOriginalElements = collectionH->size( );

                            for( d_ULong idx = 1; idx < numOriginalElements; ++idx ) {

                                CdbBdbSOi oi;

                                BdbTime beginDuration;  // will be filled by the call, but we're not going to use it
                                BdbTime endDuration;    // -//-

                                if( CdbStatus::Success != ( result = collectionH->find( idx,
                                                                                        oi,
                                                                                        beginDuration,
                                                                                        endDuration ))) {
                                    cerr << errorStr << endl
                                         << "    Failed to obtain an 'original' interval with IDX = " << idx << " from the collection." << endl;
                                    return result;
                                }

                                std::string typeName = oi.object.typeName( );

                                unsigned int nObjectsOfThisClass = 0;
                                if( 0 != counters.count( typeName )) nObjectsOfThisClass = counters[ typeName ];
                                counters[ typeName ] = ++nObjectsOfThisClass;
                            }

                          // Print results

                            for( std::map<std::string,unsigned int>::const_iterator itr = counters.begin( );
                                                                                    itr != counters.end( );
                                                                                  ++itr ) {
                                std::string typeName = (*itr).first;
                                unsigned int nObjectsOfThisClass = (*itr).second;
                                cout << conditionOwnerOriginId << "::" << conditionH->id( ) << " [" << 0 << "," << clusterH->id( ) << "," << i << "] \"" << typeName << "\" " << nObjectsOfThisClass << endl;
                            }
                        }
                    }
                }
            }
        }
        return CdbStatus::Success;
    }

    CdbStatus
    browseConditionsInFolder( d_UShort                      theOriginId,
                              d_UShort                      theViewId,
                              const CdbPathName&            theParentFolderPath,
                              const BdbRef(CdbBdbSFolderP)& theParentFolderRef  )
    {
        const char* errorStr = "::browseConditionsInFolder() - ERROR.";

        assert( theParentFolderPath.isAbsolute( ));
        assert( !BdbIsNull(theParentFolderRef));

        const BdbHandle(CdbBdbSFolderP) parentFolderH = theParentFolderRef;

        CdbStatus result = CdbStatus::Error;

      // Find all conditions directly attached to the parent folder

        {
            CdbItr< const char* > itr;
            if( CdbStatus::Success != ( result = parentFolderH->conditionIterator( itr ))) {
                cerr << errorStr << endl
                     << "    Failed to set up an iterator of conditions for folder \"" << theParentFolderPath.toString( ) << "\"." << endl;
                return result;
            }
            while( itr.next( )) {

                CdbPathName conditionPath( itr.value( ));

                BdbRef(CdbBdbSConditionAtFolderP) conditionRef;
                if( CdbStatus::Success != ( result = parentFolderH->findCondition( conditionPath,
                                                                                   conditionRef ))) {
                    cerr << errorStr << endl
                         << "    Failed to find the condition \"" <<  conditionPath.toString( ) << "\"" << endl
                         << "    in folder \"" << theParentFolderPath.toString( ) << "\"." << endl;
                    return result;
                }

                CdbBdbSId   id                = conditionRef->id( );
                CdbPathName conditionFullPath = theParentFolderPath + conditionPath;

                cout << theOriginId << "::" << theViewId << " " << id.origin << "::" << id.local << " \"" << conditionFullPath.toString( ) << "\"" << endl;
            }
        }

      // Find all sub-folders directly attached to the parent folder and proceed to them

        {
            CdbItr< const char* > itr;
            if( CdbStatus::Success != ( result = parentFolderH->folderIterator( itr ))) {
                cerr << errorStr << endl
                     << "    Failed to set up an iterator of sub-folders for folder \"" << theParentFolderPath.toString( ) << "\"." << endl;
                return result;
            }
            while( itr.next( )) {

                CdbPathName folderPath( itr.value( ));

                BdbRef(CdbBdbSFolderP) folderRef;
                if( CdbStatus::Success != ( result = parentFolderH->findFolder( folderPath,
                                                                                folderRef ))) {
                    cerr << errorStr << endl
                         << "    Failed to find the sub-folder \"" <<  folderPath.toString( ) << "\"" << endl
                         << "    in folder \"" << theParentFolderPath.toString( ) << "\"." << endl;
                    return result;
                }

                CdbPathName folderFullPath = theParentFolderPath + folderPath;

                if( CdbStatus::Success != ( result = ::browseConditionsInFolder( theOriginId,
                                                                                 theViewId,
                                                                                 folderFullPath,
                                                                                 folderRef ))) {
                    cerr << errorStr << endl
                         << "    Failed to browse conditions in the sub-folder \"" <<  folderPath.toString( ) << "\"" << endl
                         << "    of folder \"" << theParentFolderPath.toString( ) << "\"." << endl;
                    return result;
                }
            }
        }
        return CdbStatus::Success;
    }

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

        CdbStatus result = CdbStatus::Error;

      // Get the MASTER registry.

        BdbHandle(CdbBdbSRegistryP) masterRegistryH;
        if( CdbStatus::Success != ( result = CdbBdbSRegistryP::findMaster( masterRegistryH ))) {
            cerr << errorStr << endl
                 << "    Failed to find the MASTER registry." << endl;
            return result;
        }

      // Iterate over known registries and analyses them one-by-one if the corresponding origins
      // are instantiated in the input database.

        BdbHandle(CdbBdbSOriginCollectionP) originCollectionH = masterRegistryH->originCollection( );

        CdbBdbSOriginCollectionP::IteratorOfIdentifiers itr = originCollectionH->iterator_identifiers( );
        while( itr.next( )) {

          // Get the persistent registry object

            d_UShort viewOwnerOriginId = itr.value( );

            BdbHandle(CdbBdbSOriginP) originH;
            {
                BdbRef(CdbBdbSOriginP) originRef;
                if( CdbStatus::Success != ( result = originCollectionH->find( viewOwnerOriginId,
                                                                              originRef ))) {

                    cerr << errorStr << endl
                         << "    Failed to find an origin with ID = " << viewOwnerOriginId << "." << endl
                         << "    The input database may not be properly initialized." << endl;
                    return result;
                }
                originH = originRef;
            }

          // Try to get the corresponding registry. If it doesn't exist (not instantiated)
          // then we will skip that registry.

            BdbHandle(CdbBdbSRegistryP) registryH;
            {
                if( CdbStatus::Success != ( result = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                                     viewOwnerOriginId ))) {
                    if( CdbStatus::NotFound == result ) {

                      // The origin is not currently instantiated in the input database. This may happen
                      // when the origin's data are yet to be imported.

                        continue;

                    } else {
                        cerr << errorStr << endl
                             << "    Failed to find a registry for origin ID = " << viewOwnerOriginId << "." << endl;
                        return result;
                    }
                }
            }

          // Proceed to 'views' of this registry

            if( registryH->hasLocalCollections( )) {

                BdbHandle(CdbBdbSViewCollectionP) viewCollectionH = registryH->viewCollection( );

                CdbBdbSViewCollectionP::IteratorOfIdentifiers itr = viewCollectionH->iterator_identifiers( );
                while( itr.next( )) {

                  // Get the view

                    d_UShort viewId = itr.value( );

                    BdbHandle(CdbBdbSViewP) viewH;
                    {
                        BdbRef(CdbBdbSViewP) viewRef;
                        if( CdbStatus::Success != ( result = viewCollectionH->find( viewId,
                                                                                    viewRef ))) {
                            cerr << errorStr << endl
                                 << "    A view with ID = " << viewId << " was not found." << endl;
                            return result;
                        }
                        viewH = viewRef;
                    }

                  // Skip the "main" view as it's not supposed to have any valueable information

                    if( std::string( "main" ) == viewH->name( ).head( )) continue;

                  // Browse the view

                    if( CdbStatus::Success != ( result = ::browseConditionsInFolder( viewOwnerOriginId,
                                                                                     viewId,
                                                                                     CdbPathName( viewH->rootFolder( )->name( ).head( )),
                                                                                     viewH->rootFolder( )))) {
                        cerr << errorStr << endl
                             << "    Failed to browse conditions in the 'root' folder of a view with ID = " << viewId << "." << endl;
                        return result;
                    }
                }
            }
        }
        return CdbStatus::Success;
    }
}

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

---