rdbModel::MysqlConnection Class Reference

#include <MysqlConnection.h>

Inheritance diagram for rdbModel::MysqlConnection:

Public Member Functions
	MysqlConnection (std::ostream *out=0, std::ostream *errOut=0)
virtual	~MysqlConnection ()
virtual bool	open (const std::string &host, const std::string &userid, const std::string &password, const std::string &dbName)
virtual bool	open (const std::string &parms)
virtual bool	close ()
virtual bool	isConnected ()
	Return true iff open has been done with no matching close.
std::ostream *	getOut () const
std::ostream *	getErrOut () const
virtual MATCH	matchSchema (Rdb *rdb, bool matchDbName=true)
virtual bool	insertRow (const std::string &tableName, const StringVector &colNames, const StringVector &values, int *auto_value=0, const StringVector *nullCols=0)
virtual unsigned int	update (const std::string &tableName, const StringVector &colNames, const StringVector &values, const Assertion *where=0, const StringVector *nullCols=0)
virtual ResultHandle *	select (const std::string &tableName, const StringVector &getCols, const StringVector &orderCols, const Assertion *where=0, int rowLimit=0, int rowOffset=0)
virtual ResultHandle *	dbRequest (const std::string &request)
virtual bool	compileAssertion (const Assertion *a, std::string &sqlString) const
virtual void	disableModify (bool disable)
virtual Visitor::VisitorState	visitRdb (Rdb *)
	This method says if the visitor is recursive or not.
virtual Visitor::VisitorState	visitTable (Table *)
virtual Visitor::VisitorState	visitColumn (Column *)
virtual Visitor::VisitorState	visitIndex (Index *)
virtual Visitor::VisitorState	visitAssertion (Assertion *)
virtual VisitorState	visitInsertNew (InsertNew *)
virtual VisitorState	visitSupersede (Supersede *)
virtual VisitorState	visitQuery (Query *)
virtual VisitorState	visitSet (Set *)
virtual VisitorState	visitInterRow (InterRow *)
Public Member Functions inherited from rdbModel::Connection
	Connection ()
virtual	~Connection ()
virtual bool	open (const std::string &host, const std::string &userid, const std::string &password, const std::string &dbName)=0
virtual bool	close ()=0
virtual bool	open (const std::string &parms)=0
virtual bool	isConnected ()=0
	Return true iff open has been done with no matching close.
virtual std::ostream *	getOut () const =0
virtual std::ostream *	getErrOut () const =0
virtual MATCH	matchSchema (Rdb *rdb, bool matchDbName=true)=0
virtual bool	insertRow (const std::string &tableName, const StringVector &colNames, const StringVector &values, int *auto_value=0, const StringVector *nullCols=0)=0
virtual unsigned int	update (const std::string &tableName, const StringVector &colNames, const StringVector &values, const Assertion *where=0, const StringVector *nullCols=0)=0
virtual ResultHandle *	select (const std::string &tableName, const StringVector &getCols, const StringVector &orderCols, const Assertion *where=0, int rowLimit=0, int rowOffset=0)=0
virtual void	disableModify (bool disable)=0
virtual ResultHandle *	dbRequest (const std::string &request)=0
virtual bool	compileAssertion (const Assertion *a, std::string &sqlString) const =0
virtual VisitorState	visitRdb (Rdb *)=0
	This method says if the visitor is recursive or not.
virtual VisitorState	visitTable (Table *)=0
virtual VisitorState	visitColumn (Column *)=0
virtual VisitorState	visitIndex (Index *)=0
virtual VisitorState	visitAssertion (Assertion *)=0
virtual VisitorState	visitInsertNew (InsertNew *)=0
virtual VisitorState	visitSupersede (Supersede *)=0
virtual VisitorState	visitQuery (Query *)=0
virtual VisitorState	visitSet (Set *)=0
virtual VisitorState	visitInterRow (InterRow *)=0

Additional Inherited Members
Public Types inherited from rdbModel::Visitor
enum	VisitorState {   VCONTINUE = 0 , VDONE , VBRANCHDONE , VERROR ,   VERRORABORT }

Detailed Description

Class to handle connection to a MySQL database

