MysqlInterface Class Reference

#include <MysqlInterface.h>

Inheritance diagram for MysqlInterface:

List of all members.

Public Member Functions
	MysqlInterface ()
	~MysqlInterface ()
int	connect ()
int	select_db (std::string dbname)
int	query (std::string dbname, std::string query)
int	query (std::string dbname, std::string query, DatabaseRecordVector &records)
int	disconnect ()
bool	is_connected ()
void	set_host (std::string host)
void	set_user (std::string user)
void	set_passwd (std::string passwd)
void	set_dbpath (std::string path)
void	set_reuse_connection (bool flag)
Protected Member Functions
int	connect (std::string host, std::string user, std::string passwd)
Protected Attributes
bool	m_isConnected
bool	m_reuseConnection
std::string	m_dbName
std::string	m_dbHost
std::string	m_dbUser
std::string	m_dbPasswd
std::string	m_dbPath
Private Attributes
MYSQL *	m_conn

---

Detailed Description

Definition at line 7 of file MysqlInterface.h.

---

Constructor & Destructor Documentation

MysqlInterface::MysqlInterface

(

)

Definition at line 9 of file MysqlInterface.cxx.

{}

MysqlInterface::~MysqlInterface

(

)

Definition at line 11 of file MysqlInterface.cxx.

{}

---

Member Function Documentation

int MysqlInterface::connect	(	std::string	host,
		std::string	user,
		std::string	passwd
	)			[protected]

Definition at line 20 of file MysqlInterface.cxx.

References m_conn, DbInterface::m_dbName, and DbInterface::m_isConnected.

{
  try {
    m_conn = new MYSQL;
    mysql_init(m_conn);
    MYSQL* ret = 0;
    int iattempt = 0;
    for(iattempt=0;iattempt<3;iattempt++)
    {
      ret = mysql_real_connect(m_conn, host.c_str(), user.c_str(), passwd.c_str(),m_dbName.c_str(),3306,NULL,0);
      if (ret != 0) {  // Everything is fine.  Put out an info message
       std::cout << "DatabaseSvc: Connected to MySQL database" << std::endl;
       break;
      }   
      else {      
       std::cout << "Couldn't connect to MySQL database. Trying again." << std::endl;
       sleep(1);
      }
   }

   if(ret == 0 && iattempt == 2)
        throw (char*)mysql_error(m_conn);

  } catch ( std::exception &e ) {

    cerr << "Error in MySQL session initialization!" << endl;
    cerr << "*** std::exception caught:"              << endl;
    cerr << "***  error message:" << e.what()         << endl;
    return -1;
  
  } catch (...) { return -1; }

  m_isConnected = true;
  return 0;
}

int MysqlInterface::connect

(

)

[virtual]

Implements DbInterface.

Definition at line 13 of file MysqlInterface.cxx.

References DbInterface::m_dbHost, DbInterface::m_dbPasswd, DbInterface::m_dbUser, and DbInterface::m_reuseConnection.

Referenced by query(), and select_db().

{
  if( m_reuseConnection )
    connect(m_dbHost, m_dbUser, m_dbPasswd);
  return 0;
}

int MysqlInterface::disconnect

(

)

[virtual]

Implements DbInterface.

Definition at line 228 of file MysqlInterface.cxx.

References m_conn, and DbInterface::m_isConnected.

Referenced by query(), and select_db().

{
  if (m_conn)
    {
      mysql_close(m_conn);
      delete m_conn;
      m_conn = NULL;
    }
  m_isConnected = false;
  return 0;
}

bool DbInterface::is_connected

(

)

[inline, inherited]

Definition at line 27 of file DbInterface.h.

References DbInterface::m_isConnected.

Referenced by DatabaseSvc::finalize().

{ return m_isConnected; }  

int MysqlInterface::query	(	std::string	dbname,
		std::string	query,
		DatabaseRecordVector &	records
	)			[virtual]

Implements DbInterface.

Definition at line 123 of file MysqlInterface.cxx.

References DatabaseRecordVector::clear(), connect(), disconnect(), m_conn, DbInterface::m_dbHost, DbInterface::m_dbName, DbInterface::m_dbPasswd, DbInterface::m_dbUser, DbInterface::m_reuseConnection, select_db(), and type.

