---

CdbMySQLConditionAtFolder.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbMySQLConditionAtFolder.cc,v 1.9 2005/11/23 03:21:11 gapon Exp $

/// The implementation of the CdbMySQLConditionAtFolder interface.
/**
  * @see CdbMySQLConditionAtFolder
  */

#include "BaBar/BaBar.hh"

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

#include "CdbSQL/CdbSQLOrigin.hh"
#include "CdbSQL/CdbSQLView.hh"
#include "CdbSQL/CdbSQLFolder.hh"

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

#include "RdbMySQL/RdbMySQLResult.hh"

#include <assert.h>

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

#include <sstream>
using std::ostringstream;

CdbMySQLConditionAtFolder::CdbMySQLConditionAtFolder( const CdbCPtr<CdbMySQLConnection>& theConnectionPtr,
                                                      const CdbCPtr<CdbSQLFolder>&       theParentFolderPtr,
                                                      const CdbId&                       thePhysicalId,
                                                      const std::string&                 theName,
                                                      const BdbTime&                     theCreationTime,
                                                      const std::string&                 theDescription ) :
    CdbSQLConditionAtFolder( theParentFolderPtr,
                             thePhysicalId,
                             theName,
                             theCreationTime,
                             theDescription ),
   _myConnectionObjectPtr(theConnectionPtr)
{
    assert( !theConnectionPtr.isNull( ));
}

CdbMySQLConditionAtFolder::CdbMySQLConditionAtFolder( const CdbMySQLConditionAtFolder& theOther ) : 
    CdbSQLConditionAtFolder( theOther ),
    _myConnectionObjectPtr(theOther._myConnectionObjectPtr)
{ }

CdbMySQLConditionAtFolder::~CdbMySQLConditionAtFolder( )
{ }