• initiate connection
• make queries, including making returned data from queries available
• issue SQL statements such as INSERT and UPDATE which have no returned data other than status
• close down connection. Someday it might also have a method to create a database

Initial design will just use host, password, userid passed in. Will be up to caller to insure that the userid has the right privilages for the operations caller intends to do.

Definition at line 32 of file MysqlConnection.h.

Constructor & Destructor Documentation

MysqlConnection()

rdbModel::MysqlConnection::MysqlConnection	(	std::ostream *	out = 0,
		std::ostream *	errOut = 0
	)

Open a connection Allowed operations will depend on userid, etc., specified return true if successful

Definition at line 69 of file MysqlConnection.cxx.

                                                       :
    m_mysql(0), m_connected(0), m_out(out), m_err(errOut),
    m_visitorType(VISITORundefined), m_rdb(0), m_tempRes(0),
    m_writeDisabled(false)                                   {
    if (m_out == 0) m_out = &std::cout;
    if (m_err == 0) m_err = &std::cerr;
  }

~MysqlConnection()

rdbModel::MysqlConnection::~MysqlConnection ( )

virtual

Definition at line 90 of file MysqlConnection.cxx.

                                    {
    close();
    delete m_mysql;
    return;
  }

Member Function Documentation

close()

bool rdbModel::MysqlConnection::close ( )

virtual

Close the current open connection , if any. Return true if there was a connection to close and it was closed successfully

Implements rdbModel::Connection.

Definition at line 78 of file MysqlConnection.cxx.

                              {
    if (m_tempRes) {
      mysql_free_result(m_tempRes);
      m_tempRes = 0;
    }
 std::cout<<"close connection ================================"<<std::endl;
    mysql_close(m_mysql);
    m_mysql = 0;
    m_connected = false;
    return true;
  }

Referenced by main(), and ~MysqlConnection().

compileAssertion()

bool rdbModel::MysqlConnection::compileAssertion ( const Assertion *  a, std::string &  sqlString  ) const

virtual

compile method for assertions. Use it internally, but also make it publicly available so assertions belonging to a table can save the compiled version.

Implements rdbModel::Connection.

Definition at line 462 of file MysqlConnection.cxx.

                                  {
    if (!m_compileInit) {
      compileInit();
      m_compileInit = true;
    }
    try {
      return compileOperator(a->getOperator(), sqlString);
    }
    catch (RdbException ex) {
      (*m_out) << std::endl << ex.getMsg() << std::endl;
      m_out->flush();
      return false;
    }
  }

Referenced by select(), and update().

dbRequest()

ResultHandle * rdbModel::MysqlConnection::dbRequest ( const std::string &  request )

virtual

Transmit raw request of any form to our other end. If it is a request that returns results, those results will be stored in a newly-allocated ResultHandle and dbRequest will return a pointer to it. Otherwise dbRequest will return a null pointer. Throw an exception if request fails for any reason.

Implements rdbModel::Connection.

Definition at line 408 of file MysqlConnection.cxx.

                                                                   {
 
    (*m_out) << std::endl << "# About to issue SQL request:" << std::endl;
    (*m_out) << request << std::endl;
    m_out->flush();
    
    int i=0;
    int mysqlRet = mysql_query(m_mysql, request.c_str());
    for (i=0;i<10;i++) {
    //  int mysqlRet = mysql_query(m_mysql, request.c_str());
      if (mysqlRet) {  
        //not connected
    std::string msg = 
      "rdbModel::MysqlConnection::dbRequest: mysql_query error, code ";
    std::string codeString;
    facilities::Util::itoa(mysqlRet, codeString);
    msg += codeString;
    (*m_out) << std::endl <<i<<"times not connected++++ "<< msg << std::endl;
    m_out->flush();
    fprintf(stderr, "mysql_query error %d: %s\n",mysql_errno(m_mysql),mysql_error(m_mysql));
    if (i>=9){
     throw RdbException(msg, mysqlRet);
      return 0;
    }
         mysql_close(m_mysql);
         m_mysql = 0;
         sleep(100);
         bool st = open(m_host,m_user,m_password,m_dbName);
         if(st==false) continue;
        mysqlRet = mysql_query(m_mysql, request.c_str());
      }else{
    break;
      }
    }
   
 
    MYSQL_RES *myres = mysql_store_result(m_mysql);
    if (!myres) {
      // Was it supposed to return data?
      if (mysql_field_count(m_mysql) == 0) { // no data expected
    return 0;
      }
      else {
    std::string msg =
      "rdbModel::MysqlConnection::dbRequest: expected data; none returned";
    (*m_out) << std::endl << msg << std::endl;
    m_out->flush();
    throw RdbException(msg);
    return 0;
      }
    }
    return new MysqlResults(myres);
  }

