QwDatabase Class Reference

A database interface class. More...

#include <QwDatabase.h>

Collaboration diagram for QwDatabase:

Public Member Functions
template<typename Statement, typename Lambda>
void	QuerySelectForEachResult (const Statement &statement, Lambda &&lambda)
template<typename QueryResult, typename Lambda>
void	ForEachResult (QueryResult &result, Lambda &&lambda) const
template<typename Statement>
size_t	QuerySelectCountResults (const Statement &statement)
template<typename QueryResult>
size_t	CountResults (QueryResult &result) const
template<typename Statement, typename Lambda>
bool	QuerySelectForFirstResult (const Statement &statement, Lambda &&lambda)
template<typename QueryResult, typename Lambda>
bool	ForFirstResult (QueryResult &result, Lambda &&lambda) const
template<typename Statement, typename Lambda>
auto	VisitConnectionForSelect (Lambda &&lambda) -> QuerySelectReturnType< Statement >
	QwDatabase (const string &major="00", const string &minor="00", const string &point="0000")
	Simple constructor.
	QwDatabase (QwOptions &options, const string &major="00", const string &minor="00", const string &point="0000")
	Constructor with QwOptions object.
virtual	~QwDatabase ()
	Destructor.
void	SetAccessLevel (string accesslevel)
	Sets the access level flag based on string labels: "off", "ro", "rw".
Bool_t	AllowsReadAccess ()
Bool_t	AllowsWriteAccess ()
Bool_t	Connect ()
	Open a connection to the database using the predefined parameters.
void	Disconnect ()
Bool_t	Connected ()
	Get a scoped connection that automatically disconnects when destroyed.
QwScopedConnection	GetScopedConnection ()
const string	GetServerVersion ()
void	ProcessOptions (QwOptions &options)
	Processes the options contained in the QwOptions object.
void	ProcessOptions (const EQwDBType &dbtype, const TString &dbname, const TString &username, const TString &passwd, const TString &dbhost="localhost", const Int_t dbport=0, const TString &accesslevel="ro")
	Processes database options.
template<typename Statement>
size_t	QueryCount (const Statement &statement)
template<typename Statement>
bool	QueryExists (const Statement &statement)
template<typename Statement>
auto	QuerySelect (const Statement &statement)
template<typename Statement>
void	QueryExecute (const Statement &statement)
template<typename InsertStatement>
uint64_t	QueryInsertAndGetId (const InsertStatement &statement)
const string	GetVersion ()
const string	GetVersionMajor ()
	Return a full version string for the DB schema.
const string	GetVersionMinor ()
const string	GetVersionPoint ()
const string	GetValidVersion ()
void	PrintServerInfo ()

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Defines available class options for QwOptions.

Protected Attributes
Bool_t	fDBInsertMissingKeys
	True if missing keys should be inserted into the database automatically.

Private Types
enum	EQwDBType { kQwDatabaseNone }
enum class	EConnectionCheck : bool { kUnchecked = false , kChecked = true }
enum	EQwDBAccessLevel { kQwDatabaseOff , kQwDatabaseReadOnly , kQwDatabaseReadWrite }
using	DatabaseConnection
template<typename Statement>
using	QuerySelectReturnType

Private Member Functions
template<EConnectionCheck CheckConnection = EConnectionCheck::kChecked, typename Lambda>
auto	VisitConnection (Lambda &&lambda)
Bool_t	ValidateConnection ()
	Checks that given connection parameters result in a valid connection.
bool	StoreDBVersion ()
	Retrieve database schema version information from database.
	QwDatabase (const QwDatabase &rhs)
	Copy Constructor (not implemented)
QwDatabase &	operator= (const QwDatabase &rhs)
	Assignment operator (not implemented)

Private Attributes
EQwDBType	fDBType = kQwDatabaseNone
	Type of database backend to use.
DatabaseConnection	fDBConnection
EQwDBAccessLevel	fAccessLevel
	Access level of the database instance.
string	fDatabase
	Name of database to connect to.
string	fDBServer
	Name of server carrying DB to connect to.
string	fDBUsername
	Name of account to connect to DB server with.
string	fDBPassword
	DB account password.
UInt_t	fDBPortNumber
	Port number to connect to on server (mysql default port is 3306)
Bool_t	fValidConnection
	True if a valid connection was established using defined connection information.
Bool_t	fDBDebug
	True if database debug information should be printed to stdout.
string	fVersionMajor
	Major version number of current DB schema.
string	fVersionMinor
	Minor version number of current DB schema.
string	fVersionPoint
	Point version number of current DB schema.
const string	kValidVersionMajor
const string	kValidVersionMinor
const string	kValidVersionPoint

Detailed Description

A database interface class.

This class provides the connection to the Qweak database to other objects in the Qweak analyzer. A static global object gQwDatabase is used to provide these services.

Definition at line 121 of file QwDatabase.h.

Member Typedef Documentation

DatabaseConnection

using QwDatabase::DatabaseConnection

private

Initial value:

 std::variant<
      std::monostate  
 
 
 
 
 
 
 
 
 
    >

Definition at line 148 of file QwDatabase.h.

QuerySelectReturnType

template<typename Statement>

using QwDatabase::QuerySelectReturnType

private

Initial value:

 std::variant<
      std::monostate  
 
 
 
 
 
 
 
 
 
    >

Definition at line 163 of file QwDatabase.h.

Member Enumeration Documentation

EConnectionCheck

enum class QwDatabase::EConnectionCheck : bool

strongprivate

Enumerator
kUnchecked
kChecked

Definition at line 180 of file QwDatabase.h.

                                : bool {
      kUnchecked = false,
      kChecked = true
    };

EQwDBAccessLevel

enum QwDatabase::EQwDBAccessLevel

private

Enumerator
kQwDatabaseOff
kQwDatabaseReadOnly
kQwDatabaseReadWrite

Definition at line 419 of file QwDatabase.h.

{kQwDatabaseOff, kQwDatabaseReadOnly, kQwDatabaseReadWrite};

EQwDBType

enum QwDatabase::EQwDBType

private

