--- sql/oracle/parser3oracle.C	2001/10/28 14:51:30	1.2
+++ sql/oracle/parser3oracle.C	2002/12/09 11:43:08	1.26
@@ -1,13 +1,13 @@
 /** @file
 	Parser Oracle driver.
 
-	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
+	Copyright(c) 2001, 2002 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 Oracle 8.1.6 [@test tested with Oracle 7.x.x]
 */
-static const char *RCSId="$Id: parser3oracle.C,v 1.2 2001/10/28 14:51:30 paf Exp $"; 
+static const char *RCSId="$Id: parser3oracle.C,v 1.26 2002/12/09 11:43:08 paf Exp $"; 
 
 #include "config_includes.h"
 
@@ -38,6 +38,54 @@ inline int max(int a, int b) { return a>
 inline int min(int a, int b){ return a<b?a:b; }
 #endif
 
+/// @test setenv version memory. maybe key/value needs ::malloc?
+static int pa_setenv(const char *name, const char *value, bool do_append) {
+	const char *prev_value=0;
+	if(do_append)
+		prev_value=getenv(name);
+#ifdef HAVE_PUTENV
+    // MEM_LEAK_HERE. refer to EOF man putenv
+	char *buf=(char *)::malloc(strlen(name)
+		+1
+		+(prev_value?strlen(prev_value):0)
+		+strlen(value)
+		+1);
+	strcpy(buf, name);
+	strcat(buf, "=");
+	if(prev_value)
+		strcat(buf, prev_value);
+	strcat(buf, value);
+/*
+	if(FILE *f=fopen("f", "at")) {
+		fprintf(f, "****************************%s\n", buf);
+//		for (char **env = environ; env != NULL && *env != NULL; env++)
+//			fputs(*env, f);
+	
+		fclose(f);
+	}
+*/	
+	return putenv(buf);
+#else 
+	//#ifdef HAVE_SETENV
+	if(value) {
+		if(prev_value) {
+			// MEM_LEAK_HERE
+			char *buf=(char *)::malloc(strlen(prev_value)
+				+strlen(value)
+				+1);
+			strcpy(buf, prev_value);
+			strcat(buf, value);
+			value=buf;
+		}
+
+		return setenv(name, value, 1/*overwrite*/); 
+	} else {
+		unsetenv(name);
+		return 0;
+	}
+#endif
+}
+
 static char *lsplit(char *string, char delim) {
     if(string) {
 		char *v=strchr(string, delim);
@@ -49,9 +97,42 @@ 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 const char *options2env(char *options) {
+	while(options) {
+		if(char *key=lsplit(&options, '&')) {
+			if(*key) {
+				if(char *value=lsplit(key, '=')) {
+					bool do_append=key[strlen(key)-1]=='+'; // PATH+=
+					if(do_append)
+						key[strlen(key)-1]=0; // remove trailing +
+					if(strncmp(key, "ORACLE_", 7)==0  // ORACLE_HOME & co
+						|| strncmp(key, "ORA_", 4)==0 // ORA_ENCRYPT_LOGIN & co
+						|| strncmp(key, "NLS_", 4)==0 // NLS_LANG & co
+						|| do_append
+						) {
+						if(pa_setenv(key, value, do_append)!=0)
+							return "problem changing process environment" /*key*/;
+					} else
+						return "unknown option (option must start with ORACLE_, ORA_ or NLS_)" /*key*/;
+				} else 
+					return "option without =value" /*key*/;
+			}
+		}
+	}
+	return 0;
+}
+
 #ifndef DOXYGEN
 struct OracleSQL_connection_struct {
 	jmp_buf mark; char error[MAX_STRING];
+	SQL_Exception sql_exception;
 	OCIEnv *envhp;
 	OCIServer *srvhp;
 	OCIError *errhp;
@@ -108,7 +189,6 @@ void tolower(char *out, const char *in,
 
 /**
 	OracleSQL server driver
-	@test NLS_LANG=AMERICAN_AMERICA.CL8MSWIN1251
 */
 class OracleSQL_Driver : public SQL_Driver {
 public:
@@ -118,20 +198,23 @@ public:
 
 	/// get api version
 	int api_version() { return SQL_DRIVER_API_VERSION; }
-	/// initialize driver by loading sql dynamic link library
-	const char *initialize(const char *dlopen_file_spec) {
+	/** initialize driver by loading sql dynamic link library
+		@todo ?objects=1 which would turn on OCI_OBJECT init flag
+	*/
+	const char *initialize(char *dlopen_file_spec) {
+		char *options=lsplit(dlopen_file_spec, '?');
 
 		const char *error=dlopen_file_spec?
 			dlink(dlopen_file_spec):"client library column is empty";
 		if(!error) {
+			error=options2env(options);
 
-//			error="OCIInitialize replacer";/*
-			OCIInitialize((ub4)OCI_THREADED, (dvoid *)0, 
-				(dvoid * (*)(void *, unsigned int))0, 
-				(dvoid * (*)(void*, void*, unsigned int))0,  
-				(void (*)(void*, void*))0 );
-
-//			*/
+			if(!error)
+				OCIInitialize((ub4)OCI_THREADED/*| OCI_OBJECT*/, (dvoid *)0, 
+					(dvoid * (*)(void *, unsigned int))0, 
+					(dvoid * (*)(void*, void*, unsigned int))0,  
+					(void (*)(void*, void*))0 
+				);
 		}
 
 		return error;
@@ -139,7 +222,13 @@ public:
 
 	/**	connect
 		@param used_only_in_connect_url
-			format: @b user:pass@service
+			format: @b user:pass@service?
+			   ORACLE_HOME=/u01/app/oracle/product/8.1.5&
+			   ORA_NLS33=/u01/app/oracle/product/8.1.5/ocommon/nls/admin/data&
+			   NLS_LANG=RUSSIAN_AMERICA.CL8MSWIN1251&
+			   ORA_ENCRYPT_LOGIN=TRUE
+
+		@todo environment manupulation doesnt look thread safe
 	*/
 	void connect(
 		char *used_only_in_connect_url, 
@@ -153,10 +242,14 @@ public:
 		char *user=used_only_in_connect_url;
 		char *service=lsplit(user, '@');
 		char *pwd=lsplit(user, ':');
+		char *options=lsplit(service, '?');
 
 		if(!(user && pwd && service))
 			services._throw("mailformed connect part, must be 'user:pass@service'");
 
+		if(const char *error=options2env(options))
+			services._throw(error);
+
 		if(setjmp(cs.mark))
 			services._throw(cs.error);
 
@@ -223,12 +316,7 @@ public:
 		// return created connection
 		*(OracleSQL_connection_struct **)connection=&cs;
 	}
-	/// @test remove return
 	void disconnect(void *connection) {
-
-		return;
-
-
 	    OracleSQL_connection_struct &cs=*(OracleSQL_connection_struct *)connection;
 		// Terminate a user session
 		OCISessionEnd(
@@ -269,28 +357,26 @@ public:
 
 	bool ping(SQL_Driver_services&, void *connection) {
 		// maybe OCIServerVersion?
+		// select 0 from dual
 		return true;
 	}
 
 	unsigned int quote(
 		SQL_Driver_services&, void *, 
 		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;
+		if(to) { // store mode
+			unsigned int result=length;
+			while(length--) {
+				switch(*from) {
+				case '\'': // "'" -> "''"
+					*to++='\''; result++;
+					break;
+				}
+				*to++=*from++;
 			}
-			*to++=*from++;
-		}
-		return result;
+			return result;
+		} else // estimate mode
+			return length*2;
 	}
 	void query(
 		SQL_Driver_services& services, void *connection, 
@@ -357,8 +443,11 @@ cleanup: // no check call after this poi
 		if(stmthp)
 			OCIHandleFree((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT);
 
-		if(failed)
+		if(failed) {
+			if(cs.sql_exception.defined())
+				services._throw(cs.sql_exception);
 			services._throw(cs.error);
+		}
 	}
 
 private: // private funcs
@@ -397,7 +486,7 @@ private: // private funcs
 						const char *start=o;
 						bool escaped=false;
 						while(*o && !(o[0]=='\'' && o[1]!='\'' && !escaped)) {
-							escaped=*o=='\\' || (o[0]=='\'' && o[1]=='\'');
+							escaped=o[0]=='\'' && o[1]=='\'';
 							if(escaped) {
 								// write pending, skip "\" or "'"
 								if(size_t size=o-start) {
@@ -462,6 +551,9 @@ private: // private funcs
 			(dvoid *)stmthp, (ub4)OCI_HTYPE_STMT, (ub1 *)&stmt_type, 
 			(ub4 *)0, OCI_ATTR_STMT_TYPE, cs.errhp));
 	*/
+
+		while(isspace(*statement)) 
+			statement++;
 		if(strncasecmp(statement, "select", 6)==0) 
 			stmt_type=OCI_STMT_SELECT;
 		else if(strncasecmp(statement, "insert", 6)==0)
@@ -512,6 +604,18 @@ private: // private funcs
 		OCIStmt *stmthp, unsigned long offset, unsigned long limit, 
 		SQL_Driver_query_event_handlers& handlers) {
 
+		ub4 prefetch_rows=100;
+		check(services, cs, "AttrSet prefetch-rows", OCIAttrSet( 
+			(dvoid *)stmthp, (ub4)OCI_HTYPE_STMT, 
+			(dvoid *)&prefetch_rows, (ub4)0, 
+			(ub4)OCI_ATTR_PREFETCH_ROWS, (OCIError *)cs.errhp));
+
+		ub4 prefetch_mem_size=100*0x400;
+		check(services, cs, "AttrSet prefetch-memory", OCIAttrSet( 
+			(dvoid *)stmthp, (ub4)OCI_HTYPE_STMT, 
+			(dvoid *)&prefetch_mem_size, (ub4)0, 
+			(ub4)OCI_ATTR_PREFETCH_MEMORY, (OCIError *)cs.errhp));
+
 		OCIParam          *mypard;
 		ub2                    dtype;
 		text                  *col_name;
@@ -531,116 +635,125 @@ private: // private funcs
 			failed=true;
 			goto cleanup;
 		} else {
-			// idea of preincrementing is that at error time all handles would free up
-			while(++column_count<=MAX_COLS) {
-				/* get next descriptor, if there is one */
-				if(OCIParamGet(stmthp, OCI_HTYPE_STMT, cs.errhp, (void **)&mypard, 
-					(ub4) column_count)!=OCI_SUCCESS)
-					break;
-				
-				/* Retrieve the data type attribute */
-				check(services, cs, "get type", OCIAttrGet(
-					(dvoid*) mypard, (ub4)OCI_DTYPE_PARAM, 
-					(dvoid*) &dtype, (ub4 *)0, (ub4)OCI_ATTR_DATA_TYPE, 
-					(OCIError *)cs.errhp));
-				
-				/* Retrieve the column name attribute */
-				ub4 col_name_len;
-				check(services, cs, "get name", OCIAttrGet(
-					(dvoid*) mypard, (ub4)OCI_DTYPE_PARAM, 
-					(dvoid**) &col_name, (ub4 *) &col_name_len, (ub4)OCI_ATTR_NAME, 
-					(OCIError *)cs.errhp));
-				
-				{
-					size_t size=(size_t)col_name_len;
-					char *ptr=(char *)services.malloc(size);
-					tolower(ptr, (char *)col_name, size);
-					handlers.add_column(ptr, size);
-				}
-				
-				ub2 coerce_type=dtype;
-				sb4 size=0;
-				void *ptr;
-				
-				switch(dtype) {
-				case SQLT_CLOB: 
+			try {
+
+				// idea of preincrementing is that at error time all handles would free up
+				while(++column_count<=MAX_COLS) {
+					/* get next descriptor, if there is one */
+					if(OCIParamGet(stmthp, OCI_HTYPE_STMT, cs.errhp, (void **)&mypard, 
+						(ub4) column_count)!=OCI_SUCCESS) {
+						--column_count;
+						break;
+					}
+					
+					/* Retrieve the data type attribute */
+					check(services, cs, "get type", OCIAttrGet(
+						(dvoid*) mypard, (ub4)OCI_DTYPE_PARAM, 
+						(dvoid*) &dtype, (ub4 *)0, (ub4)OCI_ATTR_DATA_TYPE, 
+						(OCIError *)cs.errhp));
+					
+					/* Retrieve the column name attribute */
+					ub4 col_name_len;
+					check(services, cs, "get name", OCIAttrGet(
+						(dvoid*) mypard, (ub4)OCI_DTYPE_PARAM, 
+						(dvoid**) &col_name, (ub4 *) &col_name_len, (ub4)OCI_ATTR_NAME, 
+						(OCIError *)cs.errhp));
+					
 					{
-						check(services, cs, "alloc output var desc", OCIDescriptorAlloc(
-							(dvoid *)cs.envhp, (dvoid **)(ptr=&cols[column_count-1].var), 
-							(ub4)OCI_DTYPE_LOB, 
-							0, (dvoid **)0));
-						
-						size=0;
+						size_t size=(size_t)col_name_len;
+						char *ptr=(char *)services.malloc(size);
+						tolower(ptr, (char *)col_name, size);
+						handlers.add_column(ptr, size);
+					}
+					
+					ub2 coerce_type=dtype;
+					sb4 size=0;
+					void *ptr;
+					
+					switch(dtype) {
+					case SQLT_CLOB: 
+						{
+							check(services, cs, "alloc output var desc", OCIDescriptorAlloc(
+								(dvoid *)cs.envhp, (dvoid **)(ptr=&cols[column_count-1].var), 
+								(ub4)OCI_DTYPE_LOB, 
+								0, (dvoid **)0));
+							
+							size=0;
+							break;
+						}
+					default:
+						coerce_type=SQLT_STR;
+						ptr=cols[column_count-1].str=(char *)services.malloc(MAX_OUT_STRING_LENGTH+1);
+						size=MAX_OUT_STRING_LENGTH;
 						break;
 					}
-				default:
-					coerce_type=SQLT_STR;
-					ptr=cols[column_count-1].str=(char *)services.malloc(MAX_OUT_STRING_LENGTH+1);
-					size=MAX_OUT_STRING_LENGTH;
-					break;
+					
+					cols[column_count-1].type=coerce_type;
+					
+					check(services, cs, "DefineByPos", OCIDefineByPos(
+						stmthp, &cols[column_count-1].def, cs.errhp, 
+						column_count, (ub1 *) ptr, size, 
+						coerce_type, (dvoid *) &cols[column_count-1].indicator, 
+						(ub2 *)0, (ub2 *)0, OCI_DEFAULT));
 				}
 				
-				cols[column_count-1].type=coerce_type;
+				handlers.before_rows();
 				
-				check(services, cs, "DefineByPos", OCIDefineByPos(
-					stmthp, &cols[column_count-1].def, cs.errhp, 
-					column_count, (ub1 *) ptr, size, 
-					coerce_type, (dvoid *) &cols[column_count-1].indicator, 
-					(ub2 *)0, (ub2 *)0, OCI_DEFAULT));
-			}
-			
-			handlers.before_rows();
-			
-			for(unsigned long row=0; !limit||row<limit+offset; row++) {
-				sword status=OCIStmtFetch(stmthp, cs.errhp, (ub4)1,  (ub4)OCI_FETCH_NEXT, 
-					(ub4)OCI_DEFAULT);
-				if(status!=OCI_SUCCESS) {
-					if(status!=OCI_NO_DATA)
-						check(services, cs, "fetch", status);
-					break;
-				}
-				if(row>=offset) {
-					handlers.add_row();
-					for(int i=0; i<column_count; i++) {
-						size_t size;
-						void *ptr;
-						if(cols[i].indicator) { // NULL?
-							size=0;
-							ptr=0;
-						} else // not NULL
-							switch(cols[i].type) {
-							case SQLT_CLOB: 
-								{
-									ub4   amtp=4096000000UL;
-									ub4   offset=1;
-									ub4   loblen=0;
-									OCILobLocator *var=(OCILobLocator *)cols[i].var;
-									OCILobGetLength(cs.svchp, cs.errhp, var, &loblen);
-									if(loblen) {
-										size=(size_t)loblen;
+				for(unsigned long row=0; !limit||row<offset+limit; row++) {
+					sword status=OCIStmtFetch(stmthp, cs.errhp, (ub4)1,  (ub4)OCI_FETCH_NEXT, 
+						(ub4)OCI_DEFAULT);
+					if(status==OCI_NO_DATA)
+						break;
+					check(services, cs, "fetch", status);
+
+					if(row>=offset) {
+						handlers.add_row();
+						for(int i=0; i<column_count; i++) {
+							size_t size=0;
+							void *ptr=0;
+							if(!cols[i].indicator) // not NULL
+								switch(cols[i].type) {
+								case SQLT_CLOB: 
+									{
+										ub4   amtp=4096000000UL;
+										ub4   offset=1;
+										ub4   loblen=0;
+										OCILobLocator *var=(OCILobLocator *)cols[i].var;
+										OCILobGetLength(cs.svchp, cs.errhp, var, &loblen);
+										if(loblen) {
+											size=(size_t)loblen;
+											ptr=services.malloc(size);
+											check(services, cs, "lobread", OCILobRead(cs.svchp, cs.errhp, 
+												var, &amtp, offset, (dvoid *) ptr, 
+												loblen, (dvoid *)0, 
+												0, 
+												(ub2)0, (ub1) SQLCS_IMPLICIT));
+										}
+										break;
+									}
+								default:
+									if(const char *str=cols[i].str) {
+										size=strlen(str);
 										ptr=services.malloc(size);
-										check(services, cs, "lobread", OCILobRead(cs.svchp, cs.errhp, 
-											var, &amtp, offset, (dvoid *) ptr, 
-											loblen, (dvoid *)0, 
-											0, 
-											(ub2)0, (ub1) SQLCS_IMPLICIT));
+										memcpy(ptr, str, size);
+									} else {
+										size=0;
+										ptr=0;
 									}
 									break;
 								}
-							default:
-								if(const char *str=cols[i].str) {
-									size=strlen(str);
-									ptr=services.malloc(size);
-									memcpy(ptr, str, size);
-								} else {
-									size=0;
-									ptr=0;
-								}
-								break;
+							handlers.add_row_cell(ptr, size);
 						}
-						handlers.add_row_cell(ptr, size);
 					}
 				}
+			} catch(const SQL_Exception& e) {
+				cs.sql_exception=e;
+				failed=true;
+				goto cleanup;
+			} catch(...) {
+				cs.sql_exception=SQL_Exception("exception occured in SQL_Driver_query_event_handlers"); // out of memory...
+				failed=true;
+				goto cleanup;
 			}
 		}
 
@@ -821,9 +934,12 @@ void check(
 	const char *msg;
 	char reason[MAX_STRING/2];
 
+	const char *prefix="ERROR";
 	switch (status) {
-	case OCI_SUCCESS:
-		return; // hurrah
+	case OCI_SUCCESS: // hurrah
+	case OCI_SUCCESS_WITH_INFO:		// ignoring. example: count(column) when column contains NULLs, 
+														// count() not counting them and gives that status
+		return;
 	case OCI_ERROR:
 		{
 		sb4 errcode;
@@ -834,8 +950,6 @@ void check(
 			msg="[can not get error description]";
 		break;
 		}
-	case OCI_SUCCESS_WITH_INFO:
-		msg="SUCCESS_WITH_INFO"; break;
 	case OCI_NEED_DATA:
 		msg="NEED_DATA"; break;
 	case OCI_NO_DATA: