/data/refman/pasoursint/CMSSW_5_2_7_hltpatch2/src/CondCore/RegressionTest/src/TestFunct.cc

Go to the documentation of this file.

#include "CondCore/RegressionTest/interface/TestFunct.h"
#include "CondCore/IOVService/interface/IOVEditor.h"
#include "CondCore/IOVService/interface/IOVProxy.h"

//typedef TestPayloadClass Payload;
typedef RegressionTestPayload Payload;

TestFunct::TestFunct() {}

std::pair<int,int> TestFunct::GetMetadata(std::string mappingName)
{
        cond::DbScopedTransaction trans(s);
        std::pair<int,int> ret(-1,-1);
        try {
                trans.start(true);
                
                coral::ITable& mytable=s.nominalSchema().tableHandle("TEST_METADATA");
                std::auto_ptr< coral::IQuery > query(mytable.newQuery());
                coral::AttributeList BindVariableList;
                std::string condition="NAME =:NAME";
                BindVariableList.extend("NAME",typeid(std::string));
                BindVariableList["NAME"].data<std::string>()=mappingName;
                query->setCondition( condition, BindVariableList );
                query->addToOutputList( "SEED" );
                query->addToOutputList( "RUN" );
                coral::ICursor& cursor = query->execute();
                while( cursor.next() ) {
                        const coral::AttributeList& row = cursor.currentRow();
                        ret.first = row[ "SEED" ].data<int>();
                        ret.second =row["RUN" ].data<int>();
                }
                trans.commit();
        } catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return std::pair<int,int>(-1,-1);
        }
        return ret;
}

bool TestFunct::Read (std::string mappingName)
{
        cond::DbScopedTransaction trans(s);
        cond::MetaData  metadata(s);
        int refSeed =0;
        bool ret = false;
        try {
                trans.start(true);
                
                coral::ITable& mytable=s.nominalSchema().tableHandle("TEST_METADATA");
                std::auto_ptr< coral::IQuery > query(mytable.newQuery());
                coral::AttributeList BindVariableList;
                std::string condition="NAME =:NAME";
                BindVariableList.extend("NAME",typeid(std::string));
                BindVariableList["NAME"].data<std::string>()=mappingName;
                query->setCondition( condition, BindVariableList );
                query->addToOutputList( "SEED" );
                coral::ICursor& cursor = query->execute();
                while( cursor.next() ) {
                        const coral::AttributeList& row = cursor.currentRow();
                        refSeed=row[ "SEED" ].data<int>();
                }
                std::string readToken = metadata.getToken(mappingName);
                boost::shared_ptr<Payload> readRef0 = s.getTypedObject<Payload>( readToken ); //v4      
                std::cout << "Object with id="<<readToken<<" has been read"<<std::endl;
                Payload tp = *readRef0;
                Payload tp2(refSeed);
                if(tp == tp2){
                  ret = true;
                } else {
                  std::cout <<" read failed : seed "<<refSeed<<std::endl;
                }
                trans.commit();
        } catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return false;
        }
        return ret;
}

bool TestFunct::ReadWithIOV(std::string mappingName, 
                            int seed,
                            int validity)
{
        cond::DbScopedTransaction trans(s);
        cond::MetaData  metadata(s);
        bool ret = false;
        try {
                trans.start(true);
                std::string iovToken = metadata.getToken(mappingName);
                cond::IOVProxy iov(s,iovToken);
                cond::IOVProxy::const_iterator iPayload = iov.find( validity );
                if( iPayload == iov.end() ){
                  std::cout << "ERROR: no payload found in IOV for run="<<validity<<std::endl;
                  return false;
                }
                boost::shared_ptr<Payload> readRef0 = s.getTypedObject<Payload>( iPayload->token() ); //v4      
                std::cout << "Object with id="<<iPayload->token()<<" has been read"<<std::endl;
                Payload tp = *readRef0;
                Payload tp2(seed);
                if(tp == tp2){
                  ret = true;
                } else {
                  std::cout <<" read failed : seed="<<seed<<std::endl;
                }
                trans.commit();
        } catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return false;
        }
        return ret;
}