Referenced by main().

disableModify()

virtual void rdbModel::MysqlConnection::disableModify ( bool  disable )

inlinevirtual

Turn select and update into no-ops: output SQL string for debugging but don't change db

Implements rdbModel::Connection.

Definition at line 137 of file MysqlConnection.h.

{m_writeDisabled=disable;}

Referenced by main().

getErrOut()

std::ostream * rdbModel::MysqlConnection::getErrOut ( ) const

inlinevirtual

Implements rdbModel::Connection.

Definition at line 57 of file MysqlConnection.h.

{return m_err;}

getOut()

std::ostream * rdbModel::MysqlConnection::getOut ( ) const

inlinevirtual

Implements rdbModel::Connection.

Definition at line 56 of file MysqlConnection.h.

{return m_out;}

insertRow()

bool rdbModel::MysqlConnection::insertRow ( const std::string &  tableName, const StringVector &  colNames, const StringVector &  values, int *  auto_value = 0, const StringVector *  nullCols = 0  )

virtual

Typical derived class will form a syntactically correct INSERT statement from the input arguments and issue it to the dbms. Return true if row was inserted successfully If auto_value is non-zero and the table has an auto-increment column, its value will be returned. If nullCols is non-zero, insertRow will treat each string in the vector as a column name whose value should be set to NULL

Might also want to add a routine for INSERT ... SELECT

Implements rdbModel::Connection.

Definition at line 215 of file MysqlConnection.cxx.

                                                                {
    std::string ins;
    if (auto_value) *auto_value = 0;
 
    // check that sizes of vectors match
    unsigned  nCol = colNames.size();    
    if (!nCol || (nCol != values.size()  ) ) {
      (*m_err) << " MysqlConnection::insertRow: vector lengths incompatible"
                << std::endl;
      m_err->flush();
      return false;
    }
 
    // caller should already have checked for validity and should
    // have supplied all necessary columns
 
    ins += "insert into " + tableName;
    ins += " set " + colNames[0] + "='" + values[0] + "' ";
    for (unsigned iCol = 1; iCol < nCol; iCol++) {
      ins += ", " + colNames[iCol] + "='" + values[iCol] + "' ";
    }
    if (nullCols) {
      if (nullCols->size() > 0) {
        unsigned nNull = nullCols->size();
        for (unsigned iNull = 0; iNull < nNull; iNull++) {
          ins += ", " + (*nullCols)[iNull] + "= NULL ";
        }
      }
    }
 
    (*m_out) << std::endl << "# INSERT string is:" << std::endl;
    (*m_out) << ins << std::endl;
    m_out->flush();
 
    if (m_writeDisabled) {
      (*m_out) << "write to Db previously disabled; INSERT not sent"
               << std::endl;
      m_out->flush();
      return true;
    }
 
    int mysqlRet = mysql_query(m_mysql, ins.c_str());
 
    if (mysqlRet) {
      (*m_out) << "MySQL error during INSERT, code " << mysqlRet << std::endl;
      m_out->flush();
      return false;
    }
    if (auto_value) {
      *auto_value = mysql_insert_id(m_mysql);
    }
    return true;
  }

isConnected()

virtual bool rdbModel::MysqlConnection::isConnected ( )

inlinevirtual

Return true iff open has been done with no matching close.

Implements rdbModel::Connection.

Definition at line 54 of file MysqlConnection.h.

{return m_connected;}

matchSchema()

MATCH rdbModel::MysqlConnection::matchSchema ( Rdb *  rdb, bool  matchDbName = true  )

virtual

Check to what degree local schema definition is compatible with remote db accessed via this connection. By default check db names match, but this may be disabled.

If match is successful, may also want to cache information about some things; for example, rows for which agent = "service"

