[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.13 and 1.49

version 1.13, 2001/09/26 10:32:25 version 1.49, 2024/11/04 03:53:25
Line 1 Line 1
 /** @file  /** @file
         Parser: sql fconnection decl.          Parser: sql fconnection decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
   
         $Id$  
 */  */
   
 #ifndef PA_SQL_CONNECTION_H  #ifndef PA_SQL_CONNECTION_H
 #define PA_SQL_CONNECTION_H  #define PA_SQL_CONNECTION_H
   
 #include "pa_config_includes.h"  #define IDENT_PA_SQL_CONNECTION_H "$Id$"
 #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"
   
 /// SQL fconnection. handy wrapper around low level SQL_Driver  // defines
 class SQL_Connection : public Pooled {  
   /// @see SQL_Driver_services_impl::_throw
   #ifdef PA_WITH_SJLJ_EXCEPTIONS
           #define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) \
                   use(); \
                   actions
   #else
           #define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) \
                   use(); \
                   if(!setjmp(fservices.mark)) { \
                           actions; \
                   } else \
                           fservices.propagate_exception();
   #endif
   
   /// SQL_Driver_services Pooled implementation
   class SQL_Driver_services_impl: public SQL_Driver_services {
           const String* furl;
           Exception fexception;
           const char* frequest_charset;
           const char* fdocument_root;
 public:  public:
           SQL_Driver_services_impl(const char* arequest_charset, const char* adocument_root): furl(0), frequest_charset(arequest_charset), fdocument_root(adocument_root) {}
           void set_url(const String& aurl) { furl=&aurl;}
           const String& url_without_login() const;
   
           override void* malloc(size_t size) { return pa_malloc(size); }
           override void* malloc_atomic(size_t size) { return pa_malloc_atomic(size); }
           override void* realloc(void *ptr, size_t size) { return pa_realloc(ptr, size); }
   
           override const char* request_charset() { return frequest_charset; }
           override const char* request_document_root() { return fdocument_root; }
           
           override void transcode(const char* src, size_t src_length,
                   const char*& dst, size_t& dst_length,
                   const char* charset_from_name,
                   const char* charset_to_name
                   );
   
           /**
                   normally we can't 'throw' from dynamic library, so
                   the idea is to #1 jump to C++ some function to main body, where
                   every function stack frame has exception unwind information
                   and from there... #2 propagate_exception()
   
           but when parser configured --with-sjlj-exceptions
                   one can simply 'throw' from dynamic library.
                   [sad story: one can not longjump/throw due to some bug in gcc as of 3.2.1 version]
           */
           override void _throw(const SQL_Error& aexception) {
                   // converting SQL_exception to parser Exception
                   // hiding passwords and addresses from accidental show [imagine user forgot @exception]
   #ifdef PA_WITH_SJLJ_EXCEPTIONS
                   throw
   #else
                   fexception=
   #endif
                   Exception(aexception.type() ? aexception.type() : "sql.connect", &url_without_login(), aexception.comment());
   
         SQL_Connection(Pool& pool, const String& aurl, SQL_Driver& adriver) : Pooled(pool),  #ifndef PA_WITH_SJLJ_EXCEPTIONS
                   longjmp(mark, 1);
   #endif
           }
   
           virtual void propagate_exception() {
   #ifndef PA_WITH_SJLJ_EXCEPTIONS
                   throw fexception;
   #endif
           }
   };
   
   /// SQL connection. handy wrapper around low level SQL_Driver
   class SQL_Connection: public PA_Object {
           const String&  furl;
           SQL_Driver& fdriver;
           SQL_Driver_services_impl fservices;
           void *fconnection;
           time_t time_used;
   
   public:
   
           SQL_Connection(const String& aurl, SQL_Driver& adriver, const char* arequest_charset, const char* adocument_root):
                 furl(aurl),                  furl(aurl),
                 fdriver(adriver),                  fdriver(adriver),
                   fservices(arequest_charset, adocument_root),
                 fconnection(0),                  fconnection(0),
                 time_stamp(0) {                  time_used(0) {
         }          }
   
           SQL_Driver_services_impl& services() { return fservices; }
                   
         const String& url() { return furl; }          const String& get_url() { return furl; }
   
         void set_services(SQL_Driver_services *aservices) {          void set_url() {
                 time_stamp=time(0); // they started to use at this time                  fservices.set_url(furl);
                 fservices=aservices;  
         }          }
         bool expired(time_t older_dies) {          void use() {
                 return time_stamp<older_dies;                  time_used=time(0); // they started to use at this time
         }          }
           bool expired(time_t older_dies) {
         void close() {                  return time_used<older_dies;
                 SQL_driver_manager->close_connection(furl, *this);  
         }          }
           time_t get_time_used() { return time_used; }
   
         bool connected() { return fconnection!=0; }          bool connected() { return fconnection!=0; }
         void connect(char *used_only_in_connect_url_cstr) {           void connect(char *used_only_in_connect_url_cstr) { 
                 fdriver.connect(used_only_in_connect_url_cstr, *fservices, &fconnection);                  SQL_CONNECTION_SERVICED_FUNC_GUARDED(
         }                          fdriver.connect(used_only_in_connect_url_cstr, fservices, &fconnection)
         void disconnect() { fdriver.disconnect(fconnection); fconnection=0; }                  );
         void commit() { fdriver.commit(*fservices, fconnection); }          }
         void rollback() { fdriver.rollback(*fservices, fconnection); }          void disconnect() { 
         bool ping() { return fdriver.ping(*fservices, fconnection); }                  fdriver.disconnect(fconnection); fconnection=0; 
         uint quote(char *to, const char *from, unsigned int length) {          }
                 return fdriver.quote(*fservices, fconnection, to, from, length);          bool ping() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           return fdriver.ping(fconnection)
                   );
                   return false; // never reached, warning war
           }
           const char* quote(const char* str, unsigned int length) {
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           return fdriver.quote(fconnection, str, length)
                   );
                   return NULL; // never reached, warning war
         }          }
   
         void query(          void query(
                 const char *statement, unsigned long offset, unsigned long limit,                  const char* statement, 
                 SQL_Driver_query_event_handlers& handlers) {                   size_t placeholders_count, SQL_Driver::Placeholder* placeholders,
                 fdriver.query(*fservices, fconnection,                   unsigned long offset, unsigned long limit,
                         statement, offset, limit,                   SQL_Driver_query_event_handlers& handlers, 
                         handlers);                  const String& source) {
                   try {
                           SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                                   fdriver.query(fconnection, statement, placeholders_count, placeholders, offset, limit, handlers)
                           );
                   } catch(const Exception& e) { // query problem
                           if(strcmp(e.type(), "sql.connect")==0) { // if it is _throw exception, 
                                   // show query instead of connect string
                                   throw Exception("sql.execute", &source, "%s", e.comment());
                           } else
                                   rethrow;
                   }
           }
   
           void commit() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           fdriver.commit(fconnection) 
                   );
           }
           void rollback() { 
                   SQL_CONNECTION_SERVICED_FUNC_GUARDED(
                           fdriver.rollback(fconnection)
                   );
         }          }
   
           /// return to cache
           void close() {
                   SQL_driver_manager->close_connection(furl, this);
           }
   
 private:  
   
         const String& furl;  
         SQL_Driver& fdriver;  
         SQL_Driver_services *fservices;  
         void *fconnection;  
         time_t time_stamp;  
 };  };
   
 #endif  #endif
Removed from v.1.13  
changed lines
  Added in v.1.49

E-mail: