MysqlInterface Class Reference

#include <MysqlInterface.h>

Inheritance diagram for MysqlInterface:

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 ()
Public Member Functions inherited from DbInterface
	DbInterface ()
virtual	~DbInterface ()
virtual int	connect ()=0
virtual int	select_db (std::string dbname)=0
virtual int	query (std::string dbname, std::string query, DatabaseRecordVector &records)=0
virtual int	query (std::string dbname, std::string query)=0
virtual int	disconnect ()=0
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_port (int port)
void	set_reuse_connection (bool flag)

Protected Member Functions
int	connect (std::string host, std::string user, std::string passwd, int port=3306)

Additional Inherited Members
Protected Attributes inherited from DbInterface
bool	m_isConnected
bool	m_reuseConnection
std::string	m_dbName
std::string	m_dbHost
int	m_dbPort
std::string	m_dbUser
std::string	m_dbPasswd
std::string	m_dbPath

Detailed Description

Definition at line 7 of file MysqlInterface.h.

Constructor & Destructor Documentation

MysqlInterface()

MysqlInterface::MysqlInterface

(

)

Definition at line 9 of file MysqlInterface.cxx.

{}

~MysqlInterface()

MysqlInterface::~MysqlInterface

(

)

Definition at line 11 of file MysqlInterface.cxx.

{}

Member Function Documentation

connect() [1/2]

int MysqlInterface::connect ( )

virtual

Implements DbInterface.

Definition at line 13 of file MysqlInterface.cxx.

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

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

connect() [2/2]

int MysqlInterface::connect ( std::string  host, std::string  user, std::string  passwd, int  port = 3306  )

protected

Definition at line 20 of file MysqlInterface.cxx.

{
  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(),port,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;
}

disconnect()

int MysqlInterface::disconnect ( )

virtual

Implements DbInterface.

Definition at line 229 of file MysqlInterface.cxx.

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

Referenced by query(), and select_db().

query() [1/2]

int MysqlInterface::query ( std::string  dbname, std::string  query  )

virtual

Implements DbInterface.

Definition at line 74 of file MysqlInterface.cxx.

{
  if(! m_reuseConnection)
    connect(m_dbHost, m_dbUser, m_dbPasswd, m_dbPort);
 
  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, m_dbPort);
    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;
}

query() [2/2]

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

virtual

Implements DbInterface.

Definition at line 123 of file MysqlInterface.cxx.

{
  if(! m_reuseConnection)
    connect(m_dbHost, m_dbUser, m_dbPasswd, m_dbPort);
 
 
  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, m_dbPort);
         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;
}

select_db()

int MysqlInterface::select_db ( std::string  dbname )

virtual

Implements DbInterface.

Definition at line 56 of file MysqlInterface.cxx.

{
  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, m_dbPort);
      if ( ret == 0 ) {
          ret = mysql_select_db(m_conn, dbname.c_str());
      }
      if (ret != 0) {
          throw std::exception();
      }
  }
  return 0;
}

Referenced by query().

---

The documentation for this class was generated from the following files:

• MysqlInterface.h
• MysqlInterface.cxx