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.24 and 1.30

version 1.24, 2004/12/23 16:18:21	version 1.30, 2008/06/26 15:49:40
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 36 static const char *RCSId="$Id$";	Line 36 static const char *RCSId="$Id$";
#endif	#endif

#ifndef max	#ifndef max
inline int max(int a,int b) { return a>b?a:b; }	inline int max(int a,int b){ return a>b?a:b; }
inline int min(int a,int b){ return a<b?a:b; }	inline int min(int a,int b){ return a<b?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);	if(char *v=strchr(string, delim)){
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){
	if(string){
	if(char* v=strrchr(string, delim)){
	*v=0;
	return v+1;
	}
	}
	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){
while(size--)	while(size--)
out++=(char)toupper(in++);	out++=(char)toupper(in++);
}	}
Line 67 struct Connection {	Line 76 struct Connection {
SQL_Driver_services* services;	SQL_Driver_services* services;

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

/**	/**
Line 80 public:	Line 90 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?
dlink(dlopen_file_spec):"client library column is empty";	dlink(dlopen_file_spec):"client library column is empty";
}	}
Line 96 public:	Line 107 public:

/** connect	/** connect
@param url	@param url
format: @b user:pass@host[:port]\|[local]/database	format: @b user:pass@host[:port]\|[local]/database?
	ClientCharset=charset& // transcode by parser
	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]
	autocommit=1&
	WithoutDefaultTransaction=1 // == autocommit=0
*/	*/
void connect(	void connect(
char *url,	char* url,
SQL_Driver_services& services,	SQL_Driver_services& services,
void *connection_ref ///< output: Connection	void** connection_ref ///< output: Connection*
) {	){
char *user=url;	char* user=url;
char *host=lsplit(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* port=lsplit(host, ':');

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

char *cstrBackwardCompAskServerToTranscode=0;	char* charset=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.client_charset=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.client_charset=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;	charset=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 150 public:	Line 170 public:
}	}
}	}

if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)	if(charset){
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");	strncat(statement, charset, MAX_STRING);

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

PGresult *res=PQexec(connection.conn, 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=";
char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO	strncat(statement, datestyle, MAX_STRING);
strncat(statement, charset, MAX_STRING);
	_execute_cmd(connection, statement);
PGresult *res=PQexec(connection.conn, 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) {
Connection& connection=static_cast<Connection>(aconnection);

PQfinish(connection.conn);	void disconnect(void *aconnection){
	Connection& connection=static_cast<Connection>(aconnection);
	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);	Connection& connection=static_cast<Connection>(aconnection);
else	if(connection.autocommit){
throwPQerror;	_execute_cmd(connection, "COMMIT");
begin_transaction(connection);
}	}
	_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);	Connection& connection=static_cast<Connection>(aconnection);
else	if(connection.autocommit){
throwPQerror;	_execute_cmd(connection, "ROLLBACK");
begin_transaction(connection);
}	}
	_begin_transaction(connection);
}	}

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

return PQstatus(connection.conn)==CONNECTION_OK;	return PQstatus(connection.conn)==CONNECTION_OK;
}	}