{
  if(! m_reuseConnection)
    connect(m_dbHost, m_dbUser, m_dbPasswd);

  records.clear();

  try{
    // check database name
    if(m_dbName != dbname)
      {
        m_dbName = dbname;
        select_db(m_dbName);
      }
    
    int status = mysql_real_query(m_conn, sql.c_str(), sql.length());
    if (status)
      {
//      if(mysql_errno(m_conn)==2006){ 
//         std::cerr << "MySQL error 2006: MySQL server has gone away"<< std::endl;
         std::cerr << "MySQL error: MySQL server has gone away"<< std::endl;
         disconnect();
         // Try to re-connect
         sleep(5);
         int ret = connect(m_dbHost, m_dbUser, m_dbPasswd);
         if (ret == 0) { 
             std::cout << "Connected to MySQL database " << std::endl;
             select_db(m_dbName);
             status = mysql_real_query(m_conn, sql.c_str(), sql.length());
         }
       // }
        
        if(status)
        {
          cerr << "Query " << sql << " failed: " << mysql_error(m_conn) << endl;
          return -1;
        }
      }     
 
    MYSQL_RES* result = mysql_store_result(m_conn);

    if(result)
      {
        int num_fields = mysql_num_fields(result);
    
        if(num_fields>0)
          {
            MYSQL_FIELD *fields;
            fields = mysql_fetch_fields(result);
            
            MYSQL_ROW row;
            while ((row = mysql_fetch_row(result)))
              {
                unsigned long* lengths;
                lengths = mysql_fetch_lengths(result);
                DatabaseRecord* dbrec = new DatabaseRecord;
                int field;
                for(field = 0; field<num_fields; field++)
                  {
                    if(row[field]!=0)
                      {
                        unsigned long field_len = lengths[field];
                        char* new_record;
                        if(fields[field].type==FIELD_TYPE_BLOB)
                        { 
                          new_record = new char[field_len];
                          memcpy(new_record, row[field], field_len);
                        }
                        else // strings
                        {
                          new_record = new char[field_len+1];
                          strcpy(new_record, row[field]);       
                        }
                        
                        (*dbrec)[fields[field].name]=new_record;
                      }
                    else 
                      {
                        (*dbrec)[fields[field].name]='\0';
                      }
                  }
                records.push_back(dbrec);
              }
          }
        mysql_free_result(result);
        if(! m_reuseConnection)
          disconnect();
        
        return records.size();
      }
  } 
  catch(...)
    {
      cerr << "Could not execute query: " << mysql_error(m_conn)  << endl;
      if(! m_reuseConnection)
        disconnect();
      return -1;
    }  

  if(! m_reuseConnection)
    disconnect();

  return 0;
}

int MysqlInterface::query	(	std::string	dbname,
		std::string	query
	)			[virtual]

Implements DbInterface.

Definition at line 74 of file MysqlInterface.cxx.

References connect(), disconnect(), m_conn, DbInterface::m_dbHost, DbInterface::m_dbName, DbInterface::m_dbPasswd, DbInterface::m_dbUser, DbInterface::m_reuseConnection, and select_db().

{
  if(! m_reuseConnection)
    connect(m_dbHost, m_dbUser, m_dbPasswd);

  try{
    // check database name
    if(m_dbName != dbname)
      {
        m_dbName = dbname;
        select_db(m_dbName);
      }
    
    int status = mysql_real_query(m_conn, sql.c_str(), sql.length());
    if (status)
      {
        //        if(mysql_errno(m_conn)==2006){
        //  std::cerr << "MySQL error 2006: MySQL server has gone away"<< std::endl;
        std::cerr << "MySQL error: MySQL server has gone away"<< std::endl;
        disconnect();
        // Try to re-connect
        sleep(5);
        int ret = connect(m_dbHost, m_dbUser, m_dbPasswd);
        if (ret == 0) {
          std::cout << "Connected to MySQL database " << std::endl;
          select_db(m_dbName);
          status = mysql_real_query(m_conn, sql.c_str(), sql.length());
        }
        //  }

        if(status)
        {
          cerr << "Query " << sql << " failed: " << mysql_error(m_conn) << endl;
          return -1;
        }
      }
  } 
  catch(...)
    {
      cerr << "Could not execute query: " << mysql_error(m_conn)  << endl;
      return -1;
    }  

  if(! m_reuseConnection)
    disconnect();

  return 0;
}

