[BACK]Return to pa_sql_connection.h CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_sql_connection.h between versions 1.4 and 1.26

version 1.4, 2001/04/05 13:19:41 version 1.26, 2002/08/01 11:41:16
Line 1 Line 1
 /** @file  /** @file
         Parser: sql connection decl.          Parser: sql fconnection decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  
   
         $Id$  
 */  */
   
 #ifndef PA_SQL_CONNECTION_H  #ifndef PA_SQL_CONNECTION_H
 #define PA_SQL_CONNECTION_H  #define PA_SQL_CONNECTION_H
   
   static const char* IDENT_SQL_CONNECTION_H="$Date$";
   
 #include "pa_pool.h"  #include "pa_pool.h"
 #include "pa_sql_driver.h"  #include "pa_sql_driver.h"
 #include "pa_sql_driver_manager.h"  #include "pa_sql_driver_manager.h"
   
   // defines
   
   /// @see SQL_Driver_services_impl::_throw
   #define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) \
           if(!fservices || !setjmp(fservices->mark)) { \
                   actions; \
           } else \
                   fservices->propagate_exception();
   
 /// SQL connection. handy wrapper around low level SQL_Driver  /// SQL connection. handy wrapper around low level SQL_Driver
 class SQL_Connection : public Pooled {  class SQL_Connection : public Pooled {
   
 public:          friend class SQL_Connection_ptr;
   
         void set_services(Services_for_SQL_driver *services) {  public:
                 fdriver.set_services(services);  
         }  
   
         SQL_Connection(Pool& pool,          SQL_Connection(Pool& pool, const String& aurl, SQL_Driver& adriver) : Pooled(pool),
                 const String& aurl,   
                 SQL_Driver& adriver, Services_for_SQL_driver& services,   
                 char *url_cstr) : Pooled(pool),  
                 furl(aurl),                  furl(aurl),
                 fdriver(adriver) {                  fdriver(adriver),
                   fconnection(0),
                 set_services(&services); // associate with services[request]                  time_used(0), used(0),
                 fdriver.connect(url_cstr, &connection);                  marked_to_rollback(false) {
         }          }
           
           const String& get_url() { return furl; }
   
         void close() {          void set_services(SQL_Driver_services *aservices) {
                 set_services(0); // deassociate from services[request]                  fservices=aservices;
                 SQL_driver_manager->close_connection(furl, *this);  
         }          }
           bool expired(time_t older_dies) {
                   return !used && time_used<older_dies;
           }
           time_t get_time_used() { return time_used; }
   
         void disconnect() { fdriver.disconnect(connection); }          bool connected() { return fconnection!=0; }
         void commit() { fdriver.commit(connection); }          void connect(char *used_only_in_connect_url_cstr) { 
         void rollback() { fdriver.rollback(connection); }                  SQL_CONNECTION_SERVICED_FUNC_GUARDED(
         bool ping() { return fdriver.ping(connection); }                          fdriver.connect(used_only_in_connect_url_cstr, *fservices, &fconnection)
                   );
           }
           void disconnect() { 
                   fdriver.disconnect(fconnection); fconnection=0; 
           }
           bool ping() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           return fdriver.ping(*fservices, fconnection)
                   );
                   return 0; // never reached
           }
         uint quote(char *to, const char *from, unsigned int length) {          uint quote(char *to, const char *from, unsigned int length) {
                 return fdriver.quote(connection, to, from, length);                  SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           return fdriver.quote(*fservices, fconnection, to, from, length)
                   );
                   return 0; // never reached
         }          }
   
         void query(          void query(
                 const char *statement, unsigned long offset, unsigned long limit,                  const char *statement, unsigned long offset, unsigned long limit,
                 unsigned int *column_count, SQL_Driver::Cell **columns,                  SQL_Driver_query_event_handlers& handlers) { 
                 unsigned long *row_count, SQL_Driver::Cell ***rows) {                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                 fdriver.query(connection,                           fdriver.query(*fservices, fconnection, 
                         statement, offset, limit,                                   statement, offset, limit, 
                         column_count, columns,                                  handlers)
                         row_count, rows);                  );
           }
   
           void mark_to_rollback() {
                   marked_to_rollback=true;
           }
   
   private: // closing process
   
           void commit() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           fdriver.commit(*fservices, fconnection) 
                   );
           }
           void rollback() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           fdriver.rollback(*fservices, fconnection)
                   );
           }
   
           /// return to cache
           void close() {
                   if(marked_to_rollback) {
                           rollback();
                           marked_to_rollback=false;
                   } else
                           commit();
   
                   SQL_driver_manager->close_connection(furl, *this);
         }          }
   
   private: // connection usage methods
   
           void use() {
                   time_used=time(0); // they started to use at this time
                   used++;
           }
           void unuse() {
                   used--;
                   if(!used)
                           close();
           }
   
   private: // connection usage data
   
           int used;
   
 private:  private:
   
         SQL_Driver& fdriver;  
         void *connection;  
         const String& furl;          const String& furl;
           SQL_Driver& fdriver;
           SQL_Driver_services *fservices;
           void *fconnection;
           time_t time_used;
           bool marked_to_rollback;
   };
   
   /// Auto-object used to track SQL_Connection usage
   class SQL_Connection_ptr {
           SQL_Connection *fconnection;
   public:
           explicit SQL_Connection_ptr(SQL_Connection *aconnection) : fconnection(aconnection) {
                   fconnection->use();
           }
           ~SQL_Connection_ptr() {
                   fconnection->unuse();
           }
           SQL_Connection* operator->() {
                   return fconnection;
           }
           SQL_Connection* get() const {
                   return fconnection; 
           }
   
           // copying
           SQL_Connection_ptr(const SQL_Connection_ptr& src) : fconnection(src.fconnection) {
                   fconnection->use();
           }
           SQL_Connection_ptr& operator =(const SQL_Connection_ptr& src) {
                   // may do without this=src check
                   fconnection->unuse();
                   fconnection=src.fconnection;
                   fconnection->use();
   
                   return *this;
           }
 };  };
   
 #endif  #endif
Removed from v.1.4  
changed lines
  Added in v.1.26

E-mail: