[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.3 and 1.11

version 1.3, 2001/04/05 08:09:24 version 1.11, 2001/05/16 08:10:22
Line 25  const int MAX_PROTOCOL=20; Line 25  const int MAX_PROTOCOL=20;
 const char *LIBRARY_CREATE_FUNC_NAME="create";  const char *LIBRARY_CREATE_FUNC_NAME="create";
   
   
 /// Services_for_SQL_driver implementation  /// SQL_Driver_services Pooled implementation
 class Services_for_SQL_driver_impl : public Services_for_SQL_driver, public Pooled {  class SQL_Driver_services_impl : public SQL_Driver_services, public Pooled {
 public:  public:
         Services_for_SQL_driver_impl(Pool& apool, const String& aurl) : Pooled(apool),          SQL_Driver_services_impl(Pool& apool, const String& aurl) : Pooled(apool),
                 furl(aurl) {                  furl(aurl) {
         }          }
   
Line 52  private: Line 52  private:
 // 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& request_owned_url, 
                                                                                                    Table *protocol2library) {                                                                                                     Table *protocol2driver_and_client) {
         SYNCHRONIZED(true);          SYNCHRONIZED(true);
   
         Pool& pool=url.pool(); // request pool                                                                                               Pool& pool=request_owned_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,                          &request_owned_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(request_owned_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=request_owned_url.pos("://", 3);
         if(pos<0)          if(pos<0)
                 PTHROW(0, 0,                  PTHROW(0, 0,
                         &url,                          &request_owned_url,
                         "no protocol specified"); // NOTE: not THROW, but PTHROW                          "no protocol specified"); // NOTE: not THROW, but PTHROW
   
         // make url string on global pool          // make global_owned_url C-string on global pool
         char *url_cstr=(char *)malloc(MAX_STRING);          char *url_cstr=(char *)malloc(MAX_STRING);
         strncpy(url_cstr, url.cstr(String::UL_AS_IS), MAX_STRING);          strncpy(url_cstr, request_owned_url.cstr(String::UL_AS_IS), MAX_STRING);
           // make global_owned_url string on global pool
           String& global_owned_url=*new(this->pool()) String(this->pool(), url_cstr);
                   
         char *protocol_cstr=lsplit(&url_cstr, ':');          char *protocol_cstr=lsplit(&url_cstr, ':');
         String& protocol=*new(this->pool()) String(this->pool(), protocol_cstr);          String& protocol=*new(this->pool()) String(this->pool(), protocol_cstr);
Line 87  SQL_Connection& SQL_Driver_manager::get_ Line 92  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,                                  PTHROW(0, 0,
                                         protocol2library->origin_string(),                                          protocol2driver_and_client->origin_string(),
                                         "library column for protocol '%s' is empty", protocol_cstr);                                          "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,
                                           protocol2driver_and_client->origin_string(),
                                           "client library column for protocol '%s' is empty", protocol_cstr);
                 } else                  } else
                         PTHROW(0, 0,                          PTHROW(0, 0,
                                 &url,                                  &request_owned_url,
                                 "undefined protocol '%s'", protocol_cstr);                                  "undefined protocol '%s'", protocol_cstr);
   
                 const char *filename=library->cstr(String::UL_FILE_NAME);                  const char *filename=library->cstr(String::UL_FILE_NAME);
Line 120  SQL_Connection& SQL_Driver_manager::get_ Line 130  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_DRIVER_API_VERSION)                  if(driver_api_version!=SQL_DRIVER_API_VERSION)
                         PTHROW(0, 0,                          PTHROW(0, 0,
                                 library,                                  library,
                                 "driver API version is 0x%04X while current minimum is 0x%04X",                                  "driver implements API version 0x%04X not equal to 0x%04X",
                                         driver_api_version, SQL_DRIVER_API_VERSION);                                          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,
                                   library,
                                   "driver failed to initialize client library '%s', %s",
                                           dlopen_file_spec_cstr, error);
   
                 // cache it                  // cache it
                 put_driver_to_cache(protocol, *driver);                  put_driver_to_cache(protocol, *driver);
         }          }
                   
         // associate with request          // services associated with request
         Services_for_SQL_driver_impl& services=          SQL_Driver_services_impl& services=
                 *new(pool) Services_for_SQL_driver_impl(pool, url);                  *new(pool) SQL_Driver_services_impl(pool, request_owned_url);
   
         // allocate in global pool. associate with services[request]          // allocate in global pool 
           // associate with services[request], deassociates at close
         SQL_Connection& result=          SQL_Connection& result=
                 *new(this->pool()) SQL_Connection(this->pool(), url, *driver, services, url_cstr);                  *new(this->pool()) SQL_Connection(this->pool(), 
                   global_owned_url, *driver, services, url_cstr);
                   
         return result;          return result;
 }  }
Line 173  SQL_Connection *SQL_Driver_manager::get_ Line 194  SQL_Connection *SQL_Driver_manager::get_
         return 0;          return 0;
 }  }
   
 /// @todo cache expiration[use SQL_Driver::disconnect], pinging.   /// @todo cache expiration[use SQL_Driver::disconnect]
 void SQL_Driver_manager::put_connection_to_cache(const String& url,   void SQL_Driver_manager::put_connection_to_cache(const String& url, 
                                                                                                  SQL_Connection& connection) {                                                                                                    SQL_Connection& connection) { 
         Stack *connections;          Stack *connections;
Removed from v.1.3  
changed lines
  Added in v.1.11

E-mail: