--- parser3/src/main/pa_sql_driver_manager.C	2001/04/04 11:47:29	1.2
+++ parser3/src/main/pa_sql_driver_manager.C	2001/04/17 19:00:41	1.7
@@ -5,7 +5,7 @@
 
 	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
 
-	$Id: pa_sql_driver_manager.C,v 1.2 2001/04/04 11:47:29 paf Exp $
+	$Id: pa_sql_driver_manager.C,v 1.7 2001/04/17 19:00:41 paf Exp $
 */
 
 #include "pa_config_includes.h"
@@ -24,24 +24,52 @@ SQL_Driver_manager *SQL_driver_manager;
 const int MAX_PROTOCOL=20;
 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:
 //   protocol://user:pass@host:port/database
 //              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this is driver-dependent
 SQL_Connection& SQL_Driver_manager::get_connection(const String& url, 
-												   Table *protocol2library) {
+												   Table *protocol2driver_and_client) {
 	SYNCHRONIZED(true);
 
 	Pool& pool=url.pool(); // request pool											   
 
 	// we have table for locating protocol's library
-	if(!protocol2library)
+	if(!protocol2driver_and_client)
 		PTHROW(0, 0,
 			&url,
-			"SQL:drivers table must be defined");
+			"$SQL:drivers table must be defined");
 
 	// first trying to get cached connection
 	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
 
 	int pos=url.pos("://", 3);
@@ -62,15 +90,20 @@ SQL_Connection& SQL_Driver_manager::get_
 		url_cstr++;
 
 	SQL_Driver *driver;
+	const String *dlopen_file_spec=0;
 	// first trying to get cached driver
 	if(!(driver=get_driver_from_cache(protocol))) {
 		// no cached
 		const String *library=0;
-		if(protocol2library->locate(0, protocol)) {
-			if(!(library=protocol2library->item(1)) || library->size()==0)
+		if(protocol2driver_and_client->locate(0, protocol)) {
+			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,
-					protocol2library->origin_string(),
-					"library column for protocol '%s' is empty", protocol_cstr);
+					protocol2driver_and_client->origin_string(),
+					"client library column for protocol '%s' is empty", protocol_cstr);
 		} else
 			PTHROW(0, 0,
 				&url,
@@ -95,25 +128,42 @@ SQL_Connection& SQL_Driver_manager::get_
 
 		// validate 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,
 				library,
-				"driver API version is 0x%04X while current minimum is 0x%04X",
-					driver_api_version, SQL_API_VERSION);
+				"driver failed to initialize client library '%s', %s",
+					dlopen_file_spec_cstr, error);
 
 		// cache it
 		put_driver_to_cache(protocol, *driver);
 	}
 	
-	return *new(this->pool()) SQL_Connection(url.pool(), //< associate with request
-		*driver, url_cstr, url);
+	// services associated with request
+	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, 
 										  SQL_Connection& connection) {
 	SYNCHRONIZED(true);
 
-	connection.set_pool(0); // deassociate from request
 	put_connection_to_cache(url, connection);
 }