使用otl监控oracle和DB2代码封装

#ifndef _OTL_ORACLE_H_
#define _OTL_ORACLE_H_

#ifdef WIN32
#include <windows.h>
#endif
#include <vector>
#include <base/common.h>
#include <base/string_util.h>
#include <boost/thread/mutex.hpp>
#define OTL_DB2_CLI //OTL_ORA9I
#include "../otlv4.h"
namespace thefox{
namespace db{

class otl_oracle{

public:
typedef std::vector<string> Row;
typedef std::vector<Row> Table;
otl_oracle();
~otl_oracle();

void SetConnStr(const string &connStr);

bool Connect();
void Disconnect();

bool GetValueInt(const std::string &sql,int64_t &value);
string GetValueStr(const std::string &sql);
Row GetRow(const std::string &sql);
Table  GetTable(const std::string &sql);

// 得到一行中某个字段的数据
static inline string GetValueByIndex(const Row &row, unsigned int index)
{
if (index >= 0 && index < row.size()) {
return row[index];
}
return "";
}
static inline string GetValueByIndex(const Table &table, unsigned int row_index,unsigned int col_index)
{
if (row_index >= 0 && col_index >= 0 && row_index < table.size()) {
if (col_index < table[row_index].size())
{
return table[row_index][col_index];
}

}
return "";
}
static inline Row GetRowByIndex(const Table &table, unsigned int index)
{
Row row;
if (index >= 0 && index < table.size()) {
row = table[index];
}

return row;
}
private:
bool DoQueryFirst(const string &ssql);
bool DoQueryNext(Row &row);
void DoQueryEnd();
char* getNextVariable(otl_stream &o, char *outBuf);
string m_connStr;
otl_connect m_db;
otl_stream m_o;
boost::mutex  m_mutex;
};

}//end namespace db
}//end namespace thefox

#endif//END DEFINE _OTL_ORACLE_H_

#include "otl_oracle.h"
#include <log/Logging.h>

using namespace std;
using namespace thefox;
using namespace db;

otl_oracle::otl_oracle()
:m_connStr("")
{}

otl_oracle::~otl_oracle()
{
Disconnect();
}

void otl_oracle::SetConnStr(const string &connStr){
m_connStr = connStr;
}

bool otl_oracle::Connect(){
if (m_connStr.empty())
{
THEFOX_LOG(WARN) << "oracle conn str is empty";
return false;
}

if (m_db.connected) {
Disconnect();
}

try {
m_db.rlogon(m_connStr.c_str());// connect to Oracle
} catch(otl_exception& p){
THEFOX_LOG(ERROR) << "otl error status:" << p.code <<"sql:"<<(char*)(p.msg);
return false;
}
//THEFOX_LOG(TRACE) << "connect success connstr:" << m_connStr.c_str() ;
return true;

}

void otl_oracle::Disconnect(){

if(m_db.connected){
m_db.logoff(); // disconnect from Oracle
}
}

bool otl_oracle::DoQueryFirst(const string &ssql){
m_mutex.lock();
if (!m_db.connected) {
return false;
}
try{
m_o.open(1,ssql.c_str(),m_db);
} catch(otl_exception& p) { // intercept OTL exceptions
return false;
}
return true;
}

bool otl_oracle::DoQueryNext(Row &row){
char buf[65535];
row.clear();
while (!m_o.eof())
{
getNextVariable(m_o,buf);
row.push_back(string(buf));
try
{
m_o.check_end_of_row();
}
catch (otl_exception&)
{
continue;
}
return true;
}

return false;
}

void otl_oracle::DoQueryEnd(){
if (m_o.good())
m_o.close();
m_mutex.unlock();
}

bool otl_oracle::GetValueInt(const std::string &sql, int64_t &value)
{
value = 0;
Row row;
if (DoQueryFirst(sql))
{
if (DoQueryNext(row)) {
if (!row.empty()) {
value = StringUtil::stoi64(row[0]);
DoQueryEnd();
return true;
}
}
}

return false;
}
string otl_oracle::GetValueStr(const std::string &sql){
Row row=GetRow(sql);
if (row.size())
{
return row[0];
}else
return "";
}

otl_oracle::Row otl_oracle::GetRow(const std::string &sql)
{
Row row;
if(DoQueryFirst(sql))
DoQueryNext(row);
DoQueryEnd();
return row;
}

otl_oracle::Table otl_oracle::GetTable(const std::string &sql)
{
Table table;
Row row;
if (DoQueryFirst(sql))
{
while (DoQueryNext(row)) {
if (!row.empty()) {
table.push_back(row);
}
}
}
DoQueryEnd();
return table;
}

char* otl_oracle::getNextVariable(otl_stream &o, char *outBuf)
{
strcpy(outBuf,"");
int type = o.describe_next_out_var()->ftype;
switch (type){
case otl_var_char:
{
o >> outBuf;
break;
}
case otl_var_double:
{
double d;
o >> d;
sprintf(outBuf, "%lf", d);
break;
}
case otl_var_float:
{
float f;
o >> f;
sprintf(outBuf, "%f", f);
break;
}
case otl_var_int:
case otl_var_short:
case otl_var_long_int:
{
int i;
o >> i;
sprintf(outBuf, "%d", i);
break;
}
case otl_var_unsigned_int:
{
unsigned int i;
o >> i;
sprintf(outBuf, "%u", i);
break;
}
case 8://! otl_var_timestamp
case 16://! otl_var_db2time
case 17://! otl_var_db2date
case 18://! otl_var_tz_timestamp
case 19://! otl_var_ltz_timestamp
{
otl_datetime f1;
o>>f1;
sprintf(outBuf, "%4d-%2d-%2d %2d:%2d:%2d",
f1.year, f1.month, f1.day, f1.hour, f1.minute, f1.second);
break;
}
default :
strcpy(outBuf, "");
break;
}

return outBuf;
}