diff --git a/uppsrc/Core/Core.h b/uppsrc/Core/Core.h
index 0d4b48d1c..58a74f1a9 100644
--- a/uppsrc/Core/Core.h
+++ b/uppsrc/Core/Core.h
@@ -5,6 +5,7 @@
 
 #if defined(flagMT)
 	#define _MULTITHREADED
+	#define MULTITHREADED
 	#ifdef flagDLL
 		#define flagUSEMALLOC
 	#endif
diff --git a/uppsrc/MySql/MySql.cpp b/uppsrc/MySql/MySql.cpp
index 463abf03d..1fbf40121 100644
--- a/uppsrc/MySql/MySql.cpp
+++ b/uppsrc/MySql/MySql.cpp
@@ -109,6 +109,7 @@ bool MySqlSession::Open(const char *connect) {
 }
 
 void MySqlSession::Close() {
+	SessionClose();
 	if(mysql) {
 		mysql_close(mysql);
 		mysql = NULL;
diff --git a/uppsrc/MySql/MySql.h b/uppsrc/MySql/MySql.h
index 70ac73f4b..a1aa733ae 100644
--- a/uppsrc/MySql/MySql.h
+++ b/uppsrc/MySql/MySql.h
@@ -13,7 +13,7 @@
 #endif
 
 #ifdef PLATFORM_POSIX
-#include </usr/include/mysql/mysql.h>
+#include <mysql/mysql.h>
 #endif
 
 NAMESPACE_UPP
diff --git a/uppsrc/MySql/MySqlSchema.h b/uppsrc/MySql/MySqlSchema.h
index 7cb549026..f7d2fa471 100644
--- a/uppsrc/MySql/MySqlSchema.h
+++ b/uppsrc/MySql/MySqlSchema.h
@@ -101,5 +101,7 @@
 
 #undef UNIQUE
 
+#undef REFERENCES
+
 #undef TIMESTAMP
 #undef COMMENT
diff --git a/uppsrc/ODBC/ODBC.cpp b/uppsrc/ODBC/ODBC.cpp
index 117472f61..27291c09a 100644
--- a/uppsrc/ODBC/ODBC.cpp
+++ b/uppsrc/ODBC/ODBC.cpp
@@ -1,566 +1,567 @@
-#include "ODBC.h"
-
-NAMESPACE_UPP
-
-#define LLOG(x) // LOG(x)
-
-class ODBCConnection : public SqlConnection
-{
-public:
-	ODBCConnection(ODBCSession *session);
-	virtual ~ODBCConnection();
-
-	void                    Clear();
-
-	virtual void            SetParam(int i, const Value& r);
-	virtual bool            Execute();
-	virtual int             GetRowsProcessed() const;
-	virtual bool            Fetch();
-	virtual void            GetColumn(int i, Ref r) const;
-	virtual void            Cancel();
-	virtual SqlSession&     GetSession() const { ASSERT(session); return *session; }
-	virtual String          GetUser() const    { ASSERT(session); return session->user; }
-	virtual String          ToString() const;
-	virtual Value           GetInsertedId() const;
-
-private:
-	friend class ODBCSession;
-
-	ODBCSession           *session;
-	struct Param {
-		int    ctype;
-		int    sqltype;
-		String data;
-		SQLLEN li;
-	};
-	Array<Param>             param, bparam;
-	String                   last_insert_table;
-
-	int                      rowsprocessed;
-	Vector< Vector<double> > number;
-	Vector< Vector<int64> >  num64;
-	Vector< Vector<String> > text;
-	Vector< Vector<Time> >   time;
-	int                      rowcount;
-	int                      rowi;
-	Vector<Value>            fetchrow;
-	Vector<bool>             binary;
-	
-	bool                   IsOk(SQLRETURN ret) const;
-	void                   Flush();
-	bool                   Fetch0();
-	bool                   IsCurrent() const   { return session->current == this; }
-};
-
-bool ODBCSession::Connect(const char *cs)
-{
-	if(henv && IsOk(SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc))) {
-		if(IsOk(SQLDriverConnect(hdbc, NULL, (SQLCHAR *)cs, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT))) {
-			SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
-			return true;
-		}
-		SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
-		hdbc = SQL_NULL_HANDLE;
-		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
-		SQLSetConnectAttr(hdbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TRANSACTION_SERIALIZABLE, SQL_NTS);
-	}
-	return false;
-}
-
-bool ODBCSession::IsOpen() const
-{
-	return hdbc != SQL_NULL_HANDLE;
-}
-
-void ODBCSession::Close()
-{
-	if(hdbc != SQL_NULL_HANDLE) {
-		current = NULL;
-		FlushConnections();
-		SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
-		SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
-		hdbc = SQL_NULL_HANDLE;
-		hstmt = SQL_NULL_HANDLE;
-		current = NULL;
-	}
-}
-
-void ODBCSession::FlushConnections()
-{
-	LLOG("FlushConnections");
-	if(current) {
-		current->Flush();
-		current = NULL;
-	}
-	SQLFreeStmt(hstmt, SQL_CLOSE);
-}
-
-bool ODBCSession::IsOk(SQLRETURN ret)
-{
-	if(SQL_SUCCEEDED(ret))
-		return true;
-	SQLCHAR       SqlState[6], Msg[SQL_MAX_MESSAGE_LENGTH];
-	SQLINTEGER    NativeError;
-	SQLSMALLINT   MsgLen;
-	String        error;
-	int i = 1;
-	while(SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, i++, SqlState, &NativeError,
-	                 Msg, sizeof(Msg), &MsgLen) != SQL_NO_DATA) {
-		if(error.GetCount())
-			error << "\r\n";
-		error << (char *)Msg;
-	}
-	SetError(error, statement);
-	return false;
-}
-
-ODBCSession::ODBCSession()
-{
-	hdbc = SQL_NULL_HANDLE;
-	hstmt = SQL_NULL_HANDLE;
-	SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
-	if(henv)
-		SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
-	tlevel = 0;
-	Dialect(MSSQL);
-	current = NULL;
-}
-
-ODBCSession::~ODBCSession()
-{
-	if(henv)
-		SQLFreeHandle(SQL_HANDLE_ENV, henv);
-}
-
-void ODBCSession::Begin()
-{
-	if(tlevel == 0)
-		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, SQL_NTS);
-	tlevel++;
-}
-
-void ODBCSession::Commit()
-{
-	tlevel--;
-	ASSERT(tlevel >= 0);
-	if(tlevel == 0) {
-		SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
-		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
-	}
-}
-
-void ODBCSession::Rollback()
-{
-	tlevel--;
-	ASSERT(tlevel >= 0);
-	if(tlevel == 0) {
-		SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_ROLLBACK);
-		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
-	}
-}
-
-String ODBCSession::Savepoint()
-{
-	NEVER();
-	return "";
-}
-
-void ODBCSession::RollbackTo(const String& savepoint)
-{
-	NEVER();
-}
-
-Vector<String> ODBCSession::EnumUsers()
-{
-	return Vector<String>();
-}
-
-Vector<String> ODBCSession::EnumDatabases()
-{
-	return Vector<String>();
-}
-
-Vector<String> ODBCSession::EnumTables(String database)
-{
-	return Vector<String>();
-}
-
-Vector<String> ODBCSession::EnumViews(String database)
-{
-	return Vector<String>();
-}
-
-Vector<String> ODBCSession::EnumSequences(String database)
-{
-	return Vector<String>();
-}
-
-Vector<String> ODBCSession::EnumPrimaryKeys(String database, String table)
-{
-	return Vector<String>();
-}
-
-String ODBCSession::EnumRowID(String database, String table)
-{
-	return "";
-}
-
-bool   ODBCPerformScript(const String& text, StatementExecutor& executor, Gate2<int, int> progress_canceled)
-{
-	const char *p = text;
-	while(*p) {
-		String cmd;
-		while(*p && *p != ';')
-			if(*p == '\'') {
-				const char *s = p;
-				while(*++p && (*p != '\'' || *++p == '\''))
-					;
-				cmd.Cat(s, int(p - s));
-			}
-			else {
-				if(*p > ' ')
-					cmd.Cat(*p);
-				else if(!cmd.IsEmpty() && *cmd.Last() != ' ')
-					cmd.Cat(' ');
-				p++;
-			}
-		if(progress_canceled(int(p - text.Begin()), text.GetLength()))
-			return false;
-		if(!IsNull(cmd) && !executor.Execute(cmd))
-			return false;
-		if(*p == ';')
-			p++;
-	}
-	return true;
-}
-
-SqlConnection *ODBCSession::CreateConnection()
-{
-	return new ODBCConnection(this);
-}
-
-ODBCConnection::ODBCConnection(ODBCSession *session_)
-:	session(session_)
-{
-	LLOG("ODBCConnection " << (void *)this << " " << (void *)session);
-	rowcount = rowi = 0;
-}
-
-ODBCConnection::~ODBCConnection()
-{
-	if(IsCurrent())
-		session->current = NULL;
-	LLOG("~ODBCConnection " << (void *)this << " " << (void *)session);
-}
-
-bool ODBCConnection::IsOk(SQLRETURN ret) const
-{
-	if(SQL_SUCCEEDED(ret) || ret == SQL_NO_DATA)
-		return true;
-	SQLCHAR       SqlState[6], Msg[SQL_MAX_MESSAGE_LENGTH];
-	SQLINTEGER    NativeError;
-	SQLSMALLINT   MsgLen;
-	String        error;
-	int i = 1;
-	while(SQLGetDiagRec(SQL_HANDLE_STMT, session->hstmt, i++, SqlState, &NativeError,
-	                    Msg, sizeof(Msg), &MsgLen) != SQL_NO_DATA) {
-		if(error.GetCount())
-			error << "\r\n";
-		error << (char *)Msg;
-	}
-	session->SetError(error, statement);
-	return false;
-}
-
-void ODBCConnection::SetParam(int i, const Value& r)
-{
-	Param& p = param.At(i);
-	if(IsNumber(r)) {
-		if(r.Is<int64>()) {
-			int64 x = r;
-			p.ctype = SQL_C_SBIGINT;
-			p.sqltype = SQL_BIGINT;
-			p.data = String((char *)&x, sizeof(x));
-			p.li = sizeof(x);
-		}
-		else {
-			double x = r;
-			p.ctype = SQL_C_DOUBLE;
-			p.sqltype = SQL_DOUBLE;
-			p.data = String((char *)&x, sizeof(x));
-			p.li = sizeof(x);
-		}
-	}
-	if(IsString(r)) {
-		p.ctype = SQL_C_CHAR;
-		p.sqltype = SQL_LONGVARCHAR;
-		p.data = r;
-		p.li = p.data.GetLength();
-	}
-	if(IsDateTime(r)) {
-		p.ctype = SQL_C_TYPE_TIMESTAMP;
-		p.sqltype = SQL_TYPE_TIMESTAMP;
-		Time t = r;
-		SQL_TIMESTAMP_STRUCT tm;
-		tm.year = t.year;
-		tm.month = t.month;
-		tm.day = t.day;
-		tm.hour = t.hour;
-		tm.minute = t.minute;
-		tm.second = t.second;
-		tm.fraction = 0;
-		p.data = String((char *)&tm, sizeof(tm));
-		p.li = sizeof(tm);
-	}
-	if(IsNull(r))
-		p.li = SQL_NULL_DATA;
-}
-
-bool ODBCConnection::Execute()
-{
-	LLOG("Execute " << (void *)this << " " << (void *)session);
-	if(session->hstmt == SQL_NULL_HANDLE)
-		return false;
-	if(IsCurrent())
-		session->current = NULL;
-	session->FlushConnections();
-	last_insert_table.Clear();
-	number.Clear();
-	text.Clear();
-	time.Clear();
-	CParser p(statement);
-	if((p.Id("insert") || p.Id("INSERT")) && (p.Id("into") || p.Id("INTO")) && p.IsId())
-		last_insert_table = p.ReadId();
-	if(!IsOk(SQLPrepare(session->hstmt, (SQLCHAR *)~statement, statement.GetCount())))
-		return false;
-	parse = false;
-	bparam = param;
-	param.Clear();
-	for(int i = 0; i < bparam.GetCount(); i++) {
-		Param& p = bparam[i];
-		SQLSMALLINT     DataType;
-		SQLULEN         ParameterSize;
-		SQLSMALLINT     DecimalDigits;
-		SQLSMALLINT     Nullable;
-		if(!IsOk(SQLDescribeParam(session->hstmt, i + 1, &DataType, &ParameterSize, &DecimalDigits, &Nullable)))
-			return false;
-		if(!IsOk(SQLBindParameter(session->hstmt, i + 1, SQL_PARAM_INPUT, p.ctype, DataType,
-		                          ParameterSize, DecimalDigits, (SQLPOINTER)~p.data, p.data.GetLength(),
-		                          &p.li)))
-			return false;
-	}
-	SQLSMALLINT ncol;
-	if(!IsOk(SQLExecute(session->hstmt)) || !IsOk(SQLNumResultCols(session->hstmt, &ncol))) {
-		SQLFreeStmt(session->hstmt, SQL_CLOSE);
-		return false;
-	}
-	session->current = this;
-	info.Clear();
-	binary.Clear();
-	for(int i = 1; i <= ncol; i++) {
-		SQLCHAR      ColumnName[256];
-		SQLSMALLINT  NameLength;
-		SQLSMALLINT  DataType;
-		SQLULEN      ColumnSize;
-		SQLSMALLINT  DecimalDigits;
-		SQLSMALLINT  Nullable;
-		if(!IsOk(SQLDescribeCol(session->hstmt, i, ColumnName, 255, &NameLength, &DataType,
-		                        &ColumnSize, &DecimalDigits, &Nullable)))
-			return false;
-		binary.Add(false);
-		SqlColumnInfo& f = info.Add();
-		f.nullable = Nullable != SQL_NO_NULLS;
-		f.binary = false;
-		f.precision = DecimalDigits;
-		f.scale = 0;
-		f.width = ColumnSize;
-		f.name = (char *)ColumnName;
-		switch(DataType) {
-		case SQL_DECIMAL:
-		case SQL_NUMERIC:
-		case SQL_SMALLINT:
-		case SQL_INTEGER:
-		case SQL_REAL:
-		case SQL_FLOAT:
-		case SQL_DOUBLE:
-		case SQL_BIT:
-		case SQL_TINYINT:
-			f.type = DOUBLE_V;
-			break;
-		case SQL_BIGINT:
-			f.type = INT64_V;
-			break;
-		case SQL_TYPE_DATE:
-		case SQL_TYPE_TIMESTAMP:
-			f.type = TIME_V;
-			break;
-		case SQL_BINARY:
-		case SQL_VARBINARY:
-		case SQL_LONGVARBINARY:
-			f.type = STRING_V;
-			f.binary = true;
-			binary.Top() = true;
-			break;
-		default:
-			f.type = STRING_V;
-			break;
-		}
-	}
-	SQLLEN rc;
-	SQLRowCount(session->hstmt, &rc);
-	rowsprocessed = rc;
-	return true;
-}
-
-int ODBCConnection::GetRowsProcessed() const
-{
-	return rowsprocessed;
-}
-
-bool ODBCConnection::Fetch0()
-{
-	LLOG("Fetch0 " << (void *)this << " " << (void *)session);
-	int ret = SQLFetch(session->hstmt);
-	if(ret == SQL_NO_DATA || !IsOk(ret))
-		return false;
-	fetchrow.Clear();
-	double dbl;
-	int64 n64;
-	SQL_TIMESTAMP_STRUCT tm;
-	SQLLEN li;
-	for(int i = 0; i < info.GetCount(); i++) {
-		Value v = Null;
-		switch(info[i].type) {
-		case DOUBLE_V:
-			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_DOUBLE, &dbl, sizeof(dbl), &li)))
-			   break;
-			if(li != SQL_NULL_DATA)
-				v = dbl;
-			break;
-		case INT64_V:
-			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_SBIGINT, &n64, sizeof(n64), &li)))
-			   break;
-			if(li != SQL_NULL_DATA)
-				v = n64;
-			break;
-		case TIME_V:
-			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_TYPE_TIMESTAMP, &tm, sizeof(tm), &li)))
-			   break;
-			if(li != SQL_NULL_DATA) {
-				Time m;
-				m.year = tm.year;
-				m.month = (byte)tm.month;
-				m.day = (byte)tm.day;
-				m.hour = (byte)tm.hour;
-				m.minute = (byte)tm.minute;
-				m.second = (byte)tm.second;
-				v = m;
-			}
-			break;
-		default:
-			int ct = binary[i] ? SQL_C_BINARY : SQL_C_CHAR;
-			if(!IsOk(SQLGetData(session->hstmt, i + 1, ct, &tm, 0, &li)))
-			   break;
-			if(li != SQL_NULL_DATA) {
-				StringBuffer sb;
-				sb.SetLength(li);
-				if(!IsOk(SQLGetData(session->hstmt, i + 1, ct, ~sb, li + 1, &li)))
-				   break;
-				v = String(sb);
-			}
-			break;
-		}
-		fetchrow.Add(v);
-	}
-	return ret != SQL_NO_DATA && IsOk(ret);
-}
-
-bool ODBCConnection::Fetch()
-{
-	if(IsCurrent())
-		return Fetch0();
-	if(rowi >= rowcount)
-		return false;
-	fetchrow.Clear();
-	for(int i = 0; i < info.GetCount(); i++) {
-		Value v;
-		switch(info[i].type) {
-		case DOUBLE_V:
-			v = number[i][rowi];
-			break;
-		case INT64_V:
-			v = num64[i][rowi];
-			break;
-		case TIME_V:
-			v = time[i][rowi];
-			break;
-		default:
-			v = text[i][rowi];
-			break;
-		}
-		fetchrow.Add(v);
-	}
-	++rowi;
-	return true;
-}
-
-void ODBCConnection::GetColumn(int i, Ref r) const
-{
-	LLOG("GetColumn " << (void *)this << " " << (void *)session);
-	r.SetValue(fetchrow[i]);
-}
-
-void ODBCConnection::Flush()
-{
-	LLOG("Flush " << (void *)this);
-	rowcount = 0;
-	rowi = 0;
-	number.Clear();
-	number.SetCount(info.GetCount());
-	text.Clear();
-	text.SetCount(info.GetCount());
-	time.Clear();
-	time.SetCount(info.GetCount());
-	while(info.GetCount() && Fetch0()) {
-		rowcount++;
-		for(int i = 0; i < info.GetCount(); i++)
-			switch(info[i].type) {
-			case DOUBLE_V:
-				number[i].Add(fetchrow[i]);
-				break;
-			case INT64_V:
-				num64[i].Add(fetchrow[i]);
-				break;
-			case STRING_V:
-				text[i].Add(fetchrow[i]);
-				break;
-			case TIME_V:
-				time[i].Add(fetchrow[i]);
-				break;
-			}
-	}
-	LLOG("Flush fetched " << rowcount);
-}
-
-void ODBCConnection::Cancel()
-{
-	param.Clear();
-	bparam.Clear();
-	number.Clear();
-	text.Clear();
-	time.Clear();
-}
-
-String ODBCConnection::ToString() const
-{
-	return statement;
-}
-
-Value ODBCConnection::GetInsertedId() const
-{
-	Sql sql(GetSession());
-	return last_insert_table.GetCount() ? sql.Select("IDENT_CURRENT('" + last_insert_table + "')")
-	                                    : sql.Select("@@IDENTITY");
-}
-
-END_UPP_NAMESPACE
+#include "ODBC.h"
+
+NAMESPACE_UPP
+
+#define LLOG(x) // LOG(x)
+
+class ODBCConnection : public SqlConnection
+{
+public:
+	ODBCConnection(ODBCSession *session);
+	virtual ~ODBCConnection();
+
+	void                    Clear();
+
+	virtual void            SetParam(int i, const Value& r);
+	virtual bool            Execute();
+	virtual int             GetRowsProcessed() const;
+	virtual bool            Fetch();
+	virtual void            GetColumn(int i, Ref r) const;
+	virtual void            Cancel();
+	virtual SqlSession&     GetSession() const { ASSERT(session); return *session; }
+	virtual String          GetUser() const    { ASSERT(session); return session->user; }
+	virtual String          ToString() const;
+	virtual Value           GetInsertedId() const;
+
+private:
+	friend class ODBCSession;
+
+	ODBCSession           *session;
+	struct Param {
+		int    ctype;
+		int    sqltype;
+		String data;
+		SQLLEN li;
+	};
+	Array<Param>             param, bparam;
+	String                   last_insert_table;
+
+	int                      rowsprocessed;
+	Vector< Vector<double> > number;
+	Vector< Vector<int64> >  num64;
+	Vector< Vector<String> > text;
+	Vector< Vector<Time> >   time;
+	int                      rowcount;
+	int                      rowi;
+	Vector<Value>            fetchrow;
+	Vector<bool>             binary;
+	
+	bool                   IsOk(SQLRETURN ret) const;
+	void                   Flush();
+	bool                   Fetch0();
+	bool                   IsCurrent() const   { return session->current == this; }
+};
+
+bool ODBCSession::Connect(const char *cs)
+{
+	if(henv && IsOk(SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc))) {
+		if(IsOk(SQLDriverConnect(hdbc, NULL, (SQLCHAR *)cs, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT))) {
+			SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
+			return true;
+		}
+		SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+		hdbc = SQL_NULL_HANDLE;
+		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
+		SQLSetConnectAttr(hdbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TRANSACTION_SERIALIZABLE, SQL_NTS);
+	}
+	return false;
+}
+
+bool ODBCSession::IsOpen() const
+{
+	return hdbc != SQL_NULL_HANDLE;
+}
+
+void ODBCSession::Close()
+{
+	SessionClose();
+	if(hdbc != SQL_NULL_HANDLE) {
+		current = NULL;
+		FlushConnections();
+		SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+		SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+		hdbc = SQL_NULL_HANDLE;
+		hstmt = SQL_NULL_HANDLE;
+		current = NULL;
+	}
+}
+
+void ODBCSession::FlushConnections()
+{
+	LLOG("FlushConnections");
+	if(current) {
+		current->Flush();
+		current = NULL;
+	}
+	SQLFreeStmt(hstmt, SQL_CLOSE);
+}
+
+bool ODBCSession::IsOk(SQLRETURN ret)
+{
+	if(SQL_SUCCEEDED(ret))
+		return true;
+	SQLCHAR       SqlState[6], Msg[SQL_MAX_MESSAGE_LENGTH];
+	SQLINTEGER    NativeError;
+	SQLSMALLINT   MsgLen;
+	String        error;
+	int i = 1;
+	while(SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, i++, SqlState, &NativeError,
+	                 Msg, sizeof(Msg), &MsgLen) != SQL_NO_DATA) {
+		if(error.GetCount())
+			error << "\r\n";
+		error << (char *)Msg;
+	}
+	SetError(error, statement);
+	return false;
+}
+
+ODBCSession::ODBCSession()
+{
+	hdbc = SQL_NULL_HANDLE;
+	hstmt = SQL_NULL_HANDLE;
+	SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+	if(henv)
+		SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
+	tlevel = 0;
+	Dialect(MSSQL);
+	current = NULL;
+}
+
+ODBCSession::~ODBCSession()
+{
+	if(henv)
+		SQLFreeHandle(SQL_HANDLE_ENV, henv);
+}
+
+void ODBCSession::Begin()
+{
+	if(tlevel == 0)
+		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, SQL_NTS);
+	tlevel++;
+}
+
+void ODBCSession::Commit()
+{
+	tlevel--;
+	ASSERT(tlevel >= 0);
+	if(tlevel == 0) {
+		SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
+		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
+	}
+}
+
+void ODBCSession::Rollback()
+{
+	tlevel--;
+	ASSERT(tlevel >= 0);
+	if(tlevel == 0) {
+		SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_ROLLBACK);
+		SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
+	}
+}
+
+String ODBCSession::Savepoint()
+{
+	NEVER();
+	return "";
+}
+
+void ODBCSession::RollbackTo(const String& savepoint)
+{
+	NEVER();
+}
+
+Vector<String> ODBCSession::EnumUsers()
+{
+	return Vector<String>();
+}
+
+Vector<String> ODBCSession::EnumDatabases()
+{
+	return Vector<String>();
+}
+
+Vector<String> ODBCSession::EnumTables(String database)
+{
+	return Vector<String>();
+}
+
+Vector<String> ODBCSession::EnumViews(String database)
+{
+	return Vector<String>();
+}
+
+Vector<String> ODBCSession::EnumSequences(String database)
+{
+	return Vector<String>();
+}
+
+Vector<String> ODBCSession::EnumPrimaryKeys(String database, String table)
+{
+	return Vector<String>();
+}
+
+String ODBCSession::EnumRowID(String database, String table)
+{
+	return "";
+}
+
+bool   ODBCPerformScript(const String& text, StatementExecutor& executor, Gate2<int, int> progress_canceled)
+{
+	const char *p = text;
+	while(*p) {
+		String cmd;
+		while(*p && *p != ';')
+			if(*p == '\'') {
+				const char *s = p;
+				while(*++p && (*p != '\'' || *++p == '\''))
+					;
+				cmd.Cat(s, int(p - s));
+			}
+			else {
+				if(*p > ' ')
+					cmd.Cat(*p);
+				else if(!cmd.IsEmpty() && *cmd.Last() != ' ')
+					cmd.Cat(' ');
+				p++;
+			}
+		if(progress_canceled(int(p - text.Begin()), text.GetLength()))
+			return false;
+		if(!IsNull(cmd) && !executor.Execute(cmd))
+			return false;
+		if(*p == ';')
+			p++;
+	}
+	return true;
+}
+
+SqlConnection *ODBCSession::CreateConnection()
+{
+	return new ODBCConnection(this);
+}
+
+ODBCConnection::ODBCConnection(ODBCSession *session_)
+:	session(session_)
+{
+	LLOG("ODBCConnection " << (void *)this << " " << (void *)session);
+	rowcount = rowi = 0;
+}
+
+ODBCConnection::~ODBCConnection()
+{
+	if(IsCurrent())
+		session->current = NULL;
+	LLOG("~ODBCConnection " << (void *)this << " " << (void *)session);
+}
+
+bool ODBCConnection::IsOk(SQLRETURN ret) const
+{
+	if(SQL_SUCCEEDED(ret) || ret == SQL_NO_DATA)
+		return true;
+	SQLCHAR       SqlState[6], Msg[SQL_MAX_MESSAGE_LENGTH];
+	SQLINTEGER    NativeError;
+	SQLSMALLINT   MsgLen;
+	String        error;
+	int i = 1;
+	while(SQLGetDiagRec(SQL_HANDLE_STMT, session->hstmt, i++, SqlState, &NativeError,
+	                    Msg, sizeof(Msg), &MsgLen) != SQL_NO_DATA) {
+		if(error.GetCount())
+			error << "\r\n";
+		error << (char *)Msg;
+	}
+	session->SetError(error, statement);
+	return false;
+}
+
+void ODBCConnection::SetParam(int i, const Value& r)
+{
+	Param& p = param.At(i);
+	if(IsNumber(r)) {
+		if(r.Is<int64>()) {
+			int64 x = r;
+			p.ctype = SQL_C_SBIGINT;
+			p.sqltype = SQL_BIGINT;
+			p.data = String((char *)&x, sizeof(x));
+			p.li = sizeof(x);
+		}
+		else {
+			double x = r;
+			p.ctype = SQL_C_DOUBLE;
+			p.sqltype = SQL_DOUBLE;
+			p.data = String((char *)&x, sizeof(x));
+			p.li = sizeof(x);
+		}
+	}
+	if(IsString(r)) {
+		p.ctype = SQL_C_CHAR;
+		p.sqltype = SQL_LONGVARCHAR;
+		p.data = r;
+		p.li = p.data.GetLength();
+	}
+	if(IsDateTime(r)) {
+		p.ctype = SQL_C_TYPE_TIMESTAMP;
+		p.sqltype = SQL_TYPE_TIMESTAMP;
+		Time t = r;
+		SQL_TIMESTAMP_STRUCT tm;
+		tm.year = t.year;
+		tm.month = t.month;
+		tm.day = t.day;
+		tm.hour = t.hour;
+		tm.minute = t.minute;
+		tm.second = t.second;
+		tm.fraction = 0;
+		p.data = String((char *)&tm, sizeof(tm));
+		p.li = sizeof(tm);
+	}
+	if(IsNull(r))
+		p.li = SQL_NULL_DATA;
+}
+
+bool ODBCConnection::Execute()
+{
+	LLOG("Execute " << (void *)this << " " << (void *)session);
+	if(session->hstmt == SQL_NULL_HANDLE)
+		return false;
+	if(IsCurrent())
+		session->current = NULL;
+	session->FlushConnections();
+	last_insert_table.Clear();
+	number.Clear();
+	text.Clear();
+	time.Clear();
+	CParser p(statement);
+	if((p.Id("insert") || p.Id("INSERT")) && (p.Id("into") || p.Id("INTO")) && p.IsId())
+		last_insert_table = p.ReadId();
+	if(!IsOk(SQLPrepare(session->hstmt, (SQLCHAR *)~statement, statement.GetCount())))
+		return false;
+	parse = false;
+	bparam = param;
+	param.Clear();
+	for(int i = 0; i < bparam.GetCount(); i++) {
+		Param& p = bparam[i];
+		SQLSMALLINT     DataType;
+		SQLULEN         ParameterSize;
+		SQLSMALLINT     DecimalDigits;
+		SQLSMALLINT     Nullable;
+		if(!IsOk(SQLDescribeParam(session->hstmt, i + 1, &DataType, &ParameterSize, &DecimalDigits, &Nullable)))
+			return false;
+		if(!IsOk(SQLBindParameter(session->hstmt, i + 1, SQL_PARAM_INPUT, p.ctype, DataType,
+		                          ParameterSize, DecimalDigits, (SQLPOINTER)~p.data, p.data.GetLength(),
+		                          &p.li)))
+			return false;
+	}
+	SQLSMALLINT ncol;
+	if(!IsOk(SQLExecute(session->hstmt)) || !IsOk(SQLNumResultCols(session->hstmt, &ncol))) {
+		SQLFreeStmt(session->hstmt, SQL_CLOSE);
+		return false;
+	}
+	session->current = this;
+	info.Clear();
+	binary.Clear();
+	for(int i = 1; i <= ncol; i++) {
+		SQLCHAR      ColumnName[256];
+		SQLSMALLINT  NameLength;
+		SQLSMALLINT  DataType;
+		SQLULEN      ColumnSize;
+		SQLSMALLINT  DecimalDigits;
+		SQLSMALLINT  Nullable;
+		if(!IsOk(SQLDescribeCol(session->hstmt, i, ColumnName, 255, &NameLength, &DataType,
+		                        &ColumnSize, &DecimalDigits, &Nullable)))
+			return false;
+		binary.Add(false);
+		SqlColumnInfo& f = info.Add();
+		f.nullable = Nullable != SQL_NO_NULLS;
+		f.binary = false;
+		f.precision = DecimalDigits;
+		f.scale = 0;
+		f.width = ColumnSize;
+		f.name = (char *)ColumnName;
+		switch(DataType) {
+		case SQL_DECIMAL:
+		case SQL_NUMERIC:
+		case SQL_SMALLINT:
+		case SQL_INTEGER:
+		case SQL_REAL:
+		case SQL_FLOAT:
+		case SQL_DOUBLE:
+		case SQL_BIT:
+		case SQL_TINYINT:
+			f.type = DOUBLE_V;
+			break;
+		case SQL_BIGINT:
+			f.type = INT64_V;
+			break;
+		case SQL_TYPE_DATE:
+		case SQL_TYPE_TIMESTAMP:
+			f.type = TIME_V;
+			break;
+		case SQL_BINARY:
+		case SQL_VARBINARY:
+		case SQL_LONGVARBINARY:
+			f.type = STRING_V;
+			f.binary = true;
+			binary.Top() = true;
+			break;
+		default:
+			f.type = STRING_V;
+			break;
+		}
+	}
+	SQLLEN rc;
+	SQLRowCount(session->hstmt, &rc);
+	rowsprocessed = rc;
+	return true;
+}
+
+int ODBCConnection::GetRowsProcessed() const
+{
+	return rowsprocessed;
+}
+
+bool ODBCConnection::Fetch0()
+{
+	LLOG("Fetch0 " << (void *)this << " " << (void *)session);
+	int ret = SQLFetch(session->hstmt);
+	if(ret == SQL_NO_DATA || !IsOk(ret))
+		return false;
+	fetchrow.Clear();
+	double dbl;
+	int64 n64;
+	SQL_TIMESTAMP_STRUCT tm;
+	SQLLEN li;
+	for(int i = 0; i < info.GetCount(); i++) {
+		Value v = Null;
+		switch(info[i].type) {
+		case DOUBLE_V:
+			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_DOUBLE, &dbl, sizeof(dbl), &li)))
+			   break;
+			if(li != SQL_NULL_DATA)
+				v = dbl;
+			break;
+		case INT64_V:
+			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_SBIGINT, &n64, sizeof(n64), &li)))
+			   break;
+			if(li != SQL_NULL_DATA)
+				v = n64;
+			break;
+		case TIME_V:
+			if(!IsOk(SQLGetData(session->hstmt, i + 1, SQL_C_TYPE_TIMESTAMP, &tm, sizeof(tm), &li)))
+			   break;
+			if(li != SQL_NULL_DATA) {
+				Time m;
+				m.year = tm.year;
+				m.month = (byte)tm.month;
+				m.day = (byte)tm.day;
+				m.hour = (byte)tm.hour;
+				m.minute = (byte)tm.minute;
+				m.second = (byte)tm.second;
+				v = m;
+			}
+			break;
+		default:
+			int ct = binary[i] ? SQL_C_BINARY : SQL_C_CHAR;
+			if(!IsOk(SQLGetData(session->hstmt, i + 1, ct, &tm, 0, &li)))
+			   break;
+			if(li != SQL_NULL_DATA) {
+				StringBuffer sb;
+				sb.SetLength(li);
+				if(!IsOk(SQLGetData(session->hstmt, i + 1, ct, ~sb, li + 1, &li)))
+				   break;
+				v = String(sb);
+			}
+			break;
+		}
+		fetchrow.Add(v);
+	}
+	return ret != SQL_NO_DATA && IsOk(ret);
+}
+
+bool ODBCConnection::Fetch()
+{
+	if(IsCurrent())
+		return Fetch0();
+	if(rowi >= rowcount)
+		return false;
+	fetchrow.Clear();
+	for(int i = 0; i < info.GetCount(); i++) {
+		Value v;
+		switch(info[i].type) {
+		case DOUBLE_V:
+			v = number[i][rowi];
+			break;
+		case INT64_V:
+			v = num64[i][rowi];
+			break;
+		case TIME_V:
+			v = time[i][rowi];
+			break;
+		default:
+			v = text[i][rowi];
+			break;
+		}
+		fetchrow.Add(v);
+	}
+	++rowi;
+	return true;
+}
+
+void ODBCConnection::GetColumn(int i, Ref r) const
+{
+	LLOG("GetColumn " << (void *)this << " " << (void *)session);
+	r.SetValue(fetchrow[i]);
+}
+
+void ODBCConnection::Flush()
+{
+	LLOG("Flush " << (void *)this);
+	rowcount = 0;
+	rowi = 0;
+	number.Clear();
+	number.SetCount(info.GetCount());
+	text.Clear();
+	text.SetCount(info.GetCount());
+	time.Clear();
+	time.SetCount(info.GetCount());
+	while(info.GetCount() && Fetch0()) {
+		rowcount++;
+		for(int i = 0; i < info.GetCount(); i++)
+			switch(info[i].type) {
+			case DOUBLE_V:
+				number[i].Add(fetchrow[i]);
+				break;
+			case INT64_V:
+				num64[i].Add(fetchrow[i]);
+				break;
+			case STRING_V:
+				text[i].Add(fetchrow[i]);
+				break;
+			case TIME_V:
+				time[i].Add(fetchrow[i]);
+				break;
+			}
+	}
+	LLOG("Flush fetched " << rowcount);
+}
+
+void ODBCConnection::Cancel()
+{
+	param.Clear();
+	bparam.Clear();
+	number.Clear();
+	text.Clear();
+	time.Clear();
+}
+
+String ODBCConnection::ToString() const
+{
+	return statement;
+}
+
+Value ODBCConnection::GetInsertedId() const
+{
+	Sql sql(GetSession());
+	return last_insert_table.GetCount() ? sql.Select("IDENT_CURRENT('" + last_insert_table + "')")
+	                                    : sql.Select("@@IDENTITY");
+}
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Oracle/Oci7.cpp b/uppsrc/Oracle/Oci7.cpp
index 32cf46e39..acd634d58 100644
--- a/uppsrc/Oracle/Oci7.cpp
+++ b/uppsrc/Oracle/Oci7.cpp
@@ -830,6 +830,7 @@ SqlConnection *Oracle7::CreateConnection() {
 }
 
 void Oracle7::Close() {
+	SessionClose();
 	while(!clink.IsEmpty()) {
 		clink.GetNext()->Clear();
 		clink.GetNext()->Unlink();
diff --git a/uppsrc/Oracle/Oci8.cpp b/uppsrc/Oracle/Oci8.cpp
index 7fd7585f8..8ae1c6bfe 100644
--- a/uppsrc/Oracle/Oci8.cpp
+++ b/uppsrc/Oracle/Oci8.cpp
@@ -1304,6 +1304,7 @@ bool Oracle8::Login(const char *name, const char *pwd, const char *db, bool use_
 }
 
 void Oracle8::Logoff() {
+	SessionClose();
 	LOG("Oracle8::Logoff, #" << conn_count << " connections pending");
 	while(!clink.IsEmpty()) {
 		clink.GetNext()->Clear();
diff --git a/uppsrc/PostgreSQL/PostgreSQL.cpp b/uppsrc/PostgreSQL/PostgreSQL.cpp
index 98f6cb2aa..8cf60109c 100644
--- a/uppsrc/PostgreSQL/PostgreSQL.cpp
+++ b/uppsrc/PostgreSQL/PostgreSQL.cpp
@@ -397,11 +397,7 @@ void PostgreSQLSession::Close()
 {
 	if(!conn)
 		return;
-#ifndef flagNOAPPSQL
-	if(SQL.IsOpen() && &SQL.GetSession() == this)
-		SQL.Cancel();
-#endif
-
+	SessionClose();
 	PQfinish(conn);
 	conn = NULL;
 	level = 0;
diff --git a/uppsrc/Sql/Script.cpp b/uppsrc/Sql/Script.cpp
new file mode 100644
index 000000000..de9eae466
--- /dev/null
+++ b/uppsrc/Sql/Script.cpp
@@ -0,0 +1,113 @@
+#include "Sql.h"
+
+NAMESPACE_UPP
+
+bool StdStatementExecutor::Execute(const String& stmt)
+{
+	cursor.Execute(stmt);
+	return true;
+}
+
+#ifndef NOAPPSQL
+struct SQLStatementExecutorClass : StatementExecutor {
+	virtual bool Execute(const String& stmt) { SQL.Execute(stmt); return true; }
+};
+
+StatementExecutor& SQLStatementExecutor() {
+	return Single<SQLStatementExecutorClass>();
+}
+#endif
+
+bool SqlPerformScript(SqlSession& session, Stream& script,
+                      Gate2<int, int> progress_canceled, bool stoponerror)
+{
+	String stmt;
+	int level = 0;
+	bool ok = true;
+	while(!script.IsEof()) {
+		int c = script.Term();
+		if(IsAlpha(c)) {
+			String id;
+			while(IsAlpha(script.Term())) {
+				c = script.Get();
+				stmt.Cat(c);
+				id.Cat(ToUpper(c));
+			}
+			if(id == "BEGIN")
+				level++;
+			if(id == "END")
+				level--;
+		}
+		else
+		if(c == '\'') {
+			stmt.Cat(c);
+			script.Get();
+			for(;;) {
+				c = script.Get();
+				if(c < 0) {
+					ok = false;
+					if(stoponerror)
+						return false;
+					break;
+				}
+				stmt.Cat(c);
+				if(c == '\'')
+					break;
+			}
+		}
+		else
+		if(c == ';' && level == 0) {
+			Sql sql(session);
+			session.ClearError();
+			int q = 0;
+			while(stmt[q] == '\r' || stmt[q] == '\n')
+				q++;
+			stmt = stmt.Mid(q);
+			if(!sql.Execute(stmt)) {
+				ok = false;
+				if(stoponerror)
+					break;
+			}
+			stmt.Clear();
+			script.Get();
+		}
+		else {
+			if(c == '(')
+				level++;
+			if(c == ')')
+				level--;
+			if(c != '\r') {
+				if(session.GetDialect() == ORACLE && c == '\n')
+					stmt.Cat('\r');
+				stmt.Cat(c);
+			}
+			script.Get();
+		}
+	}
+	return ok;
+}
+
+bool SqlPerformScript(SqlSession& session, const String& script,
+                      Gate2<int, int> progress_canceled, bool stoponerror)
+{
+	StringStream ss(script);
+	return SqlPerformScript(session, ss, progress_canceled, stoponerror);
+}
+
+#ifndef NOAPPSQL
+
+bool SqlPerformScript(Stream& script,
+                      Gate2<int, int> progress_canceled, bool stoponerror)
+{
+	return SqlPerformScript(SQL.GetSession(), script, progress_canceled, stoponerror);
+}
+
+bool SqlPerformScript(const String& script,
+                      Gate2<int, int> progress_canceled, bool stoponerror)
+{
+	return SqlPerformScript(SQL.GetSession(), script, progress_canceled, stoponerror);
+}
+
+#endif
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Sql/Session.cpp b/uppsrc/Sql/Session.cpp
new file mode 100644
index 000000000..9e58386ba
--- /dev/null
+++ b/uppsrc/Sql/Session.cpp
@@ -0,0 +1,184 @@
+#include "Sql.h"
+
+NAMESPACE_UPP
+
+SqlSession::SqlSession()
+{
+	trace = NULL;
+	traceslow = INT_MAX / 4;
+	logerrors = false;
+	usrlog = false;
+	tracetime = false;
+	dialect = 255;
+	errorcode_number = Null;
+	errorclass = Sql::ERROR_UNSPECIFIED;
+	error_handler = NULL;
+}
+
+SqlSession::~SqlSession()
+{
+}
+
+void           SqlSession::Begin()                                       { NEVER(); }
+void           SqlSession::Commit()                                      { NEVER(); }
+void           SqlSession::Rollback()                                    { NEVER(); }
+String         SqlSession::Savepoint()                                   { NEVER(); return Null; }
+void           SqlSession::RollbackTo(const String&)                     { NEVER(); }
+bool           SqlSession::IsOpen() const                                { return false; }
+int            SqlSession::GetTransactionLevel() const                   { return 0; }
+RunScript      SqlSession::GetRunScript() const                          { return NULL; }
+SqlConnection *SqlSession::CreateConnection()                            { return NULL; }
+Vector<String> SqlSession::EnumUsers()                                   { return Vector<String>(); }
+Vector<String> SqlSession::EnumDatabases()                               { return Vector<String>(); }
+Vector<String> SqlSession::EnumTables(String database)                   { return Vector<String>(); }
+Vector<String> SqlSession::EnumViews(String database)                    { return Vector<String>(); }
+Vector<String> SqlSession::EnumSequences(String database)                { return Vector<String>(); }
+Vector<String> SqlSession::EnumPrimaryKey(String database, String table) { return Vector<String>(); }
+Vector<String> SqlSession::EnumReservedWords()                           { return Vector<String>(); }
+String         SqlSession::EnumRowID(String database, String table)      { return Null; }
+
+Vector<SqlColumnInfo> SqlSession::EnumColumns(String database, String table)
+{
+	Sql cursor(*this);
+	Vector<SqlColumnInfo> info;
+	SqlBool none;
+	none.SetFalse();
+	String full_name = database;
+	if(!IsNull(database))
+		full_name << '.';
+	full_name << table;
+	if(cursor.Execute(Select(SqlAll()).From(SqlSet(SqlId(full_name))).Where(none))) {
+		info.SetCount(cursor.GetColumns());
+		for(int i = 0; i < info.GetCount(); i++)
+			info[i] = cursor.GetColumnInfo(i);
+	}
+	return info;
+}
+
+void   SqlSession::SetError(String error, String stmt, int code, const char *scode, Sql::ERRORCLASS clss) {
+	if(error_handler && (*error_handler)(error, stmt, code, scode, clss))
+		return;
+	if(GetTransactionLevel() && errorstatement.GetCount())
+		return;
+	lasterror = error;
+	errorstatement = stmt;
+	errorcode_number = code;
+	errorcode_string = scode;
+	errorclass = clss;
+	String err;
+	err << "ERROR " << error << "(" << code << "): " << stmt << '\n';
+	if(logerrors)
+		BugLog() << err;
+	if(GetTrace())
+		*GetTrace() << err;
+}
+
+void SqlSession::InstallErrorHandler(bool (*handler)(String error, String stmt, int code, const char *scode, Sql::ERRORCLASS clss))
+{
+	error_handler = handler;
+}
+
+void SqlSession::SessionClose()
+{
+	if(sql) {
+		sql->Cancel();
+		sql.Clear();
+	}
+	if(sqlr) {
+		sqlr->Cancel();
+		sqlr.Clear();
+	}
+}
+
+Sql& SqlSession::GetSessionSql()
+{
+	if(!sql)
+		sql = new Sql(*this);
+	return *sql;
+}
+
+Sql& SqlSession::GetSessionSqlR()
+{
+	if(!sqlr)
+		sqlr = new Sql(*this);
+	return *sqlr;
+}
+
+void   SqlSession::ClearError()
+{
+	lasterror.Clear();
+	errorstatement.Clear();
+	errorcode_number = Null;
+	errorcode_string = Null;
+	errorclass = Sql::ERROR_UNSPECIFIED;
+}
+
+StaticMutex          sDefs;
+static SqlSession   *sGlobalSession;
+static SqlSession   *sGlobalSessionR;
+#ifdef _MULTITHREADED
+thread__ SqlSession *sThreadSession;
+thread__ SqlSession *sThreadSessionR;
+#endif
+
+void Sql::operator=(SqlSession& s)
+{
+	Mutex::Lock __(sDefs);
+	if(this == &AppCursor()) {
+	#ifdef _MULTITHREADED
+		sThreadSession = &s;
+		if(!sGlobalSession)
+	#endif
+			sGlobalSession = &s;
+		return;
+	}
+	if(this == &AppCursorR()) {
+	#ifdef _MULTITHREADED
+		sThreadSessionR = &s;
+		if(!sGlobalSessionR)
+	#endif
+			sGlobalSessionR = &s;
+		return;
+	}
+	NEVER();
+}
+
+Sql& AppCursor()
+{
+#ifdef _MULTITHREADED
+	if(sThreadSession)
+		return sThreadSession->GetSessionSql();
+#endif
+	if(sGlobalSession)
+		return sGlobalSession->GetSessionSql();
+	static Sql *empty;
+	ONCELOCK {
+		static Sql h(Sql::NULLSQL);
+		empty = &h;
+	}
+	return *empty;
+}
+
+Sql& AppCursorR()
+{
+#ifdef _MULTITHREADED
+	if(sThreadSessionR)
+		return sThreadSessionR->GetSessionSqlR();
+#endif
+	if(sGlobalSessionR)
+		return sGlobalSessionR->GetSessionSqlR();
+#ifdef _MULTITHREADED
+	if(sThreadSession)
+		return sThreadSession->GetSessionSqlR();
+#endif
+	if(sGlobalSession)
+		return sGlobalSession->GetSessionSqlR();
+	static Sql *empty;
+	ONCELOCK {
+		static Sql h(Sql::NULLSQL);
+		empty = &h;
+	}
+	return *empty;
+}
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Sql/Sql.cpp b/uppsrc/Sql/Sql.cpp
index 906250b83..33bd53ac5 100644
--- a/uppsrc/Sql/Sql.cpp
+++ b/uppsrc/Sql/Sql.cpp
@@ -114,6 +114,9 @@ bool Sql::Execute() {
 #ifndef NOAPPSQL
 		if(this == &AppCursor())
 			*s << "SQL* ";
+		else
+		if(this == &AppCursorR())
+			*s << "SQLR* ";
 #endif
 		int i = 0;
 		for(const char *q = cn->statement; *q; q++)
@@ -577,10 +580,6 @@ void   Sql::RollbackTo(const String& savepoint)   { GetSession().RollbackTo(save
 
 bool   Sql::IsOpen()                              { return cn && GetSession().IsOpen(); }
 
-#ifndef NOAPPSQL
-GLOBAL_VAR(AppSql, AppCursor)
-#endif
-
 #ifndef NOAPPSQL
 Sql::Sql() {
 	cn = NULL;
@@ -631,120 +630,17 @@ Sql::~Sql() {
 	Detach();
 }
 
-SqlSession::SqlSession()
-{
-	trace = NULL;
-	traceslow = INT_MAX / 4;
-	logerrors = false;
-	usrlog = false;
-	tracetime = false;
-	dialect = 255;
-	errorcode_number = Null;
-	errorclass = Sql::ERROR_UNSPECIFIED;
-	error_handler = NULL;
-}
-
-SqlSession::~SqlSession()
-{
-/*
 #ifndef NOAPPSQL
-	if(SQL.IsOpen() && &SQL.GetSession() == this) {
-		LLOG("Detaching SQL");
-//		SQL.Detach();
-	}
-#endif
-*/
-}
 
-void           SqlSession::Begin()                                       { NEVER(); }
-void           SqlSession::Commit()                                      { NEVER(); }
-void           SqlSession::Rollback()                                    { NEVER(); }
-String         SqlSession::Savepoint()                                   { NEVER(); return Null; }
-void           SqlSession::RollbackTo(const String&)                     { NEVER(); }
-bool           SqlSession::IsOpen() const                                { return false; }
-int            SqlSession::GetTransactionLevel() const                   { return 0; }
-RunScript      SqlSession::GetRunScript() const                          { return NULL; }
-SqlConnection *SqlSession::CreateConnection()                            { return NULL; }
-Vector<String> SqlSession::EnumUsers()                                   { return Vector<String>(); }
-Vector<String> SqlSession::EnumDatabases()                               { return Vector<String>(); }
-Vector<String> SqlSession::EnumTables(String database)                   { return Vector<String>(); }
-Vector<String> SqlSession::EnumViews(String database)                    { return Vector<String>(); }
-Vector<String> SqlSession::EnumSequences(String database)                { return Vector<String>(); }
-Vector<String> SqlSession::EnumPrimaryKey(String database, String table) { return Vector<String>(); }
-Vector<String> SqlSession::EnumReservedWords()                           { return Vector<String>(); }
-String         SqlSession::EnumRowID(String database, String table)      { return Null; }
+SqlR::SqlR()
+:	Sql(SQLR.GetSession()) {}
 
-Vector<SqlColumnInfo> SqlSession::EnumColumns(String database, String table)
-{
-	Sql cursor(*this);
-	Vector<SqlColumnInfo> info;
-	SqlBool none;
-	none.SetFalse();
-	String full_name = database;
-	if(!IsNull(database))
-		full_name << '.';
-	full_name << table;
-	if(cursor.Execute(Select(SqlAll()).From(SqlSet(SqlId(full_name))).Where(none))) {
-		info.SetCount(cursor.GetColumns());
-		for(int i = 0; i < info.GetCount(); i++)
-			info[i] = cursor.GetColumnInfo(i);
-	}
-	return info;
-}
+SqlR::SqlR(const char *stmt)
+:	Sql(stmt, SQLR.GetSession()) {}
 
-void   SqlSession::SetError(String error, String stmt, int code, const char *scode, Sql::ERRORCLASS clss) {
-	if(error_handler && (*error_handler)(error, stmt, code, scode, clss))
-		return;
-	if(GetTransactionLevel() && errorstatement.GetCount())
-		return;
-	lasterror = error;
-	errorstatement = stmt;
-	errorcode_number = code;
-	errorcode_string = scode;
-	errorclass = clss;
-	String err;
-	err << "ERROR " << error << "(" << code << "): " << stmt << '\n';
-	if(logerrors)
-		BugLog() << err;
-	if(GetTrace())
-		*GetTrace() << err;
-}
+SqlR::SqlR(const SqlStatement& s)
+:	Sql(s, SQLR.GetSession()) {}
 
-void SqlSession::InstallErrorHandler(bool (*handler)(String error, String stmt, int code, const char *scode, Sql::ERRORCLASS clss))
-{
-	error_handler = handler;
-}
-
-Sql& SqlSession::GetSessionSql()
-{
-	if(!sql)
-		sql = new Sql(*this);
-	return *sql;
-}
-
-void   SqlSession::ClearError()
-{
-	lasterror.Clear();
-	errorstatement.Clear();
-	errorcode_number = Null;
-	errorcode_string = Null;
-	errorclass = Sql::ERROR_UNSPECIFIED;
-}
-
-bool StdStatementExecutor::Execute(const String& stmt)
-{
-	cursor.Execute(stmt);
-	return true;
-}
-
-#ifndef NOAPPSQL
-struct SQLStatementExecutorClass : StatementExecutor {
-	virtual bool Execute(const String& stmt) { SQL.Execute(stmt); return true; }
-};
-
-StatementExecutor& SQLStatementExecutor() {
-	return Single<SQLStatementExecutorClass>();
-}
 #endif
 
 END_UPP_NAMESPACE
diff --git a/uppsrc/Sql/Sql.upp b/uppsrc/Sql/Sql.upp
index 7a3694203..c5ac267e4 100644
--- a/uppsrc/Sql/Sql.upp
+++ b/uppsrc/Sql/Sql.upp
@@ -18,6 +18,8 @@ file
 	SqlStatement.cpp optimize_speed,
 	Sqls.h,
 	Sql.cpp,
+	Session.cpp,
+	Script.cpp,
 	MassInsert.cpp,
 	Schema readonly separator,
 	SqlSchema.h,
diff --git a/uppsrc/Sql/SqlStatement.cpp b/uppsrc/Sql/SqlStatement.cpp
index 196ea244b..d433ed26b 100644
--- a/uppsrc/Sql/SqlStatement.cpp
+++ b/uppsrc/Sql/SqlStatement.cpp
@@ -419,94 +419,6 @@ Value SqlStatement::Fetch() const {
 	return Fetch(SQL);
 }
 
-bool SqlPerformScript(SqlSession& session, Stream& script,
-                      Gate2<int, int> progress_canceled, bool stoponerror)
-{
-	String stmt;
-	int level = 0;
-	bool ok = true;
-	while(!script.IsEof()) {
-		int c = script.Term();
-		if(IsAlpha(c)) {
-			String id;
-			while(IsAlpha(script.Term())) {
-				c = script.Get();
-				stmt.Cat(c);
-				id.Cat(ToUpper(c));
-			}
-			if(id == "BEGIN")
-				level++;
-			if(id == "END")
-				level--;
-		}
-		else
-		if(c == '\'') {
-			stmt.Cat(c);
-			script.Get();
-			for(;;) {
-				c = script.Get();
-				if(c < 0) {
-					ok = false;
-					if(stoponerror)
-						return false;
-					break;
-				}
-				stmt.Cat(c);
-				if(c == '\'')
-					break;
-			}
-		}
-		else
-		if(c == ';' && level == 0) {
-			Sql sql(session);
-			session.ClearError();
-			int q = 0;
-			while(stmt[q] == '\r' || stmt[q] == '\n')
-				q++;
-			stmt = stmt.Mid(q);
-			if(!sql.Execute(stmt)) {
-				ok = false;
-				if(stoponerror)
-					break;
-			}
-			stmt.Clear();
-			script.Get();
-		}
-		else {
-			if(c == '(')
-				level++;
-			if(c == ')')
-				level--;
-			if(c != '\r') {
-				if(session.GetDialect() == ORACLE && c == '\n')
-					stmt.Cat('\r');
-				stmt.Cat(c);
-			}
-			script.Get();
-		}
-	}
-	return ok;
-}
-
-bool SqlPerformScript(Stream& script,
-                      Gate2<int, int> progress_canceled, bool stoponerror)
-{
-	return SqlPerformScript(SQL.GetSession(), script, progress_canceled, stoponerror);
-}
-
-bool SqlPerformScript(SqlSession& session, const String& script,
-                      Gate2<int, int> progress_canceled, bool stoponerror)
-{
-	StringStream ss(script);
-	return SqlPerformScript(session, ss, progress_canceled, stoponerror);
-}
-
-bool SqlPerformScript(const String& script,
-                      Gate2<int, int> progress_canceled, bool stoponerror)
-{
-	return SqlPerformScript(SQL.GetSession(), script, progress_canceled, stoponerror);
-}
-
 #endif
 
 END_UPP_NAMESPACE
diff --git a/uppsrc/Sql/Sqls.h b/uppsrc/Sql/Sqls.h
index 5cd6c40e5..8a7981516 100644
--- a/uppsrc/Sql/Sqls.h
+++ b/uppsrc/Sql/Sqls.h
@@ -83,7 +83,8 @@ class Sql {
 	Vector<Value>   param;
 
 	friend class SqlSession;
-	friend struct AppSql;
+	friend Sql& AppCursor();
+	friend Sql& AppCursorR();
 
 	Value       Select0(const String& what);
 	void        Assign(SqlSource& src);
@@ -235,26 +236,18 @@ public:
 	Sql(const SqlStatement& s, SqlSource& session);
 	Sql(SqlConnection *connection);
 	~Sql();
+	
+	void operator=(SqlSession& s); // this only works with SQL and SQLR...
 };
 
 #ifndef NOAPPSQL
-
-struct AppSql : Sql {
-	void   operator=(SqlSource& s) { Assign(s); }
-	void   Detach()                { Sql::Detach(); }
-	AppSql() : Sql(NULLSQL) {}
+struct SqlR : Sql {
+	SqlR();
+	SqlR(const char *stmt);
+	SqlR(const SqlStatement& s);
 };
-
-AppSql& AppCursor();
-//$-
-#define SQL AppCursor()
-//$+
-//  Assist++ cheat:
-//$ AppSql SQL;
-
 #endif
 
-
 struct StatementExecutor {
 	virtual bool Execute(const String& stmt) = 0;
 	virtual ~StatementExecutor() {}
@@ -262,6 +255,9 @@ struct StatementExecutor {
 
 typedef bool (*RunScript)(const String& text, StatementExecutor& executor, Gate2<int, int> progress_canceled);
 
+class AppSql;
+class AppSqlR;
+
 class SqlSession : public SqlSource {
 public:
 	enum {
@@ -301,6 +297,9 @@ protected:
 	int                           status;
 	
 	One<Sql>                      sql;
+	One<Sql>                      sqlr;
+	
+	void                          SessionClose();
 
 public:
 	virtual void                  Begin();
@@ -359,6 +358,7 @@ public:
 	String                        GetUser()                               { return Sql(*this).GetUser(); }
 	
 	Sql&                          GetSessionSql();
+	Sql&                          GetSessionSqlR();
 
 	operator                      bool() const                            { return IsOpen(); }
 
@@ -374,6 +374,21 @@ public:
 
 };
 
+
+#ifndef NOAPPSQL
+
+Sql& AppCursor();
+Sql& AppCursorR();
+
+//$-
+#define SQL AppCursor()
+#define SQLR AppCursorR()
+//$+
+//  Assist++ cheat:
+//$ Sql SQL;
+
+#endif
+
 class OciConnection;
 
 bool SqlPerformScript(SqlSession& session, Stream& script,