sql/pgsql/parser3pgsql.C - diff

Return to parser3pgsql.C CVS log

Up to [parser3project] / sql / pgsql

Diff for /sql/pgsql/parser3pgsql.C between versions 1.35 and 1.51

version 1.35, 2010/10/27 22:48:51	version 1.51, 2021/11/08 08:57:16
Line 1	Line 1
/** @file	/** @file
Parser PgSQL driver.	Parser PgSQL driver.

Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2019 Art. Lebedev Studio (http://www.artlebedev.com)

Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

2007.10.25 using PgSQL 8.1.5	2007.10.25 using PgSQL 8.1.5
*/	*/
static const char *RCSId="$Id$";

#include "config_includes.h"	#include "config_includes.h"

Line 16 static const char *RCSId="$Id$";	Line 15 static const char *RCSId="$Id$";
#include <libpq-fe.h>	#include <libpq-fe.h>
#include <libpq/libpq-fs.h>	#include <libpq/libpq-fs.h>

	volatile const char * IDENT_PARSER3PGSQL_C="$Id$" IDENT_PA_SQL_DRIVER_H;

// from catalog/pg_type.h	// from catalog/pg_type.h
#define BOOLOID 16	#define BOOLOID 16
#define INT8OID 20	#define INT8OID 20
Line 77 static char* rsplit(char* string, char d	Line 78 static char* rsplit(char* string, char d
return v+1;	return v+1;
}	}
}	}
return NULL;	return NULL;
}	}

