ral.hpp

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks_utils source for the DUNE DAQ project.
// Fork baseline commit: c2e7dfc7 (2022-03-30).
// Renamed since fork: yes (from oks/ral.h to include/oksutils/oks/ral.hpp).
//
 
#ifndef OKS_RAL_H
#define OKS_RAL_H
 
#include <memory>
#include <string>
#include <vector>
 
#include "boost/date_time/local_time/local_time.hpp"
 
// DEFINEs to switch on / off verbose output
 
#define VerboseMsg1(MSG)                                                                                               \
  {                                                                                                                    \
    if (verbose_level > 0) {                                                                                           \
      std::cout << MSG << std::endl;                                                                                   \
    }                                                                                                                  \
  }
#define VerboseMsg2(MSG)                                                                                               \
  {                                                                                                                    \
    if (verbose_level > 1) {                                                                                           \
      std::cout << MSG << std::endl;                                                                                   \
    }                                                                                                                  \
  }
#define VerboseMsg3(MSG)                                                                                               \
  {                                                                                                                    \
    if (verbose_level > 2) {                                                                                           \
      std::cout << MSG << std::endl;                                                                                   \
    }                                                                                                                  \
  }
#define VerboseMsg4(MSG)                                                                                               \
  {                                                                                                                    \
    if (verbose_level > 3) {                                                                                           \
      std::cout << MSG << std::endl;                                                                                   \
    }                                                                                                                  \
  }
#define VerboseMsg5(MSG)                                                                                               \
  {                                                                                                                    \
    if (verbose_level > 4) {                                                                                           \
      std::cout << MSG << std::endl;                                                                                   \
    }                                                                                                                  \
  }
 
namespace coral {
class ISessionProxy;
class ConnectionService;
class AttributeList;
}
 
#include "oks/class.hpp"
#include "oks/object.hpp"
 
namespace oks {
 
namespace ral {

 
coral::ISessionProxy*
start_coral_session(const std::string& connect_string,
                    int mode,
                    std::unique_ptr<coral::ConnectionService>& connection,
                    int verbose_level);

 
int
get_head_schema_version(coral::ISessionProxy* session,
                        const std::string& schema,
                        const char* release = 0,
                        int verbose_level = 1,
                        const char* dx = "");

 
int
get_max_schema_version(coral::ISessionProxy* session,
                       const std::string& schema,
                       int verbose_level = 1,
                       const char* dx = "");

 
std::vector<int>
get_schema_versions(coral::ISessionProxy* session,
                    const std::string& schema,
                    const char* release = 0,
                    int verbose_level = 1,
                    const char* dx = "");

 
void
get_data_version(coral::ISessionProxy* session,
                 const std::string& schema,
                 const std::string& tag,
                 int& schema_version,
                 int& data_version,
                 const char* release = 0,
                 int verbose_level = 1,
                 const char* dx = "");

 
void
get_schema(OksKernel& kernel,
           coral::ISessionProxy* session,
           const std::string& schema,
           int version,
           bool read_methods,
           int verbose_level);

 
unsigned long
get_data(OksKernel& kernel,
         coral::ISessionProxy* session,
         const std::string& schema,
         int schema_version,
         int data_version,
         int verbose_level,
         const OksClass::Map* pattern = 0);

 
void
put_schema(const OksClass::Map& classes,
           coral::ISessionProxy* session,
           const std::string& schema,
           int schema_version,
           const std::string& description,
           int verbose_level);

 
struct InsertedDataDetails
{
  long m_insertedOksObjectRowsThis;
  long m_insertedOksObjectRowsBase;
  long m_insertedOksDataRelRowsThis;
  long m_insertedOksDataRelRowsBase;
  long m_insertedOksDataValRowsThis;
  long m_insertedOksDataValRowsBase;
  bool m_use_base;
 
  InsertedDataDetails()
    : m_insertedOksObjectRowsThis(0)
    , m_insertedOksObjectRowsBase(0)
    , m_insertedOksDataRelRowsThis(0)
    , m_insertedOksDataRelRowsBase(0)
    , m_insertedOksDataValRowsThis(0)
    , m_insertedOksDataValRowsBase(0)
    , m_use_base(false)
  {
    ;
  }
};

 
InsertedDataDetails
put_data(OksKernel& kernel,
         OksObject::FSet* objects,
         coral::ISessionProxy* session,
         const std::string& schema,
         int& schema_version,
         int& data_version,
         int base_version,
         const std::string& description,
         long inc_threshold,
         int verbose_level);

 
void
tag_data(coral::ISessionProxy* session,
         const std::string& schema,
         int schema_version,
         int data_version,
         const std::string& tag,
         int verbose_level);

 
void
create_archive_record(coral::ISessionProxy* session,
                      const std::string& schema,
                      int schema_version,
                      int data_version,
                      const std::string& partition_name,
                      int run_number,
                      int verbose_level);
 
void
get_time_host_user(const coral::AttributeList& data,
                   std::string& time,
                   std::string& host,
                   std::string& user,
                   boost::local_time::time_zone_ptr tz_ptr,
                   const char* prefix = 0);
 
} /* close namespace 'ral' */
 
} /* close namespace 'oks' */
 
#endif