src/sql/wsqldatabase.cpp

Go to the documentation of this file.

/*
 *    WORM - a DAL/ORM code generation framework
 *    Copyright (C) 2011  Erik Winn <erikwinnmail@yahoo.com>
 * 
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 * 
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 * 
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "wsqldatabase.h"

#include "wsqldriver.h"
#include "drivers/wsqlitedriver.h"
#include "drivers/wmysqldriver.h"

namespace WSql {

WSqlDatabase::WSqlDatabase(const WSql::DriverType &type)
{
    _driver=0;
    _driverType=type;
    _isValid=false;
    init();
}

WSqlDatabase::WSqlDatabase()
{
    _driver=0;
    _isValid=false;
}

WSqlDatabase::WSqlDatabase(const WSqlDatabase &other)
{
    _databaseName = other._databaseName;
    _userName = other._userName;
    _password = other._password;
    _hostname = other._hostname;
    _port = other._port;
    _connectionOptions = other._connectionOptions;
    _driverType = other._driverType;
    init();
}

WSqlDatabase::~WSqlDatabase()
{
    if(isValid()){
        close();
    }
    delete _driver;
}

WSqlDatabase &WSqlDatabase::operator=(const WSqlDatabase &other)
{
    if(_driver)
        delete _driver;
    _driver=0;
    
    _databaseName = other._databaseName;
    _userName = other._userName;
    _password = other._password;
    _hostname = other._hostname;
    _port = other._port;
    _connectionOptions = other._connectionOptions;
    _driverType = other._driverType;
    init();
    return *this;
}

void WSqlDatabase::init()
{
    if(_driver)
        delete _driver;
    
    _isValid = initDriver();
}

bool WSqlDatabase::initDriver()
{
    bool blnToReturn = false;
    std::string errmsg;
    
    switch(_driverType)
    {
        case WSql::NONE:
            errmsg = "WSqlDatabase: initDriver failed - no driver type set!";
            break;
        case WSql::WSQLITE :
            _driver = new WSqliteDriver(this);
            if(0 == _driver)
                errmsg = "WSqlDatabase: initDriver failed - memory allocation error!";
            else
                blnToReturn = true;
            break;
        case WSql::WMYSQL :
            _driver = new WMysqlDriver(this);
            if(0 == _driver)
                errmsg = "WSqlDatabase: initDriver failed - memory allocation error!";
            else
                blnToReturn = true;
            break;
        case WSql::WMONGO :
        case WSql::WBERKLEYDB :
        case WSql::WPSQL :
        default:
            errmsg = "WSqlDatabase: initDriver failed - driver unsupported!";
    }
    if(!errmsg.empty())
        _errorStack.push_back(WSqlError(errmsg,1, WSqlError::SYSTEM, WSqlError::WARNING));    
    return blnToReturn;
}

bool WSqlDatabase::open()
{
    return _driver->open();
}

bool WSqlDatabase::open(const std::string& username, const std::string& password)
{
    setUserName(username);
    setPassword(password);
    return _driver->open();
}

void WSqlDatabase::close()
{
    _driver->close();
}

bool WSqlDatabase::isOpen() const
{
    return _driver->isOpen();
}

bool WSqlDatabase::hasError() const
{
    return _driver->hasError();
}


void WSqlDatabase::setDatabaseName(const std::string& name)
{
    _databaseName = name;
}

void WSqlDatabase::setUserName(const std::string& name)
{
    _userName = name;
}

void WSqlDatabase::setPassword(const std::string& password)
{
    _password = password;
}

void WSqlDatabase::setHostName(const std::string& hostname)
{
    _hostname = hostname;
}

void WSqlDatabase::setPort(int port)
{
    _port = port;
}

std::string WSqlDatabase::databaseName() const
{
    return _databaseName;
}

std::string WSqlDatabase::userName() const
{
    return _userName;
}

std::string WSqlDatabase::password() const
{
    return _password;
}

std::string WSqlDatabase::hostName() const
{
    return _hostname;
}

WSqlDriver* WSqlDatabase::driver() const
{
    return _driver;
}

WSqlError WSqlDatabase::error() const
{
    return _driver->error();
}

// WSqlError WSqlDatabase::errors() const
// {
//     return _driver->getError();
// }


const std::vector<std::string>& WSqlDatabase::tableNames(WSql::TableType type)
{
    if(_tableNames.empty())
        _tableNames = _driver->tableNames();
    return _tableNames;
}

WSqlTable WSqlDatabase::tableMetaData( const std::string& tablename ) const
{
    if(!isValid())
        return WSqlTable();
    return _driver->tableMetaData(tablename);
}

void WSqlDatabase::initMetaData()
{
    //load all tablenames
    tableNames();
    //init metadata for all tables
    std::vector<std::string>::const_iterator it = _tableNames.begin();
    for(;it != _tableNames.end();++it )
        tableMetaData(*it);
    std::vector<WSqlTable>::const_iterator tbl_it = _driver->_tables.begin();
    //add referenced keys
    for(;tbl_it != _driver->_tables.end();++tbl_it)
    {
        std::vector<WSqlForeignKey>::const_iterator fk_it = tbl_it->foreignKeys().begin();
        for(;fk_it != tbl_it->foreignKeys().end();++fk_it)
        {
            WSqlTable *table = _driver->getTable( fk_it->referencedTableName());
            if(table)
            {
                WSqlReferencedKey rfk(*fk_it);
                table->addReferencedKey(rfk);
            }
        }
    }
}


void WSqlDatabase::setConnectOptions(const std::string &options)
{
     _connectionOptions = options;
}

std::string WSqlDatabase::connectionOptions() const
{
    return _connectionOptions;
}

bool WSqlDatabase::isValid() const
{
    return (_isValid && 0 != _driver && _driver->isValid());
}
bool WSqlDatabase::query(const std::string& sql)
{
    return _driver->query(sql);
}
WSqlResult * WSqlDatabase::result(bool iscached)
{
    return _driver->result(iscached);
}

    
} //namespace WSql