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.1 and 1.5

version 1.1, 2001/04/04 10:53:57	version 1.5, 2001/04/05 11:50:09
Line 11	Line 11
#include "pa_config_includes.h"	#include "pa_config_includes.h"
#include "ltdl.h"	#include "ltdl.h"
#include "pa_sql_driver_manager.h"	#include "pa_sql_driver_manager.h"
	#include "pa_sql_connection.h"
#include "pa_exception.h"	#include "pa_exception.h"
#include "pa_common.h"	#include "pa_common.h"

Line 23 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
Line 40 SQL_Connection& SQL_Driver_manager::get_	Line 66 SQL_Connection& SQL_Driver_manager::get_

// 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 66 SQL_Connection& SQL_Driver_manager::get_	Line 95 SQL_Connection& SQL_Driver_manager::get_
// no cached	// no cached
const String *library=0;	const String *library=0;
if(protocol2library->locate(0, protocol)) {	if(protocol2library->locate(0, protocol)) {
if(!(library=protocol2library->item(1)))	if(!(library=protocol2library->item(1)) \|\| library->size()==0)
PTHROW(0, 0,	PTHROW(0, 0,
protocol2library->origin_string(),	protocol2library->origin_string(),
"library column for protocol '%s' is empty", protocol_cstr);	"library column for protocol '%s' is empty", protocol_cstr);
} else	} else
PTHROW(0, 0,	PTHROW(0, 0,
protocol2library->origin_string(),	&url,
"protocol '%s' not found", 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);
lt_dlhandle handle = lt_dlopen(filename);	lt_dlhandle handle=lt_dlopen(filename);
if (!handle)	if (!handle)
PTHROW(0, 0,	PTHROW(0, 0,
library,	library,
Line 89 SQL_Connection& SQL_Driver_manager::get_	Line 118 SQL_Connection& SQL_Driver_manager::get_
library,	library,
"function '%s' was not found", LIBRARY_CREATE_FUNC_NAME);	"function '%s' was not found", LIBRARY_CREATE_FUNC_NAME);

// create library-driver	// create library-driver!
driver=(*create)();	driver=(*create)();

// 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,	PTHROW(0, 0,
library,	library,
"driver API version is 0x%04X while current minimum is 0x%04X",	"driver API version is 0x%04X while current minimum is 0x%04X",
driver_api_version, SQL_API_VERSION);	driver_api_version, SQL_DRIVER_API_VERSION);

// cache it	// cache it
put_driver_to_cache(protocol, *driver);	put_driver_to_cache(protocol, *driver);
}	}

void *info;	// services associated with request
char *error;	Services_for_SQL_driver_impl& services=
if(!driver->connect(url_cstr, &info, &error))	*new(pool) Services_for_SQL_driver_impl(pool, url);
PTHROW(0, 0,
&url,	// allocate in global pool
"can not connect - %s", error);	// associate with services[request], deassociates at close
	SQL_Connection& result=
return *new(this->pool()) SQL_Connection(url.pool(), //< associate with request	new(this->pool()) SQL_Connection(this->pool(), url, driver, services, url_cstr);
*driver, info, url);
	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);
}	}

Line 148 SQL_Connection *SQL_Driver_manager::get_	Line 177 SQL_Connection *SQL_Driver_manager::get_
return 0;	return 0;
}	}

	/// @todo cache expiration[use SQL_Driver::disconnect], pinging.
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;

E-mail:

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