const char* quote(	const char* quote(void aconnection, const char from, unsigned int length){
void *aconnection,
const char *from, unsigned int length) {
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, result, from, length, &err);
switch(*from) {
case '\'': // "'" -> "''"
*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,
unsigned long offset, unsigned long limit,	unsigned long offset, unsigned long limit,
SQL_Driver_query_event_handlers& handlers) {	SQL_Driver_query_event_handlers& handlers
// _asm int 3;	){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
const char* cstrClientCharset=connection.cstrClientCharset;	const char* client_charset=connection.client_charset;
SQL_Driver_services& services=*connection.services;	SQL_Driver_services& services=*connection.services;
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;

if(placeholders_count>0)	bool transcode_needed=_transcode_required(connection);
services._throw("bind variables not supported (yet)");
	const char** paramValues;
	if(placeholders_count>0){
	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_needed);
	}

// transcode from $request:charset to connect-string?client_charset	// transcode query from $request:charset to ?ClientCharset
if(cstrClientCharset) {	if(transcode_needed){
size_t transcoded_statement_size;	size_t length=strlen(astatement);
services.transcode(astatement, strlen(astatement),	services.transcode(astatement, length,
astatement, transcoded_statement_size,	astatement, length,
services.request_charset(),	services.request_charset(),
cstrClientCharset);	connection.client_charset);
}	}

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

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;

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:	case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...
// empty result: insert\|delete\|update\|...	PQclear(res);
PQclear(res);	return;
return;	case PGRES_TUPLES_OK:
case PGRES_TUPLES_OK:	break;
break;	default:
default:	PQclear_throwPQerror;
PQclear_throwPQerror;	break;
break;
}	}

int column_count=PQnfields(res);	int column_count=PQnfields(res);
Line 300 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 column name from ?ClientCharset to $request:charset
if(cstrClientCharset)	if(transcode_needed)
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
cstrClientCharset,	connection.client_charset,
services.request_charset());	services.request_charset());

CHECK(handlers.add_column(sql_error, str, length));	CHECK(handlers.add_column(sql_error, str, length));
Line 361 public:	Line 358 public:
str=0;	str=0;
}	}

if(str && length) {	if(transcode_needed && str && length){
// transcode to $request:charset from connect-string?client_charset	// transcode cell value from ?ClientCharset to $request:charset
if(cstrClientCharset)	services.transcode(str, length,
services.transcode(str, length,	str, length,
str, length,	connection.client_charset,
cstrClientCharset,	services.request_charset());
services.request_charset());
}	}

CHECK(handlers.add_row_cell(sql_error, str, length));	CHECK(handlers.add_row_cell(sql_error, str, length));
Line 379 cleanup:	Line 375 cleanup:
services._throw(sql_error);	services._throw(sql_error);
}	}

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

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

void begin_transaction(Connection& connection) {	paramValues[name_numner-1]=ph.value;
if(isDefaultTransaction)
{
if(PGresult *res=PQexec(connection.conn, "BEGIN"))
PQclear(res);
else
throwPQerror;
}	}
}	}


	/**
	Executes a query and throw away the result.
	*/
	void _execute_cmd(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){
	if(connection.autocommit)
	_execute_cmd(connection, "BEGIN");
	}

const char *preprocess_statement(Connection& connection,	const char *_preprocess_statement(
const char *astatement, 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);	size_t statement_size=strlen(astatement);
Line 403 private: // private funcs	Line 440 private: // private funcs
+1);	+1);
// offset & limit -> suffixes	// offset & limit -> suffixes
const char *o;	const char *o;
if(offset \|\| limit) {	if(offset \|\| limit!=SQL_NO_LIMIT){
char *cur=result;	char *cur=result;
memcpy(cur, astatement, statement_size); cur+=statement_size;	memcpy(cur, astatement, statement_size); cur+=statement_size;
if(limit)	if(limit!=SQL_NO_LIMIT)
cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);	cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);
if(offset)	if(offset)
cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);	cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);
Line 473 private: // private funcs	Line 510 private: // private funcs
return result;	return result;
}	}

	bool _transcode_required(Connection& connection){
	return (connection.client_charset && strcmp(connection.client_charset, connection.services->request_charset())!=0);
	}

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 507 private: // conn client library funcs	Line 547 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;
typedef int (t_PQnfields)(const PGresult res); t_PQnfields PQnfields;	typedef int (t_PQnfields)(const PGresult res); t_PQnfields PQnfields;
Line 523 private: // conn client library funcs	Line 573 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 539 private: // conn client library funcs li	Line 593 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 562 private: // conn client library funcs li	Line 616 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 571 private: // conn client library funcs li	Line 627 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.24
changed lines
	Added in v.1.30