src/sql/drivers/wmysqldriver.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 "wmysqlresult.h"
#include "wmysqldriver.h"

namespace WSql {

WMysqlDriver::WMysqlDriver( WSqlDatabase* db ): WSqlDriver( db )
{
    _mysql = 0;
    setIsOpen(false);
    //this _should_ make us thread safe ..
    int err =mysql_library_init(0, NULL, NULL); 
    if (err) 
    {
        std::string msg( "WMysqlDriver - WARNING! Error inilizing MySQL library!: " );
        setError( WSqlError( msg, 99, WSqlError::DRIVER, WSqlError::FATAL ) );
        setIsValid(false);
    }else
        init();    
}


WMysqlDriver::~WMysqlDriver()
{
    close();
    mysql_library_end();
}
bool WMysqlDriver::init()
{
    if ( isValid() ) 
        return true;

    //crude garbage collection: passing null tells library to free this after mysql_close()
    _mysql = mysql_init(NULL);
    if(NULL == _mysql)
    {
        setError( std::string( "WMysqlDriver: Memory allocation error!" ), WSqlError::DRIVER,
                  WSqlError::FATAL, false );
        return false;
    }
    setIsValid( true );
    return true;
}


void WMysqlDriver::close()
{
    if( !isValid() || !isOpen() )
        return;
    mysql_close(_mysql);
    if(! _result->isCached() )
        _result->setIsValid(false);
    setIsOpen(false);
}

bool WMysqlDriver::open()
{
    //this is equivilant to resetting if called more than once ..
    if ( isOpen() )
        close();
    if ( !init() ) 
        return false;
// - CLIENT_MULTI_STATEMENTS if we intend to CALL any procedures
// but for now kiss, worm doesn't need much ..
    mysql_options(_mysql,MYSQL_READ_DEFAULT_GROUP,"worm");
    MYSQL *retval = mysql_real_connect( _mysql, 
                            _database->hostName().empty()? NULL : _database->hostName().c_str(),
                            _database->userName().empty()? NULL : _database->userName().c_str(),
                            _database->password().empty()? NULL : _database->password().c_str(),
                            _database->databaseName().empty()? NULL : _database->databaseName().c_str(),
                            _database->port()<1? 0 : _database->port(),
                            NULL, //socket
                            0 // client flags ..
                            );
    if(NULL == retval)
    {
        std::string msg( "WMysqlDriver - Error opening database: " );
        msg.append( mysql_error(_mysql) );        
        setError( WSqlError( msg, mysql_errno(_mysql), WSqlError::DRIVER, WSqlError::FATAL ) );
        return false;        
    }
    setIsValid(true); //just to be sure ..
    setIsOpen(true);
    return true;
}
bool WMysqlDriver::query(std::string sqlstring )
{
    if(!isOpen())
        return false;
    
// for now it is disabled
// FIXME       std::string sql = local_escape_string(sqlstring);
        
    std::string sql = sqlstring;
    if(sql.empty() )
        setError("WARNING: WMysqlDriver string escape failed.");
    
    if(mysql_real_query(_mysql, sql.c_str(),sql.length())) //should be zero
    {
        std::string msg( "WMysqlDriver - Error executing query: '" );
        msg.append(sql + "', \n Server error: " + mysql_error(_mysql) );
        setError( WSqlError( msg, mysql_errno(_mysql), WSqlError::QUERY, WSqlError::WARNING ) );
        return false;
    }
    return true;
}

WSqlResult* WMysqlDriver::result( bool iscached )
{
    delete _result;
    _result = new WMysqlResult(this);
    if(!iscached)
        std::cerr << "Warning: WMysqlDriver noncached results unimplemented!" << std::endl;
    //local result to avoid annoying static_cast ..
    MYSQL_RES *res = mysql_store_result(_mysql);
    if(NULL == res){
        std::cout << "res is null: " << mysql_error(_mysql) << std::endl;
        int errno = mysql_errno(_mysql);
        if(errno){
            std::string msg = "WMysqlDriver: Error fetching result set. \n Server error: ";
            msg.append(mysql_error(_mysql));
            setError( WSqlError( msg, errno, WSqlError::QUERY, WSqlError::WARNING ) );
            _result->setIsValid(false);
        }
    }else{
        MYSQL_ROW row; 
        ulong numfields = mysql_num_fields(res);
        while((row = mysql_fetch_row(res)))
        {
            ulong *lengths = mysql_fetch_lengths(res);
            WSqlRecord record;
            for(ulong fld_pos=0; fld_pos < numfields; ++ fld_pos)
            {
                MYSQL_FIELD *m_field = mysql_fetch_field_direct(res, fld_pos);
                WSqlField fld;
                fld.setName(m_field->name);
                fld.setColumnName(m_field->org_name);
                if(0 == lengths[fld_pos])
                    if(NULL == lengths[fld_pos])
                        fld.setData(std::string("NULL"));
                    else
                        fld.setData(std::string(""));
                else
                    fld.setData(row[fld_pos]);
                record.append(fld);
            }
            _result->addRecord(record);
        }
        //note that the MYSQL_RES is stored in our result, not freed here..
       static_cast<WMysqlResult *>(_result)->setResult(res);
       _result->setIsValid(true);
    }
    return _result;
}

std::vector< std::string > WMysqlDriver::tableNames()
{
    std::vector<std::string>vecToReturn;
    if(!isOpen())    {
        setError("tableNames: Connection not open - use open()");
        return vecToReturn;
    }
    if(_database->databaseName().empty())    {
        setError("tableNames: You must set a database name first!");
        return vecToReturn;
    }
    std::string sql = "show tables";
    query(sql);
    result();
    int numtables = _result->count();
    for(int i=0;i<numtables;++i)
        vecToReturn.push_back(_result->fetch(i).field(0).data<std::string>());
    return vecToReturn;
}
WSqlTable WMysqlDriver::tableMetaData( const std::string& tableName )
{
    WSqlTable tblToReturn;
    if ( !_tables.empty() ) 
    {
        tblToReturn = findTable( tableName );
        if ( tblToReturn.isValid() )
            return tblToReturn;
    }
    tblToReturn.setName(tableName);
    
    std::vector<std::string> column_names;
    std::vector<std::string>::const_iterator column_names_it;
    std::string sql("show columns in "); sql.append(tableName);
    query(sql);
    result();
    WSqlColumn clm;
    WSqlRecord record = _result->fetchFirst();
    while(!record.empty())
    {
        clm.setColumnName(record.field(0).data<std::string>());
        column_names.push_back(clm.columnName());
        initColumnType(clm, record.field(1).data<std::string>());
        bool nullable = (record.field(2).data<std::string>().compare("NO") == 0);
        bool primarykey = (record.field(3).data<std::string>().compare("PRI") == 0);
        clm.setDefaultValue( record.field(4).data<std::string>());
        bool isauto = (record.field(5).data<std::string>().find("auto_increment") != std::string::npos);
        clm.setCanBeNull(nullable);
        clm.setIsPrimaryKey(primarykey);
        clm.setIsAutoIncremented(isauto);        
        tblToReturn.append(clm);
        record = _result->fetchNext();
    }
    //initialize foreign keys ..
    WSqlForeignKey fk;
    for(column_names_it = column_names.begin();column_names_it != column_names.end(); column_names_it++)
    {
        
        sql = "select constraint_name, referenced_table_schema,  referenced_table_name,"
        " referenced_column_name from information_schema.key_column_usage "
        " where table_name like '" + tableName + "' and column_name like '" + *column_names_it + "'";
        
        query(sql);
        result();
        WSqlRecord record = _result->fetchFirst();
        while(!record.empty())
        {
            if( record["referenced_column_name"].compare("NULL") == 0)
            {
                record = _result->fetchNext();
                continue;
            }
            fk.setColumnName(*column_names_it);
            fk.setTableName(tblToReturn.name());
            fk.setKeyName(record["constraint_name"]);
            fk.setReferencedColumnName(record["referenced_column_name"]);
            fk.setReferencedSchemaName(record["referenced_schema_name"]);
            fk.setReferencedTableName(record["referenced_table_name"]);
            tblToReturn.addForeignKey(fk);
            record = _result->fetchNext();
        }        
    }
    tblToReturn.setIsValid(true);
    _tables.push_back(tblToReturn);
    return tblToReturn;
}

bool WMysqlDriver::isOpen()
{
    return isValid() && WSqlDriver::isOpen();
}

void WMysqlDriver::initColumnType( WSqlColumn &clm, std::string description )
{
    std::string size;
    std::string tname;
    size_t pos = description.find("unsigned");
    if ( pos != std::string::npos)
    {
        clm.setIsUnsigned(true);
        description.erase(pos, 8);
    }
    pos = description.find_first_of("(");
    if(pos != std::string::npos)
    {
        size_t endpos = description.find_last_of(")");
        size = description.substr(pos+1, endpos - (pos+1));
        clm.setMaxLength(atoi(size.c_str()));
        description.erase(pos, endpos - pos );
    }else{
        pos = description.find_first_of(" ");
    }
    if(pos != std::string::npos)
        tname = description.substr(0,pos);
    else
        tname = description;
    clm.setDataType(WSqlDataType::toType(tname));    
}

std::string WMysqlDriver::local_escape_string(std::string& escapeme)
{
    if(escapeme.empty())
        return escapeme;
    ulong inlength = escapeme.length();
    char *buffer = new char[(inlength * 2) + 1];
    if(NULL == buffer) {
        setError("Warning: escape string memory allocation error! String not escaped.");
        return std::string();
    }
    ulong retlen = mysql_real_escape_string(_mysql, buffer, escapeme.c_str(), inlength);
    if(retlen < inlength){
        setError("Warning: escape string size error! String not escaped.");
        delete[] buffer;
        return escapeme;
    }
    std::string ret = buffer;
    delete[] buffer;
    return ret;
}

}//namespace WSql