Enumerator
kQwDatabaseNone

Definition at line 123 of file QwDatabase.h.

                   {kQwDatabaseNone
#ifdef __USE_DATABASE_SQLITE3__
      , kQwDatabaseSQLite3
#endif // __USE_DATABASE_SQLITE3__
#ifdef __USE_DATABASE_MYSQL__
      , kQwDatabaseMySQL
#endif // __USE_DATABASE_MYSQL__
#ifdef __USE_DATABASE_POSTGRESQL__
      , kQwDatabasePostgreSQL
#endif // __USE_DATABASE_POSTGRESQL__
    };

Constructor & Destructor Documentation

QwDatabase() [1/3]

QwDatabase::QwDatabase	(	const string &	major = "00",
		const string &	minor = "00",
		const string &	point = "0000" )

Simple constructor.

The simple constructor initializes member fields. This class is not used to establish the database connection.

Definition at line 78 of file QwDatabase.cc.

                                                                                    : kValidVersionMajor(major), kValidVersionMinor(minor), kValidVersionPoint(point)
{
  QwDebug << "Greetings from QwDatabase simple constructor." << QwLog::endl;
 
  // Initialize member fields
  fDatabase=fDBServer=fDBUsername=fDBPassword="";
  fVersionMajor=fVersionMinor=fVersionPoint="";
 
  fAccessLevel = kQwDatabaseOff;
 
  fDBPortNumber      = 0;
  fValidConnection   = false;
 
}

References QwLog::endl(), fAccessLevel, fDatabase, fDBPassword, fDBPortNumber, fDBServer, fDBUsername, fValidConnection, fVersionMajor, fVersionMinor, fVersionPoint, kQwDatabaseOff, kValidVersionMajor, kValidVersionMinor, kValidVersionPoint, and QwDebug.

Referenced by operator=(), and QwDatabase().

Here is the call graph for this function:

Here is the caller graph for this function:

QwDatabase() [2/3]

QwDatabase::QwDatabase	(	QwOptions &	options,
		const string &	major = "00",
		const string &	minor = "00",
		const string &	point = "0000" )

Constructor with QwOptions object.

The constructor initializes member fields using the values in the QwOptions object.

Parameters

options	The QwOptions object.
major	Major version number
minor	Minor version number
point	Point revision number

Definition at line 100 of file QwDatabase.cc.

                                                                                                        : kValidVersionMajor(major), kValidVersionMinor(minor), kValidVersionPoint(point)
{
  QwDebug << "Greetings from QwDatabase extended constructor." << QwLog::endl;
 
  // Initialize member fields
  fDatabase=fDBServer=fDBUsername=fDBPassword="";
  fVersionMajor=fVersionMinor=fVersionPoint="";
 
  fAccessLevel = kQwDatabaseOff;
 
  fDBPortNumber      = 0;
  fValidConnection   = false;
 
  ProcessOptions(options);
 
}

References QwLog::endl(), fAccessLevel, fDatabase, fDBPassword, fDBPortNumber, fDBServer, fDBUsername, fValidConnection, fVersionMajor, fVersionMinor, fVersionPoint, kQwDatabaseOff, kValidVersionMajor, kValidVersionMinor, kValidVersionPoint, ProcessOptions(), and QwDebug.

Here is the call graph for this function:

~QwDatabase()

QwDatabase::~QwDatabase ( )

virtual

Destructor.

The destructor says "Good-bye World!"

Definition at line 119 of file QwDatabase.cc.

{
  QwDebug << "QwDatabase::~QwDatabase() : Good-bye World from QwDatabase destructor!" << QwLog::endl;
  if (Connected()) Disconnect();
}

References Connected(), Disconnect(), QwLog::endl(), and QwDebug.

Here is the call graph for this function:

QwDatabase() [3/3]

QwDatabase::QwDatabase ( const QwDatabase & rhs )

private

Copy Constructor (not implemented)

References QwDatabase().

Here is the call graph for this function:

Member Function Documentation

AllowsReadAccess()

Bool_t QwDatabase::AllowsReadAccess ( )

inline

Definition at line 309 of file QwDatabase.h.

{return (fAccessLevel==kQwDatabaseReadOnly || fAccessLevel==kQwDatabaseReadWrite);};

References fAccessLevel, kQwDatabaseReadOnly, and kQwDatabaseReadWrite.

AllowsWriteAccess()

Bool_t QwDatabase::AllowsWriteAccess ( )

inline

Definition at line 310 of file QwDatabase.h.

{return (fAccessLevel==kQwDatabaseReadWrite);};

References fAccessLevel, and kQwDatabaseReadWrite.

Connect()

bool QwDatabase::Connect

(

)

Open a connection to the database using the predefined parameters.

This function is used to initiate a database connection.

Definition at line 303 of file QwDatabase.cc.

