/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Database/DatabaseSvc/DatabaseSvc-00-00-24/src/SqliteInterface.cxx

Go to the documentation of this file.

#include "DatabaseSvc/SqliteInterface.h"

#include <iostream>
#include <cstring>

#include <sqlite3.h>

using namespace std;
/*
static int callback(void *result, int argc, char **argv, char **azColName){
  int i;
  DatabaseRecordVector* recv = static_cast<DatabaseRecordVector*>(result);
  DatabaseRecord dbrec;
  for(i=0; i<argc; i++){
    //  printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    unsigned long field_len = 1;
    char* new_record = new char[];
    memcpy(new_record,argv[i],field_len);
    dbrec[azColName[i]]=new_record;
  }
  recv->push_back(dbrec);

  return 0;
}
*/
SqliteInterface::SqliteInterface(){}

SqliteInterface::~SqliteInterface(){}

int SqliteInterface::connect()
{
  return 0;
}

int SqliteInterface::connect(std::string fname)
{
  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;
}

int SqliteInterface::select_db(std::string dbname)
{
  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;
}

int SqliteInterface::query(std::string dbname, std::string sql)
{
    DatabaseRecordVector dummy;
    int status = query(dbname, sql, dummy);
    return status;
}

int SqliteInterface::query(std::string dbname, std::string sql, DatabaseRecordVector& records)
{
  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();
}

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

---