Implements rdbModel::Connection.

Definition at line 190 of file MysqlConnection.cxx.

                                                               {
    if (!m_connected) return MATCHnoConnection;
 
    m_matchDbName = matchDbName;
 
    // Check global characteristics; 
    // Could do this via Manager; seems a bit artificial, bypass for now
    m_visitorType = VISITORmatch;
    m_matchReturn = MATCHequivalent;
    unsigned int ret = rdb->accept(this);
 
    if ((ret == Visitor::VERROR) || (ret == Visitor::VERRORABORT)) {
      return MATCHfail;
    }
    else return m_matchReturn;
  }

Referenced by main().

open() [1/2]

bool rdbModel::MysqlConnection::open ( const std::string &  host, const std::string &  userid, const std::string &  password, const std::string &  dbName  )

virtual

Implements rdbModel::Connection.

Definition at line 96 of file MysqlConnection.cxx.

                                                      {
                             //     , unsigned int       port) {
    if (dbName.size() == 0) {
      (*m_err) << 
        "rdbModel::MysqlConnection::open : null db name not allowed!" <<
        std::endl;
      m_err->flush();
      return false;
    } 
   //huangb add
    m_host = host;
    m_user = user;
    m_password = password;
 
    m_mysql = new MYSQL;
    mysql_init(m_mysql);
 
    // 'host' argument is of the form hostname[:port]
    //  That is, port section is optional.  If not supplied, use
    // default port.
    std::string hostOnly;
    int port = 0;
    std::string::size_type colonLoc = host.find(":");
    if (colonLoc == std::string::npos) {
      hostOnly = host;
    }
    else {
      hostOnly = host.substr(0, colonLoc);
      std::string portString = host.substr(colonLoc+1);
      try {
        port = facilities::Util::stringToInt(portString);
      }
      catch (facilities::WrongType ex) {
        (*m_err) << "From MysqlConnection::connect.  Bad port: "
                 << ex.getMsg() << std::endl;
        m_err->flush();
        return false;
      }
 
    }
    //    mysql_init(m_mysql);
    std::cout<<"host is:"<<hostOnly.c_str()<<"::use is:: "<<user.c_str()<<":pass is::"<<password.c_str()<<":db is::"<<dbName.c_str()<<std::endl;
    MYSQL *connected = mysql_real_connect(m_mysql, hostOnly.c_str(),  
                                          user.c_str(),
                                          password.c_str(), dbName.c_str(),
                                          3306, NULL, 0);
 
    if (connected != 0) {  // Everything is fine.  Put out an info message
      (*m_out) << "Successfully connected to MySQL host " << 
        host << ", database " << dbName << std::endl;
      m_out->flush();
      m_connected = true;
      m_dbName = dbName;
    }
    else {
      (*m_err) <<  "Failed to connect to MySQL host " << host <<
        "with error:::: " << mysql_error(m_mysql) << std::endl;
      m_err->flush();
      m_connected = false;
    }
    return m_connected;
  }

Referenced by dbRequest(), main(), and open().

open() [2/2]

bool rdbModel::MysqlConnection::open ( const std::string &  parms )

virtual

Parameter is normally path for an xml file descrbing the connection parameters

Implements rdbModel::Connection.

Definition at line 162 of file MysqlConnection.cxx.

                                                   {
    using XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument;
    using XERCES_CPP_NAMESPACE_QUALIFIER DOMElement;
    xmlBase::XmlParser parser;
    DOMDocument* doc = parser.parse(parms.c_str(), "mysqlConnection");
    if (doc == 0) {
      (*m_err) << "parse of connection parameters failed" << std::endl;
      m_err->flush();
      return false;
    }
    DOMElement*  conn = doc->getDocumentElement();
    
    std::string host = xmlBase::Dom::getAttribute(conn, "host");
    std::string user = xmlBase::Dom::getAttribute(conn, "user");
    std::string password = xmlBase::Dom::getAttribute(conn, "password");
    std::string dbname = xmlBase::Dom::getAttribute(conn, "dbname");
 
    if (password.size() == 0 ) { // prompt for password?
      (*m_out) << "interactive login NYI " << std::endl;
      m_out->flush();
      return false;
    }
 
    return this->open(host, user, password, dbname);
  }

