Database.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <string>
#include <vector>
#include <iostream>
#include "DbProfile.h"
#include "Database.h"
#include "DatabaseFactory.h"
#include "IString.h"
 
#include <QStringList>
#include <QSqlError>
 
using namespace std;
 
namespace Isis {
 
  QString Database::_actualConnectionName = "";

  Database::Database() : QSqlDatabase(), _name("") {  }

  Database::Database(Database::Access dbConn) : QSqlDatabase(init()), _name("") {
    _name = _actualConnectionName;
    if((dbConn == Connect) && isValid()) {
      if(!open()) {
        QString mess = "Failed to open database default database [" + _name;
        tossDbError(mess, _FILEINFO_);
      }
    }
//  Name cannot be set, so set to determined name
  }

  Database::Database(const QString &name, Database::Access dbConn) :
    QSqlDatabase(init(name)), _name(name) {
    _name = _actualConnectionName;
    if((dbConn == Connect) && isValid()) {
      if(!open()) {
        QString mess = "Failed to open database specified as " + _name;
        tossDbError(mess, _FILEINFO_);
      }
    }
  }

  Database::Database(const QString &connName, const QString &driverType) :
    QSqlDatabase(init(connName, driverType)), _name(connName) {
    _name = _actualConnectionName;
  }

  Database::Database(const DbProfile &profile, Database::Access dbConn) :
    QSqlDatabase(init(profile, DoNotConnect)),
    _name(profile.Name()) {
    _name = _actualConnectionName;
    if((dbConn == Connect) && isValid()) {
      if(!open()) {
        QString mess = "Failed to open database with profile " + _name;
        tossDbError(mess, _FILEINFO_);
      }
    }
  }

  Database::Database(const QSqlDatabase &other, const QString &newName) :
    QSqlDatabase(QSqlDatabase::cloneDatabase(other, newName)),
    _name(newName) {  }
 

  Database::~Database() {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    if(!factory->isPersistant(_name)) {
      if(isOpen()) {
        close();
      }
      factory->remove(_name);
    }
  }

  void Database::makePersistant() {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    if(!factory->isPersistant(_name)) {
      factory->add(*this, _name);
    }
    return;
  }

  bool Database::isPersistant() const {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    return (factory->isPersistant(_name));
  }

  void Database::setAsDefault() {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    if(!factory->isPersistant(_name)) {
      factory->add(*this, _name);
    }
    factory->setDefault(_name);
    return;
  }

  void Database::remove(const QString &name)  {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    factory->destroy(name);
    return;
  }

  bool Database::addAccessConfig(const QString &confFile) {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    return (factory->addAccessProfile(confFile));
  }

  DbProfile Database::getProfile(const QString &name) {
    DatabaseFactory *factory = DatabaseFactory::getInstance();
    return (factory->getProfile(name));
  }

  QSqlDatabase Database::init(const QString &connName,
                              const QString &driverType) {
 
    _actualConnectionName = connName;
    DatabaseFactory *factory = DatabaseFactory::getInstance();
 
    // First test for condition where both name and type are not provided.
    //  This tests for the default profile and returns it if it exists,
    // otherwise it returns a default database.
    if(connName.isEmpty() && driverType.isEmpty()) {
      if(factory->isAvailable(factory->getDefault())) {
        _actualConnectionName = factory->getDefault();
        return (factory->create(_actualConnectionName));
      }
 
      //  No default is established so retreive the default profile
      DbProfile profile =  factory->getProfile();
      if(profile.isValid()) {
        return (init(profile, DoNotConnect));
      }
    }
 
    // If only the name and no driver is provided, get an existing connection
    if((!connName.isEmpty()) && (driverType.isEmpty())) {
      if(factory->isAvailable(connName)) {
        _actualConnectionName = connName;
        return (factory->create(connName));
      }
      else {
        //  See if the database exists by profile
        DbProfile profile = factory->getProfile(connName);
        return (init(profile, DoNotConnect));
      }
    }
 
    //  Finally, a driver and optional name is provided.  This condition sets up
    //  a named database for subsequent definition later
    return (factory->create(driverType, connName));
  }
 

  QSqlDatabase Database::init(const DbProfile &profile, Database::Access dbConn) {
    if(!profile.isValid()) {
      ostringstream mess;
      mess << "Database/profile [" << profile.Name() << "] is not valid!" << ends;
      throw IException(IException::Programmer, mess.str(), _FILEINFO_);
    }
 
    _actualConnectionName = profile.Name();
    DatabaseFactory *factory = DatabaseFactory::getInstance();
 
    //  initialize the database
    try {
 
      //  If we reach here, it is a valid profile.  Create the database and
      //  return it as initialized from the profile contents
      QSqlDatabase db = factory->create(profile("Type"), profile("Name"));
      _actualConnectionName = profile("Name");
      configureAccess(db, profile);
 
      //  Go ahead and connect if requested
      if(dbConn == Connect) {
        if(!db.open()) {
          QString mess = "Failed to connect to database using profile " +
                        profile("Name");
          tossDbError(mess, _FILEINFO_);
        }
      }
      return (db);
    }
    catch(IException &ie) {
      QString mess = "Unable to create database from " + profile.Name();
      throw IException(ie, IException::User, mess, _FILEINFO_);
    }
    catch(...) {
      QString mess = "Unknown exception while creating database from profile "
                    + profile.Name();
      throw IException(IException::User, mess, _FILEINFO_);
    }
  }

  void Database::configureAccess(QSqlDatabase &db, const DbProfile &profile) {
    if(profile.exists("Host")) {
      db.setHostName(profile("Host"));
    }
 
    if(profile.exists("DbName")) {
      db.setDatabaseName(profile("DbName"));
    }
 
    if(profile.exists("User")) {
      db.setUserName(profile("User"));
    }
 
    if(profile.exists("Password")) {
      db.setPassword(profile("Password"));
    }
 
    if(profile.exists("Port")) {
      bool ok;
      db.setPort(profile("Port").toInt(&ok));
      if(!ok) {
        ostringstream mess;
        mess << "Invalid port number [" << profile("Port") << "] in profile "
             << profile("Name") << ends;
        throw IException(IException::User, mess.str().c_str(), _FILEINFO_);
      }
    }
 
    if(profile.exists("Options")) {
      db.setConnectOptions(profile("Options"));
    }
    return;
  }

  Database Database::clone(const QString &name) const {
    return (Database(*this, name));
  }

  QStringList Database::getTables() const {
    return (tables(QSql::Tables));
  }

  QStringList Database::getViews() const {
    return (tables(QSql::Views));
  }

  QStringList Database::getSystemTables() const {
    return (tables(QSql::SystemTables));
  }

  void Database::tossDbError(const QString &message, const char *f, int l) const {
    QString errmess = message + " - DatabaseError = " +
                      lastError().text();
    throw IException(IException::Programmer, errmess, f, l);
  }
 
}