IDbSchema.h

Go to the documentation of this file.

#ifndef CondCore_CondDB_IDbSchema_h
#define CondCore_CondDB_IDbSchema_h

//
#include <boost/date_time/posix_time/posix_time.hpp>

#include "CondFormats/Common/interface/Time.h"
#include "CondCore/CondDB/interface/Types.h"
#include "CondCore/CondDB/interface/Binary.h"

namespace cond {

  namespace persistency {

    class ITagTable {
    public:
      virtual ~ITagTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const std::string& name ) = 0;
      virtual bool select( const std::string& name, cond::TimeType& timeType, std::string& objectType, cond::SynchronizationType& synchronizationType,
               cond::Time_t& endOfValidity, std::string& description, cond::Time_t& lastValidatedTime ) = 0;
      virtual bool getMetadata( const std::string& name, std::string& description, 
                boost::posix_time::ptime& insertionTime, boost::posix_time::ptime& modificationTime ) = 0;
      virtual void insert( const std::string& name, cond::TimeType timeType, const std::string& objectType, 
               cond::SynchronizationType synchronizationType, cond::Time_t endOfValidity, const std::string& description, 
               cond::Time_t lastValidatedTime, const boost::posix_time::ptime& insertionTime ) = 0;
      virtual void update( const std::string& name, cond::SynchronizationType synchronizationType, cond::Time_t& endOfValidity, const std::string& description, 
               cond::Time_t lastValidatedTime, const boost::posix_time::ptime& updateTime ) = 0;
      virtual void updateValidity( const std::string& name, cond::Time_t lastValidatedTime, 
                   const boost::posix_time::ptime& updateTime ) = 0;
      virtual void setValidationMode() = 0;
    };