{
  /* Open a connection to the database using the predefined parameters.
   * Must call QwDatabase::ConnectionInfo() first.
   */
 
  //  Return false, if we're not using the DB.
  if (fAccessLevel==kQwDatabaseOff) return false;
 
  // Make sure not already connected
  if (Connected()) return true;
 
  // If never connected before, then make sure connection parameters form
  // valid connection
  if (!fValidConnection) {
    ValidateConnection();
  }
 
  if (fValidConnection) {
    // FIXME (wdconinc) duplication with ValidateConnection
    try {
      switch(fDBType) 
      {
#ifdef __USE_DATABASE_MYSQL__
        case kQwDatabaseMySQL: {
          QwDebug << "QwDatabase::ValidateConnection() : Using MySQL backend." << QwLog::endl;
          sqlpp::mysql::connection_config config;
          config.host = fDBServer;
          config.user = fDBUsername;
          config.password = fDBPassword;
          config.database = fDatabase;
          config.port = fDBPortNumber;
#ifdef __USE_SQLPP11__
          config.debug = fDBDebug;
#endif
#ifdef __USE_SQLPP23__
          if (fDBDebug) {
            config.debug = sqlpp::debug_logger({sqlpp::log_category::all}, [](const std::string& msg) {
              QwMessage << "SQL Debug: " << msg << QwLog::endl;
            });
          }
#endif
          fDBConnection = std::make_shared<sqlpp::mysql::connection>(config);
          break;
        }
#endif
#ifdef __USE_DATABASE_SQLITE3__
        case kQwDatabaseSQLite3: {
          QwDebug << "QwDatabase::ValidateConnection() : Using SQLite3 backend." << QwLog::endl;
          sqlpp::sqlite3::connection_config config;
          config.path_to_database = fDatabase;
          config.password = fDBPassword;
          // FIXME (wdconinc) use proper access flags
          config.flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
#ifdef __USE_SQLPP11__
          config.debug = fDBDebug;
#endif
#ifdef __USE_SQLPP23__
          if (fDBDebug) {
            config.debug = sqlpp::debug_logger({sqlpp::log_category::all}, [](const std::string& msg) {
              QwMessage << "SQL Debug: " << msg << QwLog::endl;
            });
          }
#endif
          fDBConnection = std::make_shared<sqlpp::sqlite3::connection>(config);
          break;
        }
#endif
#ifdef __USE_DATABASE_POSTGRESQL__
        case kQwDatabasePostgreSQL: {
          QwDebug << "QwDatabase::ValidateConnection() : Using PostgreSQL backend." << QwLog::endl;
          sqlpp::postgresql::connection_config config;
          config.host = fDBServer;
          config.user = fDBUsername;
          config.password = fDBPassword;
          config.dbname = fDatabase;
          config.port = fDBPortNumber;
          fDBConnection = std::make_shared<sqlpp::postgresql::connection>(config);
          break;
        }
#endif
        default: {
          QwError << "QwDatabase::ValidateConnection() : Unsupported database type." << QwLog::endl;
          return false;
        }
      }
    } catch (const std::exception& e) {
      QwError << "QwDatabase::Connect() : " << QwLog::endl;
      QwError << e.what() << " while connecting to database" << QwLog::endl;
      fValidConnection = false;
      return false;
    }
    return true;
  } else {
    QwError << "QwDatabase::Connect() : Must establish valid connection to database." << QwLog::endl;
    return false;
  }
}

References Connected(), QwLog::endl(), fAccessLevel, fDatabase, fDBConnection, fDBDebug, fDBPassword, fDBPortNumber, fDBServer, fDBType, fDBUsername, fValidConnection, kQwDatabaseOff, QwDebug, QwError, QwMessage, and ValidateConnection().

Here is the call graph for this function:

Connected()

Bool_t QwDatabase::Connected ( )

inline

Get a scoped connection that automatically disconnects when destroyed.

Definition at line 323 of file QwDatabase.h.

References VisitConnection().

Referenced by Connect(), and ~QwDatabase().

Here is the call graph for this function:

Here is the caller graph for this function:

CountResults()

template<typename QueryResult>

size_t QwDatabase::CountResults ( QueryResult & result ) const

inline

Definition at line 248 of file QwDatabase.h.

                                                   {
      size_t count = 0;
      ForEachResult(result, [&count](const auto& row) {
        (void)row; // Suppress unused variable warning
        count++;
      });
      return count;
    }

References ForEachResult().

Here is the call graph for this function:

DefineOptions()

void QwDatabase::DefineOptions ( QwOptions & options )

static

Defines available class options for QwOptions.

Defines configuration options for QwDatabase class using QwOptions functionality.

Should apparently by called by QwOptions::DefineOptions() in QwParityOptions.h

Definition at line 409 of file QwDatabase.cc.

{
  // Specify command line options for use by QwDatabase
  // FIXME (wdconinc) add database type option
  options.AddOptions("Database options")("QwDatabase.accesslevel", po::value<string>(), "database access level (OFF,RO,RW)");
  options.AddOptions("Database options")("QwDatabase.dbname", po::value<string>(), "database name or path");
  options.AddOptions("Database options")("QwDatabase.dbserver", po::value<string>(), "database server name");
  options.AddOptions("Database options")("QwDatabase.dbusername", po::value<string>(), "database username");
  options.AddOptions("Database options")("QwDatabase.dbpassword", po::value<string>(), "database password");
  options.AddOptions("Database options")("QwDatabase.dbport", po::value<int>()->default_value(0), "database server port number (defaults to standard mysql port)");
  options.AddOptions("Database options")("QwDatabase.debug", po::value<bool>()->default_value(false), "enable database debug output (default false)");
  options.AddOptions("Database options")("QwDatabase.insert-missing-keys", po::value<bool>()->default_value(false), "insert missing keys into the database (default false)");
 
  std::stringstream dbtypes;
  dbtypes << "none";
#ifdef __USE_DATABASE_SQLITE3__
  dbtypes << ",sqlite3";
#endif // __USE_DATABASE_SQLITE3__
#ifdef __USE_DATABASE_MYSQL__
  dbtypes << ",mysql";
#endif // __USE_DATABASE_MYSQL__
#ifdef __USE_DATABASE_POSTGRESQL__
  dbtypes << ",postgresql";
#endif // __USE_DATABASE_POSTGRESQL__
  std::stringstream desc;
  desc << "database type (" << dbtypes.str() << ")";
  options.AddOptions("Database options")("QwDatabase.dbtype", po::value<string>()->default_value("none"), desc.str().c_str());
}

References QwOptions::AddOptions().

Referenced by QwOptions::DefineOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

Disconnect()

void QwDatabase::Disconnect ( )

inline

Definition at line 313 of file QwDatabase.h.

                              {
      VisitConnection<EConnectionCheck::kUnchecked>([](auto& conn) {
        using T = std::decay_t<decltype(conn)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          if (conn) {
            conn.reset();
          }
        }
      });
    }; //<! Close an open database connection

References VisitConnection().

Referenced by StoreDBVersion(), ValidateConnection(), and ~QwDatabase().

Here is the call graph for this function:

Here is the caller graph for this function:

ForEachResult()

template<typename QueryResult, typename Lambda>

void QwDatabase::ForEachResult ( QueryResult & result, Lambda && lambda ) const

inline