static void toupper_str(char out, const char in, size_t size){	static void toupper_str(char out, const char in, size_t size){
Line 85 static void toupper_str(char *out, const	Line 86 static void toupper_str(char *out, const
out++=(char)toupper(in++);	out++=(char)toupper(in++);
}	}

	inline static const char* strdup(SQL_Driver_services& services, char* str, size_t length) {
	char strm=(char)services.malloc_atomic(length+1);
	memcpy(strm, str, length);
	strm[length]=0;
	return (const char*)strm;
	}

struct Connection {	struct Connection {
SQL_Driver_services* services;	SQL_Driver_services* services;

PGconn *conn;	PGconn *conn;
const char* client_charset;	const char* client_charset;
bool autocommit;	bool autocommit;
bool without_default_transactions;	bool standard_conforming_strings;
};	};

/**	/**
Line 108 public:	Line 116 public:

/// initialize driver by loading sql dynamic link library	/// initialize driver by loading sql dynamic link library
const char initialize(char dlopen_file_spec){	const char initialize(char dlopen_file_spec){
return dlopen_file_spec?	return dlopen_file_spec ? dlink(dlopen_file_spec) : "client library column is empty";
dlink(dlopen_file_spec):"client library column is empty";
}	}

#define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))	#define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))
#define PQclear_throw(msg) { \	#define PQclear_throw(msg) { \
PQclear(res); \	PQclear(res); \
connection.services->_throw(msg); \	connection.services->_throw(msg); \
}	}
#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))	#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))

/** connect	/** connect
Line 125 public:	Line 132 public:
ClientCharset=charset& // transcode by parser	ClientCharset=charset& // transcode by parser
charset=value& // transcode by server with 'SET CLIENT_ENCODING=value'	charset=value& // transcode by server with 'SET CLIENT_ENCODING=value'
datestyle=value& // 'SET DATESTYLE=value' available values are: ISO\|SQL\|Postgres\|European\|US\|German [default=ISO]	datestyle=value& // 'SET DATESTYLE=value' available values are: ISO\|SQL\|Postgres\|European\|US\|German [default=ISO]
autocommit=1& // each transaction is commited automatically (default)	autocommit=0& // 1 -- each statement is commited automatically, only when with_default_transaction enabled
WithoutDefaultTransaction=0 // 1 -- disable any BEGIN TRAN/COMMIT/ROLLBACK [can NOT be used with autocommit option]	standard_conforming_strings=1& // 0 -- escape \ char that could be needed for old servers
*/	*/
void connect(	void connect(char* url, SQL_Driver_services& services, void** connection_ref /* < output: Connection* */){
char* url,
SQL_Driver_services& services,
void** connection_ref ///< output: Connection*
){
char* user=url;	char* user=url;
char* host=rsplit(user, '@');	char* host=rsplit(user, '@');
char* db=lsplit(host, '/');	char* db=lsplit(host, '/');
char* pwd=lsplit(user, ':');	char* pwd=lsplit(user, ':');
char* port=lsplit(host, ':');

char *options=lsplit(db, '?');	char *options=lsplit(db, '?');

char* charset=0;	char* charset=0;
char* datestyle=0;	char* datestyle=0;

	char* pq_options=0;
	size_t pq_options_len=options ? strlen(options) : 0;

Connection& connection=(Connection )services.malloc(sizeof(Connection));	Connection& connection=(Connection )services.malloc(sizeof(Connection));

*connection_ref=&connection;	*connection_ref=&connection;
connection.services=&services;	connection.services=&services;
connection.client_charset=0;	connection.client_charset=0;
connection.autocommit=true;	connection.autocommit=true;
connection.without_default_transactions=false;	connection.standard_conforming_strings=true;

connection.conn=PQsetdbLogin(
(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,
NULL, NULL, db, user, pwd);

if(!connection.conn)
services._throw("PQsetdbLogin failed");

if(PQstatus(connection.conn)!=CONNECTION_OK)
throwPQerror;

while(options){	while(options){
if(char *key=lsplit(&options, '&')){	if(char *key=lsplit(&options, '&')){
if(*key){	if(*key){
if(char *value=lsplit(key, '=')){	if(char *value=lsplit(key, '=')){
if(strcmp(key, "ClientCharset")==0){	if(strcmp(key, "ClientCharset")==0){ // transcoding with parser
toupper_str(value, value, strlen(value));	toupper_str(value, value, strlen(value));
connection.client_charset=value;	connection.client_charset=value;
} else if(strcasecmp(key, "charset")==0){	} else if(strcasecmp(key, "charset")==0){ // transcoding with server
charset=value;	charset=value;
} else if(strcasecmp(key, "datestyle")==0){	} else if(strcasecmp(key, "datestyle")==0){
datestyle=value;	datestyle=value;
} else if(strcasecmp(key, "autocommit")==0){	} else if(strcasecmp(key, "autocommit")==0){
if(connection.without_default_transactions)
services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
if(atoi(value)==0)	if(atoi(value)==0)
connection.autocommit=false;	connection.autocommit=false;
} else if(strcmp(key, "WithoutDefaultTransaction")==0){	} else if(strcasecmp(key, "standard_conforming_strings")==0){
if(!connection.autocommit)	if(atoi(value)==0)
services._throw("options WithoutDefaultTransaction and autocommit can't be used together");	connection.standard_conforming_strings=false;
if(atoi(value)==1){	} else {
connection.without_default_transactions=true;	if(!pq_options) {
connection.autocommit=false;	pq_options=(char*)services.malloc_atomic(pq_options_len+2);
	strcpy(pq_options, "?");
	} else {
	strcat(pq_options, "&");
}	}
} else	strcat(pq_options, key);
services._throw("unknown connect option" /key/);	strcat(pq_options, "=");
	strcat(pq_options, value);
	}
} else	} else
services._throw("connect option without =value" /key/);	services._throw("connect option without =value" /key/);
}	}
}	}
}	}

if(charset){	if(host && (strchr(host, ',') \|\| pq_options)){ // pq_options can exist only if host and db are not null
char statement[MAX_STRING]="SET CLIENT_ENCODING=";	char pq_url[MAX_STRING];
strncat(statement, charset, MAX_STRING);	snprintf(pq_url, MAX_STRING, "postgresql://%s/%s%s", host, db ? db : "", pq_options ? pq_options : "");
	connection.conn=PQsetdbLogin(NULL, NULL, NULL, NULL, pq_url, user, pwd);
	} else {
	char* port=lsplit(host, ':');
	connection.conn=PQsetdbLogin( (host && strcasecmp(host, "local") == 0) ? NULL /* local Unix domain socket */ : host, port, NULL, NULL, db, user, pwd);
	}

	if(!connection.conn)
	services._throw("PQsetdbLogin failed");

	if(PQstatus(connection.conn)!=CONNECTION_OK)
	throwPQerror;

	if(charset){
	char statement[MAX_STRING];
	snprintf(statement, MAX_STRING, "SET CLIENT_ENCODING=%s", charset);
_execute_cmd(connection, statement);	_execute_cmd(connection, statement);
}	}

if(datestyle){	if(datestyle){
char statement[MAX_STRING]="SET DATESTYLE=";	char statement[MAX_STRING];
strncat(statement, datestyle, MAX_STRING);	snprintf(statement, MAX_STRING, "SET DATESTYLE=%s", datestyle);

_execute_cmd(connection, statement);	_execute_cmd(connection, statement);
}	}

_transaction_begin(connection);	if(!connection.autocommit)
	_execute_cmd(connection, "BEGIN");
}	}

void disconnect(void *aconnection){	void disconnect(void *aconnection){
Line 217 public:	Line 230 public:

void commit(void *aconnection){	void commit(void *aconnection){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
_transaction_commit(connection);	if(!connection.autocommit)
_transaction_begin(connection);	_execute_cmd(connection, "COMMIT");
}	}

void rollback(void *aconnection){	void rollback(void *aconnection){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
_transaction_rollback(connection);	if(!connection.autocommit)
_transaction_begin(connection);	_execute_cmd(connection, "ROLLBACK");
}	}

bool ping(void *aconnection) {	bool ping(void *aconnection) {
Line 234 public:	Line 247 public:

// charset here is services.request_charset(), not connection.client_charset	// charset here is services.request_charset(), not connection.client_charset
// thus we can't use the sql server quoting support	// thus we can't use the sql server quoting support
const char* quote(void aconnection, const char str, unsigned int length)	const char* quote(void aconnection, const char str, unsigned int length){
{	Connection& connection=static_cast<Connection>(aconnection);

const char* from;	const char* from;
const char* from_end=str+length;	const char* from_end=str+length;

size_t quoted=0;	size_t quoted=0;

for(from=str; from<from_end; from++){	if(connection.standard_conforming_strings){
switch (*from) {	for(from=str; from<from_end; from++){
case '\'':	if(*from=='\'')
case '\\':	quoted++;
quoted++;	}
	} else {
	for(from=str; from<from_end; from++){
	switch (*from) {
	case '\'':
	case '\\':
	quoted++;
	}
}	}
}	}

if(!quoted)	if(!quoted)
return str;	return str;

Connection& connection=static_cast<Connection>(aconnection);
char result=(char)connection.services->malloc_atomic(length + quoted + 1);	char result=(char)connection.services->malloc_atomic(length + quoted + 1);
char *to = result;	char *to = result;

for(from=str; from<from_end; from++){	if(connection.standard_conforming_strings){
switch (*from) {	for(from=str; from<from_end; from++){
case '\'': // "'" -> "''"	if(*from=='\'')
*to++='\'';	*to++= '\''; // "'" -> "''"
break;	to++=from;
case '\\': // "\" -> "\\"	}
*to++='\\';	} else {
break;	for(from=str; from<from_end; from++){
	switch (*from) {
	case '\'': // "'" -> "''"
	*to++= '\'';
	break;
	case '\\': // "\" -> "\\"
	*to++='\\';
	break;
	}
	to++=from;
}	}
to++=from;
}	}

*to=0;	*to=0;
return result;	return result;
}	}

void query(void *aconnection,	void query(void aconnection, const char astatement, size_t placeholders_count, Placeholder* placeholders, unsigned long offset, unsigned long limit, SQL_Driver_query_event_handlers& handlers ){
const char *astatement,
size_t placeholders_count, Placeholder* placeholders,
unsigned long offset, unsigned long limit,
SQL_Driver_query_event_handlers& handlers
){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
SQL_Driver_services& services=*connection.services;	SQL_Driver_services& services=*connection.services;
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;
Line 293 public:	Line 316 public:
_bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);	_bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
}	}

	size_t statement_size=0;
if(transcode_needed){	if(transcode_needed){
// transcode query from $request:charset to ?ClientCharset	// transcode query from $request:charset to ?ClientCharset
size_t length=strlen(astatement);	statement_size=strlen(astatement);
services.transcode(astatement, length,	services.transcode(astatement, statement_size, astatement, statement_size, request_charset, client_charset);
astatement, length,
request_charset,
client_charset);
}	}

const char *statement=_preprocess_statement(connection, astatement, offset, limit);	const char *statement=_preprocess_statement(connection, astatement, statement_size, offset, limit);
// error after prepare?	// error after prepare?

PGresult *res;	PGresult *res;
Line 318 public:	Line 339 public:
SQL_Error sql_error;	SQL_Error sql_error;

switch(PQresultStatus(res)) {	switch(PQresultStatus(res)) {
case PGRES_EMPTY_QUERY:	case PGRES_EMPTY_QUERY:
PQclear_throw("no query");	PQclear_throw("no query");
break;	break;
case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...	case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...
PQclear(res);	PQclear(res);
if(connection.autocommit)
commit(aconnection);
return;	return;
case PGRES_TUPLES_OK:	case PGRES_TUPLES_OK:
break;	break;
default:	default:
PQclear_throwPQerror;	PQclear_throwPQerror;
break;	break;
Line 339 public:	Line 358 public:
goto cleanup; \	goto cleanup; \
}	}

int column_count=PQnfields(res);	size_t column_count=PQnfields(res);
if(!column_count)	if(!column_count)
PQclear_throw("result contains no columns");	PQclear_throw("result contains no columns");

Line 347 public:	Line 366 public:
column_count=MAX_COLS;	column_count=MAX_COLS;

unsigned int column_types[MAX_COLS];	unsigned int column_types[MAX_COLS];
bool transcode_column[MAX_COLS];

for(int i=0; i<column_count; i++){	for(size_t i=0; i<column_count; i++){
column_types[i]=PQftype(res, i);	column_types[i]=PQftype(res, i);
switch(column_types[i]){
case BOOLOID:
case INT8OID:
case INT2OID:
case INT4OID:
case FLOAT4OID:
case FLOAT8OID:
case DATEOID:
case TIMEOID:
case TIMESTAMPOID:
case TIMESTAMPTZOID:
case TIMETZOID:
case NUMERICOID:
transcode_column[i]=false;
break;
default:
transcode_column[i]=transcode_needed;
break;
}
char *name=PQfname(res, i);	char *name=PQfname(res, i);
size_t length=strlen(name);	size_t length=strlen(name);
char* strm=(char*)services.malloc(length+1);	const char* str=strdup(services, name, length);
memcpy(strm, name, length+1);
const char* str=strm;	if(transcode_needed)
	// transcode column name from ?ClientCharset to $request:charset
if(transcode_needed) // transcode column name from ?ClientCharset to $request:charset	services.transcode(str, length, str, length, client_charset, request_charset);
services.transcode(str, length,
str, length,
client_charset,
request_charset);

CHECK(handlers.add_column(sql_error, str, length));	CHECK(handlers.add_column(sql_error, str, length));
}	}
Line 390 public:	Line 386 public:
if(unsigned long row_count=(unsigned long)PQntuples(res))	if(unsigned long row_count=(unsigned long)PQntuples(res))
for(unsigned long r=0; r<row_count; r++) {	for(unsigned long r=0; r<row_count; r++) {
CHECK(handlers.add_row(sql_error));	CHECK(handlers.add_row(sql_error));
for(int i=0; i<column_count; i++){	for(size_t i=0; i<column_count; i++){
const char *cell=PQgetvalue(res, r, i);	char *cell=PQgetvalue(res, r, i);
size_t length;
	size_t length=0;
const char* str;	const char* str;

switch(column_types[i]){	switch(column_types[i]){
	case BOOLOID:
	case INT8OID:
	case INT2OID:
	case INT4OID:
	case FLOAT4OID:
	case FLOAT8OID:
	case DATEOID:
	case TIMEOID:
	case TIMESTAMPOID:
	case TIMESTAMPTZOID:
	case TIMETZOID:
	case NUMERICOID:
	length=(size_t)PQgetlength(res, r, i);
	str=length ? strdup(services, cell, length) : 0;
	// transcode is never required for these types
	break;
case OIDOID:	case OIDOID:
{	{
char *error_pos=0;
Oid oid=cell?atoi(cell):0;	Oid oid=cell?atoi(cell):0;
int fd=lo_open(conn, oid, INV_READ);	int fd=lo_open(conn, oid, INV_READ);
if(fd>=0){	if(fd>=0){
Line 420 public:	Line 432 public:
PQclear_throw("lo_read can not read all bytes of object");	PQclear_throw("lo_read can not read all bytes of object");
strm[length]=0;	strm[length]=0;
str=strm;	str=strm;
	if(transcode_needed) {
	// transcode cell value from ?ClientCharset to $request:charset
	services.transcode(str, length,
	str, length,
	client_charset,
	request_charset);
	}
} else	} else
str=0;	str=0;
if(lo_close(conn, fd)<0)	if(lo_close(conn, fd)<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
} else	} else
PQclear_throwPQerror;	PQclear_throwPQerror;
	break;
}	}
default:	default:
// normal column, read it normally	// normal column, read it normally
length=(size_t)PQgetlength(res, r, i);	length=(size_t)PQgetlength(res, r, i);
if(length){	str=length ? strdup(services, cell, length) : 0;
char* strm=(char*)services.malloc(length+1);	if(transcode_needed) {
memcpy(strm, cell, length+1);	// transcode cell value from ?ClientCharset to $request:charset
str=strm;	services.transcode(str, length,
} else	str, length,
str=0;	client_charset,
}	request_charset);
	}
if(str && length && transcode_column[i]){	break;
// transcode cell value from ?ClientCharset to $request:charset
services.transcode(str, length,
str, length,
client_charset,
request_charset);
}	}

CHECK(handlers.add_row_cell(sql_error, str, length));	CHECK(handlers.add_row_cell(sql_error, str, length));
}	}
}	}
Line 453 cleanup:	Line 467 cleanup:
PQclear(res);	PQclear(res);
if(failed)	if(failed)
services._throw(sql_error);	services._throw(sql_error);

if(connection.autocommit)
commit(aconnection);
}	}

private:	private:
void _bind_parameters(	void _bind_parameters( size_t placeholders_count, Placeholder* placeholders, const char** paramValues, Connection& connection, bool transcode_needed){
size_t placeholders_count,
Placeholder* placeholders,
const char** paramValues,
Connection& connection,
bool transcode_needed
){
for(size_t i=0; i<placeholders_count; i++){	for(size_t i=0; i<placeholders_count; i++){
Placeholder& ph=placeholders[i];	Placeholder& ph=placeholders[i];
if(transcode_needed){	if(transcode_needed){
size_t name_length;	size_t name_length;
connection.services->transcode(ph.name, strlen(ph.name),	connection.services->transcode(ph.name, strlen(ph.name), ph.name, name_length, connection.services->request_charset(), connection.client_charset);
ph.name, name_length,
connection.services->request_charset(),
connection.client_charset);

if(ph.value) {	if(ph.value) {
size_t value_length;	size_t value_length;
connection.services->transcode(ph.value, strlen(ph.value),	connection.services->transcode(ph.value, strlen(ph.value), ph.value, value_length, connection.services->request_charset(), connection.client_charset);
ph.value, value_length,
connection.services->request_charset(),
connection.client_charset);
}	}
}	}
int name_numner=atoi(ph.name);	int name_number=atoi(ph.name);
if(name_numner <= 0 \|\| (size_t)name_numner > placeholders_count)	if(name_number <= 0 \|\| (size_t)name_number > placeholders_count)
connection.services->_throw("bad bind parameter key");	connection.services->_throw("bad bind parameter key");

paramValues[name_numner-1]=ph.value;	paramValues[name_number-1]=ph.value;
}	}
}	}


void _transaction_begin(Connection& connection){
_execute_transactions_cmd(connection, "BEGIN");
}

void _transaction_commit(Connection& connection){
_execute_transactions_cmd(connection, "COMMIT");
}

void _transaction_rollback(Connection& connection){
_execute_transactions_cmd(connection, "ROLLBACK");
}

void _execute_transactions_cmd(const Connection& connection, const char *query){
if(!connection.without_default_transactions) // with option ?WithoutDefaultTransaction=1 user must execute BEGIN/COMMIT/ROLLBACK by himself
_execute_cmd(connection, query);
}

// executes a query and throw away the result.	// executes a query and throw away the result.
void _execute_cmd(const Connection& connection, const char *query){	void _execute_cmd(const Connection& connection, const char *query){
if(PGresult *res=PQexec(connection.conn, query))	if(PGresult *res=PQexec(connection.conn, query))
Line 517 private:	Line 498 private:
throwPQerror;	throwPQerror;
}	}

const char *_preprocess_statement(	const char _preprocess_statement(Connection& connection, const char astatement, size_t statement_size, unsigned long offset, unsigned long limit){
Connection& connection,
const char *astatement,
unsigned long offset,
unsigned long limit
){
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;

size_t statement_size=strlen(astatement);	if(!statement_size)
	statement_size=strlen(astatement);

char result=(char )connection.services->malloc(statement_size	char result=(char )connection.services->malloc(statement_size
+MAX_NUMBER*2+15 // limit # offset #	+MAX_NUMBER*2+15 // " limit # offset #"
+MAX_STRING // in case of short 'strings'	+MAX_STRING // in case of short 'strings'
+1);	+1);
// offset & limit -> suffixes	// offset & limit -> suffixes
Line 537 private:	Line 514 private:
char *cur=result;	char *cur=result;
memcpy(cur, astatement, statement_size); cur+=statement_size;	memcpy(cur, astatement, statement_size); cur+=statement_size;
if(limit!=SQL_NO_LIMIT)	if(limit!=SQL_NO_LIMIT)
cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);	cur+=snprintf(cur, 7+MAX_NUMBER, " limit %lu", limit);
if(offset)	if(offset)
cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);	cur+=snprintf(cur, 8+MAX_NUMBER, " offset %lu", offset);
o=result;	o=result;
} else	} else
o=astatement;	o=astatement;
Line 549 private:	Line 526 private:
while(*o) {	while(*o) {
if(	if(
o[0]=='/' &&	o[0]=='/' &&
o[1]=='*' &&	o[1]=='*' &&
o[2]=='*') { // name start	o[2]=='*') { // name start
const char* saved_o=o;	const char* saved_o=o;
o+=3;	o+=3;
while(*o)	while(*o)
if(	if(o[0]=='' && o[1]=='' && o[2]=='/' && o[3]=='\'') { // name end
o[0]=='*' &&
o[1]=='*' &&
o[2]=='/' &&
o[3]=='\'') { // name end
saved_o=0; // found, marking that	saved_o=0; // found, marking that
o+=4;	o+=4;
Oid oid=lo_creat(conn, INV_READ\|INV_WRITE);	Oid oid=lo_creat(conn, INV_READ\|INV_WRITE);
Line 679 private: // conn client library funcs	Line 652 private: // conn client library funcs

private: // conn client library funcs linking	private: // conn client library funcs linking

const char dlink(const char dlopen_file_spec) {	const char dlink(char dlopen_file_spec) {
if(lt_dlinit())	if(lt_dlinit()){
return lt_dlerror();	if(const char* result=lt_dlerror())
lt_dlhandle handle=lt_dlopen(dlopen_file_spec);	return result;
if(!handle)	return "can not prepare to dynamic loading";
	}

	lt_dlhandle handle;
	do {
	char *next=lsplit(dlopen_file_spec, ',');
	handle=lt_dlopen(dlopen_file_spec);
	dlopen_file_spec=next;
	} while (!handle && dlopen_file_spec);

	if(!handle){
	if(const char* result=lt_dlerror())
	return result;
return "can not open the dynamic link module";	return "can not open the dynamic link module";
	}

#define DSLINK(name, action) \	#define DSLINK(name, action) \
name=(t_##name)lt_dlsym(handle, #name); \	name=(t_##name)lt_dlsym(handle, #name); \
Line 692 private: // conn client library funcs li	Line 678 private: // conn client library funcs li
action;	action;

#define DLINK(name) DSLINK(name, return "function " #name " was not found")	#define DLINK(name) DSLINK(name, return "function " #name " was not found")

DLINK(PQsetdbLogin);	DLINK(PQsetdbLogin);
DLINK(PQerrorMessage);	DLINK(PQerrorMessage);
DLINK(PQstatus);	DLINK(PQstatus);
Line 708 private: // conn client library funcs li	Line 694 private: // conn client library funcs li
DLINK(PQexecParams);	DLINK(PQexecParams);
DLINK(PQftype);	DLINK(PQftype);
DLINK(PQescapeStringConn);	DLINK(PQescapeStringConn);
DLINK(lo_open); DLINK(lo_close);	DLINK(lo_open); DLINK(lo_close);
DLINK(lo_read); DLINK(lo_write);	DLINK(lo_read); DLINK(lo_write);
DLINK(lo_lseek); DLINK(lo_creat);	DLINK(lo_lseek); DLINK(lo_creat);
DLINK(lo_tell); DLINK(lo_unlink);	DLINK(lo_tell); DLINK(lo_unlink);
DLINK(lo_import); DLINK(lo_export);	DLINK(lo_import); DLINK(lo_export);

return 0;	return 0;
}	}

E-mail:

Removed from v.1.35
changed lines
	Added in v.1.51