    class IPayloadTable {
    public:
      virtual ~IPayloadTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const cond::Hash& payloadHash, std::string& objectType, 
               cond::Binary& payloadData, cond::Binary& streamerInfoData ) = 0;
      virtual bool getType( const cond::Hash& payloadHash, std::string& objectType ) = 0;
      virtual cond::Hash insertIfNew( const std::string& objectType, const cond::Binary& payloadData, 
                      const cond::Binary& streamerInfoData, const boost::posix_time::ptime& insertionTime ) = 0;
    };

    class IIOVTable {
    public:
      virtual ~IIOVTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual size_t getGroups( const std::string& tag, const boost::posix_time::ptime& snapshotTime, 
                std::vector<cond::Time_t>& groups ) = 0;
      virtual size_t select( const std::string& tag, cond::Time_t lowerGroup, cond::Time_t upperGroup, 
                 const boost::posix_time::ptime& snapshotTime, 
                 std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs) = 0;
      virtual bool getLastIov( const std::string& tag, const boost::posix_time::ptime& snapshotTime, cond::Time_t& since, cond::Hash& hash ) = 0;
      virtual bool getSize( const std::string& tag, const boost::posix_time::ptime& snapshotTime, size_t& size ) = 0;
      virtual bool getRange( const std::string& tag, cond::Time_t begin, cond::Time_t end, 
                 const boost::posix_time::ptime& snapshotTime, std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ) = 0;
      virtual void insertOne( const std::string& tag, cond::Time_t since, cond::Hash payloadHash, 
                  const boost::posix_time::ptime& insertTime ) = 0;
      virtual void insertMany( const std::string& tag, 
                   const std::vector<std::tuple<cond::Time_t,cond::Hash,boost::posix_time::ptime> >& iovs ) = 0;
      virtual void erase( const std::string& tag ) = 0;
    };
    
    class ITagMigrationTable {
    public:
      virtual ~ITagMigrationTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const std::string& sourceAccount, const std::string& sourceTag, std::string& tagName, int& statusCode ) = 0;
      virtual void insert( const std::string& sourceAccount, const std::string& sourceTag, const std::string& tagName, 
               int statusCode, const boost::posix_time::ptime& insertionTime ) = 0;
      virtual void updateValidationCode( const std::string& sourceAccount, const std::string& sourceTag, int statusCode ) = 0;
    };
    
    class IPayloadMigrationTable {
    public:
      virtual ~IPayloadMigrationTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const std::string& sourceAccount, const std::string& sourceToken, std::string& payloadId ) = 0;
      virtual void insert( const std::string& sourceAccount, const std::string& sourceToken, const std::string& payloadId, 
               const boost::posix_time::ptime& insertionTime ) = 0;
      virtual void update( const std::string& sourceAccount, const std::string& sourceToken, const std::string& payloadId, 
               const boost::posix_time::ptime& insertionTime ) = 0;
    };

    class ITagLogTable {
    public:
      virtual ~ITagLogTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual void insert( const std::string& tag, const boost::posix_time::ptime& eventTime, const std::string& userName, const std::string& hostName, 
               const std::string& command, const std::string& action, const std::string& userText ) = 0;
    };

    class IIOVSchema {
    public: 
      virtual ~IIOVSchema(){}
      virtual bool exists() = 0;
      virtual bool create() = 0;
      virtual ITagTable& tagTable() = 0;
      virtual IIOVTable& iovTable() = 0;
      virtual IPayloadTable& payloadTable() = 0;
      virtual ITagLogTable& tagLogTable() = 0;
    };

    class IGTTable {
    public:
      virtual ~IGTTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const std::string& name ) = 0;
      virtual bool select( const std::string& name, cond::Time_t& validity, boost::posix_time::ptime& snapshotTime ) = 0;
      virtual bool select( const std::string& name, cond::Time_t& validity, std::string& description, 
               std::string& release, boost::posix_time::ptime& snapshotTime ) = 0;
      virtual void insert( const std::string& name, cond::Time_t validity, const std::string& description, const std::string& release, 
               const boost::posix_time::ptime& snapshotTime, const boost::posix_time::ptime& insertionTime ) = 0;
      virtual void update( const std::string& name, cond::Time_t validity, const std::string& description, const std::string& release, 
               const boost::posix_time::ptime& snapshotTime, const boost::posix_time::ptime& insertionTime ) = 0;
    };
     
    class IGTMapTable {
    public:
      virtual ~IGTMapTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( const std::string& gtName, std::vector<std::tuple<std::string,std::string,std::string> >& tags ) = 0;
      virtual bool select( const std::string& gtName, const std::string& preFix, const std::string& postFix, 
               std::vector<std::tuple<std::string,std::string,std::string> >& tags ) = 0;
      virtual void insert( const std::string& gtName, const std::vector<std::tuple<std::string,std::string,std::string> >& tags ) = 0;
    };
    
    class IGTSchema {
    public: 
      virtual ~IGTSchema(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual IGTTable& gtTable() = 0;
      virtual IGTMapTable& gtMapTable() = 0;
    };

    class IRunInfoTable {
    public:
      virtual ~IRunInfoTable(){}
      virtual bool exists() = 0;
      virtual void create() = 0;
      virtual bool select( cond::Time_t runNumber, boost::posix_time::ptime& start, boost::posix_time::ptime& end ) = 0;
      virtual cond::Time_t getLastInserted() = 0;
      virtual bool getInclusiveRunRange( cond::Time_t lower, cond::Time_t upper,
                     std::vector<std::tuple<cond::Time_t,boost::posix_time::ptime,boost::posix_time::ptime> >& runData ) = 0;
      virtual bool getInclusiveTimeRange( const boost::posix_time::ptime& lower ,const boost::posix_time::ptime& upper, 
                      std::vector<std::tuple<cond::Time_t,boost::posix_time::ptime,boost::posix_time::ptime> >& runData ) = 0;
      virtual void insertOne( cond::Time_t runNumber, const boost::posix_time::ptime& start, const boost::posix_time::ptime& end) = 0;
      virtual void insert( const std::vector<std::tuple<cond::Time_t,boost::posix_time::ptime,boost::posix_time::ptime> >& runs ) = 0;
      virtual void updateEnd( cond::Time_t runNumber, const boost::posix_time::ptime& end ) = 0;
    };

    class IRunInfoSchema {
    public: 
      virtual ~IRunInfoSchema(){}
      virtual bool exists() = 0;
      virtual bool create() = 0;
      virtual IRunInfoTable& runInfoTable() = 0;
    };

    
  }
}
#endif