--- parser3/src/include/pa_sql_connection.h	2003/01/28 09:48:16	1.30.2.4
+++ parser3/src/include/pa_sql_connection.h	2017/02/07 22:00:36	1.44
@@ -1,16 +1,16 @@
 /** @file
 	Parser: sql fconnection decl.
 
-	Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
 #ifndef PA_SQL_CONNECTION_H
 #define PA_SQL_CONNECTION_H
 
-static const char* IDENT_SQL_CONNECTION_H="$Date: 2003/01/28 09:48:16 $";
+#define IDENT_PA_SQL_CONNECTION_H "$Id: pa_sql_connection.h,v 1.44 2017/02/07 22:00:36 moko Exp $"
+
 
-#include "pa_pool.h"
 #include "pa_sql_driver.h"
 #include "pa_sql_driver_manager.h"
 
@@ -18,9 +18,12 @@ static const char* IDENT_SQL_CONNECTION_
 
 /// @see SQL_Driver_services_impl::_throw
 #ifdef PA_WITH_SJLJ_EXCEPTIONS
-	#define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) actions
+	#define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) \
+		use(); \
+		actions
 #else
 	#define SQL_CONNECTION_SERVICED_FUNC_GUARDED(actions) \
+		use(); \
 		if(!setjmp(fservices.mark)) { \
 			actions; \
 		} else \
@@ -29,16 +32,27 @@ static const char* IDENT_SQL_CONNECTION_
 
 /// SQL_Driver_services Pooled implementation
 class SQL_Driver_services_impl: public SQL_Driver_services {
-	Pool *fpool;
-	ConstStringPtr furl;
+	const String* furl;
 	Exception fexception;
+	const char* frequest_charset;
+	const char* fdocument_root;
 public:
-	SQL_Driver_services_impl(): fpool(0), furl(0) {}
-	void set_pool_and_url(Pool *apool, ConstStringPtr aurl) { fpool=apool; furl=aurl;}
+	SQL_Driver_services_impl(const char* arequest_charset, const char* adocument_root): furl(0), frequest_charset(arequest_charset), fdocument_root(adocument_root) {}
+	void set_url(const String& aurl) { furl=&aurl;}
+	const String& url_without_login() const;
+
+	override void* malloc(size_t size) { return pa_malloc(size); }
+	override void* malloc_atomic(size_t size) { return pa_malloc_atomic(size); }
+	override void* realloc(void *ptr, size_t size) { return pa_realloc(ptr, size); }
 
-	override void *malloc(size_t size) { return fpool->malloc(size); }
-	override void *calloc(size_t size) { return fpool->calloc(size); }
-	override void *realloc(void *ptr, size_t size) { return fpool->realloc(ptr, size); }
+	override const char* request_charset() { return frequest_charset; }
+	override const char* request_document_root() { return fdocument_root; }
+	
+	override void transcode(const char* src, size_t src_length,
+		const char*& dst, size_t& dst_length,
+		const char* charset_from_name,
+		const char* charset_to_name
+		);
 
 	/**
 		normally we can't 'throw' from dynamic library, so
@@ -58,8 +72,8 @@ public:
 #else
 		fexception=
 #endif
-			Exception(aexception.type(), 
-					url_without_login(),
+		Exception(aexception.type(), 
+				&url_without_login(),
 				aexception.comment()); 
 
 #ifndef PA_WITH_SJLJ_EXCEPTIONS
@@ -71,37 +85,38 @@ public:
 		throw fexception;
 #endif
 	}
-
-private:
-	ConstStringPtr url_without_login() const;
 };
 
 /// SQL connection. handy wrapper around low level SQL_Driver
 class SQL_Connection: public PA_Object {
-	ConstStringPtr  furl;
+	const String&  furl;
 	SQL_Driver& fdriver;
 	SQL_Driver_services_impl fservices;
 	void *fconnection;
 	time_t time_used;
-	bool marked_to_rollback;
 
 public:
 
-	SQL_Connection(ConstStringPtr aurl, SQL_Driver& adriver):
+	SQL_Connection(const String& aurl, SQL_Driver& adriver, const char* arequest_charset, const char* adocument_root):
 		furl(aurl),
 		fdriver(adriver),
+		fservices(arequest_charset, adocument_root),
 		fconnection(0),
-		time_used(0), 
-		marked_to_rollback(false) {
+		time_used(0) {
 	}
+
+	SQL_Driver_services_impl& services() { return fservices; }
 	
-	ConstStringPtr get_url() { return furl; }
+	const String& get_url() { return furl; }
 
-	void set_pool(Pool *pool) {
-		fservices.set_pool_and_url(pool, pool?furl:ConstStringPtrZero);
+	void set_url() {
+		fservices.set_url(furl);
+	}
+	void use() {
+		time_used=time(0); // they started to use at this time
 	}
 	bool expired(time_t older_dies) {
-		return /*!freferences && */time_used<older_dies;
+		return time_used<older_dies;
 	}
 	time_t get_time_used() { return time_used; }
 
@@ -116,64 +131,54 @@ public:
 	}
 	bool ping() { 
 		SQL_CONNECTION_SERVICED_FUNC_GUARDED(
-			return fdriver.ping(fservices, fconnection)
+			return fdriver.ping(fconnection)
 		);
-		return 0; // never reached
 	}
-	uint quote(char *to, const char *from, unsigned int length) {
+	const char* quote(const char* str, unsigned int length) {
 		SQL_CONNECTION_SERVICED_FUNC_GUARDED(
-			return fdriver.quote(fservices, fconnection, to, from, length)
+			return fdriver.quote(fconnection, str, length)
 		);
-		return 0; // never reached
 	}
 
 	void query(
-		const char *statement, unsigned long offset, unsigned long limit,
+		const char* statement, 
+		size_t placeholders_count, SQL_Driver::Placeholder* placeholders,
+		unsigned long offset, unsigned long limit,
 		SQL_Driver_query_event_handlers& handlers, 
-		ConstStringPtr source) {
+		const String& source) {
 		try {
 			SQL_CONNECTION_SERVICED_FUNC_GUARDED(
-				fdriver.query(fservices, fconnection, 
-					statement, offset, limit, 
+				fdriver.query(fconnection, 
+					statement, 
+					placeholders_count, placeholders,
+					offset, limit, 
 					handlers)
 			);	
 		} catch(const Exception& e) { // query problem
 			if(strcmp(e.type(), "sql.connect")==0) { // if it is _throw exception, 
 				// give more specific source [were url]
 				throw Exception("sql.execute",
-					source, 
+					&source, 
 					"%s", e.comment());
 			} else
-				/*re*/throw;
+				rethrow;
 		}
 	}
 
-	void mark_to_rollback() {
-		marked_to_rollback=true;
-	}
-
-private: // closing process
-
 	void commit() { 
 		SQL_CONNECTION_SERVICED_FUNC_GUARDED(
-			fdriver.commit(fservices, fconnection) 
+			fdriver.commit(fconnection) 
 		);
 	}
 	void rollback() { 
 		SQL_CONNECTION_SERVICED_FUNC_GUARDED(
-			fdriver.rollback(fservices, fconnection)
+			fdriver.rollback(fconnection)
 		);
 	}
 
 	/// return to cache
 	void close() {
-		if(marked_to_rollback) {
-			rollback();
-			marked_to_rollback=false;
-		} else
-			commit();
-
-		SQL_driver_manager.close_connection(furl, SQL_ConnectionPtr(this));
+		SQL_driver_manager->close_connection(furl, this);
 	}
 
 };