--- sql/mysql/parser3mysql.C	2009/04/08 11:13:00	1.35
+++ sql/mysql/parser3mysql.C	2012/06/06 14:45:14	1.41
@@ -1,21 +1,22 @@
 /** @file
 	Parser MySQL driver.
 
-	Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
 
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 
-	2001.07.30 using MySQL 3.23.22b
+	2001-07-30 using MySQL 3.23.22b
 
-	2001.11.06 numrows on "HP-UX istok1 B.11.00 A 9000/869 448594332 two-user license"
+	2001-11-06 numrows on "HP-UX istok1 B.11.00 A 9000/869 448594332 two-user license"
 		3.23.42 & 4.0.0.alfa never worked, both subst & .sl version returned 0
 */
-static const char *RCSId="$Id: parser3mysql.C,v 1.35 2009/04/08 11:13:00 misha Exp $"; 
 
 #include "config_includes.h"
 
 #include "pa_sql_driver.h"
 
+volatile const char * IDENT_PARSER3MYSQL_C="$Id: parser3mysql.C,v 1.41 2012/06/06 14:45:14 moko Exp $" IDENT_PA_SQL_DRIVER_H;
+
 #define NO_CLIENT_LONG_LONG
 #include "mysql.h"
 #include "ltdl.h"
@@ -29,14 +30,16 @@ static const char *RCSId="$Id: parser3my
 #endif
 
 // for mysql < 4.1 
+#if !defined(CLIENT_MULTI_RESULTS) || !defined(CLIENT_MULTI_STATEMENTS)
+#	define OLD_MYSQL_CLIENT 1
+#endif
+
 #ifndef CLIENT_MULTI_RESULTS
-#define	CLIENT_MULTI_RESULTS (1UL << 17)
-#define OLD_MYSQL_CLIENT 1
+#	define	CLIENT_MULTI_RESULTS (1UL << 17)
 #endif
+
 #ifndef CLIENT_MULTI_STATEMENTS
-#define	CLIENT_MULTI_STATEMENTS (1UL << 16)
-#undef OLD_MYSQL_CLIENT
-#define OLD_MYSQL_CLIENT 1
+#	define	CLIENT_MULTI_STATEMENTS (1UL << 16)
 #endif
 
 static char *lsplit(char *string, char delim){
@@ -71,6 +74,46 @@ static void toupper_str(char *out, const
 		*out++=(char)toupper(*in++);
 }
 
+inline static bool is_column_transcode_required(enum_field_types type) {
+	switch(type) {
+		case MYSQL_TYPE_NULL:
+
+		case MYSQL_TYPE_DECIMAL:
+		case MYSQL_TYPE_NEWDECIMAL:
+		case MYSQL_TYPE_FLOAT:
+		case MYSQL_TYPE_DOUBLE:
+
+		case MYSQL_TYPE_TINY:
+		case MYSQL_TYPE_SHORT:
+		case MYSQL_TYPE_LONG:
+		case MYSQL_TYPE_LONGLONG:
+		case MYSQL_TYPE_INT24:
+		case MYSQL_TYPE_BIT:
+
+		case MYSQL_TYPE_DATE:
+		case MYSQL_TYPE_NEWDATE:
+		case MYSQL_TYPE_TIME:
+		case MYSQL_TYPE_DATETIME:
+		case MYSQL_TYPE_YEAR:
+		case MYSQL_TYPE_TIMESTAMP:
+
+		case MYSQL_TYPE_BLOB:
+		case MYSQL_TYPE_TINY_BLOB:
+		case MYSQL_TYPE_MEDIUM_BLOB:
+		case MYSQL_TYPE_LONG_BLOB:
+			return false;
+			break;
+	}
+	return true;
+}
+
+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 {
 	SQL_Driver_services* services;
 
@@ -178,6 +221,10 @@ public:
 							if(atoi(value))
 								if(mysql_options(connection.handle, MYSQL_OPT_NAMED_PIPE, 0)!=0)
 									services._throw(mysql_error(connection.handle));
+						} else if(strcasecmp(key, "local_infile")==0){
+							if(atoi(value))
+								if(mysql_options(connection.handle, MYSQL_OPT_LOCAL_INFILE, 0)!=0)
+									services._throw(mysql_error(connection.handle));
 						} else if(strcasecmp(key, "autocommit")==0){
 							if(atoi(value)==0)
 								connection.autocommit=false;
@@ -219,7 +266,7 @@ public:
 		}
 
 		if(charset){
-			char statement[MAX_STRING]="SET CHARACTER SET ";
+			char statement[MAX_STRING+1]="SET CHARACTER SET ";
 			strncat(statement, charset, MAX_STRING);
 			_exec(connection, statement);
 		}
@@ -251,16 +298,63 @@ public:
 		return mysql_ping(connection.handle)==0;
 	}
 