Definition at line 223 of file QwDatabase.h.

                                                                   {
      std::visit([&lambda](auto& res) {
        using T = std::decay_t<decltype(res)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          for (const auto& row : res) {
            lambda(row);
          }
        }
        // If T is std::monostate, do nothing (no results to iterate over)
      }, result);
    }

Referenced by CountResults(), ForFirstResult(), and QuerySelectForEachResult().

Here is the caller graph for this function:

ForFirstResult()

template<typename QueryResult, typename Lambda>

bool QwDatabase::ForFirstResult ( QueryResult & result, Lambda && lambda ) const

inline

Definition at line 272 of file QwDatabase.h.

                                                                    {
      bool found = false;
      ForEachResult(result, [&lambda, &found](const auto& row) {
        if (!found) {  // Only process first result
          lambda(row);
          found = true;
        }
      });
      return found;
    }

References ForEachResult().

Referenced by StoreDBVersion().

Here is the call graph for this function:

Here is the caller graph for this function:

GetScopedConnection()

QwScopedConnection QwDatabase::GetScopedConnection ( )

inline

Definition at line 335 of file QwDatabase.h.

                                             {
      return QwScopedConnection(this);
    }

GetServerVersion()

const string QwDatabase::GetServerVersion ( )

inline

Definition at line 338 of file QwDatabase.h.

                                    {
      // FIXME (wdconinc) implement server_version();
      return "";
    }; //<! Get database server version

Referenced by PrintServerInfo().

Here is the caller graph for this function:

GetValidVersion()

const string QwDatabase::GetValidVersion

(

)

Definition at line 558 of file QwDatabase.cc.

                                        {
  string version = kValidVersionMajor + "." + kValidVersionMinor + "." + kValidVersionPoint;
  return version;
}

References kValidVersionMajor, kValidVersionMinor, and kValidVersionPoint.

Referenced by ValidateConnection().

Here is the caller graph for this function:

GetVersion()

const string QwDatabase::GetVersion

(

)

Definition at line 553 of file QwDatabase.cc.

                                   {
  string version = fVersionMajor + "." + fVersionMinor + "." + fVersionPoint;
  return version;
}

References fVersionMajor, fVersionMinor, and fVersionPoint.

Referenced by ValidateConnection().

Here is the caller graph for this function:

GetVersionMajor()

const string QwDatabase::GetVersionMajor ( )

inline

Return a full version string for the DB schema.

Definition at line 411 of file QwDatabase.h.

{return fVersionMajor;} //<! fVersionMajor getter

References fVersionMajor.

GetVersionMinor()

const string QwDatabase::GetVersionMinor ( )

inline

Definition at line 412 of file QwDatabase.h.

{return fVersionMinor;} //<! fVersionMinor getter

References fVersionMinor.

GetVersionPoint()

const string QwDatabase::GetVersionPoint ( )

inline

Definition at line 413 of file QwDatabase.h.

{return fVersionPoint;} //<! fVersionPoint getter

References fVersionPoint.

operator=()

QwDatabase & QwDatabase::operator= ( const QwDatabase & rhs )

private

Assignment operator (not implemented)

References QwDatabase().

Here is the call graph for this function:

PrintServerInfo()

void QwDatabase::PrintServerInfo

(

)

This function prints the server information.

Definition at line 531 of file QwDatabase.cc.

{
  if (fValidConnection)
    {
      printf("\nQwDatabase MySQL ");
      printf("%s v%s %s -----------------\n", BOLD, GetServerVersion().c_str(), NORMAL);
      printf("Database server : %s%10s%s",    RED,  fDBServer.c_str(),   NORMAL);
      printf(" name   : %s%12s%s",            BLUE, fDatabase.c_str(),   NORMAL);
      printf(" user   : %s%6s%s",             RED,  fDBUsername.c_str(), NORMAL);
      printf(" port   : %s%6d%s\n",           BLUE, fDBPortNumber,       NORMAL);
      // FIXME (wdconinc) implement server_status();
      //printf(" %s\n\n", server_status().c_str());
    }
  else
    {
      printf("There is no connection.\n");
    }
 
  return;
}

References BLUE, BOLD, fDatabase, fDBPortNumber, fDBServer, fDBUsername, fValidConnection, GetServerVersion(), NORMAL, and RED.

Here is the call graph for this function:

ProcessOptions() [1/2]

void QwDatabase::ProcessOptions	(	const EQwDBType &	dbtype,
		const TString &	dbname,
		const TString &	username,
		const TString &	passwd,
		const TString &	dbhost = "localhost",
		const Int_t	dbport = 0,
		const TString &	accesslevel = "ro" )

Processes database options.

Definition at line 501 of file QwDatabase.cc.

{
  SetAccessLevel(static_cast<string>(accesslevel));
  fDBType = dbtype;
  fDatabase = dbname;
  fDBUsername = username;
  fDBPassword = passwd;
  fDBServer = dbhost;
  fDBPortNumber = dbport;
}

References fDatabase, fDBPassword, fDBPortNumber, fDBServer, fDBType, fDBUsername, and SetAccessLevel().

Here is the call graph for this function:

ProcessOptions() [2/2]

void QwDatabase::ProcessOptions

(

QwOptions &

options

)

Processes the options contained in the QwOptions object.

Loads the configuration options for QwDatabase class into this instance of QwDatabase from the QwOptions object.

Parameters

options

Options object

Definition at line 443 of file QwDatabase.cc.

