DatabaseFactory.cpp

Go to the documentation of this file.

#include <cstdlib>
#include <string>
#include <vector>
#include <iostream>

using namespace std;


#include <QString>
#include <QStringList>
#include <QCoreApplication>

#include "DatabaseFactory.h"
#include "DbAccess.h"
#include "Preference.h"
#include "FileName.h"
#include "IString.h"

namespace Isis {


  DatabaseFactory *DatabaseFactory::_factory = 0;

  DatabaseFactory::DatabaseFactory() : _defProfName(""),  _profiles(),
    _defDatabase(""), _dbList() {

//  Checks the existance of the Qt application core.  This is required in order
//  ensure database driver plugins are loaded - if they exist.
    QCoreApplication *cApp = QCoreApplication::instance();
    if(cApp == 0) {
      static char **argv = 0;

      if(!argv) {
        argv = new char*[2];
        argv[0] = new char[1024];
        strcpy(argv[0], "DatabaseFactory");
        argv[1] = 0;
      }

      static int argc  = 1;
      new QCoreApplication(argc, argv);
    }

    //  Initializes
    init();

    //  This ensures this singleton is shut down when the application exists,
    //  so existing database connections are terminated.
    qAddPostRoutine(DieAtExit);
  }

  DatabaseFactory::~DatabaseFactory() {
    selfDestruct();
  }

  void DatabaseFactory::DieAtExit() {
    delete  _factory;
    _factory = 0;
    return;
  }

  DatabaseFactory *DatabaseFactory::getInstance() {
    if(DatabaseFactory::_factory == 0) {
      DatabaseFactory::_factory = new DatabaseFactory();
    }
    return (DatabaseFactory::_factory);
  }

  bool DatabaseFactory::addAccessProfile(const QString &profileFile) {
    try {
      FileName dbconf(profileFile);
      if(dbconf.fileExists()) {
        DbAccess acp(profileFile);

        //  Add the top level one - may be replaced
        const DbProfile &topProf = acp.getProfile();
        _profiles.add(topProf.Name(), topProf);

        //  Now add each individual one
        for(int i = 0 ; i < acp.profileCount() ; i++) {
          const DbProfile &newProf = acp.getProfile(i);
          _profiles.add(newProf.Name(), newProf);
        }

        // See if a default exists
        if(acp.exists("DefaultProfile")) {
          _defProfName = acp.value("DefaultProfile");
        }
        return (true);
      }
    }
    catch(...) {
      // upon any failure, we were unsuccessful
      return (false);
    }

    // File did not exist
    return (false);
  }
  void DatabaseFactory::addProfile(const DbProfile &profile) {
    _profiles.add(profile.Name(), profile);
    return;
  }

  std::vector<QString> DatabaseFactory::getProfileList() const {
    std::vector<QString> plist;
    for(int i = 0 ; i < _profiles.size() ; i++) {
      plist.push_back(_profiles.key(i).ToQt());
    }
    return (plist);
  }

  DbProfile DatabaseFactory::getProfile(const QString &name) const {
    QString profName(name);
    if(profName.isEmpty()) profName = _defProfName;

    // Refer to user access if provided
    if(!_profiles.exists(profName)) {
      return(DbProfile(profName));
    }
    else {
      return (_profiles.get(profName));
    }
  }

  std::vector<QString> DatabaseFactory::available() const {
    Drivers drivers = getResourceList(true, true);
    std::vector<QString> dblist;
    for(int i = 0 ; i < drivers.size() ; i++) {
      dblist.push_back(drivers.key(i).ToQt());
    }
    return (dblist);
  }

  bool DatabaseFactory::isDriverAvailable(const QString &dbname) const {
    Drivers drivers = getResourceList(true, false);
    if(!drivers.exists(dbname)) {
      return (false);
    }
    return (QSqlDatabase::isDriverAvailable(drivers.get(dbname)));
  }

  bool DatabaseFactory::isAvailable(const QString &dbname) const {
    Drivers dbdrivers = getResourceList(false, true);
    QString name(dbname);
    if(name.isEmpty()) {
      name = _defDatabase;
    }
    return (dbdrivers.exists(name));
  }

