[BACK]Return to pa_sql_driver_manager.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_sql_driver_manager.C between versions 1.2 and 1.6.2.1

version 1.2, 2001/04/04 11:47:29 version 1.6.2.1, 2001/04/17 15:02:04
Line 24  SQL_Driver_manager *SQL_driver_manager; Line 24  SQL_Driver_manager *SQL_driver_manager;
 const int MAX_PROTOCOL=20;  const int MAX_PROTOCOL=20;
 const char *LIBRARY_CREATE_FUNC_NAME="create";  const char *LIBRARY_CREATE_FUNC_NAME="create";
   
   
   /// Services_for_SQL_driver implementation
   class Services_for_SQL_driver_impl : public Services_for_SQL_driver, public Pooled {
   public:
           Services_for_SQL_driver_impl(Pool& apool, const String& aurl) : Pooled(apool),
                   furl(aurl) {
           }
   
           /// allocates some bytes on pool
           void *malloc(size_t size) { return Pooled::malloc(size); }
           /// allocates some bytes clearing them with zeros
           void *calloc(size_t size) { return Pooled::calloc(size); }
           /// throw exception
           void _throw(const char *comment) { 
                   THROW(0, 0, 
                           &furl, 
                           comment); 
           }
   
   private:
           const String& furl;
   };
   
   // SQL_Driver_manager
   
 // url:  // url:
 //   protocol://user:pass@host:port/database  //   protocol://user:pass@host:port/database
 //              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this is driver-dependent  //              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this is driver-dependent
 SQL_Connection& SQL_Driver_manager::get_connection(const String& url,   SQL_Connection& SQL_Driver_manager::get_connection(const String& url, 
                                                                                                    Table *protocol2library) {                                                                                                     Table *protocol2driver_and_client) {
         SYNCHRONIZED(true);          SYNCHRONIZED(true);
   
         Pool& pool=url.pool(); // request pool                                                                                               Pool& pool=url.pool(); // request pool                                                                                     
   
         // we have table for locating protocol's library          // we have table for locating protocol's library
         if(!protocol2library)          if(!protocol2driver_and_client)
                 PTHROW(0, 0,                  PTHROW(0, 0,
                         &url,                          &url,
                         "SQL:drivers table must be defined");                          "$SQL:drivers table must be defined");
   
         // first trying to get cached connection          // first trying to get cached connection
         if(SQL_Connection *result=get_connection_from_cache(url))          if(SQL_Connection *result=get_connection_from_cache(url))
                 return *result;                  if(result->ping())
                           return *result;
                   else
                           result->disconnect(); // kill unpingabe=dead connection
         // no cached connection          // no cached connection
   
         int pos=url.pos("://", 3);          int pos=url.pos("://", 3);
Line 62  SQL_Connection& SQL_Driver_manager::get_ Line 90  SQL_Connection& SQL_Driver_manager::get_
                 url_cstr++;                  url_cstr++;
   
         SQL_Driver *driver;          SQL_Driver *driver;
           const String *dlopen_file_spec=0;
         // first trying to get cached driver          // first trying to get cached driver
         if(!(driver=get_driver_from_cache(protocol))) {          if(!(driver=get_driver_from_cache(protocol))) {
                 // no cached                  // no cached
                 const String *library=0;                  const String *library=0;
                 if(protocol2library->locate(0, protocol)) {                  if(protocol2driver_and_client->locate(0, protocol)) {
                         if(!(library=protocol2library->item(1)) || library->size()==0)                          if(!(library=protocol2driver_and_client->item(1)) || library->size()==0)
                                   PTHROW(0, 0,
                                           protocol2driver_and_client->origin_string(),
                                           "driver library column for protocol '%s' is empty", protocol_cstr);
                           if(!(dlopen_file_spec=protocol2driver_and_client->item(2)) || dlopen_file_spec->size()==0)
                                 PTHROW(0, 0,                                  PTHROW(0, 0,
                                         protocol2library->origin_string(),                                          protocol2driver_and_client->origin_string(),
                                         "library column for protocol '%s' is empty", protocol_cstr);                                          "client library column for protocol '%s' is empty", protocol_cstr);
                 } else                  } else
                         PTHROW(0, 0,                          PTHROW(0, 0,
                                 &url,                                  &url,
Line 95  SQL_Connection& SQL_Driver_manager::get_ Line 128  SQL_Connection& SQL_Driver_manager::get_
   
                 // validate driver api version                  // validate driver api version
                 int driver_api_version=driver->api_version();                  int driver_api_version=driver->api_version();
                 if(driver_api_version<SQL_API_VERSION)                  if(driver_api_version!=SQL_DRIVER_API_VERSION)
                           PTHROW(0, 0,
                                   library,
                                   "driver implements API version 0x%04X not equal to 0x%04X",
                                           driver_api_version, SQL_DRIVER_API_VERSION);
   
                   // initialise by connecting to sql client dynamic link library
                   const char *dlopen_file_spec_cstr=dlopen_file_spec->cstr(String::UL_FILE_NAME);
                   if(const char *error=driver->initialize(
                           dlopen_file_spec_cstr))
                         PTHROW(0, 0,                          PTHROW(0, 0,
                                 library,                                  library,
                                 "driver API version is 0x%04X while current minimum is 0x%04X",                                  "driver failed to initialize client library '%s', %s",
                                         driver_api_version, SQL_API_VERSION);                                          dlopen_file_spec_cstr, error);
   
                 // cache it                  // cache it
                 put_driver_to_cache(protocol, *driver);                  put_driver_to_cache(protocol, *driver);
         }          }
                   
         return *new(this->pool()) SQL_Connection(url.pool(), //< associate with request          // services associated with request
                 *driver, url_cstr, url);          Services_for_SQL_driver_impl& services=
                   *new(pool) Services_for_SQL_driver_impl(pool, url);
   
           // allocate in global pool 
           // associate with services[request], deassociates at close
           SQL_Connection& result=
                   *new(this->pool()) SQL_Connection(this->pool(), 
                   url, *driver, services, url_cstr);
           
           return result;
 }  }
   
 void SQL_Driver_manager::close_connection(const String& url,   void SQL_Driver_manager::close_connection(const String& url, 
                                                                                   SQL_Connection& connection) {                                                                                    SQL_Connection& connection) {
         SYNCHRONIZED(true);          SYNCHRONIZED(true);
   
         connection.set_pool(0); // deassociate from request  
         put_connection_to_cache(url, connection);          put_connection_to_cache(url, connection);
 }  }
   
Removed from v.1.2  
changed lines
  Added in v.1.6.2.1

E-mail: