SqliteInterface Class Reference

#include <SqliteInterface.h>

Inheritance diagram for SqliteInterface:

Public Member Functions
	SqliteInterface ()
	~SqliteInterface ()
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 ()
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 fname)

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 8 of file SqliteInterface.h.

Constructor & Destructor Documentation

SqliteInterface()

SqliteInterface::SqliteInterface

(

)

Definition at line 26 of file SqliteInterface.cxx.

{}

~SqliteInterface()

SqliteInterface::~SqliteInterface

(

)

Definition at line 28 of file SqliteInterface.cxx.

{}

Member Function Documentation

connect() [1/2]

int SqliteInterface::connect ( )

virtual

Implements DbInterface.

Definition at line 30 of file SqliteInterface.cxx.

{ return 0; }

Referenced by select_db().

connect() [2/2]

int SqliteInterface::connect ( std::string fname )

protected

Definition at line 32 of file SqliteInterface.cxx.

                                              {
  int status = sqlite3_open_v2( fname.c_str(), &m_conn, SQLITE_OPEN_READONLY, 0 );
  if ( status )
  {
    cerr << "Can't open database " << fname << ": " << sqlite3_errmsg( m_conn ) << endl;
    cerr.flush();
    sqlite3_close( m_conn );
    return -1;
  }
 
  // std::cout << "Open database " << fname << std::endl;
 
  m_isConnected = true;
 
  return 0;
}

disconnect()

int SqliteInterface::disconnect ( )

virtual

Implements DbInterface.

Definition at line 144 of file SqliteInterface.cxx.

                                {
  int res = sqlite3_close( m_conn );
  if ( res ) cerr << "ERROR: Cannot close connection to " << m_dbName << endl;
  m_isConnected = false;
  return 0;
}

Referenced by query(), and select_db().

query() [1/2]

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

virtual

Implements DbInterface.

Definition at line 68 of file SqliteInterface.cxx.

                                                            {
  DatabaseRecordVector dummy;
  int                  status = query( dbname, sql, dummy );
  return status;
}

Referenced by query().

query() [2/2]

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

virtual

Implements DbInterface.

Definition at line 74 of file SqliteInterface.cxx.

                                                            {
  char* zErrMsg = 0;
  // char ***pazResult;
  // int pnRow;
  // int pnColumn;
 
  int status = select_db( dbname );
  if ( status < 0 ) return -1;
 
  records.clear();
  // status = sqlite3_exec(m_conn, sql.c_str(), callback, &records, &zErrMsg);
  sqlite3_stmt* ppStmt;
  sqlite3_prepare_v2( m_conn, sql.c_str(), -1, &ppStmt, 0 );
 
  while ( true )
  {
    status = sqlite3_step( ppStmt );
    if ( status == SQLITE_DONE ) { break; }
 
    if ( status == SQLITE_ROW )
    {
      DatabaseRecord* dbrec = new DatabaseRecord;
 
      // loop over columns
      int ncolumns = sqlite3_column_count( ppStmt );
      int i;
      for ( i = 0; i < ncolumns; i++ )
      {
        // create new record
        unsigned long field_len = sqlite3_column_bytes( ppStmt, i );
        char*         new_record;
        const char*   col_name = sqlite3_column_name( ppStmt, i );
        char          column_name[255];
        strcpy( column_name, col_name );
        int type = sqlite3_column_type( ppStmt, i );
        if ( type == SQLITE_BLOB )
        {
          new_record       = new char[field_len];
          char* col_result = (char*)sqlite3_column_blob( ppStmt, i );
          memcpy( new_record, col_result, field_len );
        }
        else if ( type != SQLITE_NULL )
        {
          new_record       = new char[field_len + 1];
          char* col_result = (char*)sqlite3_column_text( ppStmt, i );
          strcpy( new_record, col_result );
        }
        else { new_record = NULL; }
        ( *dbrec )[column_name] = new_record;
      }
 
      records.push_back( dbrec );
 
      continue;
    }
 
    // anything else means that error happened
    cerr << "SQLITE query error: " << zErrMsg << endl;
    return -1;
  }
 
  sqlite3_free( zErrMsg );
  sqlite3_finalize( ppStmt );
  //  if(! m_reuseConnection)
  disconnect();
 
  return records.size();
}

select_db()

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

virtual

Implements DbInterface.

Definition at line 49 of file SqliteInterface.cxx.

                                                 {
  if ( m_isConnected )
  {
    if ( m_dbName != dbname ) // need to change db
      disconnect();
  }
 
  m_dbName     = dbname;
  string fname = m_dbPath + "/" + m_dbName + ".db";
 
  if ( !m_isConnected )
  {
    int status = connect( fname );
    if ( status < 0 ) return -1;
  }
 
  return 0;
}

Referenced by query().

---

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

• SqliteInterface.h
• SqliteInterface.cxx