--- sql/pgsql/parser3pgsql.C	2001/11/11 11:01:47	1.3
+++ sql/pgsql/parser3pgsql.C	2007/01/26 10:10:32	1.26
@@ -1,13 +1,13 @@
 /** @file
 	Parser PgSQL driver.
 
-	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
+	Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
 
-	Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 
 	2001.07.30 using PgSQL 7.1.2
 */
-static const char *RCSId="$Id: parser3pgsql.C,v 1.3 2001/11/11 11:01:47 paf Exp $"; 
+static const char *RCSId="$Id: parser3pgsql.C,v 1.26 2007/01/26 10:10:32 misha Exp $"; 
 
 #include "config_includes.h"
 
@@ -22,7 +22,7 @@ static const char *RCSId="$Id: parser3pg
 // actually writing chunks of that size failed, reduced it twice
 #define LO_BUFSIZE		  0x1000
 // from postgres_ext.h
-#define InvalidOid		((Oid) 0)
+//#define InvalidOid		((Oid) 0)
 
 
 #include "ltdl.h"
@@ -51,6 +51,36 @@ static char *lsplit(char *string, char d
     return 0;
 }
 
+static char *lsplit(char **string_ref, char delim) {
+    char *result=*string_ref;
+	char *next=lsplit(*string_ref, delim);
+    *string_ref=next;
+    return result;
+}
+
+static char* rsplit(char* string, char delim) {
+    if(string) {
+		char* v=strrchr(string, delim); 
+		if(v) {
+			*v=0;
+			return v+1;
+		}
+    }
+    return NULL;	
+}
+
+static void toupper_str(char *out, const char *in, size_t size) {
+	while(size--)
+		*out++=(char)toupper(*in++);
+}
+
+struct Connection {
+	SQL_Driver_services* services;
+
+	PGconn *conn;
+	const char* cstrClientCharset;
+};
+
 /**
 	PgSQL server driver
 */
@@ -68,95 +98,189 @@ public:
 			dlink(dlopen_file_spec):"client library column is empty";
 	}
 