CdbStatus
CdbMySQLConditionAtFolder::find_config_element( CdbConfigElement& theElement,
                                                const BdbTime&    theValidityTime )
{
    const char* errorStr = "CdbMySQLConditionAtFolder::find_config_element() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Formulate a query

        const unsigned short originId = parent( )->parentView( )->parent( )->id( );
        const unsigned short   viewId = parent( )->parentView( )->id( );

        std::string query;
        {
            ostringstream s;
            s << "SELECT "
              <<   "c.begin begin, c.end end, c.use_revision use_revision, c.partition_id partition_id, c.revision revision "
              << "FROM "
              <<   _myConnectionObjectPtr->database( ) << ".o" << originId << "_folders_conditions fc, "
              <<   _myConnectionObjectPtr->database( ) << ".o" << originId << "_conditions_configs c "
              << "WHERE "
              <<   "fc.view_id = " << viewId << " "
              << "AND "
              <<   "BINARY fc.path = '" << _myConnectionObjectPtr->translate_string_to_escaped( CdbPathName::separatorTerminated( parent( )->fullPathName( )))
              <<                           _myConnectionObjectPtr->translate_string_to_escaped( name( )) << "' "
              << "AND "
              <<   "fc.entry_type = 'C' "
              << "AND "
              <<   "fc.id = c.entry_id "
              << "AND "
              <<   "c.begin <= " << CdbTimeUtils::to_nsec( theValidityTime ) << " "
              << "AND "
              <<   CdbTimeUtils::to_nsec( theValidityTime ) << " < c.end;";
            query = s.str( );
        }

      // Execute the query

        CdbMySQLSelectQuery selectQuery( _myConnectionObjectPtr,
                                         query );

        std::vector<CdbConfigElement> listOfElements;

        if( !execute_query( selectQuery, listOfElements )) {
            cerr << errorStr << endl
                 << "    Failed to execute the query and/or translate its results." << endl
                 << "        QUERY : \"" << query.c_str( ) << "\"" << endl;
            break;
        }
        unsigned int numFound = listOfElements.size( );
        if( 1 != numFound) {
            if( 0 == numFound ) {
                result = CdbStatus::NotFound;
                break;
            }
            cerr << errorStr << endl
                 << "    The query executor returned unexpected number of rows." << endl
                 << "    The number of entries matching the query is " << numFound << "." << endl
                 << "        QUERY : \"" << query << "\"" << endl;
            break;
        }

      // Done

        theElement = listOfElements[0];

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbMySQLConditionAtFolder::config_elements( std::vector<CdbConfigElement>& theList )
{
    const char* errorStr = "CdbMySQLConditionAtFolder::config_elements() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Formulate the query

        const unsigned short originId = parent( )->parentView( )->parent( )->id( );
        const unsigned short   viewId = parent( )->parentView( )->id( );

        std::string query;
        {
            ostringstream s;
            s << "SELECT "
              <<   "c.begin begin,c.end end, c.use_revision use_revision, c.partition_id partition_id, c.revision revision "
              << "FROM "
              <<   _myConnectionObjectPtr->database( ) << ".o" << originId << "_folders_conditions fc, "
              <<   _myConnectionObjectPtr->database( ) << ".o" << originId << "_conditions_configs c "
              << "WHERE "
              <<   "fc.view_id = " << viewId << " "
              << "AND "
              <<   "BINARY fc.path = '" << _myConnectionObjectPtr->translate_string_to_escaped( CdbPathName::separatorTerminated( parent( )->fullPathName( )))
              <<                           _myConnectionObjectPtr->translate_string_to_escaped( name( )) << "' "
              << "AND "
              <<   "fc.entry_type = 'C' "
              << "AND "
              <<   "fc.id = c.entry_id "
              << "ORDER BY "
              <<   "c.begin;";
            query = s.str( );
        }

        CdbMySQLSelectQuery selectQuery( _myConnectionObjectPtr,
                                         query );

        if( !execute_query( selectQuery, theList )) {
            cerr << errorStr << "\n"
                 << "    Failed to execute the query and/or translate its results.\n"
                 << "        Query : \"" << query.c_str( ) << "\"" << endl;
            break;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbMySQLConditionAtFolder::set_config( std::vector<CdbConfigElement>& theList,
                                       const bool                     patchOnlyFlag )
{
    const char* errorStr = "CdbMySQLConditionAtFolder::set_config() -- ERROR.";
    const char* context  = "CdbMySQLConditionAtFolder::set_config()";

  // Save the current configuration first

    std::vector<CdbConfigElement> savedConfigList;
    if( CdbStatus::Success != config_elements( savedConfigList )) {
        cerr << errorStr << "\n"
             << "    Failed to get the current configuration." << endl;
        return CdbStatus::Error;
    }

  // Tables we're going to deal with

    std::string foldersConditionsTableName;
    std::string conditionConfigsTableName;
    {
        ostringstream s;
        s << _myConnectionObjectPtr->database( ) << ".o" << parent( )->parentView( )->parent( )->id ( );
        const std::string baseTableName = s.str( );

        foldersConditionsTableName = baseTableName + "_folders_conditions";
        conditionConfigsTableName  = baseTableName + "_conditions_configs";
    }

  // Get the "entry id" for the current condition. That identifier serves as a primary key
  // in a table of "folders & conditions". We need to know it as a foreign key when manipulating
  // entries in a table of "condition configs".

    unsigned int entryId = 0;
    {
        ostringstream s;
        s << "SELECT id FROM " << foldersConditionsTableName
          << " WHERE view_id = " << parent( )->parentView( )->id( )
          << " AND BINARY path = '" << _myConnectionObjectPtr->translate_string_to_escaped( CdbPathName::separatorTerminated( parent( )->fullPathName( )))
          <<                           _myConnectionObjectPtr->translate_string_to_escaped( name( )) << "'";
        const std::string query = s.str( );

        CdbMySQLSelectQuery selectQuery( _myConnectionObjectPtr,
                                         query );

        if( !execute_query( selectQuery, entryId )) {
            cerr << errorStr << "\n"
                 << "    Failed to execute the query and/or translate its results.\n"
                 << "        Query : \"" << query.c_str( ) << "\"" << endl;
            return CdbStatus::Error;
        }
    }

  // Get rid of the current configuration in the database

    {
        ostringstream s;
        s << "DELETE FROM " << conditionConfigsTableName << " WHERE entry_id = " << entryId;
        const std::string query = s.str( );

        CdbCPtr<RdbMySQLResult> resultPtr;
        if( CdbStatus::Success != CdbMySQLQueryUtils::execute_query( resultPtr,
                                                                    _myConnectionObjectPtr,
                                                                    query,
                                                                    context )) return CdbStatus::Error;
    }

  // Merge the input configuration with the saved one taking into accound the "patchOnlyFlag".
  // At this step we'll produce a new configuration list

    std::vector<CdbConfigElement> newConfigList;
    {
        if( patchOnlyFlag ) {

            std::vector<CdbConfigElement>::const_iterator savedItr = savedConfigList.begin( );
            std::vector<CdbConfigElement>::const_iterator inputItr = theList.begin( );

            BdbTime prevEnd = BdbTime::minusInfinity;

            while( BdbTime::plusInfinity != prevEnd ) {

                if( inputItr == theList.end( )) {

                  // When all input elements are exhausted then we simply copy the rest (if anything
                  // is still left) of the saved list into the output vector.

                    for( ; savedItr != savedConfigList.end( ); ++savedItr ) {

                        CdbConfigElement saved = *savedItr;

                      // Skip the element if it ended before the previously recorded end time

                        if( saved.end <= prevEnd ) continue;

                      // Truncate the begin time of the interval if it starts earlier than the end
                      // time of the previously stored new configuration

                        BdbTime adjustedBeginTime = saved.begin;
                        if( adjustedBeginTime < prevEnd ) adjustedBeginTime = prevEnd;

                        newConfigList.push_back( CdbConfigElement( saved.policy,
                                                                   adjustedBeginTime,
                                                                   saved.end ));
                        prevEnd = saved.end;
                    }

                  // Terminate the loop

                    prevEnd = BdbTime::plusInfinity;

                    break;

                } else {

                    CdbConfigElement input = *(inputItr++);

                  // Check if there are saved elements in between the end time of the previously
                  // stored configuration and the begin time of the above found input one. If so
                  // then we need to store them as well.

                    if( input.begin > prevEnd ) {

                        for( ; savedItr != savedConfigList.end( ); ++savedItr ) {

                            CdbConfigElement saved = *savedItr;

                          // Skip the saved element if it ends before the end of the previously stored
                          // end time.
                          //
                          // NOTE: To tell the truth getting there is supposed to be an algorithm error.
                          //       So let's just check this and provoke a crash in case if the code gets
                          //       compiled in the DEBUG mode

                            if( saved.end <= prevEnd ) {
                                assert( 0 );    // A bug in the current algorithm
                                continue;
                            }

                          // Quit the loop of the saved element begins after the begin time
                          // of the currently processed input one

                            if( saved.begin > input.begin ) break;

                          // Adjust both the begin and the end times of the saved interval, so that
                          // it won't be beyond the limits between the end of the previously stored
                          // interval and the begin time of the current input one.

                            BdbTime adjustedBeginTime = saved.begin;
                            if( adjustedBeginTime < prevEnd ) adjustedBeginTime = prevEnd;

                            BdbTime adjustedEndTime = saved.end;
                            if( adjustedEndTime > input.begin ) adjustedEndTime = input.begin;

                            assert( adjustedBeginTime <= adjustedEndTime ); // A bug in the current algorithm

                          // Save the (truncated) element only if it doesn't have a zero length, which
                          // may happen if the saved interval is completelly hidden by the input one

                            if( adjustedBeginTime < adjustedEndTime )
                                newConfigList.push_back( CdbConfigElement( saved.policy,
                                                                           adjustedBeginTime,
                                                                           adjustedEndTime ));
                        }
                    }

                  // Store the input element as well

                    newConfigList.push_back( input );

                    prevEnd = input.end;
                }
            }

        } else {
            newConfigList = theList;
        }
    }

  // Load the new configuration into the database

    {
        const unsigned int num = newConfigList.size( );
        for( unsigned int i = 0; i < num; ++i ) {
            CdbConfigElement e = newConfigList[i];
            if( e.accessIsAllowed ) {
                ostringstream s;
                s << "INSERT INTO " << conditionConfigsTableName << " (entry_id,begin,end,use_revision,partition_id,revision ) VALUES ("
                  << entryId << ","
                  << CdbTimeUtils::to_nsec( e.begin ) << ","
                  << CdbTimeUtils::to_nsec( e.end ) << ",'"
                  << ( e.policy.useRevision( ) ? 'Y' : 'N' ) << "',"
                  << e.policy.partitionId( ) << ","
                  << CdbTimeUtils::to_nsec( e.policy.revisionId( )) << ")";
                const std::string query = s.str( );

                CdbCPtr<RdbMySQLResult> resultPtr;
                if( CdbStatus::Success != CdbMySQLQueryUtils::execute_query( resultPtr,
                                                                            _myConnectionObjectPtr,
                                                                            query,
                                                                            context )) return CdbStatus::Error;
            }
        }
    }
    return CdbStatus::Success;
}

CdbMySQLConditionAtFolder::CloneType*
CdbMySQLConditionAtFolder::clone( ) const
{
    return new CdbMySQLConditionAtFolder( *this );
}

bool
CdbMySQLConditionAtFolder::equals( const ComparedType& theOtherObject ) const
{
    const char* warningStr = "CdbMySQLConditionAtFolder::equals() -- WARNING";
    cerr << warningStr << "\n"
         << "    This operation is not implemented." << endl;
    return false;
}

bool
CdbMySQLConditionAtFolder::execute_query( CdbMySQLSelectQuery&           theQuery,
                                          std::vector<CdbConfigElement>& theList )
{
    const char* errorStr = "CdbMySQLConditionAtFolder::execute_query(folder) -- ERROR";

    theList.clear( );

  // Process row-by-row and translate results

    while( true ) {

      // Move to the next row

        CdbStatus status = theQuery.next_row( );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) break;

            cerr << errorStr << "\n"
                 << "    Failed to get result of the next row." << endl;
            return false;
        }

      // Now do the interpretation of values of fileds in the row.
      //
      // NOTE: We're assuming that results returned by the query are consistent
      //       with our expectations on how the table shoudl look alike.

        BdbTime        begin        = BdbTime::minusInfinity;
        BdbTime        end          = BdbTime::minusInfinity;
        std::string    use_revision = "";
        unsigned short partition_id = 0xFFFF;
        BdbTime        revision     = BdbTime::minusInfinity;

        theQuery.get( begin,        "begin"        );
        theQuery.get( end,          "end"          );
        theQuery.get( use_revision, "use_revision" );
        theQuery.get( partition_id, "partition_id" );
        theQuery.get( revision,     "revision"     );

      // Create the desired object
      //
      // NOTE: A clone of the current object will be the parent object of
      //       of the newely created one.

        theList.push_back( CdbConfigElement(( 'Y' == use_revision[0] ? CdbRevisionPolicy( revision, partition_id )
                                                                     : CdbRevisionPolicy( )),
                                             begin,
                                             end ));
    }
    return true;
}

bool
CdbMySQLConditionAtFolder::execute_query( CdbMySQLSelectQuery& theQuery,
                                          unsigned int&        theId )
{
    const char* errorStr = "CdbMySQLConditionAtFolder::execute_query(entry_id) -- ERROR";

  // Process the first row (if any) only. We don't care if there will be more rows.
  // However, we do care that the must be at least one row in a set. Otherwise the table's contents
  // would be inconsistent.

    CdbStatus status = theQuery.next_row( );
    if( CdbStatus::Success != status ) {
        if( CdbStatus::NotFound == status ) {
            cerr << errorStr << "\n"
                 << "    The contents of teh database has foumd not to be consistent.\n"
                 << "    There must be exactly one row in the set." << endl;
        } else {
            cerr << errorStr << "\n"
                 << "    Failed to get result of the next row." << endl;
        }
        return false;
    }
    theQuery.get( theId, "id" );
    return true;
}

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

---