select()

ResultHandle * rdbModel::MysqlConnection::select ( const std::string &  tableName, const StringVector &  getCols, const StringVector &  orderCols, const Assertion *  where = 0, int  rowLimit = 0, int  rowOffset = 0  )

virtual

Support only for relatively simple SELECT, involving just one table.

Parameters

tableName
getCols	vector of columns to be retrieved
where	ptr to an Assertion object
rowLimit	max number of rows to return
rowOffset	offset for first row returned among those satisfying conditions; ignored if 0.

Returns

If the SELECT succeeds, a pointer to an object which manages the returned data; else 0. Caller is responsible for deleting the ResultHandle object.

Implements rdbModel::Connection.

Definition at line 329 of file MysqlConnection.cxx.

                                                         {
    std::string sqlString = "SELECT ";
    unsigned nGet = getCols.size();
    unsigned nOrder = orderCols.size();
 
     std::cout<<"tableName is:"<<tableName<<std::endl;
 
//     tableName="metadata_v2r1";
       
    sqlString += getCols[0];
    for (unsigned iGet = 1; iGet < nGet; iGet++) {
      sqlString += ",";
      sqlString += getCols[iGet];
    }
    sqlString +=  " FROM " + tableName +  " ";
     std::cout<<"sqlString is11:"<<sqlString<<std::endl;
   if (where != 0) {
      sqlString += " WHERE ";
      bool ret = compileAssertion(where, sqlString);
      if (!ret) return 0;
    }
   
    std::cout<<"sqlString is22:"<<sqlString<<std::endl;
  
    /*maqm  if (nOrder > 0 ) {
      sqlString += " ORDER BY " + orderCols[0]; 
      for (unsigned iOrder = 1; iOrder < nOrder; iOrder++) {
        sqlString += ",";
        sqlString += orderCols[iOrder];
      }
    }
   */ 
//     sqlString ="SELECT ser_no FROM metadata_v2r1  WHERE ((completion='OK') AND (instrument='LAT') AND (calib_type='MDC_t0') AND (flavor='vanilla'))";
    if (rowLimit > 0) {
      // SQL format is LIMIT offset,limit      or
      //               LIMIT limit             or
      //               LIMIT limit   OFFSET offset  [don't use this one]
      sqlString += " LIMIT ";
      std::string limitStr;
      if (rowOffset > 0) {
        facilities::Util::itoa(rowOffset, limitStr);
        sqlString += limitStr + ",";
      }
      limitStr.clear();
      facilities::Util::itoa(rowLimit, limitStr);
       std::cout<<"limitStr is:"<<limitStr<<std::endl;
      sqlString += limitStr;
    }
 
    (*m_out) << std::endl << " # About to issue SELECT:" << std::endl;
    (*m_out) << sqlString << std::endl;
    m_out->flush();
   //maqm add
//     sqlString="SELECT ser_no FROM metadata_v2r1";
 
     
    int mysqlRet = mysql_query(m_mysql, sqlString.c_str());
    if (mysqlRet) {
      std::string msg = 
        "rdbModel::MysqlConnection::select: mysql_query error, code ";
      std::string codeString;
      facilities::Util::itoa(mysqlRet, codeString);
      msg += codeString;
      (*m_out) << std::endl << msg << std::endl;
      m_out->flush();
      throw RdbException(msg, mysqlRet);
      return 0;
    }
 
    MYSQL_RES *myres = mysql_store_result(m_mysql);
    MysqlResults* results = new MysqlResults(myres);
    return results;
  }

update()

unsigned int rdbModel::MysqlConnection::update ( const std::string &  tableName, const StringVector &  colNames, const StringVector &  values, const Assertion *  where = 0, const StringVector *  nullCols = 0  )

virtual

Generic UPDATE. Return value is number of rows changed.

Implements rdbModel::Connection.