  bool DatabaseFactory::isConnected(const QString &dbname) const {
    QString name(dbname);
    if(name.isEmpty()) {
      name = _defDatabase;
    }
    return (QSqlDatabase::contains(name));
  }

  bool DatabaseFactory::isPersistant(const QString &dbname) const {
    return (_dbList.exists(dbname));
  }


  QSqlDatabase DatabaseFactory::create(const QString &driver,
                                       const QString &dbname) {
    // Check driver availability
    if(!isDriverAvailable(driver)) {
      QString mess = "Driver [" + driver + "] for database [" + dbname
                     + "] does not exist";
      throw IException(IException::Unknown, mess, _FILEINFO_);
    }

    //  Create the database with the specified driver and name
    Drivers drivers = getResourceList(true, false);
    return (QSqlDatabase::addDatabase(drivers.get(driver), dbname));
  }

  QSqlDatabase DatabaseFactory::create(const QString &dbname) {

    //  Return an existing connection
    if(_dbList.exists(dbname)) {
      return (_dbList.get(dbname));
    }

    // One doesn't exist, throw an error
    QString mess = "Database [" + dbname + "] does not exist";
    throw IException(IException::Unknown, mess, _FILEINFO_);
  }

  void DatabaseFactory::add(const QSqlDatabase &db, const QString &name,
                            bool setAsDefault) {
    _dbList.add(name, db);
    if(setAsDefault) {
      _defDatabase = name;
    }
    return;
  }

  void DatabaseFactory::destroy(const QString &name) {
    remove(name);
    QSqlDatabase::removeDatabase(name);
    return;
  }

  void DatabaseFactory::remove(const QString &name) {
    _dbList.remove(name);
#if 0
    if(IString::Equal(name, _defDatabase)) {
      _defDatabase = "";
    }
#endif
    return;
  }

  void DatabaseFactory::init() {
    //  Add the PostgreSQL database driver explicitly if it doesn't exist
    loadDrivers();

    //  Use the users Preferences to determine if a default exists
    initPreferences();
    return;
  }

  void DatabaseFactory::initPreferences() {
    Preference &userPref = Preference::Preferences();
    if(userPref.hasGroup("Database")) {
      PvlGroup &dbgroup = userPref.findGroup("Database");
      if(dbgroup.hasKeyword("AccessConfig")) {
        addAccessProfile(dbgroup["AccessConfig"]);
      }
      // Get default profile name for later use
      if(dbgroup.hasKeyword("DefaultProfile"))
        _defProfName = (QString) dbgroup["DefaultProfile"];
    }
    return;
  }

  DatabaseFactory::Drivers DatabaseFactory::getResourceList(bool drivers,
      bool connections)
  const {
    QStringList dblist;
    if(drivers)     dblist += QSqlDatabase::drivers();
    if(connections) dblist += QSqlDatabase::connectionNames();
    Drivers dbDrivers;
    for(int i = 0 ; i < dblist.size() ; i++) {
      QString dbname(dblist.at(i));
      dbDrivers.add(dbname, dbname);
    }


    //  Now create pseudonyms for well known databases
    //  PostgreSQL and UPC
    if(dbDrivers.exists("QPSQL")) {
      dbDrivers.add("PostgreSQL", "QPSQL");
    }

    // MySQL and HiCAT
    if(dbDrivers.exists("QMYSQL")) {
      dbDrivers.add("MySQL", "QMYSQL");
    }

    // Oracle
    if(dbDrivers.exists("QOCI")) {
      dbDrivers.add("Oracle", "QOCI");
    }

    // SQLite
    if(dbDrivers.exists("QSQLITE")) {
      dbDrivers.add("SQLite", "QSQLITE");
    }

    //  That's it
    return (dbDrivers);
  }

  void DatabaseFactory::loadDrivers() {
    //  Currently relying on Qt plugins - but that could change
    return;
  }

  void DatabaseFactory::selfDestruct() {
    while(_dbList.size() > 0) {
      _dbList.remove(_dbList.key(0));
    }
    QStringList dblist = QSqlDatabase::connectionNames();
    for(int i = 0 ; i < dblist.size() ; i++) {
      QSqlDatabase::removeDatabase(dblist[i]);
    }
    return;
  }

}