---

dsPGi.h

Go to the documentation of this file.

/*
 * $Id: dsPGi.h,v 1.2 2002/12/10 11:17:05 dsamersoff Exp $
 */

#ifndef dsPGi_h 
#define dsPGi_h

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#ifndef 
# include <string>
#endif

#include <libpq-fe.h>
#include <libpq-int.h>

#include <limits.h>
#include <stdlib.h>
#include <os.h>

#include <dsSmartException.h>


#define LIBPQ_VERSION  64

DECLARE_EXCEPTION(dsPGi);

// dsPGiData exception returned by runAction (presumable trigger error).
DECLARE_EXCEPTION2(dsPGiData, dsPGi);

class dsPGi
{
public :
        PGconn *_conn;
        PGresult *_res;
        PGresult *_act_res;
        char * _cursor;
        char *_dbName;
        FILE *debf;
        int _has_begin;
public :

        dsPGi()
         { _conn      = 0;
           _res       = 0;
           _act_res   = 0;
           _cursor    = 0;
           _dbName    = 0; 
            debf      = 0;
           _has_begin = 0; 
         }

        dsPGi(const char *database, const char *user = 0, const char *passwd = 0)
        { memset(this, 0, sizeof(*this) );
          connect(database,0,0,user, passwd);
        }

        dsPGi(const char *database, const char *host, const char *port, 
                                         const char *user, const char *passwd = 0)
        { memset(this, 0, sizeof(*this) );
          connect(database,host,port,user, passwd);
        }


       ~dsPGi()
          {
            destructor;
             if (_act_res) PQclear(_act_res);
             if (_conn) PQfinish(_conn); 
             if (_dbName) delete _dbName; 
          }

        // extract runQuery results to preserve them into dummy dsPGi object
        dsPGi *get_result(); 

     void connect(const char* dbName, 
                      const char *host,  const char *port,
                      const char *user, const char *passwd);

      void close()
        {
            if (_act_res) 
                PQclear(_act_res);
            if (_conn) 
                PQfinish(_conn);
            _act_res = 0;
            _conn = 0;
        }

      void openCursor(const char *query, const char *cursor = 0);

#ifndef 
      void openCursor(const std::string& query, const char *cursor = 0) { 
          openCursor((const char *) query.c_str(), cursor);
      }
#endif

      void closeCursor();
      int fetchNext();
      int fetchAll();

      void runActionAsync(const char* query, int alarm_timeout = 10);

      enum tts { no_trans = 0, do_trans = 3, begin_trans = 1, end_trans = 2 };
      void runAction(const char* query, tts use_tts = do_trans);

#ifndef 
      void runAction(const std::string& query, tts use_tts = do_trans) {
           runAction((const char *) query.c_str(), use_tts);
      }
#endif

      void runQuery(const char *query);

#ifndef 
      void runQuery(const std::string& query) { runQuery( (const char *) query.c_str()); }
#endif

      // Number of touples affected by INSERT, DELETE or UPDATE
      int touples_changed() const 
      {
          const char *res =(const char *) PQcmdTuples(_act_res);
          return res ? atoi(res) : 0;
      }

      // oid of lass accessed record
      const char *last_oid() const 
      { 
          const char *res = (const char *)PQoidStatus(_act_res);
          return res ? res : "";
      }
          

       /* some inteface clean up */
         const int  __tuples( PGresult *x_res){ return PQntuples(x_res); }
         const int  __fields( PGresult *x_res){ return PQnfields(x_res); }
         const char * __fieldname(PGresult *x_res, int i){ return PQfname(x_res, i); }
         const char * __value(PGresult *x_res, int tuple, int field) 
                { if (tuple >= __tuples(x_res)) 
                        throw dsPGiException("Invalid tuple number: %d", tuple);
                  if (field >= __fields(x_res))
                        throw dsPGiException("Invalid field number: %d", field);
                  return PQgetvalue(x_res, tuple, field);
                }

          const char *__value(PGresult *x_res, int tuple, char *field)
                { for( int i = 0; i < __fields(x_res); ++i)
                     { if (strcmp( __fieldname(x_res, i), field ) == 0 )
                          { return __value(x_res, tuple, i);
                          }
                     }
                    throw dsPGiException("No such field: '%s'", field);
                }




      // access to results of SELECT via runAction 
      int qtuples() { return __tuples(_act_res); }
      int qtouples() { return __tuples(_act_res); }
      int qfields(){ return __fields(_act_res); }
      const char *qfieldname(int i){ return __fieldname(_act_res,i); }
      const char *qvalue(int field){ return __value(_act_res, 0, field); }
      const char *qvalue(char *field){ return __value(_act_res,0,field); }
      const char *qvalue(int tuple, int field){ return __value(_act_res, tuple, field); } 
      const char *qvalue(int tuple, char *field){ return __value(_act_res,tuple,field); }

      int tuples(){ return __tuples(_res); }
      int touples(){ return __tuples(_res); }
      int fields(){ return __fields(_res); }
      const char *fieldname(int i){ return __fieldname(_res,i); }
      const char *value(int field){ return __value(_res, 0, field); }
      const char *value(char *field){ return __value(_res,0,field); }
      const char *value(int tuple, int field){ return __value(_res, tuple, field); } 
      const char *value(int tuple, char *field){ return __value(_res,tuple,field); }

       
      const char *cursor(){ return _cursor; }

      const char *operator [](int field){ return __value(_res, 0, field); }  
      const char *operator [](char *field){ return __value(_res, 0, field); }

      void trace(const char *fname = 0)
       {
        char qbuf[64];
 
        if (fname)
           {  if (*fname == '-') 
                 debf = (*fname == '-') ?  stderr : fopen(fname, "w");
           }
           else
             { sprintf(qbuf,"trace.%04d", getpid() );
               debf = fopen( (char *)qbuf, "w");
             }

         if (!debf) debf = stderr;  
         PQtrace(_conn, debf);
       }
      void trace(FILE *f) { PQtrace(_conn, f); }
      

      PGresult *getResult(){ return _res; }

      // transaction management
      void begin();
      void commit();
      void rollback();
};

#endif

---