Definition at line 274 of file MysqlConnection.cxx.

                                                                     {
 
    unsigned int nCol = colNames.size();
    if (nCol != values.size()) {
      (*m_err) << "rdbModel::mysqlConnection::update: ";
      (*m_err) << "Incompatible vector arguments " << std::endl;
      m_err->flush();
      return 0;
    }
    std::string sqlString = "UPDATE " + tableName + " SET ";
    sqlString += colNames[0] + " = '" + values[0] + "'";
    for (unsigned int iCol = 1; iCol < nCol; iCol++) {
      sqlString += "," + colNames[iCol] + " = '" + values[iCol] + "'";
    }
    if (nullCols) {
      unsigned nNull = nullCols->size();
      for (unsigned iNull = 0; iNull < nNull; iNull++) {
        sqlString += ", " + (*nullCols)[iNull] + "= NULL ";
      }
    }
 
    if (where) {
      sqlString += " WHERE ";
      bool ret = compileAssertion(where, sqlString);
      if (!ret) return 0;
    }
    (*m_out) << std::endl << "#  UPDATE to be issued:" << std::endl;
    (*m_out) << sqlString << std::endl;
    m_out->flush();
    if (m_writeDisabled) {
      (*m_out) << "write to Db previously disabled; UPDATE not sent"
               << std::endl;
      m_out->flush();
      return 0;
    }
    int mysqlRet = mysql_query(m_mysql, sqlString.c_str());
 
    if (mysqlRet) {
      (*m_out) << "rdbModel::MysqlConnection::update: ";
      (*m_out) << "MySQL error during UPDATE, code " << mysqlRet << std::endl;
      m_out->flush();
      return 0;
    }
    my_ulonglong nModLong = mysql_affected_rows(m_mysql);
    // Not much chance that we'll change more rows than will fit in just long
    unsigned nMod = nModLong;
    return nMod;
 
 
  }

visitAssertion()

Visitor::VisitorState rdbModel::MysqlConnection::visitAssertion ( Assertion *  )

virtual

Implements rdbModel::Visitor.

Definition at line 840 of file MysqlConnection.cxx.

                                                                {
    return Visitor::VCONTINUE;
  }

visitColumn()

Visitor::VisitorState rdbModel::MysqlConnection::visitColumn ( Column *  col )

virtual

Implements rdbModel::Visitor.

Definition at line 684 of file MysqlConnection.cxx.

                                                              {
    std::string myName = col->getName();
    if (m_colIx.find(myName) == m_colIx.end()) {
      m_matchReturn = MATCHfail;
      return Visitor::VERRORABORT;
    }
    unsigned int ix = m_colIx[myName];
    mysql_data_seek(m_tempRes, ix);
    MYSQL_ROW colDescrip = mysql_fetch_row(m_tempRes);
 
    // Type
    std::string sqlDtype = std::string(colDescrip[1]);
    Datatype* dtype = col->getDatatype();
    if (!checkDType(dtype, sqlDtype)) {
      m_matchReturn = MATCHfail;
      (*m_out) << "Failed dtype match of col " << myName << std::endl;
      return Visitor::VERRORABORT;
    }
 
    // Null
    bool nullable = (std::string(colDescrip[2]) == std::string("YES"));
    if (nullable != col->nullAllowed()) {
      m_matchReturn = MATCHfail;
      (*m_out) << "Failed null/not null match of col " << myName << std::endl;
      return Visitor::VERRORABORT;
    }
    // Key (PRI for primary, MUL if first in a multiple-field key
    // Save primary key info, if any
    if (std::string(colDescrip[3]) == std::string("PRI")) {
      m_primColName = myName;
    }
 
    // Field 4 is default
    // Extra (may say auto_increment)
    bool autoInc = 
      (std::string(colDescrip[5]) == std::string("auto_increment"));
    if (autoInc != col->isAutoIncrement()) {
      m_matchReturn = MATCHfail;
      (*m_out) << "Failed isAutoIncrement match of col " << myName << std::endl;
      return Visitor::VERRORABORT;
    }
    return Visitor::VCONTINUE;
  }

visitIndex()

Visitor::VisitorState rdbModel::MysqlConnection::visitIndex ( Index *  )

virtual

Implements rdbModel::Visitor.

Definition at line 835 of file MysqlConnection.cxx.

                                                         {
    return Visitor::VCONTINUE;
    // might put something real here later
  }

visitInsertNew()

Visitor::VisitorState rdbModel::MysqlConnection::visitInsertNew ( InsertNew *  )

virtual

Implements rdbModel::Visitor.

