C++: c++ wrap for libpq

C++: c++ wrap for libpq

class DBConnection
{
public:
     class TParams
    {
     public:
        TParams( int size);
         virtual ~TParams();
     private:
        TParams( const TParams&  params) {}
        TParams&  operator = ( const TParams&  params) {  return * this; }
     public:
         void Add( const  char* val,  int size);
         void Add( int val);
         void Add(unsigned  int val);
         void Add(uint64_t val);
         void Add( short val);
        
         void Free();
        
         int Size()  const {  return _size; }
         const  char *  const * Value()  const {  return value; }
         const  int* Length()  const {  return length; }
         const  int* Format()  const {  return format; }
     public:
         char** value;
         int* length;
         int* format;
     private:
         int _size;
         int _pos;
    };
public:
    DBConnection()
    : conn(NULL)
    {
    }
     virtual ~DBConnection();
public:
     int Connect( const  char* info);
     void Disconnect();
    
     int ExecCmd( const  char* cmd);
    PGresult* ExecQuery( const  char* sql);
     int ExecCmdWithParams( const  char* cmd,  const TParams&  params);
    PGresult* ExecQueryWithParams( const  char* sql,  const TParams&  params);
     int BeginTranscation();
     int EndTranscation();
private:
    PGconn* conn;
};

DBConnection::TParams::TParams( int size)
: _size(size), _pos(0)
{
    value =  new  char*[_size];
    length =  new  int[_size];
    format =  new  int[_size];
}

DBConnection::TParams::~TParams()
{
    Free();
}

void DBConnection::TParams::Free()
{
     if (_size == 0)
    {
         return;
    }
    
     for ( int i = 0; i < _size; ++ i)
    {
         if (format[i] == 0)
        {
            delete[] value[i];
        }
         else  if (length[i] ==  sizeof( int) || length[i] ==  sizeof(unsigned  int))
        {
            delete ( int*)value[i];
        }
         else  if (length[i] ==  sizeof(uint64_t))
        {
            delete (uint64_t*)value[i];
        }
         else
        {
            delete ( short*)value[i];
        }
    }
    
    delete[] value, value = NULL;
    delete[] length, length = NULL;
    delete[] format, format = NULL;
    
    _size = 0;
    
    DEBUG(DEBUG_ANY, "<DBConnection::TParams::Free()>"<< std::endl);
}

void DBConnection::TParams::Add( const  char* val,  int size)
{
     char* char_val =  new  char[size + 1];
    char_val[size] = '\0';
//     char* char_val = new char[size];
    memcpy(char_val, val, size);
    
    value[_pos] = char_val;
    length[_pos] = size + 1;
    format[_pos] = 0;
    
    ++ _pos;
}

void DBConnection::TParams::Add( int val)
{
#ifdef __OS_MAC__
     int* int_val =  new ( int)(val);
#else
     int* int_val =  new ( int)(htonl(val));
#endif
    value[_pos] = ( char*)(int_val);
    length[_pos] =  sizeof( int);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add(unsigned  int val)
{
#ifdef __OS_MAC__
    unsigned  int* int_val =  new (unsigned  int)(val);
#else
    unsigned  int* int_val =  new (unsigned  int)(htonl(val));
#endif

    value[_pos] = ( char*)(int_val);
    length[_pos] =  sizeof( int);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add(uint64_t val)
{
#ifdef __OS_MAC__
    uint64_t* uint64_val =  new uint64_t(val);
#else
    uint64_t* uint64_val =  new uint64_t(htobe64(val));
#endif
    value[_pos] = ( char*)(uint64_val);
    length[_pos] =  sizeof(uint64_t);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add( short val)
{
#ifdef __OS_MAC__
     short* int_val =  new ( short)(val);
#else
     short* int_val =  new ( short)(htons(val));
#endif
    value[_pos] = ( char*)(int_val);
    length[_pos] =  sizeof( short);
    format[_pos] = 1;
    
    ++ _pos;
}

/// /

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

int DBConnection::Connect( const  char* info)
{
    conn = PQconnectdb(info);
     if (PQstatus(conn) != CONNECTION_OK)
    {
        DEBUG(DEBUG_ANY, "PQ connection failed.");
        PQfinish(conn);
         return -1;
    }
    
     return 0;
}

void DBConnection::Disconnect()
{
     if (conn != NULL)
    {
        PQfinish(conn);
        conn = NULL;
    }
}

int DBConnection::ExecCmd( const  char* cmd)
{
    PGresult* res = PQexec(conn, cmd);
     if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecCmd> failed - " << cmd << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecCmd> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
         return -1;
    }
     //     int ret = ntohl(*PQcmdTuples(res));
     int ret = *PQcmdTuples(res);
    PQclear(res);
     return ret;
}

PGresult* DBConnection::ExecQuery( const  char* sql)
{
    PGresult* res = PQexec(conn, sql);
     if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecQuery> failed - " << sql << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecQuery> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
         return NULL;
    }
     return res;
}

int DBConnection::ExecCmdWithParams( const  char* cmd,  const DBConnection::TParams&  params)
{
    PGresult* res = PQexecParams(conn, cmd,  params.Size(), NULL,  params.Value(),  params.Length(),  params.Format(), 0);
     if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecCmdWithParams> failed - " << cmd << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecCmdWithParams> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
         return -1;
    }
//     int ret = ntohl(*PQcmdTuples(res));
     int ret = *PQcmdTuples(res);
    PQclear(res);
    
    DEBUG(DEBUG_ANY, "<DBConnection::ExecCmdWithParams> succ - " << cmd << std::endl);
    
     return ret;
//     return 0;
}

PGresult* DBConnection::ExecQueryWithParams( const  char* sql,  const TParams&  params)
{
    PGresult* res = PQexecParams(conn, sql,  params.Size(), NULL,  params.Value(),  params.Length(),  params.Format(), 0);
     if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecQueryWithParams> failed - " << sql << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecQueryWithParams> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
         return NULL;
    }
     return res;
}

int DBConnection::BeginTranscation()
{
     return ExecCmd("BEGIN");
}

int DBConnection::EndTranscation()
{
     return ExecCmd("END");
}