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

version 1.28, 2007/10/25 17:08:41	version 1.29, 2008/06/24 17:43:48
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){
if(strcmp(value, "1" ) == 0) {	if(atoi(value)==0)
isDefaultTransaction = false;	connection.autocommit=false;
} else if(strcmp(value, "0" ) == 0) {	} else if(strcmp(key, "WithoutDefaultTransaction")==0){ // backward, use autocommit=0
isDefaultTransaction = true;	if(atoi(value)==1)
} else {	connection.autocommit=false;
services._throw("Bad WithoutDefaultTransaction option value. Only 0 or 1 are accepted." /value/);
}
} else	} else
services._throw("unknown connect option" /key/);	services._throw("unknown connect option" /key/);
} else	} else
Line 167 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);

execute_resultless(connection, statement);	execute_resultless(connection, statement);
}	}

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);

execute_resultless(connection, statement);	execute_resultless(connection, statement);
}	}

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) {	void commit(void *aconnection) {
execute_transaction_cmd(aconnection, "COMMIT");	execute_transaction_cmd(aconnection, "COMMIT");
}	}

void rollback(void *aconnection) {	void rollback(void *aconnection) {
execute_transaction_cmd(aconnection, "ROLLBACK");	execute_transaction_cmd(aconnection, "ROLLBACK");
}	}
Line 214 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);
int err = 0;	int err=0;
PQescapeStringConn (connection.conn,	PQescapeStringConn (connection.conn,
result, from, length,	result, from, length,
&err);	&err);
return result;	return result;
}	}

Line 240 public:	Line 242 public:
bind_parameters(placeholders_count, placeholders, paramValues, connection);	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 295 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 357 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 408 private: // private funcs	Line 410 private: // private funcs


void execute_transaction_cmd(void aconnection, const char query) {	void execute_transaction_cmd(void aconnection, const char query) {
if(isDefaultTransaction)	Connection& connection=static_cast<Connection>(aconnection);
{
	if(connection.autocommit){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
execute_resultless(connection, query);	execute_resultless(connection, query);
begin_transaction(connection);
}	}

	begin_transaction(connection);
}	}

/**	/**
Line 427 private: // private funcs	Line 431 private: // private funcs
}	}

void begin_transaction(Connection& connection) {	void begin_transaction(Connection& connection) {
if(isDefaultTransaction)	if(connection.autocommit){
{
execute_resultless(connection, "BEGIN");	execute_resultless(connection, "BEGIN");
}	}
}	}
Line 529 private: // lo_read/write exchancements	Line 532 private: // lo_read/write exchancements
int size_op;	int size_op;
while(len && (size_op=lo_func(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {	while(len && (size_op=lo_func(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
buf+=size_op;	buf+=size_op;
len-=size_op;	len-=size_op;
}	}
return len==0;	return len==0;
}	}
Line 548 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;
//PQexecParams
typedef PGresult (t_PQexecParams)(	typedef PGresult (t_PQexecParams)(
PGconn *conn,	PGconn *conn,
const char *query,	const char *query,
int nParams,	int nParams,
const Oid *paramTypes,	const Oid *paramTypes,
const char * const *paramValues,	const char * const *paramValues,
const int *paramLengths,	const int *paramLengths,
const int *paramFormats,	const int *paramFormats,
int resultFormat); t_PQexecParams PQexecParams;	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 576 private: // conn client library funcs	Line 578 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,	typedef size_t (t_PQescapeStringConn)(PGconn conn,
char to, const char from, size_t length,	char to, const char from, size_t length,
int *error); t_PQescapeStringConn PQescapeStringConn;	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;
Line 595 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 629 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.28
changed lines
	Added in v.1.29