bool TestFunct::ReadAll()
{
        cond::DbScopedTransaction trans(s);
        cond::MetaData  metadata(s);
        std::vector<std::string> tokenList;
        bool ret = true;
        try {
                trans.start(true);
                metadata.listAllTags(tokenList);
                for(unsigned int i=0; i<tokenList.size(); i++)
                {
                  if(!Read(tokenList[i])) ret = false;
                }
                trans.commit();
        } 
        catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return false;
        }
        return ret;
}
bool TestFunct::Write (std::string mappingName, int payloadID)
{
        cond::DbScopedTransaction trans(s);
        cond::MetaData  metadata(s);
        std::string tok0("");
        try 
        {
            trans.start();
            coral::ITable& mytable=s.nominalSchema().tableHandle("TEST_METADATA");
            coral::AttributeList rowBuffer;
            coral::ITableDataEditor& dataEditor = mytable.dataEditor();
            dataEditor.rowBuffer( rowBuffer );
            rowBuffer["NAME"].data<std::string>()=mappingName;
            rowBuffer["SEED"].data<int>()=payloadID;
            rowBuffer["RUN"].data<int>()=-1;
            dataEditor.insertRow( rowBuffer );          
            s.createDatabase();
            boost::shared_ptr<Payload> myRef0(new Payload(payloadID)); //v4
            tok0 = s.storeObject( myRef0.get(),"cont1"); //v4
            metadata.addMapping(mappingName, tok0);
            std::cout << "Stored object with id = "<<tok0<<std::endl;
            trans.commit();
        } catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return false;
        }
        return true;
}

bool TestFunct::WriteWithIOV(std::string mappingName, 
                             int payloadID, 
                             int runValidity,
                             bool updateTestMetadata ){
   cond::DbScopedTransaction trans(s);
   cond::MetaData  metadata(s);
   std::string tok0("");
   try {
     cond::IOVEditor iov(s);
     trans.start();
     if( updateTestMetadata ){
       coral::ITable& mytable=s.nominalSchema().tableHandle("TEST_METADATA");
       coral::AttributeList rowBuffer;
       coral::ITableDataEditor& dataEditor = mytable.dataEditor();
       dataEditor.rowBuffer( rowBuffer );
       rowBuffer["NAME"].data<std::string>()=mappingName;
       rowBuffer["SEED"].data<int>()=payloadID;
       rowBuffer["RUN"].data<int>()= runValidity;
       dataEditor.insertRow( rowBuffer );               
     }
     s.createDatabase();
     boost::shared_ptr<Payload> myRef0(new Payload(payloadID)); //v4
     std::string payloadTok = s.storeObject( myRef0.get(),"cont1"); 
     iov.create( cond::runnumber );
     iov.append( runValidity, payloadTok );
     metadata.addMapping(mappingName, iov.token());
     trans.commit();
   } catch ( const cond::Exception& exc )
     {
       std::cout << "ERROR: "<<exc.what()<<std::endl;
       return false;
     }
   return true;    
   
}

bool TestFunct::CreateMetaTable ()
{
        cond::DbScopedTransaction trans(s);
        try
        {
                trans.start();
                coral::ISchema& schema=s.nominalSchema();
                coral::TableDescription description;
                description.setName("TEST_METADATA");
                description.insertColumn(  "NAME", coral::AttributeSpecification::typeNameForId( typeid(std::string)) );
                description.insertColumn( "SEED", coral::AttributeSpecification::typeNameForId( typeid(int)) );
                description.insertColumn( "RUN", coral::AttributeSpecification::typeNameForId( typeid(int)) );
                std::vector<std::string> cols;
                cols.push_back( "NAME" );
                description.setPrimaryKey(cols);
                description.setNotNullConstraint("SEED");
                description.setNotNullConstraint("RUN");
                coral::ITable& table=schema.createTable(description);
                table.privilegeManager().grantToPublic( coral::ITablePrivilegeManager::Select);
                std::cout<<"Table created"<<std::endl;
                trans.commit();
        }catch( const coral::TableAlreadyExistingException& er ){
                std::cout<<"table alreay existing, not creating a new one"<<std::endl;
                return false;
        }
        return true;
}
bool TestFunct::DropTables(std::string connStr)
{
        std::set<std::string> exclude;
        exclude.insert("VERSION_TABLE");
        exclude.insert("TEST_STATUS");
        exclude.insert("SEQUENCES");
        exclude.insert("TEST_RESULTS");
        exclude.insert("RUN_HEADER");
        exclude.insert("RUN_RESULT");
        exclude.insert("RUN_STEP_RESULT");
        try
        {
                ora::SchemaUtils::cleanUp(connStr, exclude); //v4
        }
        catch ( const std::exception& exc )
        {
                std::cout <<" ERROR: "<<exc.what()<<std::endl;
                return false;
    }
        return true;
}
bool TestFunct::DropItem(std::string mappingName)
{
        cond::DbScopedTransaction trans(s);
        cond::MetaData  metadata(s);
        try {
                trans.start(false);
                std::string token = metadata.getToken(mappingName);
                s.deleteObject(token);
                metadata.deleteEntryByTag(mappingName);
                trans.commit();
        } 
        catch ( const cond::Exception& exc )
        {
                std::cout << "ERROR: "<<exc.what()<<std::endl;
                return false;
        }
        
        return true;
}