-	#define throwPQerror services._throw(PQerrorMessage(conn))
+	#define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))
+	#define PQclear_throw(msg) { \
+			PQclear(res); \
+			connection.services->_throw(msg); \
+		}						
+	#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))
 
 	/**	connect
-		@param used_only_in_connect_url
+		@param url
 			format: @b user:pass@host[:port]|[local]/database
 	*/
 	void connect(
-		char *used_only_in_connect_url, 
+		char *url, 
 		SQL_Driver_services& services, 
-		void **connection ///< output: PGconn *
+		void **connection_ref ///< output: Connection*
 		) {
-		char *user=used_only_in_connect_url;
-		char *host=lsplit(user, '@');
+		char *user=url;
+		char *host=rsplit(user, '@');
 		char *db=lsplit(host, '/');
 		char *pwd=lsplit(user, ':');
 		char *port=lsplit(host, ':');
 
-		PGconn *conn=PQsetdbLogin(
-			strcasecmp(host, "local")==0?NULL/* local Unix domain socket */:host, port, 
+		char *options=lsplit(db, '?');
+
+		char *cstrBackwardCompAskServerToTranscode=0;
+
+		Connection& connection=*(Connection  *)services.malloc(sizeof(Connection));
+		*connection_ref=&connection;
+		connection.services=&services;
+		connection.cstrClientCharset=0;	
+		connection.conn=PQsetdbLogin(
+			(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port, 
 			NULL, NULL, db, user, pwd);
-		if(!conn)
+		if(!connection.conn)
 			services._throw("PQsetdbLogin failed");
-		if(PQstatus(conn)!=CONNECTION_OK)  
+		if(PQstatus(connection.conn)!=CONNECTION_OK)  
 			throwPQerror;
 
-		*(PGconn **)connection=conn;
-		begin_transaction(services, conn);
+		char *charset=0;
+		char *datestyle=0;
+		isDefaultTransaction = true;
+
+		while(options) {
+			if(char *key=lsplit(&options, '&')) {
+				if(*key) {
+					if(char *value=lsplit(key, '=')) {
+						if(strcmp(key, "ClientCharset" ) == 0) {
+							toupper_str(value, value, strlen(value));
+							connection.cstrClientCharset=value;
+						} else if(strcasecmp(key, "charset")==0) { // left for backward compatibility, consider using ClientCharset
+							cstrBackwardCompAskServerToTranscode=value;
+						} else if(strcasecmp(key, "datestyle")==0) {
+							datestyle=value;
+						} else if(strcmp(key, "WithoutDefaultTransaction")==0) {
+							if(strcmp(value, "1" ) == 0) {
+								isDefaultTransaction = false;
+							} else if(strcmp(value, "0" ) == 0) {
+								isDefaultTransaction = true;
+							} else {
+								services._throw("Bad WithoutDefaultTransaction option value. Only 0 or 1 are accepted." /*value*/);
+							}
+						} else
+							services._throw("unknown connect option" /*key*/);
+					} else 
+						services._throw("connect option without =value" /*key*/);
+				}
+			}
+		}
+
+		if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)
+			services._throw("use 'ClientCharset' option only, "
+				"'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);
+
+			execute_resultless(connection, statement);
+		}
+
+		if(datestyle) {
+			// set DATESTYLE
+			char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO
+			strncat(statement, charset, MAX_STRING);
+
+			execute_resultless(connection, statement);
+		}
+
+		begin_transaction(connection);
 	}
-	void disconnect(void *connection) {
-	    PQfinish((PGconn *)connection);
+	void disconnect(void *aconnection) {
+		Connection& connection=*static_cast<Connection*>(aconnection);
+
+	    PQfinish(connection.conn);
+		connection.conn=0;
 	}
-	void commit(SQL_Driver_services& services, void *connection) {
-		PGconn *conn=(PGconn *)connection;
-		if(PGresult *res=PQexec(conn, "COMMIT"))
-			PQclear(res);
-		else
-			throwPQerror;
-		begin_transaction(services, conn);
+	void commit(void *aconnection) {
+		execute_transaction_cmd(aconnection, "COMMIT");
 	}
-	void rollback(SQL_Driver_services& services, void *connection) {
-		PGconn *conn=(PGconn *)connection;
-		if(PGresult *res=PQexec(conn, "ROLLBACK"))
-			PQclear(res);
-		else
-			throwPQerror;
-		begin_transaction(services, conn);
+	void rollback(void *aconnection) {
+		execute_transaction_cmd(aconnection, "ROLLBACK");
 	}
 
-	bool ping(SQL_Driver_services&, void *connection) {
-		return PQstatus((PGconn *)connection)==CONNECTION_OK;
+	bool ping(void *aconnection) {
+		Connection& connection=*static_cast<Connection*>(aconnection);
+
+		return PQstatus(connection.conn)==CONNECTION_OK;
 	}
 
-	unsigned int quote(
-		SQL_Driver_services&, void *connection,
-		char *to, const char *from, unsigned int length) {
-		/*
-			it's already UNTAINT_TIMES_BIGGER
-		*/
-		unsigned int result=length;
-		while(length--) {
-			switch(*from) {
-			case '\'': // "'" -> "''"
-				*to++='\'';
-				break;
-			case '\\': // "\" -> "\\"
-				*to++='\'';
-				break;
-			}
-			*to++=*from++;
-		}
+	const char* quote(
+		void *aconnection,
+		const char *from, unsigned int length) {
+		Connection& connection=*static_cast<Connection*>(aconnection);
+
+		char *result=(char*)connection.services->malloc_atomic(length*2+1);
+		int err = 0;
+		PQescapeStringConn (connection.conn,
+                           result, from, length,
+                           &err);
 		return result;
 	}
-	void query(
-		SQL_Driver_services& services, void *connection, 
-		const char *astatement, unsigned long offset, unsigned long limit,
+	
+	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) {
 //		_asm int 3;
+		Connection& connection=*static_cast<Connection*>(aconnection);
+		const char* cstrClientCharset=connection.cstrClientCharset;
+		SQL_Driver_services& services=*connection.services;
+		PGconn *conn=connection.conn;
+
+		const char** paramValues;
+		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));
+			for(size_t i=0; i<placeholders_count; ++i) {
+				Placeholder& ph=placeholders[i];
+				size_t value_length;
+				if(cstrClientCharset) {
+					size_t name_length;
+					services.transcode(ph.name, strlen(ph.name),
+						ph.name, name_length,
+						services.request_charset(),
+						cstrClientCharset);
+
+					if(ph.value){
+						services.transcode(ph.value, strlen(ph.value),
+							ph.value, value_length,
+							services.request_charset(),
+							cstrClientCharset);
+					}
+				} else {
+					value_length=ph.value? strlen(ph.value): 0;
+				}
+				if( atoi(ph.name) <= 0 || atoi(ph.name) > placeholders_count) {
+					services._throw("bad bind parameter key");
+				}
+				paramValues[atoi(ph.name)-1] = ph.value;
+			}
+		}
 
-		PGconn *conn=(PGconn *)connection;
-		#define PQclear_throw(msg) { \
-				PQclear(res); \
-				services._throw(msg); \
-			}						
-		#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(conn))
+		// transcode from $request:charset to connect-string?client_charset
+		if(cstrClientCharset) {
+			size_t transcoded_statement_size;
+			services.transcode(astatement, strlen(astatement),
+				astatement, transcoded_statement_size,
+				services.request_charset(),
+				cstrClientCharset);
+		}
 
-		const char *statement=preprocess_statement(services, conn,
+		const char *statement=preprocess_statement(connection,
 			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) 
 			throwPQerror;
 
@@ -179,23 +303,40 @@ public:
 		if(!column_count)
 			PQclear_throw("result contains no columns");
 
+		bool failed=false;
+		SQL_Error sql_error;
+#define CHECK(afailed) \
+		if(afailed) { \
+			failed=true; \
+			goto cleanup; \
+		}
+
 		for(int i=0; i<column_count; i++){
 			char *name=PQfname(res, i);
-			size_t size=strlen(name);
-			void *ptr=services.malloc(size);
-			memcpy(ptr, name, size);
-			handlers.add_column(ptr, size);
+			size_t length=strlen(name);
+			char* strm=(char*)services.malloc(length+1);
+			memcpy(strm, name, length+1);
+			const char* str=strm;
+
+			// transcode to $request:charset from connect-string?client_charset
+			if(cstrClientCharset) 
+				services.transcode(str, length,
+					str, length,
+					cstrClientCharset,
+					services.request_charset());
+
+			CHECK(handlers.add_column(sql_error, str, length));
 		}
 
-		handlers.before_rows();
+		CHECK(handlers.before_rows(sql_error));
 
 		if(unsigned long row_count=(unsigned long)PQntuples(res))
 			for(unsigned long r=0; r<row_count; r++) {
-				handlers.add_row();
+				CHECK(handlers.add_row(sql_error));
 				for(int i=0; i<column_count; i++){
 					const char *cell=PQgetvalue(res, r, i);
-					size_t size;
-					void *ptr;
+					size_t length;
+					const char* str;
 					if(PQftype(res, i)==OIDOID) {
 						// ObjectID column, read object bytes
 
@@ -206,55 +347,91 @@ public:
 							// seek to end
 							if(lo_lseek(conn, fd, 0, SEEK_END)<0)
 								PQclear_throwPQerror;
-							// get size
+							// get length
 							int size_tell=lo_tell(conn, fd);
 							if(size_tell<0)
 								PQclear_throwPQerror;
 							// seek to begin
 							if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
 								PQclear_throwPQerror;
-							size=(size_t)size_tell;
-							if(size) {
+							length=(size_t)size_tell;
+							if(length) {
 								// read 
-								ptr=services.malloc(size);
-								if(!lo_read_ex(conn, fd, (const char *)ptr, size_tell))
+								char* strm=(char*)services.malloc(length+1);
+								if(!lo_read_ex(conn, fd, strm, size_tell))
 									PQclear_throw("lo_read can not read all bytes of object");
+								strm[length]=0;
+								str=strm;
 							} else
-								ptr=0;
+								str=0;
 							if(lo_close(conn, fd)<0)
 								PQclear_throwPQerror;
 						} else
 							PQclear_throwPQerror;
 					} else {
 						// normal column, read it normally
-						size=(size_t)PQgetlength(res, r, i);
-						if(size) {
-							ptr=services.malloc(size);
-							memcpy(ptr, cell, size);
+						length=(size_t)PQgetlength(res, r, i);
+						if(length) {
+							char* strm=(char*)services.malloc(length+1);
+							memcpy(strm, cell, length+1);
+							str=strm;
 						} else
-							ptr=0;
+							str=0;
+					}
+
+					if(str && length) {
+						// transcode to $request:charset from connect-string?client_charset
+						if(cstrClientCharset)
+							services.transcode(str, length,
+								str, length,
+								cstrClientCharset,
+								services.request_charset());
 					}
-					handlers.add_row_cell(ptr, size);
+
+					CHECK(handlers.add_row_cell(sql_error, str, length));
 				}
 			}
-
+cleanup:
 		PQclear(res);
+		if(failed)
+			services._throw(sql_error);
 	}
 
 private: // private funcs
 
-	void begin_transaction(SQL_Driver_services& services, PGconn *conn) {
-		if(PGresult *res=PQexec(conn, "BEGIN"))
-			PQclear(res);
+	void execute_transaction_cmd(void *aconnection, const char *query) {
+		if(isDefaultTransaction)
+		{
+			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;
 	}
 
-	const char *preprocess_statement(SQL_Driver_services& services, PGconn *conn,
+	void begin_transaction(Connection& connection) {
+		if(isDefaultTransaction)
+		{
+			execute_resultless(connection, "BEGIN");
+		}
+	}
+
+	const char *preprocess_statement(Connection& connection,
 		const char *astatement, unsigned long offset, unsigned long limit) {
+		PGconn *conn=connection.conn;
+
 		size_t statement_size=strlen(astatement);
 
-		char *result=(char *)services.malloc(statement_size
+		char *result=(char *)connection.services->malloc(statement_size
 			+MAX_NUMBER*2+15 // limit # offset #
 			+MAX_STRING // in case of short 'strings'
 			+1);
@@ -278,6 +455,7 @@ private: // private funcs
 				o[0]=='/' &&
 				o[1]=='*' && 
 				o[2]=='*') { // name start
+				const char* saved_o=o;
 				o+=3;
 				while(*o)
 					if(
@@ -285,6 +463,7 @@ private: // private funcs
 						o[1]=='*' &&
 						o[2]=='/' &&
 						o[3]=='\'') { // name end
+						saved_o=0; // found, marking that
 						o+=4;
 						Oid oid=lo_creat(conn, INV_READ|INV_WRITE);
 						if(oid==InvalidOid)
@@ -298,13 +477,13 @@ private: // private funcs
 								if(escaped) {
 									// write pending, skip "\" or "'"
 									if(!lo_write_ex(conn, fd, start, o-start))
-										services._throw("lo_write could not write all bytes of object (1)");
+										connection.services->_throw("lo_write could not write all bytes of object (1)");
 									start=++o;
 								} else
 									o++;
 							}
 							if(!lo_write_ex(conn, fd, start, o-start))
-								services._throw("lo_write can not write all bytes of object (2)");
+								connection.services->_throw("lo_write can not write all bytes of object (2)");
 							if(lo_close(conn, fd)<0)
 								throwPQerror;
 						} else
@@ -316,6 +495,10 @@ private: // private funcs
 						break;
 					} else
 						o++; // /**skip**/'xxx'
+				if(saved_o) {
+					o=saved_o;
+					*n++=*o++;
+				}
 			} else
 				*n++=*o++;
 		}
@@ -327,19 +510,18 @@ private: // private funcs
 private: // lo_read/write exchancements
 
 	bool lo_read_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {
-		int size_read;
-		while(len && (size_read=lo_read(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
-			buf+=size_read;
-			len-=size_read;									
-		}
-		return len==0;
+		return lo_rw_method (conn, fd, buf, len, lo_read);
 	}
 
 	bool lo_write_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {
-		int size_written;
-		while(len && (size_written=lo_write(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
-			buf+=size_written;
-			len-=size_written;									
+		return lo_rw_method (conn, fd, buf, len, lo_write);
+	}
+
+	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;
 	}
@@ -359,6 +541,17 @@ private: // conn client library funcs
 	typedef ConnStatusType (*t_PQstatus)(const PGconn *conn); t_PQstatus PQstatus;
 	typedef PGresult *(*t_PQexec)(PGconn *conn,
 	                 const char *query); t_PQexec PQexec;
+//PQexecParams
+	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 int (*t_PQgetlength)(const PGresult *res,
 					int tup_num,
@@ -374,6 +567,10 @@ private: // conn client library funcs
 
 	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_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;
@@ -388,6 +585,8 @@ private: // conn client library funcs
 private: // conn client library funcs linking
 
 	const char *dlink(const char *dlopen_file_spec) {
+		if(lt_dlinit())
+			return lt_dlerror();
         lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
         if(!handle)
 			return "can not open the dynamic link module";
@@ -411,7 +610,9 @@ private: // conn client library funcs li
 		DLINK(PQclear);
 		DLINK(PQresultStatus);
 		DLINK(PQexec);
+		DLINK(PQexecParams);
 		DLINK(PQftype);
+		DLINK(PQescapeStringConn);
 		DLINK(lo_open);		DLINK(lo_close);
 		DLINK(lo_read);		DLINK(lo_write);
 		DLINK(lo_lseek);		DLINK(lo_creat);
@@ -421,6 +622,7 @@ private: // conn client library funcs li
 		return 0;
 	}
 
+	bool isDefaultTransaction;
 };
 
 extern "C" SQL_Driver *SQL_DRIVER_CREATE() {