-	const char* quote(void *aconnection, const char *from, unsigned int length) {
+	// charset here is services.request_charset(), not connection.client_charset
+	// thus we can't use the sql server quoting support
+	const char* quote(void *aconnection, const char *str, unsigned int length) {
+		const char* from;
+		const char* from_end=str+length;
+
+		size_t quoted=0;
+
+		for(from=str; from<from_end; from++){
+			switch (*from) {
+			case 0:
+			case '\n':
+			case '\r':
+			case '\032':
+			case '\\':
+			case '\'':
+			case '"':
+				quoted++;
+			}
+		}
+
+		if(!quoted)
+			return str;
+
 		Connection& connection=*static_cast<Connection*>(aconnection);
-		/*
-			3.23.22b
-			You must allocate the to buffer to be at least length*2+1 bytes long. 
-			(In the worse case, each character may need to be encoded as using two bytes, 
-			and you need room for the terminating null byte.)
-		*/
-		char *result=(char*)connection.services->malloc_atomic(length*2+1);
-		mysql_escape_string(result, from, length);
+		char *result=(char*)connection.services->malloc_atomic(length + quoted + 1);
+		char *to = result;
+
+		for(from=str; from<from_end; from++){
+			char escape;
+			switch (*from) {
+			case 0: 
+				escape= '0'; 
+				break;
+			case '\n': 
+				escape= 'n'; 
+				break;
+			case '\r': 
+				escape= 'r'; 
+				break;
+			case '\032': 
+				escape= 'Z'; 
+				break;
+			case '\\': 
+			case '\'': 
+			case '"': 
+				escape= *from; 
+				break;
+			default:
+				*to++=*from;
+				continue;
+			}
+			*to++= '\\';
+			*to++= escape;
+		}
+		
+		*to=0;
 		return result;
 	}
 
@@ -279,39 +373,42 @@ public:
 
 		bool transcode_needed=_transcode_required(connection);
 
-		// transcode query from $request:charset to ?ClientCharset
-		if(transcode_needed){
-			size_t length=strlen(astatement);
-			services.transcode(astatement, length,
-				astatement, length,
+		size_t statement_size=0;
+
+		if(transcode_needed) {
+			statement_size=strlen(astatement);
+			// transcode query from $request:charset to ?ClientCharset
+			services.transcode(astatement, statement_size,
+				astatement, statement_size,
 				services.request_charset(),
 				connection.client_charset);
 		}
 
 		const char *statement;
-		if(offset || limit!=SQL_NO_LIMIT){
-			size_t statement_size=strlen(astatement);
+		if(offset || limit!=SQL_NO_LIMIT) {
+			if(!statement_size)
+				statement_size=strlen(astatement);
 			char *statement_limited=(char *)services.malloc_atomic(
 				statement_size+MAX_NUMBER*2+8/* LIMIT #,#*/+1);
 			char *cur=statement_limited;
 			memcpy(cur, astatement, statement_size); cur+=statement_size;
 			cur+=sprintf(cur, " LIMIT ");
 			if(offset)
-				cur+=snprintf(cur, MAX_NUMBER+1, "%u,", offset);
+				cur+=snprintf(cur, MAX_NUMBER+1, "%lu,", offset);
 			if(limit!=SQL_NO_LIMIT)
-				cur+=snprintf(cur, MAX_NUMBER, "%u", limit);
+				cur+=snprintf(cur, MAX_NUMBER, "%lu", limit);
 			statement=statement_limited;
 		} else
 			statement=astatement;
 
 		if(mysql_query(connection.handle, statement)) 
 			_throw(connection, mysql_error(connection.handle));
-		if(!(res=mysql_store_result(connection.handle)) && mysql_field_count(connection.handle)) 
+		if(!(res=mysql_store_result(connection.handle)) && mysql_field_count(connection.handle))
 			_throw(connection, mysql_error(connection.handle));
 		if(!res) // empty result: insert|delete|update|...
 			return;
-		
-		int column_count=mysql_num_fields(res);
+
+		size_t column_count=mysql_num_fields(res);
 		if(!column_count) // old client
 			column_count=mysql_field_count(connection.handle);
 
@@ -319,65 +416,71 @@ public:
 			mysql_free_result(res);
 			services._throw("result contains no columns");
 		}
-		
+
 		bool failed=false;
 		SQL_Error sql_error;
-#define CHECK(afailed) \
-		if(afailed) { \
-			failed=true; \
+
+#define CHECK(afailed)    \
+		if(afailed) {     \
+			failed=true;  \
 			goto cleanup; \
 		}
 
-		for(int i=0; i<column_count; i++){
-			if(MYSQL_FIELD *field=mysql_fetch_field(res)){
-				size_t length=strlen(field->name);
-				char* strm=(char*)services.malloc_atomic(length+1);
-				memcpy(strm, field->name, length+1);
-				const char* str=strm;
-
-				// transcode column name from ?ClientCharset to $request:charset 
-				if(transcode_needed){
+#define DO_FETCH_FIELDS(transcode_column_name) {                                \
+			MYSQL_FIELD *fields = mysql_fetch_fields(res);                      \
+			for(size_t i=0; i<column_count; i++) {                              \
+				size_t length=fields[i].name_length;                            \
+				const char* str=strdup(services, fields[i].name, length);       \
+				transcode_column_name                                           \
+				CHECK(handlers.add_column(sql_error, str, length));             \
+			}                                                                   \
+		}
+
+#define DO_FETCH_ROWS(transcode_cell_value) {                                   \
+			while(MYSQL_ROW mysql_row=mysql_fetch_row(res)) {                   \
+				CHECK(handlers.add_row(sql_error));                             \
+				unsigned long *lengths=mysql_fetch_lengths(res);                \
+				for(size_t i=0; i<column_count; i++) {                          \
+					const char* str=0;                                          \
+					size_t length=lengths[i];                                   \
+					if(length) {                                                \
+						str=strdup(services, mysql_row[i], length);             \
+						transcode_cell_value                                    \
+					}                                                           \
+					CHECK(handlers.add_row_cell(sql_error, str, length));       \
+				}                                                               \
+			}                                                                   \
+		}
+
+		bool* transcode_column=0;
+		if(transcode_needed) {
+			transcode_column = new bool[column_count];
+			DO_FETCH_FIELDS(
+				transcode_column[i] = is_column_transcode_required(fields[i].type);
+				// transcode column's name from ?ClientCharset to $request:charset
+				services.transcode(str, length,
+					str, length,
+					connection.client_charset,
+					services.request_charset());
+			)
+			CHECK(handlers.before_rows(sql_error));
+			DO_FETCH_ROWS(
+				if(transcode_column[i])
+					// transcode cell's value from ?ClientCharset to $request:charset
 					services.transcode(str, length,
 						str, length,
 						connection.client_charset,
 						services.request_charset());
-				}
-				
-				CHECK(handlers.add_column(sql_error, str, length));
-			} else {
-				// seen some broken client, 
-				// which reported "44" for column count of response to "select 2+2"
-				column_count=i;
-				break;
-			}
-		}
-
-		CHECK(handlers.before_rows(sql_error));
-		
-		while(MYSQL_ROW mysql_row=mysql_fetch_row(res)){
-			CHECK(handlers.add_row(sql_error));
-			unsigned long *lengths=mysql_fetch_lengths(res);
-			for(int i=0; i<column_count; i++){
-				size_t length=(size_t)lengths[i];
-				const char* str;
-				if(length){
-					char *strm=(char*)services.malloc_atomic(length+1);
-					memcpy(strm, mysql_row[i], length);
-					strm[length]=0;
-					str=strm;
-
-					// transcode cell value from ?ClientCharset to $request:charset
-					if(transcode_needed)
-						services.transcode(str, length,
-							str, length,
-							connection.client_charset,
-							services.request_charset());
-				} else
-					str=0;
-				CHECK(handlers.add_row_cell(sql_error, str, length));
-			}
+			)
+		} else {
+			// without transcoding
+			DO_FETCH_FIELDS()
+			CHECK(handlers.before_rows(sql_error));
+			DO_FETCH_ROWS()
 		}
 cleanup:
+		if(transcode_column)
+			delete transcode_column;
 		mysql_free_result(res);
 		if(failed)
 			services._throw(sql_error);
@@ -441,7 +544,7 @@ private: // mysql client library funcs
 	
 	typedef MYSQL_ROW	(STDCALL *t_mysql_fetch_row)(MYSQL_RES *result); t_mysql_fetch_row mysql_fetch_row;
 	
-	typedef MYSQL_FIELD*	(STDCALL *t_mysql_fetch_field)(MYSQL_RES *result); t_mysql_fetch_field mysql_fetch_field;
+	typedef MYSQL_FIELD*	(STDCALL *t_mysql_fetch_fields)(MYSQL_RES *result); t_mysql_fetch_fields mysql_fetch_fields;
 	
 	typedef unsigned int	(STDCALL *t_mysql_num_fields)(MYSQL_RES *); t_mysql_num_fields mysql_num_fields;
 	typedef unsigned int	(STDCALL *t_mysql_field_count)(MYSQL *); t_mysql_field_count mysql_field_count;
@@ -487,7 +590,7 @@ private: // mysql client library funcs l
 		DLINK(mysql_free_result);
 		DLINK(mysql_fetch_lengths);
 		DLINK(mysql_fetch_row);
-		DLINK(mysql_fetch_field);
+		DLINK(mysql_fetch_fields);
 		SLINK(mysql_num_fields);
 		SLINK(mysql_field_count);
 		return 0;