SqliteRecord.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef RDBACCESSSVC_SQLITERECORD_H
#define RDBACCESSSVC_SQLITERECORD_H
 
#include "RDBAccessSvc/IRDBRecord.h"
#include <map>
#include <memory>
#include <variant>
#include <string>
#include <tuple>
#include <stdexcept>
 
enum SqliteInpType
{
  SQLITEINP_INT
  , SQLITEINP_LONG
  , SQLITEINP_FLOAT
  , SQLITEINP_DOUBLE
  , SQLITEINP_STRING
  , SQLITEINP_UNDEF
};
 
typedef std::variant<int
                     , long
                     , float
                     , double
                     , std::string> SqliteInp;
 
typedef std::map<std::string,SqliteInpType> SqliteInpDef;
typedef std::shared_ptr<SqliteInpDef> SqliteInpDef_ptr;
 
class SqliteRecord final : public IRDBRecord
{
 public:
  SqliteRecord(SqliteInpDef_ptr def);
  SqliteRecord() = delete;
  SqliteRecord (const SqliteRecord&) = delete;
  SqliteRecord& operator= (const SqliteRecord&) = delete;
 
  ~SqliteRecord() override;
 
  bool isFieldNull(const std::string& field) const override;
 
  int getInt(const std::string& field) const override;
 
  long getLong(const std::string& field) const override;
 
  double getDouble(const std::string& field) const override;
 
  float getFloat(const std::string& field) const override;
 
  virtual const std::string& getString(const std::string& field) const override;
 
  // Access array values by index
  // arrays are implemented using the field with names like NAME_0, NAME_1 etc.
 
  int getInt(const std::string& field, unsigned int index) const override;
 
  long getLong(const std::string& field, unsigned int index) const override;
 
  double getDouble(const std::string& field, unsigned int index) const override;
 
  float getFloat(const std::string& field, unsigned int index) const override;
 
  virtual const std::string& getString(const std::string& field, unsigned int index) const override;
 
  void dump() const;
 
  void addValue(const std::string& field
        , SqliteInp value);
 
 private:
  typedef std::map<std::string,SqliteInp> Record;
  typedef Record::const_iterator RecordCIterator;
  enum FieldCheckCode
  {
    FIELD_CHECK_OK
    , FIELD_CHECK_BAD_NAME
    , FIELD_CHECK_BAD_TYPE
    , FIELD_CHECK_NULL_VAL
  };
  typedef std::tuple<RecordCIterator,FieldCheckCode> FieldCheckResult;
 
  SqliteInpDef_ptr m_def;
  Record           m_record;
 
  FieldCheckResult checkField(const std::string& field
                  , SqliteInpType fieldType) const;
  void             handleError(const std::string& field
                   ,FieldCheckCode checkCode) const;
};
 
inline SqliteRecord::FieldCheckResult SqliteRecord::checkField(const std::string& field
                                   , SqliteInpType fieldType) const
{
  FieldCheckCode checkCode{FIELD_CHECK_OK};
  RecordCIterator checkIt{m_record.end()};
 
  auto defIt = m_def->find(field);
  if(defIt==m_def->end()) checkCode = FIELD_CHECK_BAD_NAME;
  if(defIt->second!=fieldType) checkCode = FIELD_CHECK_BAD_TYPE;
 
  if(checkCode==FIELD_CHECK_OK) {
    checkIt = m_record.find(field);
    if(checkIt==m_record.end()) {
      checkCode = FIELD_CHECK_NULL_VAL;
    }
  }
  return std::make_tuple(checkIt,checkCode);
}
 
inline void SqliteRecord::handleError(const std::string& field
                      ,FieldCheckCode checkCode) const
{
  switch(checkCode) {
  case FIELD_CHECK_BAD_NAME:
    throw std::runtime_error( "Wrong name for the field " + field);
  case FIELD_CHECK_BAD_TYPE:
    throw std::runtime_error( "Wrong data type requested for the field " + field);
  case FIELD_CHECK_NULL_VAL:
    throw std::runtime_error( field + " is NULL");
  default:
    break;
  }
  return;
}
 
#endif