{
  if (options.HasValue("QwDatabase.accesslevel")) {
    string access = options.GetValue<string>("QwDatabase.accesslevel");
    SetAccessLevel(access);
  }
  else {
    QwWarning << "QwDatabase::ProcessOptions : No access level specified; database access is OFF" << QwLog::endl;
    fAccessLevel = kQwDatabaseOff;
  }
  if (options.HasValue("QwDatabase.dbtype")) {
    string dbtype = options.GetValue<string>("QwDatabase.dbtype");
    fDBType = kQwDatabaseNone;
#ifdef __USE_DATABASE_MYSQL__
    if (dbtype == "mysql") {
      fDBType = kQwDatabaseMySQL;
    }
#endif
#ifdef __USE_DATABASE_SQLITE3__
    if (dbtype == "sqlite3") {
      fDBType = kQwDatabaseSQLite3;
    }
#endif
#ifdef __USE_DATABASE_POSTGRESQL__
    if (dbtype == "postgresql") {
      fDBType = kQwDatabasePostgreSQL;
    }
#endif
    if (fDBType == kQwDatabaseNone) {
      QwWarning << "QwDatabase::ProcessOptions : Unrecognized database type \"" << dbtype << "\"; using none" << QwLog::endl;
    }
  } else {
    QwMessage << "QwDatabase::ProcessOptions : No database type specified" << QwLog::endl;
    fDBType = kQwDatabaseNone;
  }
  if (options.HasValue("QwDatabase.dbport")) {
    fDBPortNumber = options.GetValue<int>("QwDatabase.dbport");
  }
  if (options.HasValue("QwDatabase.dbname")) {
    fDatabase = options.GetValue<string>("QwDatabase.dbname");
  }
  if (options.HasValue("QwDatabase.dbusername")) {
    fDBUsername = options.GetValue<string>("QwDatabase.dbusername");
  }
  if (options.HasValue("QwDatabase.dbpassword")) {
    fDBPassword = options.GetValue<string>("QwDatabase.dbpassword");
  }
  if (options.HasValue("QwDatabase.dbserver")) {
    fDBServer = options.GetValue<string>("QwDatabase.dbserver");
  }
  if (options.HasValue("QwDatabase.debug")) {
    fDBDebug = options.GetValue<bool>("QwDatabase.debug");
  }
  if (options.HasValue("QwDatabase.insert-missing-keys")) {
    fDBInsertMissingKeys = options.GetValue<bool>("QwDatabase.insert-missing-keys");
  }
}

References QwLog::endl(), fAccessLevel, fDatabase, fDBDebug, fDBInsertMissingKeys, fDBPassword, fDBPortNumber, fDBServer, fDBType, fDBUsername, QwOptions::GetValue(), QwOptions::HasValue(), kQwDatabaseNone, kQwDatabaseOff, QwMessage, QwWarning, and SetAccessLevel().

Referenced by QwDatabase().

Here is the call graph for this function:

Here is the caller graph for this function:

QueryCount()

template<typename Statement>

size_t QwDatabase::QueryCount ( const Statement & statement )

inline

Definition at line 348 of file QwDatabase.h.

                                                  {
      return VisitConnection<EConnectionCheck::kChecked>([&statement](auto& connection) -> size_t {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          auto result = (*connection)(statement);
          size_t count = 0;
          for (const auto& row : result) {
            (void)row; // Suppress unused variable warning
            count++;
          }
          return count;
        }
        // This should never be reached due to VisitConnection logic
        throw std::runtime_error("Unreachable: monostate in QueryCount lambda");
      });
    }

References VisitConnection().

Referenced by QueryExists(), and StoreDBVersion().

Here is the call graph for this function:

Here is the caller graph for this function:

QueryExecute()

template<typename Statement>

void QwDatabase::QueryExecute ( const Statement & statement )

inline

Definition at line 383 of file QwDatabase.h.

                                                  {
      VisitConnection<EConnectionCheck::kChecked>([&statement](auto& connection) {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          (*connection)(statement);
        }
      });
    } //<! Execute a statement without returning a result.

References VisitConnection().

Here is the call graph for this function:

QueryExists()

template<typename Statement>

bool QwDatabase::QueryExists ( const Statement & statement )

inline

Definition at line 366 of file QwDatabase.h.

                                                 {
      return QueryCount(statement) > 0;
    } //<! Generate a query to check existence in the database.

References QueryCount().

Here is the call graph for this function:

QueryInsertAndGetId()

template<typename InsertStatement>

uint64_t QwDatabase::QueryInsertAndGetId ( const InsertStatement & statement )

inline

Definition at line 393 of file QwDatabase.h.

                                                                   {
      return VisitConnection<EConnectionCheck::kChecked>([&statement](auto& connection) -> uint64_t {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          auto result = (*connection)(statement);
          // For INSERT operations, most databases return the ID directly as uint64_t
          if constexpr (std::is_integral_v<decltype(result)>) {
            return static_cast<uint64_t>(result);
          } else {
            throw std::runtime_error("Unexpected result type from INSERT operation - expected integral type");
          }
        }
        // This should never be reached due to VisitConnection logic
        throw std::runtime_error("Unreachable: monostate in QueryInsertAndGetId lambda");
      });
    } //<! Execute an INSERT statement and return the auto-increment ID.

References VisitConnection().

Here is the call graph for this function:

QuerySelect()

template<typename Statement>

auto QwDatabase::QuerySelect ( const Statement & statement )

inline

Definition at line 371 of file QwDatabase.h.

                                                 {
      return VisitConnectionForSelect<Statement>([&statement](auto& connection) {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (!std::is_same_v<T, std::monostate>) {
          return (*connection)(statement);
        }
        // This should never be reached due to VisitConnectionForSelect logic
        throw std::runtime_error("Unreachable: monostate in QuerySelect lambda");
      });
    } //<! Execute a SELECT statement and return the result.

References VisitConnectionForSelect().

Referenced by QuerySelectForEachResult(), and StoreDBVersion().

Here is the call graph for this function:

Here is the caller graph for this function:

QuerySelectCountResults()

template<typename Statement>

size_t QwDatabase::QuerySelectCountResults ( const Statement & statement )

inline

Definition at line 237 of file QwDatabase.h.

                                                               {
      size_t count = 0;
      QuerySelectForEachResult(statement, [&count](const auto& row) {
        (void)row; // Suppress unused variable warning
        count++;
      });
      return count;
    }

References QuerySelectForEachResult().

Here is the call graph for this function:

QuerySelectForEachResult()

template<typename Statement, typename Lambda>

void QwDatabase::QuerySelectForEachResult ( const Statement & statement, Lambda && lambda )

inline

