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.25 and 1.29

version 1.25, 2004/12/23 16:54:52	version 1.29, 2008/06/24 17:43:48
Line 5	Line 5

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

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

Line 22 static const char *RCSId="$Id$";	Line 22 static const char *RCSId="$Id$";
// actually writing chunks of that size failed, reduced it twice	// actually writing chunks of that size failed, reduced it twice
#define LO_BUFSIZE 0x1000	#define LO_BUFSIZE 0x1000
// from postgres_ext.h	// from postgres_ext.h
#define InvalidOid ((Oid) 0)	//#define InvalidOid ((Oid) 0)


#include "ltdl.h"	#include "ltdl.h"
Line 41 inline int min(int a,int b){ return a<b?	Line 41 inline int min(int a,int b){ return a<b?
#endif	#endif

static char lsplit(char string, char delim) {	static char lsplit(char string, char delim) {
if(string) {	if(string) {
char *v=strchr(string, delim);	char *v=strchr(string, delim);
if(v) {	if(v) {
*v=0;	*v=0;
return v+1;	return v+1;
}	}
}	}
return 0;	return 0;
}	}

static char lsplit(char *string_ref, char delim) {	static char lsplit(char *string_ref, char delim) {
char result=string_ref;	char result=string_ref;
char next=lsplit(string_ref, delim);	char next=lsplit(string_ref, delim);
*string_ref=next;	*string_ref=next;
return result;	return result;
}	}

static char* rsplit(char* string, char delim) {	static char* rsplit(char* string, char delim) {
if(string) {	if(string) {
char* v=strrchr(string, delim);	char* v=strrchr(string, delim);
if(v) {	if(v) {
*v=0;	*v=0;
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 79 struct Connection {	Line 79 struct Connection {

PGconn *conn;	PGconn *conn;
const char* cstrClientCharset;	const char* cstrClientCharset;
	bool autocommit;
};	};

/**	/**
Line 92 public:	Line 93 public:

/// get api version	/// get api version
int api_version() { return SQL_DRIVER_API_VERSION; }	int api_version() { return SQL_DRIVER_API_VERSION; }

/// 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?
Line 107 public:	Line 109 public:

/** connect	/** connect
@param url	@param url
format: @b user:pass@host[:port]\|[local]/database	format: @b user:pass@host[:port]\|[local]/database?
	ClientCharset=xyz& // transcode by parser
	charset=xyz& // transcode by server with 'set CLIENT_ENCODING=xyz'
	datestyle=xyz& // set DATESTYLE=xyz
	autocommit=1&
	WithoutDefaultTransaction=1 // == autocommit=0
*/	*/
void connect(	void connect(
char *url,	char *url,
Line 123 public:	Line 130 public:
char *options=lsplit(db, '?');	char *options=lsplit(db, '?');

char *cstrBackwardCompAskServerToTranscode=0;	char *cstrBackwardCompAskServerToTranscode=0;
	char* datestyle=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.cstrClientCharset=0;	connection.cstrClientCharset=0;
	connection.autocommit=true;
connection.conn=PQsetdbLogin(	connection.conn=PQsetdbLogin(
(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,	(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,
NULL, NULL, db, user, pwd);	NULL, NULL, db, user, pwd);

if(!connection.conn)	if(!connection.conn)
services._throw("PQsetdbLogin failed");	services._throw("PQsetdbLogin failed");
if(PQstatus(connection.conn)!=CONNECTION_OK)
	if(PQstatus(connection.conn)!=CONNECTION_OK)
throwPQerror;	throwPQerror;

char *charset=0;	while(options){
char *datestyle=0;	if(char *key=lsplit(&options, '&')){
isDefaultTransaction = true;	if(*key){
	if(char *value=lsplit(key, '=')){
while(options) {	if(strcmp(key, "ClientCharset")==0) { // transcoding with parser
if(char *key=lsplit(&options, '&')) {
if(*key) {
if(char *value=lsplit(key, '=')) {
if(strcmp(key, "ClientCharset" ) == 0) {
toupper_str(value, value, strlen(value));	toupper_str(value, value, strlen(value));
connection.cstrClientCharset=value;	connection.cstrClientCharset=value;
} else if(strcasecmp(key, "charset")==0) { // left for backward compatibility, consider using ClientCharset	} else if(strcasecmp(key, "charset")==0){ // transcoding with server
cstrBackwardCompAskServerToTranscode=value;	cstrBackwardCompAskServerToTranscode=value;
} else if(strcasecmp(key, "datestyle")==0) {	} else if(strcasecmp(key, "datestyle")==0) {
datestyle=value;	datestyle=value;
} else if(strcmp(key, "WithoutDefaultTransaction")==0) {	} else if(strcasecmp(key, "autocommit")==0){
isDefaultTransaction = false;	if(atoi(value)==0)
	connection.autocommit=false;
	} else if(strcmp(key, "WithoutDefaultTransaction")==0){ // backward, use autocommit=0
	if(atoi(value)==1)
	connection.autocommit=false;
} else	} else
services._throw("unknown connect option" /key/);	services._throw("unknown connect option" /key/);
} else	} else
Line 161 public:	Line 172 public:
}	}
}	}

if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)	if(cstrBackwardCompAskServerToTranscode){
services._throw("use 'ClientCharset' option only, "	char statement[MAX_STRING]="set CLIENT_ENCODING=";
"'charset' option is obsolete and should not be used with new 'ClientCharset' option");

if(cstrBackwardCompAskServerToTranscode) {
// set CLIENT_ENCODING
char statement[MAX_STRING]="set CLIENT_ENCODING="; // win
strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);	strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);

PGresult *res=PQexec(connection.conn, statement);	execute_resultless(connection, statement);
if(!res)
throwPQerror;
PQclear(res); // throw out the result [don't need but must call]
}	}

if(datestyle) {	if(datestyle){
// set DATESTYLE
char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO	char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO
strncat(statement, charset, MAX_STRING);	strncat(statement, datestyle, MAX_STRING);

PGresult *res=PQexec(connection.conn, statement);	execute_resultless(connection, statement);
if(!res)
throwPQerror;
PQclear(res); // throw out the result [don't need but must call]
}	}

begin_transaction(connection);	begin_transaction(connection);
}	}

void disconnect(void *aconnection) {	void disconnect(void *aconnection) {
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);

PQfinish(connection.conn);	PQfinish(connection.conn);
connection.conn=0;	connection.conn=0;
}	}
void commit(void *aconnection) {
if(isDefaultTransaction)
{
Connection& connection=static_cast<Connection>(aconnection);

if(PGresult *res=PQexec(connection.conn, "COMMIT"))	void commit(void *aconnection) {
PQclear(res);	execute_transaction_cmd(aconnection, "COMMIT");
else
throwPQerror;
begin_transaction(connection);
}
}	}
void rollback(void *aconnection) {
if(isDefaultTransaction)
{
Connection& connection=static_cast<Connection>(aconnection);

if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))	void rollback(void *aconnection) {
PQclear(res);	execute_transaction_cmd(aconnection, "ROLLBACK");
else
throwPQerror;
begin_transaction(connection);
}
}	}

bool ping(void *aconnection) {	bool ping(void *aconnection) {
Line 232 public:	Line 216 public:
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);

char result=(char)connection.services->malloc_atomic(length*2+1);	char result=(char)connection.services->malloc_atomic(length*2+1);
char *to=result;	int err=0;
while(length--) {	PQescapeStringConn (connection.conn,
switch(*from) {	result, from, length,
case '\'': // "'" -> "''"	&err);
*to++='\'';
break;
case '\\': // "\" -> "\\"
*to++='\\';
break;
}
to++=from++;
}
*to=0;
return result;	return result;
}	}

void query(void *aconnection,	void query(void *aconnection,
const char *astatement,	const char *astatement,
size_t placeholders_count, Placeholder* placeholders,	size_t placeholders_count, Placeholder* placeholders,
Line 258 public:	Line 234 public:
SQL_Driver_services& services=*connection.services;	SQL_Driver_services& services=*connection.services;
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;

if(placeholders_count>0)	const char** paramValues;
services._throw("bind variables not supported (yet)");	if(placeholders_count>0){
	//services._throw("bind variables not supported (yet)");
	int binds_size=sizeof(char) * placeholders_count;
	paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));
	bind_parameters(placeholders_count, placeholders, paramValues, connection);
	}

// transcode from $request:charset to connect-string?client_charset	// transcode from $request:charset to ?ClientCharset
if(cstrClientCharset) {	if(cstrClientCharset) {
size_t transcoded_statement_size;	size_t transcoded_statement_size;
services.transcode(astatement, strlen(astatement),	services.transcode(astatement, strlen(astatement),
Line 273 public:	Line 254 public:
const char *statement=preprocess_statement(connection,	const char *statement=preprocess_statement(connection,
astatement, offset, limit);	astatement, offset, limit);

PGresult *res=PQexec(conn, statement);	PGresult *res;
	if(placeholders_count>0){
	res=PQexecParams(conn, statement, placeholders_count, NULL, paramValues, NULL, NULL, 0);
	} else {
	res=PQexec(conn, statement);
	}
if(!res)	if(!res)
throwPQerror;	throwPQerror;

Line 311 public:	Line 297 public:
memcpy(strm, name, length+1);	memcpy(strm, name, length+1);
const char* str=strm;	const char* str=strm;

// transcode to $request:charset from connect-string?client_charset	// transcode from ?ClientCharset to $request:charset
if(cstrClientCharset)	if(cstrClientCharset)
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
Line 373 public:	Line 359 public:
}	}

if(str && length) {	if(str && length) {
// transcode to $request:charset from connect-string?client_charset	// transcode from ?ClientCharset to $request:charset
if(cstrClientCharset)	if(cstrClientCharset)
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
Line 392 cleanup:	Line 378 cleanup:

private: // private funcs	private: // private funcs

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

	if(ph.value) {
	connection.services->transcode(ph.value, strlen(ph.value),
	ph.value, value_length,
	connection.services->request_charset(),
	connection.cstrClientCharset);
	}
	}
	if( atoi(ph.name) <= 0 \|\| atoi(ph.name) > placeholders_count) {
	connection.services->_throw("bad bind parameter key");
	}
	paramValues[atoi(ph.name)-1] = ph.value;
	}
	}


	void execute_transaction_cmd(void aconnection, const char query) {
	Connection& connection=static_cast<Connection>(aconnection);

	if(connection.autocommit){
	Connection& connection=static_cast<Connection>(aconnection);
	execute_resultless(connection, query);
	}

	begin_transaction(connection);
	}

	/**
	Executes a query and throws the result.
	*/
	void execute_resultless(const Connection& connection, const char *query) {
	if(PGresult *res=PQexec(connection.conn, query))
	PQclear(res); // throw out the result [don't need but must call]
	else
	throwPQerror;
	}

void begin_transaction(Connection& connection) {	void begin_transaction(Connection& connection) {
if(isDefaultTransaction)	if(connection.autocommit){
{	execute_resultless(connection, "BEGIN");
if(PGresult *res=PQexec(connection.conn, "BEGIN"))
PQclear(res);
else
throwPQerror;
}	}
}	}

Line 487 private: // private funcs	Line 521 private: // private funcs
private: // lo_read/write exchancements	private: // lo_read/write exchancements

bool lo_read_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {	bool lo_read_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {
int size_read;	return lo_rw_method (conn, fd, buf, len, lo_read);
while(len && (size_read=lo_read(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
buf+=size_read;
len-=size_read;
}
return len==0;
}	}

bool lo_write_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {	bool lo_write_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {
int size_written;	return lo_rw_method (conn, fd, buf, len, lo_write);
while(len && (size_written=lo_write(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {	}
buf+=size_written;
len-=size_written;	bool lo_rw_method(PGconn conn, int fd, const/paf/ char buf, size_t len, int (lo_func)(PGconn conn, int fd, const/paf/ char *buf, size_t len)) {
	int size_op;
	while(len && (size_op=lo_func(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
	buf+=size_op;
	len-=size_op;
}	}
return len==0;	return len==0;
}	}
Line 518 private: // conn client library funcs	Line 551 private: // conn client library funcs
typedef char (t_PQerrorMessage)(const PGconn* conn); t_PQerrorMessage PQerrorMessage;	typedef char (t_PQerrorMessage)(const PGconn* conn); t_PQerrorMessage PQerrorMessage;
typedef ConnStatusType (t_PQstatus)(const PGconn conn); t_PQstatus PQstatus;	typedef ConnStatusType (t_PQstatus)(const PGconn conn); t_PQstatus PQstatus;
typedef PGresult (t_PQexec)(PGconn *conn,	typedef PGresult (t_PQexec)(PGconn *conn,
const char *query); t_PQexec PQexec;	const char *query); t_PQexec PQexec;
	typedef PGresult (t_PQexecParams)(
	PGconn *conn,
	const char *query,
	int nParams,
	const Oid *paramTypes,
	const char * const *paramValues,
	const int *paramLengths,
	const int *paramFormats,
	int resultFormat); t_PQexecParams PQexecParams;

typedef ExecStatusType (t_PQresultStatus)(const PGresult res); t_PQresultStatus PQresultStatus;	typedef ExecStatusType (t_PQresultStatus)(const PGresult res); t_PQresultStatus PQresultStatus;
typedef int (t_PQgetlength)(const PGresult res,	typedef int (t_PQgetlength)(const PGresult res,
int tup_num,	int tup_num,
int field_num); t_PQgetlength PQgetlength;	int field_num); t_PQgetlength PQgetlength;
typedef char* (t_PQgetvalue)(const PGresult res,	typedef char* (t_PQgetvalue)(const PGresult res,
int tup_num,	int tup_num,
int field_num); t_PQgetvalue PQgetvalue;	int field_num); t_PQgetvalue PQgetvalue;
typedef int (t_PQntuples)(const PGresult res); t_PQntuples PQntuples;	typedef int (t_PQntuples)(const PGresult res); t_PQntuples PQntuples;
typedef char (t_PQfname)(const PGresult *res,	typedef char (t_PQfname)(const PGresult *res,
int field_index); t_PQfname PQfname;	int field_index); t_PQfname PQfname;
Line 534 private: // conn client library funcs	Line 577 private: // conn client library funcs

typedef Oid (t_PQftype)(const PGresult res, int field_num); t_PQftype PQftype;	typedef Oid (t_PQftype)(const PGresult res, int field_num); t_PQftype PQftype;

	typedef size_t (t_PQescapeStringConn)(PGconn conn,
	char to, const char from, size_t length,
	int *error); t_PQescapeStringConn PQescapeStringConn;

typedef int (t_lo_open)(PGconn conn, Oid lobjId, int mode); t_lo_open lo_open;	typedef int (t_lo_open)(PGconn conn, Oid lobjId, int mode); t_lo_open lo_open;
typedef int (t_lo_close)(PGconn conn, int fd); t_lo_close lo_close;	typedef int (t_lo_close)(PGconn conn, int fd); t_lo_close lo_close;
typedef int (t_lo_read)(PGconn conn, int fd, const/paf/ char *buf, size_t len); t_lo_read lo_read;	typedef int (t_lo_read)(PGconn conn, int fd, const/paf/ char *buf, size_t len); t_lo_read lo_read;
Line 550 private: // conn client library funcs li	Line 597 private: // conn client library funcs li
const char dlink(const char dlopen_file_spec) {	const char dlink(const char dlopen_file_spec) {
if(lt_dlinit())	if(lt_dlinit())
return lt_dlerror();	return lt_dlerror();
lt_dlhandle handle=lt_dlopen(dlopen_file_spec);	lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
if(!handle)	if(!handle)
return "can not open the dynamic link module";	return "can not open the dynamic link module";

#define DSLINK(name, action) \	#define DSLINK(name, action) \
Line 573 private: // conn client library funcs li	Line 620 private: // conn client library funcs li
DLINK(PQclear);	DLINK(PQclear);
DLINK(PQresultStatus);	DLINK(PQresultStatus);
DLINK(PQexec);	DLINK(PQexec);
	DLINK(PQexecParams);
DLINK(PQftype);	DLINK(PQftype);
	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);
Line 582 private: // conn client library funcs li	Line 631 private: // conn client library funcs li

return 0;	return 0;
}	}

bool isDefaultTransaction;
};	};

extern "C" SQL_Driver *SQL_DRIVER_CREATE() {	extern "C" SQL_Driver *SQL_DRIVER_CREATE() {

E-mail:

Removed from v.1.25
changed lines
	Added in v.1.29