Definition at line 844 of file MysqlConnection.cxx.

                                                                {
    return Visitor::VCONTINUE;
  }

visitInterRow()

Visitor::VisitorState rdbModel::MysqlConnection::visitInterRow ( InterRow *  )

virtual

Implements rdbModel::Visitor.

Definition at line 860 of file MysqlConnection.cxx.

                                                              {
    return Visitor::VCONTINUE;
  }

visitQuery()

Visitor::VisitorState rdbModel::MysqlConnection::visitQuery ( Query *  )

virtual

Implements rdbModel::Visitor.

Definition at line 852 of file MysqlConnection.cxx.

                                                        {
    return Visitor::VCONTINUE;
  }

visitRdb()

Visitor::VisitorState rdbModel::MysqlConnection::visitRdb ( Rdb *  )

virtual

This method says if the visitor is recursive or not.

This method sets if the visitor is recursive or not

Implements rdbModel::Visitor.

Definition at line 608 of file MysqlConnection.cxx.

                                                        {
 
    if (m_matchDbName) {
      if (m_dbName != rdb->getDbName()) {
    m_matchReturn = MATCHfail;
    return Visitor::VDONE;
      }
    }
 
    unsigned int nLocal = rdb->getNTable();
 
    // Null pointer for 2nd argument means "list all tables"
 
    MYSQL_RES* res = mysql_list_tables(m_mysql, 0);
    if (!res) {
      m_matchReturn = MATCHfail;
      return Visitor::VERRORABORT;
    }
    unsigned int nRemote = mysql_num_rows(res);
    mysql_free_result(res);
 
    if (nRemote < nLocal) {
      m_matchReturn = MATCHfail;
      return Visitor::VDONE;
    }
    else if (nRemote > nLocal) m_matchReturn = MATCHcompatible;
 
    // Tell Rdb about this 
    rdb->setConnection(this);
 
    return Visitor::VCONTINUE;
  }

visitSet()

Visitor::VisitorState rdbModel::MysqlConnection::visitSet ( Set *  )

virtual

Implements rdbModel::Visitor.

Definition at line 856 of file MysqlConnection.cxx.

                                                    {
    return Visitor::VCONTINUE;
  }

visitSupersede()

Visitor::VisitorState rdbModel::MysqlConnection::visitSupersede ( Supersede *  )

virtual

Implements rdbModel::Visitor.

Definition at line 848 of file MysqlConnection.cxx.

                                                                {
    return Visitor::VCONTINUE;
  }

visitTable()

Visitor::VisitorState rdbModel::MysqlConnection::visitTable ( Table *  table )

virtual

Implements rdbModel::Visitor.

Definition at line 641 of file MysqlConnection.cxx.

                                                              {
    const std::string& tName = table->getName();
 
    // Result set will have all fields for the table
    if (m_tempRes) {
      mysql_free_result(m_tempRes);
      m_tempRes = 0;
    }
    m_primColName.clear();
 
    std::string query = "SHOW COLUMNS FROM " + tName;
 
    (*m_out) << std::endl << "# About to issue SHOW COLUMNS request :" 
      << std::endl;
    (*m_out) << query << std::endl;
    m_out->flush();
 
    int ret = mysql_query(m_mysql, query.c_str());
    if (ret) {
      m_matchReturn = MATCHfail;
      return Visitor::VERRORABORT;
    }
 
    m_tempRes = mysql_store_result(m_mysql);
    if (!m_tempRes) {
      m_matchReturn = MATCHfail;
      return Visitor::VERRORABORT;
    }
    // Result set is a table with fields "Field"(the name) "Type" "Null"(yes
    // or no) "Key" "Default", "Extra"  
    // Make it easier for accept(Column* ) to find relevant information
    unsigned int nRow = mysql_num_rows(m_tempRes);
    m_colIx.clear();
    for (unsigned iRow = 0; iRow < nRow; iRow++) {
      MYSQL_ROW colDescrip = mysql_fetch_row(m_tempRes);
      std::string name = std::string(colDescrip[0]);
      std::cout<<"name is:"<<name<<std::endl;
      m_colIx[name] = iRow;
    }
    return Visitor::VCONTINUE;
 
  }

---

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

• MysqlConnection.h
• MysqlConnection.cxx