Definition at line 216 of file QwDatabase.h.

                                                                               {
      auto results = QuerySelect(statement);
      ForEachResult(results, std::forward<Lambda>(lambda));
    }

References ForEachResult(), and QuerySelect().

Referenced by QuerySelectCountResults(), and QuerySelectForFirstResult().

Here is the call graph for this function:

Here is the caller graph for this function:

QuerySelectForFirstResult()

template<typename Statement, typename Lambda>

bool QwDatabase::QuerySelectForFirstResult ( const Statement & statement, Lambda && lambda )

inline

Definition at line 259 of file QwDatabase.h.

                                                                                {
      bool found = false;
      QuerySelectForEachResult(statement, [&lambda, &found](const auto& row) {
        if (!found) {  // Only process first result
          lambda(row);
          found = true;
        }
      });
      return found;
    }

References QuerySelectForEachResult().

Here is the call graph for this function:

SetAccessLevel()

void QwDatabase::SetAccessLevel

(

string

accesslevel

)

Sets the access level flag based on string labels: "off", "ro", "rw".

Definition at line 512 of file QwDatabase.cc.

{
  TString level = accesslevel.c_str();
  level.ToLower();
  if (level=="off")     fAccessLevel = kQwDatabaseOff;
  else if (level=="ro") fAccessLevel = kQwDatabaseReadOnly;
  else if (level=="rw") fAccessLevel = kQwDatabaseReadWrite;
  else{
    QwWarning << "QwDatabase::SetAccessLevel  : Unrecognized access level \""
          << accesslevel << "\"; setting database access OFF"
          << QwLog::endl;
    fAccessLevel = kQwDatabaseOff;
  }
  return;
}

References QwLog::endl(), fAccessLevel, kQwDatabaseOff, kQwDatabaseReadOnly, kQwDatabaseReadWrite, and QwWarning.

Referenced by ProcessOptions(), and ProcessOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

StoreDBVersion()

bool QwDatabase::StoreDBVersion ( )

private

Retrieve database schema version information from database.

Definition at line 567 of file QwDatabase.cc.

{
  try
    {
      QwParitySchema::db_schema db_schema;
      size_t record_count = QueryCount(
          sqlpp::select(sqlpp::all_of(db_schema))
          .from(db_schema)
          .where(sqlpp::value(true))
      );
      QwDebug << "QwDatabase::StoreDBVersion => Number of rows returned:  " << record_count << QwLog::endl;
 
      // If there is more than one run in the DB with the same run number, then there will be trouble later on.  Catch and bomb out.
      if (record_count > 1)
      {
        QwError << "Unable to find unique schema version in database." << QwLog::endl;
        QwError << "Schema query returned " << record_count << " rows." << QwLog::endl;
        QwError << "Please make sure that db_schema contains one unique." << QwLog::endl;
        Disconnect();
        return false;
      }
 
      // Run already exists in database.  Pull run_id and move along.
      if (record_count == 1)
      {
        auto results = QuerySelect(
            sqlpp::select(sqlpp::all_of(db_schema))
            .from(db_schema)
            .where(sqlpp::value(true))
        );
        ForFirstResult(
          results,
          [this](const auto& row) {
            QwDebug << "QwDatabase::StoreDBVersion => db_schema_id = " << row.db_schema_id << QwLog::endl;
            this->fVersionMajor = row.major_release_number;
            this->fVersionMinor = row.minor_release_number;
            this->fVersionPoint = row.point_release_number;
          }
        );
        Disconnect();
      }
    }
  catch (const std::exception& er)
    {
      QwError << er.what() << QwLog::endl;
      Disconnect();
      return false;
    }
 
    return true;
 
}

References Disconnect(), QwLog::endl(), ForFirstResult(), fVersionMajor, fVersionMinor, fVersionPoint, QueryCount(), QuerySelect(), QwDebug, and QwError.

Referenced by ValidateConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

ValidateConnection()

Bool_t QwDatabase::ValidateConnection ( )

private

Checks that given connection parameters result in a valid connection.

This function is used to load the connection information for the database. It tests the connection to make sure it is valid and causes a program exit if no valid connection can be formed.

It is called the first time Connect() is called.

Definition at line 131 of file QwDatabase.cc.

