parser3/src/main/pa_sql_driver_manager.C - diff

Return to pa_sql_driver_manager.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_sql_driver_manager.C between versions 1.5 and 1.9

version 1.5, 2001/04/05 11:50:09	version 1.9, 2001/04/26 10:16:07
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))
if(result->ping())	if(result->ping())
return *result;	return *result;
else	else
result->disconnect(); // kill unpingabe=dead connection	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 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 url string on global pool
	String& 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 90 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,
	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 123 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);
}	}

// services associated 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, url);

// allocate in global pool	// allocate in global pool
// associate with services[request], deassociates at close	// 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(),
	url, *driver, services, url_cstr);

return result;	return result;
}	}

E-mail:

Removed from v.1.5
changed lines
	Added in v.1.9