--- sql/sqlite/parser3sqlite.C	2008/06/27 17:36:30	1.7
+++ sql/sqlite/parser3sqlite.C	2019/11/30 21:51:35	1.16
@@ -3,12 +3,12 @@
 
 	(c) Dmitry "Creator" Bobrik, 2004
 */
-//static const char *RCSId="$Id: parser3sqlite.C,v 1.7 2008/06/27 17:36:30 misha Exp $"; 
 
 #include "config_includes.h"
 
 #include "pa_sql_driver.h"
-//#include "windows.h"  // for messagebox
+
+volatile const char * IDENT_PARSER3SQLITE_C="$Id: parser3sqlite.C,v 1.16 2019/11/30 21:51:35 moko Exp $" IDENT_PA_SQL_DRIVER_H;
 
 #define NO_CLIENT_LONG_LONG
 #include "sqlite3.h"
@@ -54,6 +54,7 @@ struct Connection {
 	const char* client_charset;
 	bool multi_statements;
 	bool autocommit;
+	int busy_timeout;
 };
 
 
@@ -78,10 +79,11 @@ public:
 
 	/**	connect
 		@param url
-			format: @b [localhost/]dbfile?
-			autocommit=1&
-			multi_statements=0&
-			ClientCharset=UTF-8
+			format: @b db-file|:memory:|temporary:?
+			autocommit=1&			// =0 disable autocommit. in this case 1 connect == 1 transaction.
+									//	or you can use begin/commit|rollback explicitly
+			multi_statements=0&		// =1 allow many statements in 1 query
+			ClientCharset=UTF-8		// will transcode to/from specified charset instead of UTF-8 (default for sqlite)
 	*/
 	void connect(
 				char *url, 
@@ -93,29 +95,28 @@ public:
 		*connection_ref=&connection;
 		connection.services=&services;
 
-		connection.client_charset=SQLITE_DEFAULT_CHARSET;	
+		connection.client_charset=SQLITE_DEFAULT_CHARSET;
 		connection.multi_statements=false;
 		connection.autocommit=true;
+		connection.busy_timeout=4000;
 
 		char* db_path=0;
 		char* db=url;
 		char* options=lsplit(db, '?');
 
-		if(strcmp(db, ":memory:")==0){ // in-memory table
+		if(strcmp(db, ":memory:")==0){ // in-memory temporary DB
 			db_path=db;
-		} else if(strcmp(db, ":temporary:")==0){ // on disk temporary table (in :memory: style)
+		} else if(strcmp(db, ":temporary:")==0){ // on-disk temporary DB
 			// do nothing: empty path mean temporary table on disk
-		} else { // build path to DB-file from document_root (as anywhere in parser)
-			if(char* document_root=(char*)services.request_document_root()){
-				db_path=(char*)services.malloc_atomic(strlen(document_root)+strlen(db)+1+1);
-				db_path=strncpy(db_path, document_root, MAX_STRING);
-				db_path=strncat(db_path, "/", MAX_STRING);
-			} else {
-				// if document root empty -- build path from executable file
-				db_path=(char*)services.malloc_atomic(strlen(db)+2+1);
-				db_path=strncpy(db_path, "./", MAX_STRING);
-			}
-			db_path=strncat(db_path, db, strlen(db));
+		} else {
+			char* document_root=(char*)services.request_document_root();
+			if(!document_root) // path to DB-file which was specified by user is path from document_root as anywhere in parser
+				services._throw("document_root is empty");
+
+			db_path=(char*)services.malloc_atomic(strlen(document_root)+1+strlen(db)+1);
+			strcpy(db_path, document_root);
+			strcat(db_path, "/");
+			strcat(db_path, db);
 		}
 
 		//services._throw(db_path);
@@ -124,20 +125,17 @@ public:
 			if(char* key=lsplit(&options, '&')){
 				if(*key) {
 					if(char* value=lsplit(key, '=')){
-						if(strcasecmp(key, "multi_statements")==0) {
+						if(strcasecmp(key, "multi_statements")==0){
 							if(atoi(value)!=0)
 								connection.multi_statements=true;
+						} else if(strcasecmp(key, "busy_timeout")==0){
+							connection.busy_timeout=atoi(value);
 						} else if(strcasecmp(key, "autocommit")==0){
 							if(atoi(value)==0)
 								connection.autocommit=false;
-							continue;
-						} else if(strcmp(key, "ClientCharset")==0){	// transcoding with parser. 
-												// by default we always transcode to UTF-8 (sqlite default)
-												// so use this option only if you already stored data in your sqlite DB
-												// in wrong encoding (1251 for ex.)
+						} else if(strcmp(key, "ClientCharset")==0){
 							toupper_str(value, value, strlen(value));
 							connection.client_charset=value;
-							continue;
 						} else
 							services._throw("unknown connect option" /*key*/);
 					} else 
@@ -164,6 +162,8 @@ public:
 			_throw(connection, error_msg);
 		}
 		
+		sqlite3_busy_timeout(connection.handle, connection.busy_timeout);
+		
 		_begin_transaction(connection);
 	}
 
@@ -193,23 +193,33 @@ public:
 		return true; // not needed
 	}
 
-	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++){
+			if(*from=='\'')
+				quoted++;
+		}
+
+		if(!quoted)
+			return str;
+
 		Connection& connection=*static_cast<Connection*>(aconnection);
-		/*
-			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);
-		char *to=result;
-		while(length--) {
-			if(*from=='\'') { // ' -> ''
-				*to++='\'';
-			} else if(*from=='\"') { // " -> ""
-				*to++='\"';
-			}
-			*to++=*from++;
+		char *result=(char*)connection.services->malloc_atomic(length + quoted + 1);
+		char *to = result;
+
+		for(from=str; from<from_end; from++){
+			if(*from=='\'')
+				*to++= '\''; // ' -> ''
+			*to++=*from;
 		}
+		
 		*to=0;
 		return result;
 	}
@@ -226,7 +236,9 @@ public:
 
 		if(placeholders_count>0)
 			services._throw("bind variables not supported yet");
-   
+		
+		const char* request_charset=services.request_charset();
+		const char* client_charset=connection.client_charset;
 		bool transcode_needed=_transcode_required(connection);
 
 		// transcode query from $request:charset to ?ClientCharset
@@ -234,8 +246,8 @@ public:
 			size_t length=strlen(astatement);
 			services.transcode(astatement, length,
 				astatement, length,
-				services.request_charset(),
-				connection.client_charset);
+				request_charset,
+				client_charset);
 		}
 		
 		const char *statement;
@@ -248,9 +260,9 @@ public:
 			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;
@@ -267,12 +279,12 @@ public:
 			rc=sqlite3_prepare(connection.handle, statement, -1, &SQL, &pzTail);
 			next_statement_length=strlen(pzTail);
 			if(rc!=SQLITE_OK){
-				sqlite3_free((char*)pzTail);
+				//sqlite3_free((char*)pzTail);
 				_throw(connection, sqlite3_errmsg(connection.handle));
 			}
 			if(!connection.multi_statements && next_statement_length>0){ // multi statements was not allowed but pzTail point to not empty one
-				sqlite3_free((char*)pzTail);
-				_throw(connection, "multi statements are not allowed in this connection");
+				//sqlite3_free((char*)pzTail);
+				_throw(connection, "multi statements are not allowed until option ?multi_statements=1 in connect string is specified.");
 			}
 			
 			#define CHECK(afailed) if(afailed){ failed=true; goto cleanup; }
@@ -293,15 +305,14 @@ public:
 					if(transcode_needed){
 						services.transcode(str, length,
 							str, length,
-							connection.client_charset,
-							services.request_charset());
+							client_charset,
+							request_charset);
 					}
 							
 					CHECK(handlers.add_column(sql_error, (const char*)str, length));
 				}
 				CHECK(handlers.before_rows(sql_error));
 
-				int column_type;
 				const char *str;
 				size_t length=0;
 
@@ -313,8 +324,8 @@ public:
 
 						for(int i=0; i<column_count; i++){
 							// SQLite allow to get value of any type using sqlite3_column_text function
-							column_type=sqlite3_column_type(SQL, i);
 							bool transcode_value=false;
+							int column_type=sqlite3_column_type(SQL, i);
 							switch(column_type){
 								case SQLITE_NULL:
 									length=0;
@@ -325,10 +336,10 @@ public:
 									length=(size_t)sqlite3_column_bytes(SQL, i);
 									break;
 								case SQLITE_TEXT: // for text transcoding can be required
+								default: // anything else?
 									transcode_value=transcode_needed;
 								case SQLITE_INTEGER:
 								case SQLITE_FLOAT:
-								default: // what else? may be for future purposes
 									str=(const char*)sqlite3_column_text(SQL, i);
 									length=(size_t)sqlite3_column_bytes(SQL, i);
 									break;
@@ -336,15 +347,16 @@ public:
 
 							if(length){
 								char* strm=(char*)services.malloc_atomic(length+1);
-								memcpy(strm, str, length+1);
+								memcpy(strm, str, length);
+								strm[length]=0;
 								str=strm;
 
-								// transcode cell value from ?ClientCharset to $request:charset 
 								if(transcode_value){
+									// transcode cell value from ?ClientCharset to $request:charset
 									services.transcode(str, length,
 										str, length,
-										connection.client_charset,
-										services.request_charset());
+										client_charset,
+										request_charset);
 								}
 							} else
 								str=0;
@@ -414,6 +426,8 @@ private: // sqlite client library funcs
 
 	typedef int (*t_sqlite3_close)(sqlite3 *); t_sqlite3_close sqlite3_close;
 
+	typedef int (*t_sqlite3_busy_timeout)(sqlite3*, int ms); t_sqlite3_busy_timeout sqlite3_busy_timeout;
+
 	typedef int (*t_sqlite3_exec)(sqlite3*, const char *sql, sqlite3_callback, void *, char **errmsg); t_sqlite3_exec sqlite3_exec;
 
 	typedef void (*t_sqlite3_free)(char *z); t_sqlite3_free sqlite3_free;
@@ -442,13 +456,17 @@ private: // sqlite client library funcs
 private: // sqlite 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) {
-            if(const char* result=lt_dlerror())
-            	return result;
+		if(lt_dlinit()){
+			if(const char* result=lt_dlerror())
+				return result;
+			return "can not prepare to dynamic loading";
+		}
+
+		lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
 
+		if(!handle){
+			if(const char* result=lt_dlerror())
+				return result;
 			return "can not open the dynamic link module";
 		}
 
@@ -462,6 +480,7 @@ private: // sqlite client library funcs
 		
 		DLINK(sqlite3_open);
 		DLINK(sqlite3_close);
+		DLINK(sqlite3_busy_timeout);
 		DLINK(sqlite3_exec);
 		DLINK(sqlite3_free);
 		DLINK(sqlite3_errmsg);