{
  QwDebug << "Entering QwDatabase::ValidateConnection()..." << QwLog::endl;
 
  // Bool_t status;
  //
  // Retrieve options if they haven't already been filled.
  //
  //   if (fDatabase.empty()){
  //     status = ProcessOptions(gQwOptions);
  //     if (!status) return status;
  //   }
 
  //  Check values.
  if (fAccessLevel!=kQwDatabaseOff){
    if (fDatabase.empty()){
      QwError << "QwDatabase::ValidateConnection() : No database supplied.  Unable to connect." << QwLog::endl;
      fValidConnection=false;
    }
#ifdef __USE_DATABASE_SQLITE3__
    if (fDBType != kQwDatabaseSQLite3) {
#else
    // If SQLite3 is not available, all databases require username/password
    if (true) {
#endif
      if (fDBUsername.empty()){
        QwError << "QwDatabase::ValidateConnection() : No database username supplied.  Unable to connect." << QwLog::endl;
        fValidConnection=false;
      }
      if (fDBPassword.empty()){
        QwError << "QwDatabase::ValidateConnection() : No database password supplied.  Unable to connect." << QwLog::endl;
        fValidConnection=false;
      }
      if (fDBServer.empty()){
        QwMessage << "QwDatabase::ValidateConnection() : No database server supplied.  Attempting localhost." << QwLog::endl;
        fDBServer = "localhost";
      }
    }
    //
    // Try to connect with given information
    //
    try {
      // FIXME (wdconinc) duplication with Connect
      switch(fDBType) 
      {
#ifdef __USE_DATABASE_MYSQL__
        case kQwDatabaseMySQL: {
          QwDebug << "QwDatabase::ValidateConnection() : Using MySQL backend." << QwLog::endl;
          sqlpp::mysql::connection_config config;
          config.host = fDBServer;
          config.user = fDBUsername;
          config.password = fDBPassword;
          config.database = fDatabase;
          config.port = fDBPortNumber;
#ifdef __USE_SQLPP11__
          config.debug = fDBDebug;
#endif
#ifdef __USE_SQLPP23__
          if (fDBDebug) {
            config.debug = sqlpp::debug_logger({sqlpp::log_category::all}, [](const std::string& msg) {
              QwMessage << "SQL Debug: " << msg << QwLog::endl;
            });
          }
#endif
          fDBConnection = std::make_shared<sqlpp::mysql::connection>(config);
          break;
        }
#endif
#ifdef __USE_DATABASE_SQLITE3__
        case kQwDatabaseSQLite3: {
          QwDebug << "QwDatabase::ValidateConnection() : Using SQLite3 backend." << QwLog::endl;
          sqlpp::sqlite3::connection_config config;
          config.path_to_database = fDatabase;
          config.password = fDBPassword;
          // FIXME (wdconinc) use proper access flags
          config.flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
#ifdef __USE_SQLPP11__
          config.debug = fDBDebug;
#endif
#ifdef __USE_SQLPP23__
          if (fDBDebug) {
            config.debug = sqlpp::debug_logger({sqlpp::log_category::all}, [](const std::string& msg) {
              QwMessage << "SQL Debug: " << msg << QwLog::endl;
            });
          }
#endif
          fDBConnection = std::make_shared<sqlpp::sqlite3::connection>(config);
          break;
        }
#endif
#ifdef __USE_DATABASE_POSTGRESQL__
        case kQwDatabasePostgreSQL: {
          QwDebug << "QwDatabase::ValidateConnection() : Using PostgreSQL backend." << QwLog::endl;
          sqlpp::postgresql::connection_config config;
          config.host = fDBServer;
          config.user = fDBUsername;
          config.password = fDBPassword;
          config.dbname = fDatabase;
          config.port = fDBPortNumber;
#ifdef __USE_SQLPP11__
          config.debug = fDBDebug;
#endif
#ifdef __USE_SQLPP23__
          if (fDBDebug) {
            config.debug = sqlpp::debug_logger({sqlpp::log_category::all}, [](const std::string& msg) {
              QwMessage << "SQL Debug: " << msg << QwLog::endl;
            });
          }
#endif
          fDBConnection = std::make_shared<sqlpp::postgresql::connection>(config);
          break;
        }
#endif
        default: {
          QwError << "QwDatabase::ValidateConnection() : Unsupported database type." << QwLog::endl;
          fAccessLevel = kQwDatabaseOff;
          return false;
        }
      }
    } catch (std::exception const& e) {
      QwError << "QwDatabase::ValidateConnection() : " << QwLog::endl;
      QwError << e.what() << " while validating connection" << QwLog::endl;
      QwError << "Database name = " << fDatabase <<QwLog::endl;
      QwError << "Database server = " << fDBServer <<QwLog::endl;
      QwError << "Database username = " << fDBUsername <<QwLog::endl;
      QwError << "Database port = " << fDBPortNumber <<QwLog::endl;
      QwError << "Continuing without database." << QwLog::endl;
      QwWarning << "Might have left database connection dangling..." << QwLog::endl;
      fAccessLevel = kQwDatabaseOff;
      return kFALSE;
    }
 
    QwDebug << "QwDatabase::ValidateConnection() : Made it past connect() call."  << QwLog::endl;
 
    // Get database schema version information
    if (StoreDBVersion()) {
      fValidConnection = true;
      // Success!
      QwMessage << "QwDatabase::ValidateConnection() : Successfully connected to requested database." << QwLog::endl;
    } else {
      QwError << "QwDatabase::ValidateConnection() : Unsuccessfully connected to requested database." << QwLog::endl;
      // Connection was bad so clear the member variables
      fValidConnection = false;
      fDatabase.clear();
      fDBServer.clear();
      fDBUsername.clear();
      fDBPassword.clear();
      fDBPortNumber=0;
    }
    Disconnect();
  }
 
  // Check to make sure database and QwDatabase schema versions match up.
  if (fAccessLevel == kQwDatabaseReadWrite && 
      (fVersionMajor != kValidVersionMajor ||
       fVersionMinor != kValidVersionMinor ||
       fVersionPoint <  kValidVersionPoint)) {
    fValidConnection = false;
    QwError << "QwDatabase::ValidConnection() : Connected database schema inconsistent with current version of analyzer." << QwLog::endl;
    QwError << "  Database version is " << this->GetVersion() << QwLog::endl;
    QwError << "  Required database version is " << this->GetValidVersion() << QwLog::endl;
    QwError << "  Please connect to a database supporting the required schema version." << QwLog::endl;
    exit(1);
  }
 
  QwDebug << "QwDatabase::ValidateConnection() : Exiting successfully." << QwLog::endl;
  return fValidConnection;
}

References Disconnect(), QwLog::endl(), fAccessLevel, fDatabase, fDBConnection, fDBDebug, fDBPassword, fDBPortNumber, fDBServer, fDBType, fDBUsername, fValidConnection, fVersionMajor, fVersionMinor, fVersionPoint, GetValidVersion(), GetVersion(), kQwDatabaseOff, kQwDatabaseReadWrite, kValidVersionMajor, kValidVersionMinor, kValidVersionPoint, QwDebug, QwError, QwMessage, QwWarning, and StoreDBVersion().

Referenced by Connect().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitConnection()

template<EConnectionCheck CheckConnection = EConnectionCheck::kChecked, typename Lambda>

auto QwDatabase::VisitConnection ( Lambda && lambda )

inlineprivate

Definition at line 187 of file QwDatabase.h.

                                          {
      return std::visit([&lambda](auto& connection) -> decltype(lambda(connection)) {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (std::is_same_v<T, std::monostate>) {
          if constexpr (CheckConnection == EConnectionCheck::kChecked) {
            throw std::runtime_error("Database not connected (no backend available)");
          } else {
            // For unchecked mode with monostate, return appropriate default
            if constexpr (std::is_void_v<decltype(lambda(connection))>) {
              return; // Return void for void lambdas
            } else {
              return decltype(lambda(connection)){}; // Return default-constructed value
            }
          }
        } else {
          if constexpr (CheckConnection == EConnectionCheck::kChecked) {
            if (!connection) {
              throw std::runtime_error("Database not connected");
            }
          }
          return lambda(connection);
        }
      }, fDBConnection);
    }

References fDBConnection, and kChecked.

Referenced by Connected(), Disconnect(), QueryCount(), QueryExecute(), and QueryInsertAndGetId().

Here is the caller graph for this function:

VisitConnectionForSelect()

template<typename Statement, typename Lambda>

auto QwDatabase::VisitConnectionForSelect ( Lambda && lambda ) -> QuerySelectReturnType<Statement>

inline

Definition at line 285 of file QwDatabase.h.

                                                                                       {
      using ReturnVariant = QuerySelectReturnType<Statement>;
      return std::visit([&lambda](auto& connection) -> ReturnVariant {
        using T = std::decay_t<decltype(connection)>;
        if constexpr (std::is_same_v<T, std::monostate>) {
          throw std::runtime_error("Database not connected (no backend available)");
        } else {
          if (!connection) {
            throw std::runtime_error("Database not connected");
          }
          return ReturnVariant{lambda(connection)};
        }
      }, fDBConnection);
    }

References fDBConnection.

Referenced by QuerySelect().

Here is the caller graph for this function:

Field Documentation

fAccessLevel

EQwDBAccessLevel QwDatabase::fAccessLevel

private

Access level of the database instance.

Definition at line 431 of file QwDatabase.h.

Referenced by AllowsReadAccess(), AllowsWriteAccess(), Connect(), ProcessOptions(), QwDatabase(), QwDatabase(), SetAccessLevel(), and ValidateConnection().

fDatabase

string QwDatabase::fDatabase

private

Name of database to connect to.

Definition at line 433 of file QwDatabase.h.

Referenced by Connect(), PrintServerInfo(), ProcessOptions(), ProcessOptions(), QwDatabase(), QwDatabase(), and ValidateConnection().

fDBConnection

DatabaseConnection QwDatabase::fDBConnection

private

Definition at line 176 of file QwDatabase.h.

Referenced by Connect(), ValidateConnection(), VisitConnection(), and VisitConnectionForSelect().

fDBDebug

Bool_t QwDatabase::fDBDebug

private

True if database debug information should be printed to stdout.

Definition at line 439 of file QwDatabase.h.

Referenced by Connect(), ProcessOptions(), and ValidateConnection().

fDBInsertMissingKeys

Bool_t QwDatabase::fDBInsertMissingKeys

protected

True if missing keys should be inserted into the database automatically.

Definition at line 449 of file QwDatabase.h.

Referenced by ProcessOptions().

fDBPassword

string QwDatabase::fDBPassword

private

DB account password.

Definition at line 436 of file QwDatabase.h.

Referenced by Connect(), ProcessOptions(), ProcessOptions(), QwDatabase(), QwDatabase(), and ValidateConnection().

fDBPortNumber

UInt_t QwDatabase::fDBPortNumber

private

Port number to connect to on server (mysql default port is 3306)

Definition at line 437 of file QwDatabase.h.

Referenced by Connect(), PrintServerInfo(), ProcessOptions(), ProcessOptions(), QwDatabase(), QwDatabase(), and ValidateConnection().

fDBServer

string QwDatabase::fDBServer

private

Name of server carrying DB to connect to.

Definition at line 434 of file QwDatabase.h.

Referenced by Connect(), PrintServerInfo(), ProcessOptions(), ProcessOptions(), QwDatabase(), QwDatabase(), and ValidateConnection().

fDBType

EQwDBType QwDatabase::fDBType = kQwDatabaseNone

private

Type of database backend to use.

Definition at line 134 of file QwDatabase.h.

Referenced by Connect(), ProcessOptions(), ProcessOptions(), and ValidateConnection().

fDBUsername

string QwDatabase::fDBUsername

private

Name of account to connect to DB server with.

Definition at line 435 of file QwDatabase.h.

Referenced by Connect(), PrintServerInfo(), ProcessOptions(), ProcessOptions(), QwDatabase(), QwDatabase(), and ValidateConnection().

fValidConnection

Bool_t QwDatabase::fValidConnection

private

True if a valid connection was established using defined connection information.

Definition at line 438 of file QwDatabase.h.

Referenced by Connect(), PrintServerInfo(), QwDatabase(), QwDatabase(), and ValidateConnection().

fVersionMajor

string QwDatabase::fVersionMajor

private

Major version number of current DB schema.

Definition at line 441 of file QwDatabase.h.

Referenced by GetVersion(), GetVersionMajor(), QwDatabase(), QwDatabase(), StoreDBVersion(), and ValidateConnection().

fVersionMinor

string QwDatabase::fVersionMinor

private

Minor version number of current DB schema.

Definition at line 442 of file QwDatabase.h.

Referenced by GetVersion(), GetVersionMinor(), QwDatabase(), QwDatabase(), StoreDBVersion(), and ValidateConnection().

fVersionPoint

string QwDatabase::fVersionPoint

private

Point version number of current DB schema.

Definition at line 443 of file QwDatabase.h.

Referenced by GetVersion(), GetVersionPoint(), QwDatabase(), QwDatabase(), StoreDBVersion(), and ValidateConnection().

kValidVersionMajor

const string QwDatabase::kValidVersionMajor

private

Definition at line 444 of file QwDatabase.h.

Referenced by GetValidVersion(), QwDatabase(), QwDatabase(), and ValidateConnection().

kValidVersionMinor

const string QwDatabase::kValidVersionMinor

private

Definition at line 445 of file QwDatabase.h.

Referenced by GetValidVersion(), QwDatabase(), QwDatabase(), and ValidateConnection().

kValidVersionPoint

const string QwDatabase::kValidVersionPoint

private

Definition at line 446 of file QwDatabase.h.

Referenced by GetValidVersion(), QwDatabase(), QwDatabase(), and ValidateConnection().

---

The documentation for this class was generated from the following files:

• QwDatabase.h
• QwDatabase.cc