int MysqlInterface::select_db

(

std::string

dbname

)

[virtual]

Implements DbInterface.

Definition at line 56 of file MysqlInterface.cxx.

References connect(), disconnect(), m_conn, DbInterface::m_dbHost, DbInterface::m_dbPasswd, and DbInterface::m_dbUser.

Referenced by query().

{
  int ret = mysql_select_db(m_conn, dbname.c_str());
  if ( ret != 0 ) {
      disconnect();
      // Try to re-connect
      sleep(5);
      ret = connect(m_dbHost, m_dbUser, m_dbPasswd);
      if ( ret == 0 ) {
          ret = mysql_select_db(m_conn, dbname.c_str());
      }
      if (ret != 0) {
          throw std::exception();
      }
  }
  return 0;
}

void DbInterface::set_dbpath

(

std::string

path

)

[inline, inherited]

Definition at line 32 of file DbInterface.h.

References DbInterface::m_dbPath.

Referenced by DatabaseSvc::initialize().

{m_dbPath=path;};

void DbInterface::set_host

(

std::string

host

)

[inline, inherited]

Definition at line 29 of file DbInterface.h.

References DbInterface::m_dbHost.

Referenced by DatabaseSvc::initialize().

{m_dbHost=host;};

void DbInterface::set_passwd

(

std::string

passwd

)

[inline, inherited]

Definition at line 31 of file DbInterface.h.

References DbInterface::m_dbPasswd.

Referenced by DatabaseSvc::initialize().

{m_dbPasswd=passwd;};

void DbInterface::set_reuse_connection

(

bool

flag

)

[inline, inherited]

Definition at line 33 of file DbInterface.h.

References DbInterface::m_reuseConnection.

Referenced by DatabaseSvc::initialize().

{ m_reuseConnection=flag;};

void DbInterface::set_user

(

std::string

user

)

[inline, inherited]

Definition at line 30 of file DbInterface.h.

References DbInterface::m_dbUser.

Referenced by DatabaseSvc::initialize().

{m_dbUser=user;};

---

Member Data Documentation

MYSQL* MysqlInterface::m_conn [private]

Definition at line 23 of file MysqlInterface.h.

Referenced by connect(), disconnect(), query(), and select_db().

std::string DbInterface::m_dbHost [protected, inherited]

Definition at line 41 of file DbInterface.h.

Referenced by connect(), query(), select_db(), and DbInterface::set_host().

std::string DbInterface::m_dbName [protected, inherited]

Definition at line 39 of file DbInterface.h.

Referenced by connect(), DbInterface::DbInterface(), SqliteInterface::disconnect(), query(), and SqliteInterface::select_db().

std::string DbInterface::m_dbPasswd [protected, inherited]

Definition at line 43 of file DbInterface.h.

Referenced by connect(), query(), select_db(), and DbInterface::set_passwd().

std::string DbInterface::m_dbPath [protected, inherited]

Definition at line 44 of file DbInterface.h.

Referenced by SqliteInterface::select_db(), and DbInterface::set_dbpath().

std::string DbInterface::m_dbUser [protected, inherited]

Definition at line 42 of file DbInterface.h.

Referenced by connect(), query(), select_db(), and DbInterface::set_user().

bool DbInterface::m_isConnected [protected, inherited]

Definition at line 33 of file DbInterface.h.

Referenced by SqliteInterface::connect(), connect(), DbInterface::DbInterface(), SqliteInterface::disconnect(), disconnect(), DbInterface::is_connected(), and SqliteInterface::select_db().

bool DbInterface::m_reuseConnection [protected, inherited]

Definition at line 37 of file DbInterface.h.

Referenced by connect(), DbInterface::DbInterface(), query(), and DbInterface::set_reuse_connection().

---