diff --git a/bazaar/Firebird/Firebird.cpp b/bazaar/Firebird/Firebird.cpp
new file mode 100644
index 000000000..56a038d38
--- /dev/null
+++ b/bazaar/Firebird/Firebird.cpp
@@ -0,0 +1,1877 @@
+#include "Firebird.h"
+#include <time.h>
+
+NAMESPACE_UPP
+
+TransAuto::TransAuto(SqlSession& s) : abort(true), isSession(true), session(&s)
+{
+	session->Begin();
+}
+
+TransAuto::TransAuto(Sql& s) : abort(true), isSession(false), sql(&s)
+{
+	sql->Begin();
+}
+
+TransAuto::~TransAuto()
+{
+	try	{
+		if (isSession)
+		{
+			if(abort) {
+				session->Rollback();
+			} else {
+				session->Commit();
+			}
+		} else {
+			if(abort) {
+				sql->Rollback();
+			} else {
+				sql->Commit();
+			}
+		}
+	} catch(...) {
+		// Ignore all exceptions in destructor.
+		ASSERT(false);
+	}
+}
+
+class TransRetain
+{
+public:
+	TransRetain(FBSession& s) : abort(true), session(&s)
+	{
+	}
+	~TransRetain()
+	{
+		try	{
+			if(abort) {
+				session->RollbackRetaining();
+			} else {
+				session->CommitRetaining();
+			}
+		} catch(...) {
+			// Ignore all exceptions in the destructor.
+			ASSERT(false);
+		}
+	}
+
+public:
+	operator bool() const { return abort; }
+	void Finish() { abort = false; }
+
+protected:
+	bool abort:1;
+	FBSession* session;
+};
+
+#define TRANSACTION_RETAIN(trans) \
+for(TransRetain auto_trans_##__LINE__(trans); \
+    auto_trans_##__LINE__; \
+    auto_trans_##__LINE__.Finish() )
+
+struct FBValue {
+	short       nullInd;
+	XSQLVAR*	pXSQLVar;
+	
+	FBValue(XSQLVAR& v);
+	virtual ~FBValue();
+	
+	bool CanBeNull() const { return pXSQLVar->sqltype & 1; }
+	bool IsNull() const { return nullInd == -1; }
+	void SetNull(bool flag = true) { nullInd = flag ? -1 : 0; }
+	
+	virtual void GetValue(Ref r) const = 0;
+	virtual void SetValue(const Value& v) = 0;
+};
+
+FBValue::FBValue(XSQLVAR& v)
+{
+	pXSQLVar = &v;
+	if (CanBeNull())
+	{
+		v.sqlind = &nullInd;
+		nullInd = -1;
+	}
+}
+
+FBValue::~FBValue()
+{
+}
+
+struct FBInt : public FBValue {
+	int	value;
+
+	FBInt(XSQLVAR& v);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBInt::FBInt(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_LONG + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+	v.sqllen = sizeof(value);
+}
+
+void FBInt::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		switch(r.GetType()) 
+		{
+		case INT_V:
+			RefInt(r) = value;
+			break;
+		case DOUBLE_V:
+			RefDouble(r) = static_cast<double>(value);
+			break;
+		case STRING_V:
+			RefString(r) = FormatInt(value);
+			break;
+		case VALUE_V:
+			RefValue(r) = Value(value);
+			break;
+		case WSTRING_V:
+			RefWString(r) = FormatInt(value).ToWString();
+			break;
+		case INT64_V:
+			RefInt64(r) = value;
+			break;
+		case BOOL_V:
+			RefBool(r) = value != 0;
+			break;
+		case DATE_V:
+		case TIME_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBInt::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	switch (v.GetType())
+	{
+	case INT_V:
+		value = ValueTo<int>(v);
+		break;
+	case DOUBLE_V:
+		value = static_cast<int>(ValueTo<double>(v));
+		break;
+	case STRING_V:
+		value = ScanInt(ValueTo<String>(v));
+		break;
+//		case DATE_V:
+//		case TIME_V:
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		value = ScanInt(ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		value = static_cast<int>(ValueTo<int64>(v));
+		break;
+	case BOOL_V:
+		value = ValueTo<bool>(v) ? 1 : 0;
+		break;
+	default:
+		ASSERT(false);
+		break;
+	}
+}
+
+struct FBInt64 : public FBValue {
+	int64	value;
+
+	FBInt64(XSQLVAR& v);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBInt64::FBInt64(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_INT64 + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+	v.sqllen = sizeof(value);
+}
+
+void FBInt64::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		switch(r.GetType()) 
+		{
+		case INT_V:
+			RefInt(r) = static_cast<int>(value);
+			break;
+		case DOUBLE_V:
+			RefDouble(r) = static_cast<double>(value);
+			break;
+		case STRING_V:
+			RefString(r) = FormatInt64(value);
+			break;
+		case VALUE_V:
+			RefValue(r) = Value(value);
+			break;
+		case WSTRING_V:
+			RefWString(r) = FormatInt64(value).ToWString();
+			break;
+		case INT64_V:
+			RefInt64(r) = value;
+			break;
+		case BOOL_V:
+			RefBool(r) = value != 0;
+			break;
+		case DATE_V:
+		case TIME_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBInt64::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	switch (v.GetType())
+	{
+	case INT_V:
+		value = ValueTo<int>(v);
+		break;
+	case DOUBLE_V:
+		value = static_cast<int64>(ValueTo<double>(v));
+		break;
+	case STRING_V:
+		value = ScanInt64(ValueTo<String>(v));
+		break;
+//		case DATE_V:
+//		case TIME_V:
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		value = ScanInt64(ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		value = ValueTo<int64>(v);
+		break;
+	case BOOL_V:
+		value = ValueTo<bool>(v) ? 1 : 0;
+		break;
+	default:
+		ASSERT(false);
+		break;
+	}
+}
+
+struct FBDouble : public FBValue {
+	double	value;
+
+	FBDouble(XSQLVAR& v);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBDouble::FBDouble(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_DOUBLE + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+	v.sqllen = sizeof(value);
+	v.sqlscale = 18;
+}
+
+void FBDouble::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		switch(r.GetType()) 
+		{
+		case INT_V:
+			RefInt(r) = static_cast<int>(value);
+			break;
+		case DOUBLE_V:
+			RefDouble(r) = value;
+			break;
+		case STRING_V:
+			RefString(r) = FormatDouble(value);
+			break;
+		case VALUE_V:
+			RefValue(r) = Value(value);
+			break;
+		case WSTRING_V:
+			RefWString(r) = FormatDouble(value).ToWString();
+			break;
+		case INT64_V:
+			RefInt64(r) = static_cast<int64>(value);
+			break;
+		case BOOL_V:
+			RefBool(r) = value != 0.0;
+			break;
+		case DATE_V:
+		case TIME_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBDouble::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	switch (v.GetType())
+	{
+	case INT_V:
+		value = ValueTo<int>(v);
+		break;
+	case DOUBLE_V:
+		value = ValueTo<double>(v);
+		break;
+	case STRING_V:
+		value = ScanDouble(ValueTo<String>(v));
+		break;
+//		case DATE_V:
+//		case TIME_V:
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		value = ScanDouble(ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		value = static_cast<double>(ValueTo<int64>(v));
+		break;
+	case BOOL_V:
+		value = ValueTo<bool>(v) ? 1.0 : 0.0;
+		break;
+	default:
+		ASSERT(false);
+		break;
+	}
+}
+
+// This macro is used to declare structures representing SQL VARCHAR types
+#define SQL_VARCHAR(len) struct {short vary_length; char vary_string[(len) + 1];} 
+
+struct FBVarying : public FBValue {
+//	enum { max_varchar_size = 8 * 1024 };
+	enum { max_varchar_size = 32765 };
+
+	//String	value;
+	SQL_VARCHAR(32765) buff;
+
+	FBVarying(XSQLVAR& v);
+	
+	void SetValue(const String& str);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBVarying::FBVarying(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_VARYING + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&buff);
+	v.sqllen = v.sqllen == 0 ? max_varchar_size : v.sqllen;
+}
+
+void FBVarying::SetValue(const String& str)
+{
+	ASSERT(pXSQLVar);
+	buff.vary_length = min<short>(str.GetCount(), pXSQLVar->sqllen);
+	strncpy(buff.vary_string, ~str, buff.vary_length);
+}
+
+void FBVarying::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		switch(r.GetType()) {
+		case INT_V:
+			{
+				const char* e = buff.vary_string + buff.vary_length;
+				RefInt(r) = ScanInt(buff.vary_string, &e);
+			}
+			break;
+		case DOUBLE_V:
+			{
+				const char* e = buff.vary_string + buff.vary_length;
+				RefDouble(r) = ScanDouble(buff.vary_string, &e);
+			}
+			break;
+		case STRING_V:
+			RefString(r) = String(buff.vary_string, buff.vary_length);
+			break;
+		case DATE_V:
+			r.SetValue(UPP::Scan(DATE_V, String(buff.vary_string, buff.vary_length)));
+			break;
+		case TIME_V:
+			r.SetValue(UPP::Scan(TIME_V, String(buff.vary_string, buff.vary_length)));
+			break;
+		case VALUE_V:
+			RefValue(r) = Value(String(buff.vary_string, buff.vary_length));
+			break;
+		case WSTRING_V:
+			RefWString(r) = WString(buff.vary_string, buff.vary_length);
+			break;
+		case INT64_V:
+			{
+				const char* e = buff.vary_string + buff.vary_length;
+				RefInt64(r) = ScanInt64(buff.vary_string, &e);
+			}
+			break;
+		case BOOL_V:
+			{
+				const char* e = buff.vary_string + buff.vary_length;
+				RefBool(r) = ScanInt(buff.vary_string, &e) != 0;
+			}
+			break;
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBVarying::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	switch (v.GetType())
+	{
+	case INT_V:
+		SetValue(AsString(ValueTo<int>(v)));
+		break;
+	case DOUBLE_V:
+		SetValue(AsString(ValueTo<double>(v)));
+		break;
+	case STRING_V:
+		SetValue(ValueTo<String>(v));
+		break;
+//		case DATE_V:
+//		case TIME_V:
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		SetValue(ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		SetValue(AsString(ValueTo<int64>(v)));
+		break;
+	case BOOL_V:
+		SetValue(IntStr((int)ValueTo<bool>(v)));
+		break;
+	default:
+		ASSERT(false);
+		break;
+	}
+}
+
+struct FBTimeStamp : public FBValue {
+	ISC_TIMESTAMP	value;
+
+	FBTimeStamp(XSQLVAR& v);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBTimeStamp::FBTimeStamp(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_TIMESTAMP + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+	v.sqllen = sizeof(value);
+}
+
+void FBTimeStamp::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		const LanguageInfo& li = GetLanguageInfo();
+		struct tm	time;
+		isc_decode_timestamp(&value, &time);
+		
+		const Time t(time.tm_year + 1900, time.tm_mon + 1, time.tm_mday, 
+			time.tm_hour, time.tm_min, time.tm_sec);
+		
+		switch(r.GetType()) {
+		case STRING_V:
+			RefString(r) = li.FormatTime(t);
+			break;
+		case DATE_V:
+			RefDate(r) = t;
+			break;
+		case TIME_V:
+			RefTime(r) = t;
+			break;
+		case VALUE_V:
+			RefValue(r) = t;
+			break;
+		case WSTRING_V:
+			RefWString(r) = li.FormatTime(t).ToWString();
+			break;
+		case INT64_V:
+			RefInt64(r) = t.Get();
+			break;
+		case DOUBLE_V:
+			RefDouble(r) = static_cast<double>(t.Get());
+			break;
+		case INT_V:
+		case BOOL_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBTimeStamp::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+
+	Time t;	
+	switch (v.GetType())
+	{
+	case INT_V:
+		t.Set(ValueTo<int>(v));
+		break;
+	case DOUBLE_V:
+		t.Set((int64)ValueTo<double>(v));
+	case STRING_V:
+		t = UPP::Scan(TIME_V, ValueTo<String>(v));
+		break;
+	case DATE_V:
+	{
+		const Date& d = ValueTo<Date>(v);
+		t = Time(d.year, d.month, d.day);
+	}
+		break;
+	case TIME_V:
+		t = ValueTo<Time>(v);
+		break;
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		t = UPP::Scan(TIME_V, ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		t.Set(ValueTo<int64>(v));
+		break;
+	case BOOL_V:
+	default:
+		ASSERT(false);
+		break;
+	}
+		
+	struct tm time;
+	time.tm_year = t.year - 1900;
+	time.tm_mon = t.month - 1;
+	time.tm_mday = t.day;
+	time.tm_hour = t.hour;
+	time.tm_min = t.minute;
+	time.tm_sec = t.second;
+	time.tm_isdst = -1;
+
+	isc_encode_timestamp(&time, &value);
+}
+
+struct FBDate : public FBValue {
+	ISC_DATE	value;
+
+	FBDate(XSQLVAR& v);
+
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBDate::FBDate(XSQLVAR& v) : FBValue(v)
+{
+	v.sqltype = SQL_DATE + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+	v.sqllen = sizeof(value);
+}
+
+void FBDate::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		const LanguageInfo& li = GetLanguageInfo();
+		struct tm	time;
+		isc_decode_sql_date(&value, &time);
+		
+		const Date d(time.tm_year + 1900, time.tm_mon + 1, time.tm_mday);
+		
+		switch(r.GetType()) {
+		case STRING_V:
+			RefString(r) = li.FormatDate(d);
+			break;
+		case DATE_V:
+			RefDate(r) = d;
+			break;
+		case TIME_V:
+			RefTime(r) = Time(d.year, d.month, d.day);
+			break;
+		case VALUE_V:
+			RefValue(r) = d;
+			break;
+		case WSTRING_V:
+			RefWString(r) = li.FormatDate(d).ToWString();
+			break;
+		case INT64_V:
+			RefInt64(r) = d.Get();
+			break;
+		case INT_V:
+			RefInt(r) = d.Get();
+			break;
+		case DOUBLE_V:
+			RefDouble(r) = d.Get();
+			break;
+		case BOOL_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBDate::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	Date d;	
+	switch (v.GetType())
+	{
+	case INT_V:
+		d.Set(ValueTo<int>(v));
+		break;
+	case DOUBLE_V:
+		d.Set((int)ValueTo<double>(v));
+	case STRING_V:
+		d = UPP::Scan(DATE_V, ValueTo<String>(v));
+		break;
+	case DATE_V:
+		d = ValueTo<Date>(v);
+		break;
+	case TIME_V:
+		d = ValueTo<Time>(v);
+		break;
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		d = UPP::Scan(DATE_V, ValueTo<WString>(v).ToString());
+		break;
+	case INT64_V:
+		d.Set((int)ValueTo<int64>(v));
+		break;
+	case BOOL_V:
+	default:
+		ASSERT(false);
+		break;
+	}
+		
+	struct tm time;
+	time.tm_year = d.year - 1900;
+	time.tm_mon = d.month - 1;
+	time.tm_mday = d.day;
+	time.tm_hour = 0;
+	time.tm_min = 0;
+	time.tm_sec = 0;
+	time.tm_isdst = -1;
+
+	isc_encode_sql_date(&time, &value);
+}
+
+struct FBBlob : public FBValue {
+	mutable ibpp::SegmentBlob	value;
+
+	FBBlob(const FBSession& s, XSQLVAR& v);
+
+	long GetLength() const
+	{
+		return value.getInfo().getLenght();
+	}
+	
+	String GetEntire() const;
+	void SetEntire(const char* data_ptr, int data_len);
+	
+	virtual void GetValue(Ref r) const;
+	virtual void SetValue(const Value& v);
+};
+
+FBBlob::FBBlob(const FBSession& s, XSQLVAR& v)
+: FBValue(v)
+, value(s.db, s.tr)
+{
+	v.sqltype = SQL_BLOB + (v.sqltype & 1);
+	v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value.getID());
+	v.sqllen = sizeof(GDS_QUAD);
+}
+
+String FBBlob::GetEntire() const
+{
+	// Max value is 2 >> 16 ...
+	const unsigned short db_segment_size = 0xFFFF;
+	String data;
+	unsigned short actualSize;
+	char buff[db_segment_size];
+	
+	value.open();
+	while (value.getSegment(actualSize, sizeof(buff), buff))
+	    data.Cat(buff, actualSize);
+	value.close();
+	
+	return data;
+}
+
+void FBBlob::SetEntire(const char* data_ptr, int data_len)
+{
+	value.create();
+	value.put_segment(data_ptr, data_len);
+	value.close();
+}
+
+void FBBlob::GetValue(Ref r) const
+{
+	if (IsNull())
+		r = Null;
+	else {
+		unsigned short actualSize;
+		value.open();
+
+		switch(r.GetType()) {
+		case INT_V:
+			{
+				int v;
+				if (value.getSegment(actualSize, sizeof(v), reinterpret_cast<char*>(&v)))
+					RefInt(r) = v;
+			}
+			break;
+		case DOUBLE_V:
+			{
+				double v;
+				if (value.getSegment(actualSize, sizeof(v), reinterpret_cast<char*>(&v)))
+					RefDouble(r) = v;
+			}
+			break;
+		case STRING_V:
+			RefString(r) = GetEntire();
+			break;
+		case DATE_V:
+			r.SetValue(UPP::Scan(DATE_V, GetEntire()));
+			break;
+		case TIME_V:
+			r.SetValue(UPP::Scan(TIME_V, GetEntire()));
+			break;
+		case VALUE_V:
+			r.SetValue(GetEntire());
+			break;
+		case WSTRING_V:
+			RefWString(r) = GetEntire().ToWString();
+			break;
+		case INT64_V:
+			{
+				int64 v;
+				if (value.getSegment(actualSize, sizeof(v), reinterpret_cast<char*>(&v)))
+					RefInt64(r) = v;
+			}
+			break;
+		case BOOL_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+
+		value.close();
+	}
+}
+
+void FBBlob::SetValue(const Value& v)
+{
+	SetNull(v.IsNull());
+
+	if (v.IsNull())
+		return;
+	
+	const LanguageInfo& li = GetLanguageInfo();
+	switch (v.GetType())
+	{
+	case INT_V:
+		SetEntire(reinterpret_cast<const char*>(&ValueTo<int>(v)), sizeof(int));
+		break;
+	case DOUBLE_V:
+		SetEntire(reinterpret_cast<const char*>(&ValueTo<double>(v)), sizeof(double));
+		break;
+	case STRING_V:
+		{
+			String s = ValueTo<String>(v);
+			SetEntire(~s, s.GetCount());
+		}
+		break;
+	case DATE_V:
+		{
+			String s = li.FormatDate(ValueTo<Date>(v));
+			SetEntire(~s, s.GetCount());
+		}
+		break;
+	case TIME_V:
+		{
+			String s = li.FormatTime(ValueTo<Time>(v));
+			SetEntire(~s, s.GetCount());
+		}
+		break;
+	case VALUE_V:
+		SetValue(ValueTo<Value>(v));
+		break;
+	case WSTRING_V:
+		{
+			String s = ValueTo<WString>(v).ToString();
+			SetEntire(~s, s.GetCount());
+		}
+		break;
+	case INT64_V:
+		SetEntire(reinterpret_cast<const char*>(&ValueTo<int64>(v)), sizeof(int64));
+		break;
+	case BOOL_V:
+	default:
+		ASSERT(false);
+		break;
+	}
+}
+
+struct FBArray : public FBValue {
+	ISC_QUAD	value;
+
+	FBArray(XSQLVAR& v) : FBValue(v)
+	{
+		v.sqltype = SQL_ARRAY + (v.sqltype & 1);
+		v.sqldata = reinterpret_cast<ISC_SCHAR*>(&value);
+		v.sqllen = sizeof(value);
+	}
+
+	virtual void GetValue(Ref r) const
+	{
+		if (IsNull())
+			r = Null;
+		else {
+			switch(r.GetType()) {
+//			case INT_V:
+//				{
+//					const char* e = buff.vary_string + buff.vary_length;
+//					RefInt(r) = ScanInt(buff.vary_string, &e);
+//				}
+//				break;
+//			case DOUBLE_V:
+//				{
+//					const char* e = buff.vary_string + buff.vary_length;
+//					RefDouble(r) = ScanDouble(buff.vary_string, &e);
+//				}
+//				break;
+//			case STRING_V:
+//				RefString(r) = String(buff.vary_string, buff.vary_length);
+//				break;
+//			case DATE_V:
+//				r.SetValue(UPP::Scan(DATE_V, String(buff.vary_string, buff.vary_length)));
+//				break;
+//			case TIME_V:
+//				r.SetValue(UPP::Scan(TIME_V, String(buff.vary_string, buff.vary_length)));
+//				break;
+//			case VALUE_V:
+//				r.SetValue(String(buff.vary_string, buff.vary_length));
+//				break;
+//			case WSTRING_V:
+//				RefWString(r) = WString(buff.vary_string, buff.vary_length);
+//				break;
+//			case INT64_V:
+//				{
+//					const char* e = buff.vary_string + buff.vary_length;
+//					RefInt64(r) = ScanInt64(buff.vary_string, &e);
+//				}
+//				break;
+			case BOOL_V:
+			default:
+				ASSERT(false);
+				break;
+			}
+		}
+	}
+	
+	virtual void SetValue(const Value& v)
+	{
+		SetNull(v.IsNull());
+	
+		if (v.IsNull())
+			return;
+		
+		switch (v.GetType())
+		{
+		case INT_V:
+			break;
+		case DOUBLE_V:
+		case STRING_V:
+		case DATE_V:
+		case TIME_V:
+		case VALUE_V:
+			SetValue(ValueTo<Value>(v));
+			break;
+		case WSTRING_V:
+		case INT64_V:
+		case BOOL_V:
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+};
+
+
+class FBConnection : public SqlConnection {
+public:
+	enum StatementType
+	{
+		stNone,
+		stSelect,
+		stSelect4Update,
+		stInsert,
+		stDelete,
+		stUpdate,
+		stDDL,
+		stTrBegin,
+		stTrCommit,
+		stTrRollback,
+//		stCreate,
+//		stCreateDB,
+//		stDrop,
+//		stAlter,
+//		stFunction,
+//		stSet,
+//		stSetTransaction
+	};
+
+public:
+	FBConnection(FBSession& s);
+	
+protected:
+	virtual void Cancel();
+	virtual bool Execute();
+	virtual bool Fetch();
+	virtual void GetColumn(int i, Ref r) const;
+//	virtual Value GetInsertedId() const;
+//	virtual int GetRowsProcessed() const;
+	virtual SqlSession& GetSession() const;
+	virtual String GetUser() const;
+	virtual void SetParam(int i, const Value& r);
+	virtual String ToString() const;
+
+protected:
+    bool IsDML() const { return st == stInsert || st == stDelete || st == stUpdate; }
+//    bool IsDDL() const { return st == stCreate || st == stDrop || st == stAlter; }
+    bool IsDDL() const { return st == stDDL; }
+    bool IsSelect() const { return st == stSelect || st == stSelect4Update; }
+    
+	StatementType GetST() const { return st; }
+	
+	void Prepare();
+	void CloseCursor();
+	void SetupConverters(ibpp::SQLDataArray& from, Array<FBValue>& to) const;
+	
+protected:
+	bool				executed_:1;
+	StatementType		st;
+	int					bindNum;
+	int					defineNum;
+	FBSession&			session;
+	ibpp::DynamicSQL	dSQL_;
+	Array<FBValue>		defineBind;
+	Array<FBValue>		bindBind;
+};
+
+FBConnection::FBConnection(FBSession& s)
+: executed_(false)
+, st(stNone)
+, session(s)
+, dSQL_(s.db, s.tr)
+{
+}
+
+String FBConnection::GetUser() const
+{
+	Sql stmt(session);
+	String result;
+	Ref rResult(result);
+	
+	stmt.SetStatement(
+	    "SELECT current_user FROM rdb$database"
+	);
+	stmt.RunX();
+	if (stmt.Fetch())
+		stmt.GetColumn(0, rResult);
+	
+	return result;
+}
+
+void FBConnection::SetParam(int i, const Value& v)
+{
+	Prepare();
+	bindBind[i].SetValue(v);
+}
+
+void FBConnection::SetupConverters(ibpp::SQLDataArray& from, Array<FBValue>& to) const
+{
+	const int size = from.getSize();
+	
+	for (int i = 0; i < size; ++i)
+	{
+		XSQLVAR& var = from[i];
+		
+		switch (var.sqltype & ~1)
+		{
+		case SQL_TEXT:
+		case SQL_VARYING:
+			to.Add(new FBVarying(var));
+			break;
+		case SQL_SHORT:
+		case SQL_LONG:
+			if (var.sqlscale < 0)
+				to.Add(new FBDouble(var));
+			else
+				to.Add(new FBInt(var));
+			break;
+		case SQL_INT64:
+			if (var.sqlscale < 0)
+				to.Add(new FBDouble(var));
+			else
+				to.Add(new FBInt64(var));
+			break;
+		case SQL_FLOAT:
+		case SQL_D_FLOAT:
+		case SQL_DOUBLE:
+			to.Add(new FBDouble(var));
+			break;
+		case SQL_DATE:
+		case SQL_TYPE_TIME:
+			to.Add(new FBTimeStamp(var));
+			break;
+		case SQL_TYPE_DATE:
+			to.Add(new FBDate(var));
+			break;
+		case SQL_BLOB:
+			to.Add(new FBBlob(session, var));
+			break;
+		case SQL_ARRAY:
+			to.Add(new FBArray(var));
+			break;
+//			break;
+//		case SQL_QUAD:
+//			break;
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+}
+
+void FBConnection::Prepare()
+{
+	if (parse)
+	{
+		CloseCursor();
+		
+		// Special case. Statement should not be prepared in case of
+		// "CREATE DATABASE" and "SET TRANSACTION" 	
+
+		dSQL_.prepare(statement, session.tmpDataArray);
+		
+		const int stmt_type = dSQL_.getStmtType();
+		
+		switch(stmt_type) 
+		{
+		case isc_info_sql_stmt_select:
+			st = stSelect;
+			break;
+		case isc_info_sql_stmt_insert:
+			st = stInsert;
+			break;
+		case isc_info_sql_stmt_update:
+			st = stUpdate;
+			break;
+		case isc_info_sql_stmt_delete:
+			st = stDelete;
+			break;
+		case isc_info_sql_stmt_ddl:
+			st = stDDL;
+			break;
+//		case isc_info_sql_stmt_get_segment:
+//			st = ???;
+//			break;
+//		case isc_info_sql_stmt_put_segment:
+//			st = ???;
+//			break;
+//		case isc_info_sql_stmt_exec_procedure:
+//			st = ???;
+//			break;
+		case isc_info_sql_stmt_start_trans:
+			st = stTrBegin;
+			break;
+		case isc_info_sql_stmt_commit:
+			st = stTrCommit;
+			break;
+		case isc_info_sql_stmt_rollback:
+			st = stTrRollback;
+			break;
+		case isc_info_sql_stmt_select_for_upd:
+			st = stSelect4Update;
+			break;
+//		case isc_info_sql_stmt_set_generator:
+//			st = ???;
+//			break;
+//		case isc_info_sql_stmt_savepoint:
+//			st = ???;
+//			break;
+		default:
+			break;
+		}
+		
+		executed_ = false;
+
+		defineBind.Clear();
+		defineNum = session.tmpDataArray.getRequredSize();
+		defineBind.Reserve(defineNum);
+		ibpp::SQLDataArray& out = dSQL_.GetOut();
+		out.setSize(defineNum);
+		if (defineNum > 0)
+		{
+			dSQL_.describe_define(out);			
+			SetupConverters(out, defineBind);
+		}
+		
+		dSQL_.describe_bind(session.tmpDataArray);
+		bindNum = session.tmpDataArray.getRequredSize();
+		bindBind.Clear();
+		bindBind.Reserve(bindNum);
+		ibpp::SQLDataArray& in = dSQL_.GetIn();
+		in.setSize(bindNum);
+		if (bindNum)
+		{
+			dSQL_.describe_bind(in);
+			SetupConverters(in, bindBind);
+		}
+		
+		parse = false;
+	}
+}
+
+void FBConnection::CloseCursor()
+{
+	if (executed_ && IsSelect() && !session.CursorIsClosed())
+	{
+		dSQL_.close_cursor();
+		session.SetCursorIsClosed();
+	}
+}
+
+bool FBConnection::Execute()
+{
+	try {
+		Prepare();
+		
+		// Special case. Statement should not be prepared in case of
+		// "CREATE DATABASE" and "SET TRANSACTION" 	
+//		if (GetST() == stCreateDB || GetST() == stSetTransaction)
+//			dSQL_.execute_immediate_no_trans(statement);
+//		else 
+		if (IsDDL()) {
+			// Rollback transaction and start another.
+			// This seems to be a default behaviour with other databases.
+			session.RollbackRetaining();
+			TRANSACTION_RETAIN(session) {
+				dSQL_.execute();
+			}
+		} else if (IsSelect()) {
+			CloseCursor();
+			dSQL_.execute();
+			executed_ = true;
+		} else {
+			// For EXECUTE PROCEDURE, for example ...
+			if(session.IsExplicitTrans())
+				dSQL_.execute2();
+			else {
+				// Commit/Rollback implicitly.
+				TRANSACTION_RETAIN(session) {
+					dSQL_.execute2();
+				}
+			}
+		}
+	} catch(ibpp::DbExc& e) {
+		session.SetError(~e, statement, e.GetErrNum());
+		return false;
+	}
+	
+	return true;
+}
+
+bool FBConnection::Fetch()
+{
+	ASSERT(executed_);
+	const bool rc = dSQL_.fetch();
+	session.SetCursorIsClosed(false);
+	return rc;
+}
+
+void FBConnection::GetColumn(int i, Ref r) const
+{
+	defineBind[i].GetValue(r);
+}
+
+void FBConnection::Cancel()
+{
+}
+
+String FBConnection::ToString() const
+{
+	return String();
+}
+
+SqlSession& FBConnection::GetSession() const
+{
+	return session;
+}
+
+FBSession::FBSession()
+: SvcConnected(false)
+, DbConnected(false)
+, TrStarted(false)
+, CursIsClosed(true)
+, TrExplicit(false)
+, tmpDataArray(1)
+{
+}
+
+FBSession::~FBSession()
+{
+	if (TrExplicit)
+		RollbackInternal();
+	else
+		CommitInternal();
+	
+	if (DbConnected)
+		db.dettach();
+	
+	if (SvcConnected)
+		svc.detach();
+}
+
+void FBSession::Connect(
+	const char* dbname,
+	const char* host,
+	const char* user,
+	const char* pswd,
+	ibpp::network_protocol_t protocol
+	)
+{
+	// Service
+	svc.attach(host, user, pswd, protocol);
+	SvcConnected = true;
+
+	// Database
+	db.setUserName(user);
+	db.setPassword(pswd);
+	db.attach(dbname);
+	DbConnected = true;
+	dbName = dbname;
+	
+	// Transaction
+	tr.setVersion3();
+	tr.setReadWrite();
+	tr.setReadCommitted();
+	tr.setRecVersion();
+	
+	BeginInternal();
+}
+
+SqlConnection * FBSession::CreateConnection()
+{
+	return new FBConnection(*this);
+}
+
+Vector<SqlColumnInfo> FBSession::EnumColumns(String /*database*/, String table)
+{
+	Vector<SqlColumnInfo> result;
+	Sql stmt(*this);
+	String name;
+	int null_flag;
+	int field_type;
+	int field_width;
+	int field_precision;
+	int field_scale;
+		
+	Ref rName(name);
+	Ref rNullFlag(null_flag);
+	Ref rFieldType(field_type);
+	Ref rFieldWidth(field_width);
+	Ref rFieldPrecision(field_precision);
+	Ref rFieldScale(field_scale);
+	
+	stmt.SetStatement(
+		" SELECT f.rdb$field_name, \n"
+		" f.rdb$field_position, \n"
+		" f.rdb$null_flag, \n"
+		" fs.rdb$field_type, \n"
+		" fs.rdb$field_length, \n"
+		" fs.rdb$field_precision, \n"
+		" fs.rdb$field_scale, \n"
+		" fs.rdb$field_sub_type, \n"
+		" fs.rdb$computed_source, \n"
+		" fs.rdb$character_length \n"
+		" FROM rdb$relation_fields f \n"
+		" LEFT JOIN rdb$fields fs ON fs.rdb$field_name = f.rdb$field_source \n"
+		" WHERE f.rdb$relation_name = ? \n"
+		" ORDER BY f.rdb$field_position"
+	);
+	stmt.SetParam(0, table);
+	stmt.RunX();
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, rName);
+		stmt.GetColumn(2, rNullFlag);
+		stmt.GetColumn(3, rFieldType);
+		stmt.GetColumn(4, rFieldWidth);
+		stmt.GetColumn(5, rFieldPrecision);
+		stmt.GetColumn(6, rFieldScale);
+
+		SqlColumnInfo& ci = result.Add();
+		ci.name = name;
+		ci.type = field_type;
+		ci.width = field_width;
+		ci.precision = field_precision;
+		ci.scale = field_scale;
+		ci.nullable = rNullFlag != 1;
+	}
+	
+	return result;
+}
+
+Vector<String> FBSession::EnumDatabases()
+{
+	Vector<String> result;
+	result.Add(dbName);
+	return result;
+}
+
+Vector<String> FBSession::EnumPrimaryKey(String /*database*/, String table)
+{
+	Vector<String> result;
+	Sql stmt(*this);
+	String name;
+	Ref rName(name);
+	
+	stmt.SetStatement(
+		" SELECT i.rdb$field_name, \n"
+		" i.rdb$field_position \n"
+		" FROM rdb$relation_constraints rc, rdb$index_segments i \n"
+		" WHERE (i.rdb$index_name = rc.rdb$index_name) \n"
+		" AND (rc.rdb$constraint_type = 'PRIMARY KEY') \n"
+		" AND (rc.rdb$relation_name = ?) \n"
+		" ORDER BY i.rdb$field_position"
+	);
+	stmt.SetParam(0, table);
+	stmt.RunX();
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, rName);
+		result.Add(name);
+	}
+	
+	return result;
+}
+
+namespace {
+	static const char *rwlist[] = {
+		"ACTION", "ACTIVE", "ADD",
+		"ADMIN", "AFTER", "ALL",
+		"ALTER", "AND", "ANY",
+		"AS", "ASC", "ASCENDING",
+		"AT", "AUTO", "AUTODDL",
+		"AVG", "BASED", "BASENAME",
+		"BASE_NAME", "BEFORE", "BEGIN",
+		"BETWEEN", "BLOB", "BLOBEDIT",
+		"BUFFER", "BY", "CACHE",
+		"CASCADE", "CAST", "CHAR",
+		"CHARACTER", "CHARACTER_LENGTH", "CHAR_LENGTH",
+		"CHECK", "CHECK_POINT_LEN", "CHECK_POINT_LENGTH",
+		"COLLATE", "COLLATION", "COLUMN",
+		"COMMIT", "COMMITTED", "COMPILETIME",
+		"COMPUTED", "CLOSE", "CONDITIONAL",
+		"CONNECT", "CONSTRAINT", "CONTAINING",
+		"CONTINUE", "COUNT", "CREATE",
+		"CSTRING", "CURRENT", "CURRENT_DATE",
+		"CURRENT_TIME", "CURRENT_TIMESTAMP", "CURSOR",
+		"DATABASE", "DATE", "DAY",
+		"DB_KEY", "DEBUG", "DEC",
+		"DECIMAL", "DECLARE", "DEFAULT",
+		"DELETE", "DESC", "DESCENDING",
+		"DESCRIBE", "DESCRIPTOR", "DISCONNECT",
+		"DISPLAY", "DISTINCT", "DO",
+		"DOMAIN", "DOUBLE", "DROP",
+		"ECHO", "EDIT", "ELSE",
+		"END", "ENTRY_POINT", "ESCAPE",
+		"EVENT", "EXCEPTION", "EXECUTE",
+		"EXISTS", "EXIT", "EXTERN",
+		"EXTERNAL", "EXTRACT", "FETCH",
+		"FILE", "FILTER", "FLOAT",
+		"FOR", "FOREIGN", "FOUND",
+		"FREE_IT", "FROM", "FULL",
+		"FUNCTION", "GDSCODE", "GENERATOR",
+		"GEN_ID", "GLOBAL", "GOTO",
+		"GRANT", "GROUP", "GROUP_COMMIT_WAIT",
+		"GROUP_COMMIT_", "WAIT_TIME", "HAVING",
+		"HELP", "HOUR", "IF",
+		"IMMEDIATE", "IN", "INACTIVE",
+		"INDEX", "INDICATOR", "INIT",
+		"INNER", "INPUT", "INPUT_TYPE",
+		"INSERT", "INT", "INTEGER",
+		"INTO", "IS", "ISOLATION",
+		"ISQL", "JOIN", "KEY",
+		"LC_MESSAGES", "LC_TYPE", "LEFT",
+		"LENGTH", "LEV", "LEVEL",
+		"LIKE", "LOGFILE", "LOG_BUFFER_SIZE",
+		"LOG_BUF_SIZE", "LONG", "MANUAL",
+		"MAX", "MAXIMUM", "MAXIMUM_SEGMENT",
+		"MAX_SEGMENT", "MERGE", "MESSAGE",
+		"MIN", "MINIMUM", "MINUTE",
+		"MODULE_NAME", "MONTH", "NAMES",
+		"NATIONAL", "NATURAL", "NCHAR",
+		"NO", "NOAUTO", "NOT",
+		"NULL", "NUMERIC", "NUM_LOG_BUFS",
+		"NUM_LOG_BUFFERS", "OCTET_LENGTH", "OF",
+		"ON", "ONLY", "OPEN",
+		"OPTION", "OR", "ORDER",
+		"OUTER", "OUTPUT", "OUTPUT_TYPE",
+		"OVERFLOW", "PAGE", "PAGELENGTH",
+		"PAGES", "PAGE_SIZE", "PARAMETER",
+		"PASSWORD", "PLAN", "POSITION",
+		"POST_EVENT", "PRECISION", "PREPARE",
+		"PROCEDURE", "PROTECTED", "PRIMARY",
+		"PRIVILEGES", "PUBLIC", "QUIT",
+		"RAW_PARTITIONS", "RDB$DB_KEY", "READ",
+		"REAL", "RECORD_VERSION", "REFERENCES",
+		"RELEASE", "RESERV", "RESERVING",
+		"RESTRICT", "RETAIN", "RETURN",
+		"RETURNING_VALUES", "RETURNS", "REVOKE",
+		"RIGHT", "ROLE", "ROLLBACK",
+		"RUNTIME", "SCHEMA", "SECOND",
+		"SEGMENT", "SELECT", "SET",
+		"SHADOW", "SHARED", "SHELL",
+		"SHOW", "SINGULAR", "SIZE",
+		"SMALLINT", "SNAPSHOT", "SOME",
+		"SORT", "SQLCODE", "SQLERROR",
+		"SQLWARNING", "STABILITY", "STARTING",
+		"STARTS", "STATEMENT", "STATIC",
+		"STATISTICS", "SUB_TYPE", "SUM",
+		"SUSPEND", "TABLE", "TERMINATOR",
+		"THEN", "TIME", "TIMESTAMP",
+		"TO", "TRANSACTION", "TRANSLATE",
+		"TRANSLATION", "TRIGGER", "TRIM",
+		"TYPE", "UNCOMMITTED", "UNION",
+		"UNIQUE", "UPDATE", "UPPER",
+		"USER", "USING", "VALUE",
+		"VALUES", "VARCHAR", "VARIABLE",
+		"VARYING", "VERSION", "VIEW",
+		"WAIT", "WEEKDAY", "WHEN",
+		"WHENEVER", "WHERE", "WHILE",
+		"WITH", "WORK", "WRITE",
+		"YEAR", "YEARDAY",
+	};
+}
+
+Vector<String> FBSession::EnumReservedWords()
+{
+	Vector<String> result;
+	result.SetCount(__countof(rwlist));
+	for(int i = 0; i < __countof(rwlist); i++)
+		result[i] = rwlist[i];
+	return result;
+}
+
+Vector<String> FBSession::EnumSequences(String /*database*/)
+{
+	Vector<String> result;
+	Sql stmt(*this);
+	String name;	
+	Ref rName(name);
+	
+	stmt.SetStatement(
+	    "SELECT RDB$GENERATOR_NAME FROM RDB$GENERATORS WHERE (RDB$SYSTEM_FLAG is NULL) or (RDB$SYSTEM_FLAG <> 1)"
+	);
+	stmt.RunX();
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, rName);
+		result.Add(name);
+	}
+	
+	return result;
+}
+
+Vector<String> FBSession::EnumTables(String /*database*/)
+{
+	Vector<String> result;
+	Sql stmt(*this);
+	String name;	
+	Ref rName(name);
+	
+	stmt.SetStatement(
+	    "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS WHERE (RDB$VIEW_BLR IS NULL) AND (RDB$SYSTEM_FLAG = 0)"
+	);
+	stmt.RunX();
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, rName);
+		result.Add(name);
+	}
+	
+	return result;
+}
+
+Vector<String> FBSession::EnumUsers()
+{
+	using namespace ibpp;
+	using namespace ibpp::svc_cmd;
+	
+	Vector<String> result;
+	get_users users(svc);
+	
+	users.execute();
+	const Vector<user_info>& ui = users.get_info();
+	
+	for(int i = 0; i < ui.GetCount(); ++i)
+		result.Add(ui[i].user_name);
+	
+	return result;
+}
+
+Vector<String> FBSession::EnumViews(String /*database*/)
+{
+	Vector<String> result;
+	Sql stmt(*this);
+	String name;	
+	Ref rName(name);
+	
+	stmt.SetStatement(
+	    "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS WHERE NOT (RDB$VIEW_BLR IS NULL)"
+	);
+	stmt.RunX();
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, rName);
+		result.Add(name);
+	}
+	
+	return result;
+}
+
+void FBSession::RollbackTo(const String& savepoint)
+{
+	Sql stmt(*this);
+
+	stmt.SetStatement(
+	    "ROLLBACK TO SAVEPOINT " + savepoint
+	);
+	stmt.RunX();
+}
+
+String FBSession::Savepoint()
+{
+	static dword i;
+	i = (i + 1) & 0x8fffffff;
+	String s = Sprintf("SESSION_SAVEPOINT_%d", i);
+	Sql stmt(*this);
+
+	stmt.SetStatement(
+	    "SAVEPOINT " + s
+	);
+	stmt.RunX();
+	return s;
+}
+
+inline
+static bool IsIdentChar(int s)
+{
+	return IsAlNum(s) || s == '_';
+}
+
+inline
+static void SkipSpaces(const char*& s)
+{
+	while (IsSpace(*s)) ++s;
+}
+
+class BackTrack
+{
+public:
+	BackTrack(const char*& s) : Pos(s), BtPos(s) {}
+	
+	bool Check(bool v) const
+	{
+		if (!v)
+			Pos = BtPos;
+		
+		return v;
+	}
+	
+private:
+	const char*& Pos;
+	const char*  BtPos;
+};
+
+static bool scmpw(const char*& s, const char *w) 
+{
+	BackTrack bt(s);
+	
+	for(;;) {
+		if(*w == '\0')
+			return bt.Check(!IsIdentChar(*s));
+		if(ToUpper(*s++) != ToUpper(*w++))
+			return bt.Check(false);
+	}
+}
+
+static bool SkipOrAlter(const char*& s)
+{
+	SkipSpaces(s);
+	
+	if (scmpw(s, "or"))
+	{
+		SkipSpaces(s);
+	
+		scmpw(s, "alter");
+	}
+	
+	return true;
+}
+
+bool FirebirdPerformScript(const String& text, StatementExecutor& exe, Gate2<int, int> progress_canceled)
+{
+	String statement;
+	String term(";");
+	String new_term;
+	const int size = text.GetCount();
+	const char* s = text;
+	bool found;
+
+	do {
+		found = false;
+		bool found_block = true;
+		bool prev_ident_char = false;
+		bool execute = false;
+		int level = 0;
+		const char* b = s;
+
+		while (*s) {
+			// Multi-line comment.
+			if (*s == '/' && *(s+1) == '*') {
+				s += 2;
+				while (*s && (*s++ != '*' || *s != '/'));
+				if (*s) ++s;
+			}
+			// One-line comment.
+			else if (*s == '-' && *(s+1) == '-') {
+				s += 2;
+				while (*s && *s != '\n') ++s;
+				if (*s) ++s;
+			}
+			// String. 
+			else if (*s == '\'') {
+				while(*++s && (*s != '\'' || *++s == '\''));
+				if (*s) ++s;
+			}
+			else if (scmpw(s, term) && level == 0) {
+				if (!new_term.IsEmpty()) {
+					term = new_term;
+					new_term = Null;
+					found = true;
+					// Statement starts from here.
+					b = s;
+					break;
+				}
+				else if (found_block) {
+					statement.Cat(b, s);
+					found = true;
+					execute = true;
+					break;
+				}
+			}
+			else if (!prev_ident_char && level == 0 && scmpw(s, "set")) {
+				SkipSpaces(s);
+				
+				if (scmpw(s, "term"))
+				{
+					SkipSpaces(s);
+					const char* b = s;
+					while (!IsSpace(*s)) ++s;
+					new_term.Cat(b, s);
+				}
+			}
+			else if (!prev_ident_char && scmpw(s, "begin")) {
+				found_block = true;
+				++level;
+			}
+			else if (!prev_ident_char && scmpw(s, "end")) {
+				--level;
+			}
+			else if (!prev_ident_char && scmpw(s, "alter") || scmpw(s, "recreate") || (scmpw(s, "create") && SkipOrAlter(s)))
+			{
+				SkipSpaces(s);
+				
+				if (scmpw(s, "procedure") || scmpw(s, "trigger"))
+					found_block = false;
+			}
+			else
+			{
+				prev_ident_char = IsIdentChar(*s);
+				++s;
+			}
+		}
+		
+		if (found && execute)
+		{
+			if(!exe.Execute(statement)) return false;
+			statement = Null;
+		}	
+	} while (found);
+	
+	return true;
+}
+
+RunScript FBSession::GetRunScript() const
+{
+	return &FirebirdPerformScript;
+}
+
+void FBSession::Begin()
+{
+	BeginInternal();
+	TrExplicit = true;
+}
+
+void FBSession::Commit()
+{
+	CommitRetaining();
+	TrExplicit = false;
+}
+
+void FBSession::Rollback()
+{
+	RollbackRetaining();
+	TrExplicit = false;
+}
+
+void FBSession::CommitRetaining()
+{
+	if (IsTransStarted())
+	{
+		tr.commit_retaining();
+		SetCursorIsClosed(); // By transaction.
+	}
+}
+
+void FBSession::RollbackRetaining()
+{
+	if (IsTransStarted())
+	{
+		tr.rollback_retaining();
+		SetCursorIsClosed(); // By transaction.
+	}
+}
+
+void FBSession::BeginInternal()
+{
+	if (!IsTransStarted())
+	{
+		tr.start(db);
+		TrStarted = true;
+	}
+}
+
+void FBSession::CommitInternal()
+{
+	if (IsTransStarted())
+	{
+		tr.commit();
+		TrStarted = false;
+		SetCursorIsClosed(); // By transaction.
+	}
+}
+
+void FBSession::RollbackInternal()
+{
+	if (IsTransStarted())
+	{
+		tr.rollback();
+		TrStarted = false;
+		SetCursorIsClosed(); // By transaction.
+	}
+}
+
+bool FBSession::IsOpen() const
+{
+	return DbConnected;
+}
+
+Value FBSequence::Get() {
+	static SqlId ONE_RECORD_TABLE("RDB$DATABASE");
+#ifndef NOAPPSQL
+	Sql sql(session ? *session : SQL.GetSession());
+#else
+	ASSERT(session);
+	Sql sql(*session);
+#endif
+
+	sql.SetStatement(
+	    "SELECT GEN_ID(" + seq.ToString() + ", 1) FROM RDB$DATABASE"
+	);
+	
+	if (sql.Run() && sql.Fetch())
+		return sql[0];
+	
+	return ErrorValue();
+}
+
+END_UPP_NAMESPACE
diff --git a/bazaar/Firebird/Firebird.h b/bazaar/Firebird/Firebird.h
new file mode 100644
index 000000000..201bb5189
--- /dev/null
+++ b/bazaar/Firebird/Firebird.h
@@ -0,0 +1,136 @@
+#ifndef _Firebird_Firebird_h
+#define _Firebird_Firebird_h
+
+#include "fb.h"
+
+NAMESPACE_UPP
+
+class TransAuto
+{
+public:
+	TransAuto(SqlSession& s);
+	TransAuto(Sql& s);
+	~TransAuto();
+
+public:
+	operator bool() const { return abort; }
+	void Finish() { abort = false; }
+
+protected:
+	bool abort:1;
+	bool isSession:1;
+	union {
+		SqlSession*	session;
+		Sql*		sql;
+	};
+};
+
+#define TRANSACTION(trans) \
+for(TransAuto auto_trans_##__LINE__(trans); \
+    auto_trans_##__LINE__; \
+    auto_trans_##__LINE__.Finish() )
+
+
+#ifndef NOAPPSQL
+bool FirebirdPerformScript(const String& text, StatementExecutor& se = SQLStatementExecutor(), Gate2<int, int> progress_canceled = false);
+#else
+bool FirebirdPerformScript(const String& text, StatementExecutor& se, Gate2<int, int> progress_canceled = false);
+#endif
+
+
+class FBSession : public SqlSession {
+	friend class FBConnection;
+	friend class TransRetain;
+	friend struct FBBlob;
+		
+public:
+	virtual SqlConnection *CreateConnection();
+	virtual Vector<SqlColumnInfo> EnumColumns(String database, String table);
+	virtual Vector<String> EnumDatabases();
+	virtual Vector<String> EnumPrimaryKey(String database, String table);
+	virtual Vector<String> EnumReservedWords();
+//	virtual String EnumRowID(String database, String table);
+	virtual Vector<String> EnumSequences(String database);
+	virtual Vector<String> EnumTables(String database);
+	virtual Vector<String> EnumUsers();
+	virtual Vector<String> EnumViews(String database);
+	virtual RunScript GetRunScript() const;
+//	virtual int GetTransactionLevel() const;
+	virtual void RollbackTo(const String& savepoint);
+	virtual String Savepoint();
+
+public:
+	FBSession();
+	virtual ~FBSession();
+	
+public:
+	void Connect(
+		const char* dbname,
+		const char* host = NULL,
+		const char* user = NULL,
+		const char* pswd = NULL,
+		ibpp::network_protocol_t protocol = ibpp::np_local
+	);
+
+	virtual void Begin();
+	virtual void Commit();
+	virtual void Rollback();
+
+	virtual bool IsOpen() const;
+
+	bool IsTransStarted() const { return TrStarted; }
+	bool IsExplicitTrans() const { return TrExplicit; }
+	
+protected:
+	void BeginInternal();
+	void CommitInternal();
+	void RollbackInternal();
+
+	//	Commit a transaction, and start a new one using the original
+	//	transaction's context
+	void CommitRetaining();
+	void RollbackRetaining();
+
+	bool CursorIsClosed() const { return CursIsClosed; }
+	void SetCursorIsClosed(bool flag = true) { CursIsClosed = flag; }
+	
+private:
+	bool SvcConnected:1;
+	bool DbConnected:1;
+	bool TrStarted:1;
+	bool CursIsClosed:1;
+	bool TrExplicit:1;
+
+	String				dbName;		
+	ibpp::Service		svc; 
+	ibpp::DataBase		db;
+	ibpp::Transaction	tr;
+	ibpp::SQLDataArray  tmpDataArray;
+};
+
+class FBSequence : public ValueGen {
+	SqlId       ssq;
+	SqlId&      seq;
+	SqlSession *session;
+
+public:
+	virtual Value  Get();
+
+	Value operator++()                                                  { return Get(); }
+
+	void Set(SqlId id, SqlSession& s)                                   { ssq = id; session = &s; }
+
+#ifndef NOAPPSQL
+	void Set(SqlId id)                                                  { ssq = id; session = NULL; }
+	FBSequence(const char *name) : ssq(name), seq(ssq)                  { session = NULL; }
+	FBSequence(SqlId& seq) : seq(seq)                                   { session = NULL; }
+#endif
+	FBSequence(const char *name, SqlSession& s) : ssq(name), seq(ssq)   { session = &s; }
+	FBSequence(SqlId& seq, SqlSession& s) : seq(seq)                    { session = &s; }
+	FBSequence() : seq(ssq)                                             { session = NULL; }
+};
+
+END_UPP_NAMESPACE
+
+#endif
+
diff --git a/bazaar/Firebird/Firebird.upp b/bazaar/Firebird/Firebird.upp
new file mode 100644
index 000000000..d79772455
--- /dev/null
+++ b/bazaar/Firebird/Firebird.upp
@@ -0,0 +1,19 @@
+description "Firebird/Interbase interface\377";
+
+uses
+	Sql;
+
+library(WIN32) fbclient_ms.lib;
+
+library(LINUX) fbclient;
+
+file
+	fb.h,
+	fb.cpp,
+	Firebird.h,
+	Firebird.cpp,
+	FirebirdSchema.h;
+
+mainconfig
+	"" = "";
+
diff --git a/bazaar/Firebird/FirebirdSchema.h b/bazaar/Firebird/FirebirdSchema.h
new file mode 100644
index 000000000..29c2a4a7f
--- /dev/null
+++ b/bazaar/Firebird/FirebirdSchema.h
@@ -0,0 +1,141 @@
+#define BOOL(x)                    COLUMN("numeric(1)", bool, x, 0, 0)
+#define BOOL_ARRAY(x, items)       COLUMN_ARRAY("numeric(1)", bool, x, 0, 0, items)
+#define BOOL_(x)                   COLUMN_("numeric(1)", bool, x, 0, 0)
+#define BOOL_ARRAY_(x, items)      COLUMN_ARRAY_("numeric(1)", bool, x, 0, 0, items)
+
+#define INT(x)                     COLUMN("integer", int, x, 0, 0)
+#define INT_ARRAY(x, items)        COLUMN_ARRAY("integer", int, x, 0, 0, items)
+#define INT_(x)                    COLUMN_("integer", int, x, 0, 0)
+#define INT_ARRAY_(x, items)       COLUMN_ARRAY("integer", int, x, 0, 0, items)
+
+#define INT64(x)                   COLUMN("bigint", int64, x, 0, 0)
+#define INT64_ARRAY(x, items)      COLUMN_ARRAY("bigint", int64, x, 0, 0, items)
+#define INT64_(x)                  COLUMN_("bigint", int64, x, 0, 0)
+#define INT64_ARRAY_(x, items)     COLUMN_ARRAY("bigint", int64, x, 0, 0, items)
+
+#define DOUBLE(x)                  COLUMN("double precision", double, x, 0, 0)
+#define DOUBLE_ARRAY(x, items)     COLUMN_ARRAY("double precision", double, x, 0, 0, items)
+#define DOUBLE_(x)                 COLUMN_("double precision", double, x, 0, 0)
+#define DOUBLE_ARRAY_(x, items)    COLUMN_ARRAY_("double precision", double, x, 0, 0, items)
+
+#define STRING(x, n)               COLUMN("varchar(" #n ")", String, x, n, 0)
+#define STRING_ARRAY(x, n, items)  COLUMN_ARRAY("varchar(" #n ")", String, x, n, 0, items)
+#define STRING_(x, n)              COLUMN_("varchar(" #n ")", String, x, n, 0)
+#define STRING_ARRAY_(x, n, items) COLUMN_ARRAY_("varchar(" #n ")", String, x, n, 0, items)
+
+#define DATE(x)                    COLUMN("date", Date, x, 0, 0)
+#define DATE_ARRAY(x, items)       COLUMN_ARRAY("date", Date, x, 0, 0, items)
+#define DATE_(x)                   COLUMN_("date", Date, x, 0, 0)
+#define DATE_ARRAY_(x, items)      COLUMN_ARRAY_("date", Date, x, 0, 0, items)
+
+#define TIME(x)                    COLUMN("timestamp", Time, x, 0, 0)
+#define TIME_ARRAY(x, items)       COLUMN_ARRAY("timestamp", Time, x, 0, 0, items)
+#define TIME_(x)                   COLUMN_("timestamp", Time, x, 0, 0)
+#define TIME_ARRAY_(x, items)      COLUMN_ARRAY_("timestamp", Time, x, 0, 0, items)
+
+#define BLOB(x)                    COLUMN("blob", String, x, 0, 0)
+#define BLOB_(x)                   COLUMN_("blob", String, x, 0, 0)
+
+#define SEQUENCE(x)                SCHEMA("create sequence " #x "; alter sequence " #x " restart with 1;",\
+                                          "drop sequence " #x ";") \
+                                   UPGRADE("create sequence " #x ";")
+#define SEQUENCE_(x)               DOID(x) SEQUENCE(x)
+
+#define PRIMARY_KEY                INLINE_ATTRIBUTE("primary key")
+#define NOT_NULL                   INLINE_ATTRIBUTE("not null")
+#define UNIQUE                     INLINE_ATTRIBUTE("unique")
+#define SQLDEFAULT(v)              INLINE_ATTRIBUTE("default " v)
+
+#define INDEX                      ATTRIBUTE("create index IDX_@x on @t(@c);", \
+                                             "drop index IDX_@x;")
+#ifndef REFERENCES
+#define REFERENCES(x)              ATTRIBUTE("alter table @t add (constraint FK_@x foreign key "\
+                                             "(@c) references " #x ");",\
+                                             "alter table @t drop constraint FK_@x;")
+#endif
+#ifndef REFERENCES_CASCADE
+#define REFERENCES_CASCADE(x)      ATTRIBUTE("alter table @t add (constraint FK_@x foreign key "\
+                                             "(@c) references " #x " on delete cascade);",\
+                                             "alter table @t drop constraint FK_@x;")
+#endif
+#ifndef REFERENCES_
+#define REFERENCES_(n, x)          ATTRIBUTE("alter table @t add (constraint FK_@x$" #n " foreign key "\
+                                             "(@c) references " #x ");",\
+                                             "alter table @t drop constraint FK_@x$" #n ";")
+#endif
+#ifndef REFERENCES_CASCADE_
+#define REFERENCES_CASCADE_(n, x)  ATTRIBUTE("alter table @t add (constraint FK_@x$" #n " foreign key "\
+                                             "(@c) references " #x " on delete cascade);",\
+                                             "alter table @t drop constraint FK_@x$" #n ";")
+#endif
+
+#define DUAL_PRIMARY_KEY(k1, k2)   INLINE_ATTRIBUTE(", primary key (" #k1 ", " #k2 ")")
+
+#define DUAL_UNIQUE(k1, k2)        ATTRIBUTE("alter table @t add constraint DQ_@t unique "\
+                                             "(" #k1 ", " #k2 ");",\
+                                             "alter table @t drop constraint DQ_@t;")
+
+#define UNIQUE_LIST(u, l)          ATTRIBUTE("alter table @t add constraint UQ_@t$" #u " unique "\
+                                             "(" l ");",\
+                                             "alter table @t drop constraint UQ_@t$" #u ";")
+
+#define SQLCHECK(n, ct)            ATTRIBUTE("alter table @t add constraint CHK_@t$" #n " check "\
+                                             "(" ct ");",\
+                                             "alter table @t drop constraint CHK_@t$" #n ";")
+
+#include <Sql/sch_model.h>
+
+
+#undef BOOL
+#undef BOOL_ARRAY
+#undef BOOL_
+#undef BOOL_ARRAY_
+
+#undef INT
+#undef INT_ARRAY
+#undef INT_
+#undef INT_ARRAY_
+
+#undef INT64
+#undef INT64_ARRAY
+#undef INT64_
+#undef INT64_ARRAY_
+
+#undef DOUBLE
+#undef DOUBLE_ARRAY
+#undef DOUBLE_
+#undef DOUBLE_ARRAY_
+
+#undef STRING
+#undef STRING_ARRAY
+#undef STRING_
+#undef STRING_ARRAY_
+
+#undef DATE
+#undef DATE_ARRAY
+#undef DATE_
+#undef DATE_ARRAY_
+
+#undef TIME
+#undef TIME_ARRAY
+#undef TIME_
+#undef TIME_ARRAY_
+
+#undef BLOB
+#undef BLOB_
+
+#undef SEQUENCE
+
+#undef PRIMARY_KEY
+#undef NOT_NULL
+#undef INDEX
+#undef UNIQUE
+#undef SQLDEFAULT
+#undef REFERENCES
+#undef REFERENCES_
+#undef REFERENCES_CASCADE
+#undef REFERENCES_CASCADE_
+#undef DUAL_PRIMARY_KEY
+#undef DUAL_UNIQUE
+#undef UNIQUE_LIST
+#undef SQLCHECK
diff --git a/bazaar/Firebird/fb.cpp b/bazaar/Firebird/fb.cpp
new file mode 100644
index 000000000..5810a2fda
--- /dev/null
+++ b/bazaar/Firebird/fb.cpp
@@ -0,0 +1,2385 @@
+#include "fb.h"
+
+// Development-time comments ...
+
+
+// Conversions ...
+// void        ISC_EXPORT isc_decode_date (ISC_QUAD ISC_FAR *,
+//                     void ISC_FAR *);
+//
+// void        ISC_EXPORT isc_decode_sql_date (ISC_DATE ISC_FAR *,
+//                     void ISC_FAR *);
+//
+// void        ISC_EXPORT isc_decode_sql_time (ISC_TIME ISC_FAR *,
+//                     void ISC_FAR *);
+//
+// void        ISC_EXPORT isc_decode_timestamp (ISC_TIMESTAMP ISC_FAR *,
+//                     void ISC_FAR *);
+//
+// void        ISC_EXPORT isc_encode_date (void ISC_FAR *,
+//                     ISC_QUAD ISC_FAR *);
+//
+// void        ISC_EXPORT isc_encode_sql_date (void ISC_FAR *,
+//                     ISC_DATE ISC_FAR *);
+//
+// void        ISC_EXPORT isc_encode_sql_time (void ISC_FAR *,
+//                     ISC_TIME ISC_FAR *);
+//
+// void        ISC_EXPORT isc_encode_timestamp (void ISC_FAR *,
+//                     ISC_TIMESTAMP ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_dsql_finish (isc_db_handle ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_dsql_insert (ISC_STATUS ISC_FAR *,
+//                        isc_stmt_handle ISC_FAR *,
+//                        unsigned short,
+//                        XSQLDA ISC_FAR *);
+//
+
+
+// Print ...
+// void        ISC_EXPORT isc_print_sqlerror (short,
+//                        ISC_STATUS ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_print_status (ISC_STATUS ISC_FAR *);
+//
+
+
+
+// Not supported ...
+
+
+// The isc_create_database ( ) method is not currently supported
+// from user applications. is for internal use only.
+// ISC_STATUS  ISC_EXPORT isc_create_database (ISC_STATUS ISC_FAR *,
+//                         short,
+//                         char ISC_FAR *,
+//                         isc_db_handle ISC_FAR *,
+//                         short,
+//                         char ISC_FAR *,
+//                         short);
+
+
+// Not documented ...
+
+// void        ISC_EXPORT isc_sql_interprete (short,
+//                        char ISC_FAR *,
+//                        short);
+//
+// ISC_LONG    ISC_EXPORT isc_vax_integer (char ISC_FAR *,
+//                     short);
+//
+// ISC_INT64   ISC_EXPORT isc_portable_integer  (unsigned char ISC_FAR *,
+//                                               short);
+// ISC_STATUS  ISC_EXPORT isc_compile_request (ISC_STATUS ISC_FAR *,
+//                         isc_db_handle ISC_FAR *,
+//                         isc_req_handle ISC_FAR *,
+//                         short,
+//                         char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_compile_request2 (ISC_STATUS ISC_FAR *,
+//                          isc_db_handle ISC_FAR *,
+//                          isc_req_handle ISC_FAR *,
+//                          short,
+//                          char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_ddl (ISC_STATUS ISC_FAR *,
+//                     isc_db_handle ISC_FAR *,
+//                     isc_tr_handle ISC_FAR *,
+//                     short,
+//                     char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_receive (ISC_STATUS ISC_FAR *,
+//                     isc_req_handle ISC_FAR *,
+//                     short,
+//                     short,
+//                     void ISC_FAR *,
+//                     short);
+//
+// ISC_STATUS  ISC_EXPORT isc_release_request (ISC_STATUS ISC_FAR *,
+//                         isc_req_handle ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_request_info (ISC_STATUS ISC_FAR *,
+//                      isc_req_handle ISC_FAR *,
+//                      short,
+//                      short,
+//                      char ISC_FAR *,
+//                      short,
+//                      char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_send (ISC_STATUS ISC_FAR *,
+//                  isc_req_handle ISC_FAR *,
+//                  short,
+//                  short,
+//                  void ISC_FAR *,
+//                  short);
+//
+// ISC_STATUS  ISC_EXPORT isc_start_and_send (ISC_STATUS ISC_FAR *,
+//                        isc_req_handle ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        short,
+//                        short,
+//                        void ISC_FAR *,
+//                        short);
+//
+// ISC_STATUS  ISC_EXPORT isc_start_request (ISC_STATUS ISC_FAR *,
+//                       isc_req_handle ISC_FAR *,
+//                       isc_tr_handle ISC_FAR *,
+//                       short);
+//
+// ISC_STATUS  ISC_EXPORT isc_unwind_request (ISC_STATUS ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        short);
+//
+// ISC_STATUS  ISC_EXPORT isc_close (ISC_STATUS ISC_FAR *,
+//                   char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_declare (ISC_STATUS ISC_FAR *,
+//                     char ISC_FAR *,
+//                     char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_describe (ISC_STATUS ISC_FAR *,
+//                     char ISC_FAR *,
+//                     XSQLDA ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_describe_bind (ISC_STATUS ISC_FAR *,
+//                       char ISC_FAR *,
+//                       XSQLDA ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_open (ISC_STATUS ISC_FAR *,
+//                  isc_tr_handle ISC_FAR *,
+//                  char ISC_FAR *,
+//                  XSQLDA ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_dsql_release (ISC_STATUS ISC_FAR *,
+//                      char ISC_FAR *);
+//
+// ISC_LONG    ISC_EXPORT isc_ftof (char ISC_FAR *,
+//                  unsigned short,
+//                  char ISC_FAR *,
+//                  unsigned short);
+//
+// ISC_STATUS  ISC_EXPORT isc_print_blr (char ISC_FAR *,
+//                       isc_callback,
+//                       void ISC_FAR *,
+//                       short);
+//
+// void        ISC_EXPORT isc_set_debug (int);
+//
+// void        ISC_EXPORT isc_qtoq (ISC_QUAD ISC_FAR *,
+//                  ISC_QUAD ISC_FAR *);
+//
+// void        ISC_EXPORT isc_vtof (char ISC_FAR *,
+//                  char ISC_FAR *,
+//                  unsigned short);
+//
+// void        ISC_EXPORT isc_vtov (char ISC_FAR *,
+//                  char ISC_FAR *,
+//                  short);
+//
+// ISC_LONG    ISC_EXPORT isc_reset_fpe (unsigned short);
+
+
+
+
+
+
+
+
+namespace ibpp
+{
+	///////////////////////////////////////////////////////////////////////////
+	Error ib_error;
+
+	inline
+	void
+	check(ISC_STATUS rc)
+	{
+		if (rc)
+		{
+			ib_error.check();
+		}
+	}
+	
+
+	///////////////////////////////////////////////////////////////////////////
+	long
+	Error::getSQLCode()
+	{
+		sqlCode_ = isc_sqlcode(status_vector_);
+		if (sqlCode_ == 999)
+		{
+			sqlCode_ = 0;
+		}
+		return sqlCode_;
+	}
+
+	String
+	Error::getErrorText()
+	{
+		// isc_sql_interprete(sqlCode_, msg_, sizeof(msg_));
+		// return msg_;
+
+		String errStr;
+
+#if 0
+		ISC_STATUS* pVector = status_vector_;
+		isc_interprete(msg_, &pVector);
+		errStr += msg_;
+		while (isc_interprete(msg_, &pVector))
+		{
+			errStr += "; ";
+			errStr += msg_;
+		}
+#else
+		const ISC_STATUS* pVector = status_vector_;
+		fb_interpret(msg_, sizeof(msg_), &pVector);
+		errStr += msg_;
+		while (fb_interpret(msg_, sizeof(msg_), &pVector))
+		{
+			errStr += "; ";
+			errStr += msg_;
+		}
+#endif
+
+		return errStr;
+	}
+
+	void
+	Error::check()
+	{
+		// static char already_exists[] = "already exists";
+		// static char duplicate_value[] = "duplicate value";
+
+		if (status_vector_[0] == 1 && status_vector_[1])
+		{
+			String err_str = getErrorText();
+
+			// if (!info_str.empty())
+			// {
+			//     err_str += " ";
+			//     err_str += info_str;
+			// }
+
+			long error_code = getSQLCode();
+
+			throw DbExc(err_str, error_code);
+		}
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	dpb::dpb() :
+			pos_(0)
+	{
+		memset(buff_, 0, sizeof(buff_));
+	}
+
+	void
+	dpb::addParam(char value)
+	{
+		ASSERT(sizeof(pos_) < sizeof(buff_));
+		buff_[pos_++] = value;
+	}
+
+	void
+	dpb::addCluster(char type, const char* value)
+	{
+		short len = value ? (short)strlen(value) : 0;
+
+		ASSERT(sizeof(pos_ + 2 + len - 1) < sizeof(buff_));
+		buff_[pos_++] = type;
+		buff_[pos_++] = char(len);
+//         strncpy(&buff_[pos_], value, len);
+		memcpy(&buff_[pos_], value, len);
+		pos_ += len;
+	}
+
+	void
+	dpb::addCluster(char type, short value)
+	{
+		ASSERT(sizeof(pos_ + 4 - 1) < sizeof(buff_));
+		buff_[pos_++] = type;
+		buff_[pos_++] = char(2);
+		*(short*)&buff_[pos_] = value;
+		pos_ += short(2);
+	}
+
+	void
+	dpb::addCluster(char type, bool value)
+	{
+		ASSERT(sizeof(pos_ + 3 - 1) < sizeof(buff_));
+		buff_[pos_++] = type;
+		buff_[pos_++] = char(1);
+		buff_[pos_++] = char(value ? 1 : 0);
+	}
+
+	void
+	dpb::addCluster(char type, char value)
+	{
+		ASSERT(sizeof(pos_ + 3 - 1) < sizeof(buff_));
+		buff_[pos_++] = type;
+		buff_[pos_++] = char(1);
+		buff_[pos_++] = value;
+	}
+
+	void
+	dpb::addCluster(char type, unsigned long value)
+	{
+		ASSERT(pos_ + 1 + sizeof(value) - 1 < sizeof(buff_));
+		buff_[pos_++] = type;
+		*(unsigned long*)&buff_[pos_] = value;
+		pos_ += short(sizeof(value));
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	DBParamBuff::DBParamBuff()
+	{
+		addParam(isc_dpb_version1);
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	DataBase::DataBase() :
+			handle_(NULL)
+	{
+	}
+
+	void
+	DataBase::attach(const char* name)
+	{
+		handle_ = NULL;
+		check(isc_attach_database(
+				  ib_error.getErrorVector(),
+				  strlen(name),
+				  const_cast<char*>(name),
+				  &handle_,
+				  paramBuff_.getBuffSize(),
+				  const_cast<char*>(paramBuff_.getBuff())
+			  ));
+	}
+
+	void
+	DataBase::dettach()
+	{
+		if (handle_ != 0)
+		{
+			check(isc_detach_database(
+					  ib_error.getErrorVector(),
+					  //const_cast<void**>(&handle_)
+					  &handle_
+				  ));
+		}
+	}
+
+	void
+	DataBase::drop()
+	{
+		check(isc_drop_database(
+				  ib_error.getErrorVector(),
+				  //const_cast<void**>(&handle_)
+				  &handle_
+			  ));
+		handle_ = NULL;
+	}
+
+	void
+	DataBase::execute_immediate(const String& stmt)
+	{
+		ASSERT(handle_ == 0);
+		isc_tr_handle tr_handle = NULL;
+
+		check(isc_dsql_execute_immediate(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  &tr_handle,
+				  stmt.GetCount(),
+				  stmt,
+				  3, // dialect_,
+				  NULL // inDataArray_.getBuffer()
+			  ));
+			  
+		check(isc_detach_database(
+				  ib_error.getErrorVector(),
+				  //static_cast<void**>(&handle_)
+				  &handle_
+			  ));
+	}
+
+	void
+	DataBase::expand_dpb() const
+	{
+		// isc_expand_dpb() allocates a new block for the DPB. to avoid memory leaks, call
+		// isc_free() to release that space.
+
+		// void        ISC_EXPORT_VARARG isc_expand_dpb (char ISC_FAR * ISC_FAR *,
+//                           short ISC_FAR *,
+//                           ...);
+//
+
+// void        ISC_EXPORT isc_print_sqlerror (short,
+	}
+
+	void
+	DataBase::modify_dpb() const
+	{
+// int        ISC_EXPORT isc_modify_dpb (char ISC_FAR * ISC_FAR *,
+//                      short ISC_FAR *, unsigned short,
+//                      char ISC_FAR *, short );
+//
+	}
+
+	void
+	DataBase::getInfo() const
+	{
+// ISC_STATUS  ISC_EXPORT isc_database_info (ISC_STATUS ISC_FAR *,
+//                       isc_db_handle ISC_FAR *,
+//                       short,
+//                       char ISC_FAR *,
+//                       short,
+//                       char ISC_FAR *);
+	}
+
+	void version_callback(void* user_arg, char* data)
+	{
+		ASSERT(user_arg);
+		if (user_arg)
+		{
+			DataBase* pDataBase = (DataBase*)user_arg;
+
+			if (pDataBase->dbVersion_.IsEmpty())
+			{
+				pDataBase->dbVersion_ = data;
+			}
+			else
+			{
+				pDataBase->odsVersion_ = data;
+			}
+		}
+	}
+
+	void
+	DataBase::retrieveVersion()
+	{
+		dbVersion_.Clear();
+		odsVersion_.Clear();
+
+#if FB_API_VER < 20
+		typedef isc_callback cb_type;
+#else
+		typedef ISC_VERSION_CALLBACK cb_type;
+#endif
+
+		check(isc_version(
+				  &handle_,
+				  (cb_type)version_callback,
+				  this
+			  ));
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	Transaction::Transaction() :
+			handle_(0L)
+	{
+	}
+
+	void
+	Transaction::start(const DataBase& db)
+	{
+		handle_ = NULL;
+
+		// Note If a TPB is not created for a transaction, a NULL pointer must be passed to
+		// isc_start_transaction () in its place. A default set of attributes is automatically assigned to
+		// such transactions.
+
+		check(isc_start_transaction(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  1, // Number of database handles passed in this call
+				  db.getHandleP(),
+				  paramBuff_.getBuffSize(),
+				  const_cast<char*>(paramBuff_.getBuff())
+			  ));
+	}
+
+	void
+	Transaction::start_multiple()
+	{
+// ISC_STATUS  ISC_EXPORT isc_start_multiple (ISC_STATUS ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        short,
+//                        void ISC_FAR *);
+//
+	}
+
+	void
+	Transaction::commit()
+	{
+		check(isc_commit_transaction(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Transaction::commit_retaining()
+	{
+		check(isc_commit_retaining(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Transaction::rollback()
+	{
+		check(isc_rollback_transaction(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Transaction::rollback_retaining()
+	{
+		// isc_rollback_retaining () should be used with caution because the error
+		// that caused the rollback may be in the transactions context. In this case, until the context
+		// is released the error will continue.
+		check(isc_rollback_retaining(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Transaction::prepare()
+	{
+		check(isc_prepare_transaction(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Transaction::prepare2()
+	{
+// ISC_STATUS  ISC_EXPORT isc_prepare_transaction2 (ISC_STATUS ISC_FAR *,
+//                          isc_tr_handle ISC_FAR *,
+//                          short,
+//                          char ISC_FAR *);
+//
+	}
+
+	void
+	Transaction::getInfo()
+	{
+// ISC_STATUS  ISC_EXPORT isc_transaction_info (ISC_STATUS ISC_FAR *,
+//                          isc_tr_handle ISC_FAR *,
+//                          short,
+//                          char ISC_FAR *,
+//                          short,
+//                          char ISC_FAR *);
+	}
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_transact_request (ISC_STATUS ISC_FAR *,
+//                          isc_db_handle ISC_FAR *,
+//                          isc_tr_handle ISC_FAR *,
+//                          unsigned short,
+//                          char ISC_FAR *,
+//                          unsigned short,
+//                          char ISC_FAR *,
+//                          unsigned short,
+//                          char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_reconnect_transaction (ISC_STATUS ISC_FAR *,
+//                           isc_db_handle ISC_FAR *,
+//                           isc_tr_handle ISC_FAR *,
+//                           short,
+//                           char ISC_FAR *);
+//
+
+	///////////////////////////////////////////////////////////////////////////
+	SQLDataArray::SQLDataArray(size_t size) :
+			pDA_(NULL),
+			size_(0)
+	{
+		setSize(size);
+	}
+
+	SQLDataArray::SQLDataArray(const SQLDataArray& /*theArray*/)
+	{
+		ASSERT(false);
+	}
+
+	SQLDataArray::~SQLDataArray()
+	{
+		try
+		{
+			setSize(0);
+		}
+		catch (...)
+		{
+			ASSERT(false);
+		}
+	}
+
+	void
+	SQLDataArray::setSize(size_t size)
+	{
+		if (size != size_)
+		{
+			if (pDA_)
+			{
+				free(pDA_);
+				pDA_ = NULL;
+			}
+			size_ = size;
+			if (size_ != 0)
+			{
+				size_t len = XSQLDA_LENGTH(size_);
+				pDA_ = (XSQLDA *)malloc(len);
+				memset(pDA_, 0, len);
+				// Initialize it ...
+				pDA_->version = SQLDA_VERSION1;
+				pDA_->sqln = size_;
+				pDA_->sqld = size_; // actual number of fields ...
+			}
+		}
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	DynamicSQL::DynamicSQL(const DataBase& db, const Transaction& tr)
+			: dialect_(3)
+			, pDBHandle_(db.getHandleP())
+			, pTRHandle_(tr.getHandleP())
+			, handle_(NULL)
+			, all_data_fetched_(false)
+	{
+		allocate_stmt2();
+	}
+	
+	DynamicSQL::~DynamicSQL()
+	{
+		try
+		{
+			drop_statement();
+		}
+		catch (...)
+		{
+			ASSERT(false);
+		}
+	}
+
+	void
+	DynamicSQL::execute_immediate(const String& stmt)
+	{
+		check(isc_dsql_execute_immediate(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  stmt.GetCount(),
+				  stmt,
+				  dialect_,
+				  inDataArray_.getBuffer()
+			  ));
+		// There is no data to fetch ...
+		// all_data_fetched_ = false;
+	}
+
+	void
+	DynamicSQL::execute_immediate_data(const String& stmt)
+	{
+		check(isc_dsql_exec_immed2(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  stmt.GetCount(),
+				  stmt,
+				  dialect_,
+				  inDataArray_.getBuffer(),
+				  outDataArray_.getBuffer()
+			  ));
+		all_data_fetched_ = false;
+	}
+
+	void
+	DynamicSQL::execute_immediate_no_trans(const String& stmt)
+	{
+		ASSERT(*pDBHandle_ == 0);
+		ASSERT(*pTRHandle_ == 0);
+
+		check(isc_dsql_execute_immediate(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  stmt.GetCount(),
+				  stmt,
+				  dialect_,
+				  inDataArray_.getBuffer()
+			  ));
+		// There is no data to fetch ...
+		// all_data_fetched_ = false;
+	}
+
+	void
+	DynamicSQL::prepare(const String& stmt, const SQLDataArray& define_da)
+	{
+		check(isc_dsql_prepare(
+				  ib_error.getErrorVector(),
+				  pTRHandle_,
+				  &handle_,
+				  stmt.GetCount(),
+				  stmt,
+				  dialect_,
+				  define_da.getBuffer()
+			  ));
+	}
+
+	void
+	DynamicSQL::execute()
+	{
+		check(isc_dsql_execute(
+				  ib_error.getErrorVector(),
+				  pTRHandle_,
+				  &handle_,
+				  // Indicates the version of the extended SQL descriptor area (XSQLDA)
+				  // ???? ??????? ???? 3-?, ?? SQL_DIALECT_V6, ???? ?????? - SQL_DIALECT_V5
+				  SQL_DIALECT_V6,
+				  inDataArray_.getBuffer()
+			  ));
+		all_data_fetched_ = false;
+	}
+
+	void
+	DynamicSQL::execute2()
+	{
+		check(isc_dsql_execute2(
+				  ib_error.getErrorVector(),
+				  pTRHandle_,
+				  &handle_,
+				  // Indicates the version of the extended SQL descriptor area (XSQLDA)
+				  // ???? ??????? ???? 3-?, ?? SQL_DIALECT_V6, ???? ?????? - SQL_DIALECT_V5
+				  SQL_DIALECT_V6,
+				  inDataArray_.getBuffer(),
+				  outDataArray_.getBuffer()
+			  ));
+		// all_data_fetched_ = false;
+	}
+
+	void
+	DynamicSQL::describe_bind(const SQLDataArray& da)
+	{
+		check(isc_dsql_describe_bind(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  // Indicates the version of the extended SQL descriptor area (XSQLDA)
+				  // ???? ??????? ???? 3-?, ?? SQL_DIALECT_V6, ???? ?????? - SQL_DIALECT_V5
+				  SQL_DIALECT_V6,
+				  da.getBuffer()
+			  ));
+	}
+
+	void
+	DynamicSQL::describe_define(const SQLDataArray& da)
+	{
+		check(isc_dsql_describe(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  // Indicates the version of the extended SQL descriptor area (XSQLDA)
+				  // ???? ??????? ???? 3-?, ?? SQL_DIALECT_V6, ???? ?????? - SQL_DIALECT_V5
+				  SQL_DIALECT_V6,
+				  da.getBuffer()
+			  ));
+	}
+
+	void
+	DynamicSQL::setCursorName(const char* name)
+	{
+		check(isc_dsql_set_cursor_name(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  const_cast<char*>(name),
+				  0 // Reserved for future use; set to 0
+			  ));
+	}
+
+	bool
+	DynamicSQL::fetch()
+	{
+		if (!all_data_fetched_)
+		{
+			int fetch_stat = isc_dsql_fetch(
+								 ib_error.getErrorVector(),
+								 &handle_,
+								 // Indicates the version of the extended SQL descriptor area (XSQLDA)
+								 // ???? ??????? ???? 3-?, ?? SQL_DIALECT_V6, ???? ?????? - SQL_DIALECT_V5
+								 SQL_DIALECT_V6,
+								 outDataArray_.getBuffer()
+							 );
+
+			switch (fetch_stat)
+			{
+			case 0:
+				return true;
+			case 100:
+				// No more data.
+				all_data_fetched_ = true;
+				return false;
+			default:
+				ib_error.check();
+				break;
+			}
+		}
+
+		return false;
+	}
+
+	int
+	DynamicSQL::getStmtType()
+	{
+		// Get Statement type in our case ...
+		char type_item[] = {isc_info_sql_stmt_type};
+		char res_buffer[8];
+		int  st_type = 0;
+
+		check(isc_dsql_sql_info(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  sizeof(type_item),
+				  type_item,
+				  sizeof(res_buffer),
+				  res_buffer
+			  ));
+
+		if (res_buffer[0] == isc_info_sql_stmt_type)
+		{
+			short length;
+			length = static_cast<short>(isc_portable_integer(reinterpret_cast<unsigned char*>(res_buffer + 1), 2));
+			st_type = static_cast<int>(isc_portable_integer(reinterpret_cast<unsigned char*>(res_buffer + 3), length));
+		}
+		
+		return st_type;
+	}
+
+	void
+	DynamicSQL::allocate_stmt()
+	{
+		// Note The isc_dsql_allocate_statement2() function is similar to the
+		// isc_dsql_alloc_statement() function except that statement handles allocated using
+		// isc_dsql_allocate_statement2() are automatically reset to
+		// NULL when the database under which they are allocated is detached.
+
+		if (handle_ == 0)
+		{
+			check(isc_dsql_allocate_statement(
+					  ib_error.getErrorVector(),
+					  pDBHandle_,
+					  &handle_
+				  ));
+		}
+		else
+		{
+			ASSERT(handle_ == 0);
+		}
+	}
+
+	void
+	DynamicSQL::allocate_stmt2()
+	{
+		// Note The isc_dsql_allocate_statement2() function is similar to the
+		// isc_dsql_alloc_statement() function except that statement handles allocated using
+		// isc_dsql_allocate_statement2() are automatically reset to
+		// NULL when the database under which they are allocated is detached.
+
+		if (handle_ == 0)
+		{
+			check(isc_dsql_alloc_statement2(
+					  ib_error.getErrorVector(),
+					  pDBHandle_,
+					  &handle_
+				  ));
+		}
+		else
+		{
+			ASSERT(handle_ == 0);
+		}
+	}
+
+	void
+	DynamicSQL::close_cursor()
+	{
+		check(isc_dsql_free_statement(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  DSQL_close
+			  ));
+		// !!! Do not set handle_ = NULL here !!!;
+	}
+
+	void
+	DynamicSQL::drop_statement()
+	{
+		check(isc_dsql_free_statement(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  DSQL_drop
+			  ));
+		handle_ = NULL;
+	}
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_execute (ISC_STATUS ISC_FAR *,
+//                     isc_tr_handle ISC_FAR *,
+//                     char ISC_FAR *,
+//                     XSQLDA ISC_FAR *);
+//
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_execute_immediate (ISC_STATUS ISC_FAR *,
+//                           isc_db_handle ISC_FAR *,
+//                           isc_tr_handle ISC_FAR *,
+//                           short ISC_FAR *,
+//                           char ISC_FAR *);
+//
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_fetch (ISC_STATUS ISC_FAR *,
+//                   char ISC_FAR *,
+//                   XSQLDA ISC_FAR *);
+//
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_prepare (ISC_STATUS ISC_FAR *,
+//                     isc_db_handle ISC_FAR *,
+//                     isc_tr_handle ISC_FAR *,
+//                     char ISC_FAR *,
+//                     short ISC_FAR *,
+//                     char ISC_FAR *,
+//                     XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_execute_m (ISC_STATUS ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        isc_stmt_handle ISC_FAR *,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        unsigned short,
+//                        char ISC_FAR *);
+//
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_execute2_m (ISC_STATUS ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        isc_stmt_handle ISC_FAR *,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        unsigned short,
+//                        char ISC_FAR *);
+
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_execute_immediate_m (ISC_STATUS ISC_FAR *,
+//                              isc_db_handle ISC_FAR *,
+//                              isc_tr_handle ISC_FAR *,
+//                              unsigned short,
+//                              char ISC_FAR *,
+//                              unsigned short,
+//                              unsigned short,
+//                              char ISC_FAR *,
+//                              unsigned short,
+//                              unsigned short,
+//                              char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_exec_immed3_m (ISC_STATUS ISC_FAR *,
+//                            isc_db_handle ISC_FAR *,
+//                            isc_tr_handle ISC_FAR *,
+//                            unsigned short,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            unsigned short,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            unsigned short,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            unsigned short,
+//                            char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_fetch_m (ISC_STATUS ISC_FAR *,
+//                      isc_stmt_handle ISC_FAR *,
+//                      unsigned short,
+//                      char ISC_FAR *,
+//                      unsigned short,
+//                      unsigned short,
+//                      char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_insert_m (ISC_STATUS ISC_FAR *,
+//                       isc_stmt_handle ISC_FAR *,
+//                       unsigned short,
+//                       char ISC_FAR *,
+//                       unsigned short,
+//                       unsigned short,
+//                       char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_dsql_prepare_m (ISC_STATUS ISC_FAR *,
+//                        isc_tr_handle ISC_FAR *,
+//                        isc_stmt_handle ISC_FAR *,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        unsigned short,
+//                        char ISC_FAR *,
+//                        unsigned short,
+//                        char ISC_FAR *);
+//
+
+	///////////////////////////////////////////////////////////////////////////
+	EmbededSQL::EmbededSQL()
+	{
+	}
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_close (ISC_STATUS ISC_FAR *,
+//                          char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_declare (ISC_STATUS ISC_FAR *,
+//                           char ISC_FAR *,
+//                           char ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_describe (ISC_STATUS ISC_FAR *,
+//                         char ISC_FAR *,
+//                         unsigned short,
+//                         XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_describe_bind (ISC_STATUS ISC_FAR *,
+//                              char ISC_FAR *,
+//                              unsigned short,
+//                              XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_execute (ISC_STATUS ISC_FAR *,
+//                            isc_tr_handle ISC_FAR *,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_execute2 (ISC_STATUS ISC_FAR *,
+//                         isc_tr_handle ISC_FAR *,
+//                         char ISC_FAR *,
+//                         unsigned short,
+//                         XSQLDA ISC_FAR *,
+//                         XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_execute_immed (ISC_STATUS ISC_FAR *,
+//                              isc_db_handle ISC_FAR *,
+//                              isc_tr_handle ISC_FAR *,
+//                              unsigned short,
+//                              char ISC_FAR *,
+//                              unsigned short,
+//                              XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_fetch (ISC_STATUS ISC_FAR *,
+//                          char ISC_FAR *,
+//                          unsigned short,
+//                          XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_open (ISC_STATUS ISC_FAR *,
+//                         isc_tr_handle ISC_FAR *,
+//                         char ISC_FAR *,
+//                         unsigned short,
+//                         XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_open2 (ISC_STATUS ISC_FAR *,
+//                          isc_tr_handle ISC_FAR *,
+//                          char ISC_FAR *,
+//                          unsigned short,
+//                          XSQLDA ISC_FAR *,
+//                          XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_insert (ISC_STATUS ISC_FAR *,
+//                           char ISC_FAR *,
+//                           unsigned short,
+//                           XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_prepare (ISC_STATUS ISC_FAR *,
+//                            isc_db_handle ISC_FAR *,
+//                            isc_tr_handle ISC_FAR *,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            char ISC_FAR *,
+//                            unsigned short,
+//                            XSQLDA ISC_FAR *);
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_embed_dsql_release (ISC_STATUS ISC_FAR *,
+//                            char ISC_FAR *);
+
+	///////////////////////////////////////////////////////////////////////////
+	void
+	BlobDescr::get(
+		SegmentBlob& blob,
+		const String& tbl_name,
+		const String& clm_name
+	)
+	{
+		char clm_global_name[256];
+
+		check(isc_blob_lookup_desc(
+				  ib_error.getErrorVector(),
+				  blob.pDBHandle_,
+				  blob.pTRHandle_,
+				  (unsigned char ISC_FAR *)~tbl_name,
+				  (unsigned char ISC_FAR *)~clm_name,
+				  &blobDescr_,
+				  (unsigned char ISC_FAR *)clm_global_name
+			  ));
+	}
+
+	void
+	BlobDescr::getDefault()
+	{
+		// void       ISC_EXPORT isc_blob_default_desc (ISC_BLOB_DESC ISC_FAR *,
+		//                                         unsigned char ISC_FAR *,
+		//                                         unsigned char ISC_FAR *);
+		//
+	}
+
+	void
+	BlobDescr::set()
+	{
+		// ISC_STATUS ISC_EXPORT isc_blob_set_desc (ISC_STATUS ISC_FAR *,
+		//                      unsigned char ISC_FAR *,
+		//                      unsigned char ISC_FAR *,
+		//                      short,
+		//                      short,
+		//                      short,
+		//                      ISC_BLOB_DESC ISC_FAR *);
+		//
+	}
+
+	// ISC_STATUS ISC_EXPORT isc_blob_gen_bpb (ISC_STATUS ISC_FAR *,
+	//                     ISC_BLOB_DESC ISC_FAR *,
+	//                     ISC_BLOB_DESC ISC_FAR *,
+	//                     unsigned short,
+	//                     unsigned char ISC_FAR *,
+	//                     unsigned short ISC_FAR *);
+	//
+
+	///////////////////////////////////////////////////////////////////////////
+	SegmentBlob::info::info() :
+			lenght_(0),
+			maxSegments_(0),
+			numSegments_(0),
+			type_segmented(false)
+	{
+	}
+
+	SegmentBlob::SegmentBlob(const DataBase& db, const Transaction& tr) :
+			pDBHandle_(db.getHandleP()),
+			pTRHandle_(tr.getHandleP()),
+			isOpen_(false),
+			hasInfo_(false)
+	{
+		handle_ = NULL;
+
+		id_.gds_quad_low = 0;
+		id_.gds_quad_high = 0;
+
+		lastID_.gds_quad_low = 0;
+		lastID_.gds_quad_high = 0;
+	}
+
+	SegmentBlob::~SegmentBlob()
+	{
+		// This is not a right place to close BLOB ...
+		// close();
+	}
+
+	void 
+	SegmentBlob::open_internal()
+	{
+		handle_ = NULL;
+
+		check(isc_open_blob(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  &handle_,   /* set by this function to refer to the SegmentBlob */
+				  &id_       /* SegmentBlob ID put into out_sqlda by isc_dsql_fetch() */
+			  ));
+	}
+
+	void
+	SegmentBlob::open2_internal()
+	{
+		handle_ = NULL;
+
+		check(isc_open_blob2(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  &handle_,   /* set by this function to refer to the SegmentBlob */
+				  &id_,       /* SegmentBlob ID put into out_sqlda by isc_dsql_fetch() */
+				  0,          /* BPB length = 0; no filter will be used */
+				  NULL        /* NULL BPB, since no filter will be used */
+			  ));
+	}
+
+	void
+	SegmentBlob::setup_open()
+	{
+		isOpen_ = true;
+		lastID_ = id_;
+		hasInfo_ = false;
+	}
+
+	void
+	SegmentBlob::setup_close()
+	{
+		isOpen_ = false;
+		lastID_.gds_quad_low = 0;
+		lastID_.gds_quad_high = 0;
+		hasInfo_ = false;
+	}
+
+	void
+	SegmentBlob::open()
+	{
+		if (!isOpen_)
+		{
+			open2_internal();
+			setup_open();
+		}
+		else if ((lastID_.gds_quad_high != id_.gds_quad_high) || (lastID_.gds_quad_low != id_.gds_quad_low))
+		{
+			close();
+			open2_internal();
+			setup_open();
+		}
+	}
+
+	void
+	SegmentBlob::create_internal()
+	{
+		handle_ = NULL;
+		id_.gds_quad_low = 0;
+		id_.gds_quad_high = 0;
+
+		check(isc_create_blob(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  &handle_,   /* set by this function to refer to the SegmentBlob */
+				  &id_        /* SegmentBlob ID put into out_sqlda by isc_dsql_fetch() */
+			  ));
+	}
+
+	void
+	SegmentBlob::create2_internal()
+	{
+		handle_ = NULL;
+		id_.gds_quad_low = 0;
+		id_.gds_quad_high = 0;
+
+		check(isc_create_blob2(
+				  ib_error.getErrorVector(),
+				  pDBHandle_,
+				  pTRHandle_,
+				  &handle_,   /* set by this function to refer to the SegmentBlob */
+				  &id_,       /* SegmentBlob ID put into out_sqlda by isc_dsql_fetch() */
+				  0,          /* BPB length = 0; no filter will be used */
+				  NULL        /* NULL BPB, since no filter will be used */
+			  ));
+	}
+
+	void
+	SegmentBlob::create()
+	{
+		close();
+		create2_internal();
+		setup_open();
+	}
+
+	void
+	SegmentBlob::close()
+	{
+		if (isOpen_)
+		{
+			ASSERT(handle_);
+			check(isc_close_blob(
+					  ib_error.getErrorVector(),
+					  &handle_
+				  ));
+			handle_ = NULL;
+			setup_close();
+		}
+	}
+
+	bool
+	SegmentBlob::getSegment(
+		unsigned short& actualSegLen,
+		unsigned short maxSegLen,
+		char* pSegment
+	)
+	{
+		bool result = false;
+
+		if (!isOpen_)
+			open();
+		
+		ASSERT(handle_);
+		stat_ = isc_get_segment(
+					ib_error.getErrorVector(),
+					&handle_,
+					&actualSegLen,
+					maxSegLen,
+					pSegment
+				);
+		if (stat_ == 0 || (stat_ != 0 && ib_error.get_err_code() == isc_segment))
+			result = true;
+		else if (stat_ == isc_segstr_eof)
+			result = false;
+		else
+			// Exception.
+			ib_error.check();
+
+		return result;
+	}
+
+	void
+	// SegmentBlob::addSegment(const String& data)
+	SegmentBlob::addSegment(const char* pSegment, unsigned short seg_length)
+	{
+		if (!isOpen_)
+			open();
+
+		ASSERT(handle_);
+		check(isc_put_segment(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  seg_length,
+				  const_cast<char*>(pSegment)
+			  ));
+	}
+
+	void
+	SegmentBlob::put_segment(const char* data_ptr, size_t data_len)
+	{
+		long cur_str_pos = 0;
+		unsigned short cur_segment_size = 0;
+		long size_left = data_len;
+		const unsigned short db_segment_size = 0xFFFF;
+
+		// !!! Segment size is limited to "unsigned short" ...
+		while (size_left > 0)
+		{
+			cur_segment_size = (size_left > db_segment_size ? db_segment_size : static_cast<unsigned short>(size_left));
+
+			addSegment(data_ptr + cur_str_pos, cur_segment_size);
+			
+			size_left -= cur_segment_size;
+			cur_str_pos += cur_segment_size;
+		}
+	}
+
+	void
+	SegmentBlob::cancel()
+	{
+		ASSERT(handle_);
+		check(isc_cancel_blob(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+		setup_close();
+	}
+
+	void
+	SegmentBlob::retrieve_info()
+	{
+		if (!hasInfo_)
+		{
+			char res_buffer[40];
+			char blob_items[] =
+			{
+				isc_info_blob_total_length,
+				isc_info_blob_max_segment,
+				isc_info_blob_num_segments,
+				isc_info_blob_type
+			};
+
+			if (!isOpen_)
+				open();
+
+			ASSERT(handle_);
+			check(isc_blob_info(
+					  ib_error.getErrorVector(),
+					  &handle_,
+					  sizeof(blob_items),/* Length of item-list buffer. */
+					  blob_items, /* Item-list buffer. */
+					  sizeof(res_buffer),/* Length of result buffer. */
+					  res_buffer /* Result buffer */
+				  ));
+
+			// Extract values returned in the result buffer
+			for (char* p = res_buffer; *p != isc_info_end ;)
+			{
+
+				char item = *p++;
+
+				short length = (short)isc_vax_integer(p, 2);
+
+				p += 2;
+
+				switch (item)
+				{
+				case isc_info_blob_total_length:
+					info_.lenght_ = isc_vax_integer(p, length);
+					break;
+				case isc_info_blob_max_segment:
+					info_.maxSegments_ = isc_vax_integer(p, length);
+					break;
+				case isc_info_blob_num_segments:
+					info_.numSegments_ = isc_vax_integer(p, length);
+					break;
+				case isc_info_blob_type:
+					info_.type_segmented = (isc_vax_integer(p, length) == 0);
+					break;
+				case isc_info_truncated:
+					// handle error
+					throw DbExc("BLOB information was truncated.");
+					break;
+				case isc_info_error:
+					// handle error
+					throw DbExc("Requested BLOB information is unavailable.");
+					break;
+				default:
+					break;
+				}
+
+				p += length;
+			}
+			
+			hasInfo_ = true;
+		}
+	}
+
+// Stream Blobs ...
+// http://www.ibphoenix.com/a4556.htm
+
+// Not documented ...
+// ISC_STATUS  ISC_EXPORT isc_seek_blob (ISC_STATUS ISC_FAR *,
+//                       isc_blob_handle ISC_FAR *,
+//                       short,
+//                       ISC_LONG,
+//                       ISC_LONG ISC_FAR *);
+//
+
+
+
+
+// Not documented ...
+// BSTREAM     ISC_FAR * ISC_EXPORT BLOB_open (isc_blob_handle,
+//                         char ISC_FAR *,
+//                         int);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_put (char,
+//                  BSTREAM ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_close (BSTREAM ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_get (BSTREAM ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_display (ISC_QUAD ISC_FAR *,
+//                      isc_db_handle,
+//                      isc_tr_handle,
+//                      char ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_dump (ISC_QUAD ISC_FAR *,
+//                   isc_db_handle,
+//                   isc_tr_handle,
+//                   char ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_edit (ISC_QUAD ISC_FAR *,
+//                   isc_db_handle,
+//                   isc_tr_handle,
+//                   char ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_load (ISC_QUAD ISC_FAR *,
+//                   isc_db_handle,
+//                   isc_tr_handle,
+//                   char ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_text_dump (ISC_QUAD ISC_FAR *,
+//                   isc_db_handle,
+//                   isc_tr_handle,
+//                   char ISC_FAR *);
+//
+
+// Not documented ...
+// int         ISC_EXPORT BLOB_text_load (ISC_QUAD ISC_FAR *,
+//                   isc_db_handle,
+//                   isc_tr_handle,
+//                   char ISC_FAR *);
+//
+
+// Not documented ...
+// BSTREAM     ISC_FAR * ISC_EXPORT Bopen (ISC_QUAD ISC_FAR *,
+//                         isc_db_handle,
+//                         isc_tr_handle,
+//                         char ISC_FAR *);
+//
+
+// Not documented ...
+// BSTREAM     ISC_FAR * ISC_EXPORT Bopen2 (ISC_QUAD ISC_FAR *,
+//                      isc_db_handle,
+//                      isc_tr_handle,
+//                      char ISC_FAR *,
+//                      unsigned short);
+
+
+
+	///////////////////////////////////////////////////////////////////////////
+	spb::spb(size_t buff_size) :
+			buff_size_(buff_size),
+			pos_(0)
+	{
+		buff_ptr_ = new char[buff_size_];
+		memset(buff_ptr_, 0, buff_size_);
+	}
+
+	spb::~spb()
+	{
+		delete [] buff_ptr_;
+	}
+
+	void
+	spb::addParam(char value)
+	{
+		ASSERT(pos_ < buff_size_);
+		buff_ptr_[pos_++] = value;
+	}
+
+	void
+	spb::addCluster(char type, const char* value)
+	{
+		unsigned short len = (unsigned short)strlen(value);
+
+		ASSERT(static_cast<size_t>(pos_ + 1 + 2 + len - 1) < buff_size_);
+		buff_ptr_[pos_++] = type;
+		char* p = &buff_ptr_[pos_];
+		ADD_SPB_LENGTH(p, len); // It is okay to have a warning "conversion from 'unsigned short' to 'char'" here.
+		pos_ += sizeof(len);
+		memcpy(&buff_ptr_[pos_], value, len);
+		pos_ += len;
+	}
+
+	void
+	spb::addCluster(char type, unsigned long value)
+	{
+		ASSERT(pos_ + 1 + sizeof(value) - 1 < buff_size_);
+		buff_ptr_[pos_++] = type;
+		// *(short*)&buff_ptr_[pos_] = value;
+		char* p = &buff_ptr_[pos_];
+		ADD_SPB_NUMERIC(p, value);
+		pos_ += short(sizeof(value));
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	void
+	Service::attach(
+		const char* host,
+		const char* user,
+		const char* pswd,
+		network_protocol_t protocol
+	)
+	{
+		String service_host;
+
+		service_host = host;
+		if (!service_host.IsEmpty())
+		{
+			switch (protocol)
+			{
+			case np_TCP_IP:
+				service_host += ":service_mgr";
+				break;
+			case np_NetBEUI:
+				service_host = "\\\\" + service_host;
+				service_host += "\\service_mgr";
+				break;
+			case np_IPX_SPX:
+				service_host += "@service_mgr";
+				break;
+			case np_local:
+				service_host = "service_mgr";
+				break;
+			}
+		}
+		else
+		{
+			service_host = "service_mgr";
+		}
+
+		dpb paramBuff;
+		paramBuff.addParam(isc_spb_version);
+		paramBuff.addParam(isc_spb_current_version);
+		paramBuff.addCluster(isc_spb_user_name, user);
+		paramBuff.addCluster(isc_spb_password, pswd);
+
+		handle_ = 0L;
+		check(isc_service_attach(
+				  ib_error.getErrorVector(),
+				  service_host.GetCount(),
+				  service_host,
+				  &handle_,
+				  paramBuff.getBuffSize(),
+				  const_cast<char*>(paramBuff.getBuff())
+			  ));
+	}
+
+	void
+	Service::detach()
+	{
+		check(isc_service_detach(
+				  ib_error.getErrorVector(),
+				  &handle_
+			  ));
+	}
+
+	void
+	Service::executeCommand(const spb& pb)
+	{
+		check(isc_service_start(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  NULL,
+				  pb.getBuffSize(),
+				  const_cast<char*>(pb.getBuff())
+			  ));
+	}
+
+	void
+	Service::query(const spb& request, const spb& result)
+	{
+		spb flags_buff;
+
+		flags_buff.addParam(isc_spb_version);
+		flags_buff.addParam(isc_spb_current_version);
+		flags_buff.addCluster(isc_info_svc_timeout, 60);
+
+		check(isc_service_query(
+				  ib_error.getErrorVector(),
+				  &handle_,
+				  NULL,
+				  flags_buff.getBuffSize(), flags_buff.getBuff(),
+				  request.getBuffSize(), request.getBuff(),
+				  result.getBuffMaxSize(), result.getBuff()
+			  ));
+
+//         char spb_buffer[6], *spb = spb_buffer;
+//         char request_buffer[] = {
+//             isc_info_svc_version,
+//             isc_info_svc_server_version,
+//             isc_info_svc_implementation,
+//             isc_info_svc_get_env,
+//             isc_info_svc_get_env_lock,
+//             isc_info_svc_get_env_msg,
+//             isc_info_svc_get_licensed_users,
+//             isc_info_svc_user_dbpath
+//             };
+//         char result_buffer[1024], *p = result_buffer;
+//         memset(result_buffer, 0, sizeof(result_buffer));
+//
+//         // *spb++ = isc_info_svc_timeout;
+//         // ADD_SPB_NUMERIC(spb, 60); /* 1 minute timeout */
+//
+//         if (isc_service_query (
+//             ib_error.getErrorVector(),
+//             &handle_,
+//             NULL,
+//             spb - spb_buffer, spb_buffer,
+//             // sizeof(request_buffer), request_buffer,
+//             request.getBuffSize(), request.getBuff(),
+//             // sizeof(result_buffer), result_buffer
+//             result.getBuffMaxSize(), result.getBuff()
+//             )
+//         )
+//         {
+//             isc_print_status(ib_error.getErrorVector());
+//             isc_service_detach(ib_error.getErrorVector(), &handle_);
+//             return;
+//         }
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	user_info::user_info() :
+			user_id(0),
+			group_id(0)
+	{
+	}
+
+	user_info::user_info(const user_info& info)
+	{
+		copy(info);
+	}
+
+	void
+	user_info::copy(const user_info& info)
+	{
+		user_id = info.user_id;
+		group_id = info.group_id;
+		user_name = info.user_name;
+		first_name = info.first_name;
+		middle_name = info.middle_name;
+		last_name = info.last_name;
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	server_info::server_info() :
+			svc_version(0),
+			num_licensed_users(0)
+	{
+	}
+
+	server_info::server_info(const server_info& info)
+	{
+		copy(info);
+	}
+
+	void
+	server_info::copy(const server_info& info)
+	{
+		svc_version = info.svc_version;
+		num_licensed_users = info.num_licensed_users;
+		server_version = info.server_version;
+		implementation_str = info.implementation_str;
+		env_ib_str = info.env_ib_str;
+		env_lock_str = info.env_lock_str;
+		env_msg_str = info.env_msg_str;
+		user_db_path_str = info.user_db_path_str;
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	namespace svc_cmd
+	{
+		///////////////////////////////////////////////////////////////////////////
+		base::base(Service& svc) :
+				svc_ptr_(&svc)
+		{
+		}
+
+		unsigned long
+		base::read_long(char*& p) const
+		{
+			unsigned long result;
+
+			// p += sizeof(unsigned short);
+			result = (unsigned long)isc_portable_integer((unsigned char*)p, sizeof(result));
+			p += sizeof(unsigned long);
+			return result;
+		}
+
+		unsigned short
+		base::read_short(char*& p) const
+		{
+			unsigned short result;
+
+			// p += sizeof(unsigned short);
+			result = (unsigned short)isc_portable_integer((unsigned char*)p, sizeof(result));
+			p += sizeof(unsigned short);
+			return result;
+		}
+
+		String
+		base::read_string(char*& p) const
+		{
+			String result;
+			size_t str_length;
+
+			str_length = (unsigned short)isc_portable_integer((unsigned char*)p, sizeof(unsigned short));
+			p += sizeof(unsigned short);
+			result = String(p, str_length);
+			p += str_length;
+			return result;
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		backup::backup(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		restore::restore(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		set_properties::set_properties(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		repair::repair(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		get_db_stats::get_db_stats(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		get_server_info::get_server_info(Service& svc) :
+				base(svc)
+		{
+		}
+
+		void
+		get_server_info::execute()
+		{
+			spb request;
+			spb result(1024);
+
+			// Prepare request ...
+			request.addParam(isc_info_svc_version);
+			request.addParam(isc_info_svc_server_version);
+			request.addParam(isc_info_svc_implementation);
+			request.addParam(isc_info_svc_get_env);
+			request.addParam(isc_info_svc_get_env_lock);
+			request.addParam(isc_info_svc_get_env_msg);
+			request.addParam(isc_info_svc_get_licensed_users);
+			request.addParam(isc_info_svc_user_dbpath);
+
+			// Execute ...
+			svc_ptr_->query(request, result);
+
+			// Parse results ...
+			char* p = const_cast<char*>(result.getBuff());
+
+			do
+			{
+				switch (*p++)
+				{
+				case isc_info_truncated:
+					throw DbExc("Server information was truncated.");
+					break;
+				case isc_info_svc_version:
+					info_.svc_version = read_long(p);
+					break;
+				case isc_info_svc_get_licensed_users:
+					info_.num_licensed_users = read_long(p);
+					break;
+				case isc_info_svc_server_version:
+					info_.server_version = read_string(p);
+					break;
+				case isc_info_svc_implementation:
+					info_.implementation_str = read_string(p);
+					break;
+				case isc_info_svc_get_env:
+					info_.env_ib_str = read_string(p);
+					break;
+				case isc_info_svc_get_env_lock:
+					info_.env_lock_str = read_string(p);
+					break;
+				case isc_info_svc_get_env_msg:
+					info_.env_msg_str = read_string(p);
+					break;
+				case isc_info_svc_user_dbpath:
+					info_.user_db_path_str = read_string(p);
+					break;
+				}
+			}
+			while (*p);
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		get_log::get_log(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		get_user_info::get_user_info(Service& svc, const String& user_name) :
+				base(svc),
+				user_name_(user_name)
+		{
+			paramBuff_.addParam(isc_action_svc_display_user);
+			paramBuff_.addCluster(isc_spb_sec_username, user_name);
+		}
+
+		void
+		get_user_info::execute()
+		{
+			spb request;
+			spb result(1024);
+
+			unsigned short loop;
+
+			// Executea task ...
+			svc_ptr_->executeCommand(paramBuff_);
+
+			// Prepare request ...
+			request.addParam(isc_info_svc_get_users);
+
+			// Execute ...
+			svc_ptr_->query(request, result);
+
+			// Parse results ...
+			char* p = const_cast<char*>(result.getBuff());
+
+			do
+			{
+				switch (*p++)
+				{
+				case isc_info_truncated:
+					throw DbExc("User information was truncated.");
+					break;
+				case isc_info_svc_get_users:
+					loop = read_short(p);
+					while (*p != isc_info_end)
+					{
+						switch (*p++)
+						{
+						case isc_spb_sec_username:
+							info_.user_name = read_string(p);
+							loop -= (info_.user_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_firstname:
+							info_.first_name = read_string(p);
+							loop -= (info_.first_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_middlename:
+							info_.middle_name = read_string(p);
+							loop -= (info_.middle_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_lastname:
+							info_.last_name = read_string(p);
+							loop -= (info_.last_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_groupid:
+							info_.group_id = read_long(p);
+							loop -= (sizeof(unsigned long) + 1);
+							break;
+						case isc_spb_sec_userid:
+							info_.user_id = read_long(p);
+							loop -= (sizeof(unsigned long) + 1);
+							break;
+						}
+					}
+					break;
+				}
+			}
+			while (*p);
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		get_users::get_users(Service& svc) :
+				base(svc)
+		{
+			paramBuff_.addParam(isc_action_svc_display_user);
+		}
+
+		void
+		get_users::execute()
+		{
+			spb request;
+			spb result(1024);
+
+			unsigned short loop;
+
+			// Executea task ...
+			svc_ptr_->executeCommand(paramBuff_);
+
+			// Prepare request ...
+			request.addParam(isc_info_svc_get_users);
+
+			// Execute ...
+			svc_ptr_->query(request, result);
+
+			// Parse results ...
+			char* p = const_cast<char*>(result.getBuff());
+			user_info info;
+
+			do
+			{
+				switch (*p++)
+				{
+				case isc_info_truncated:
+					throw DbExc("User list information was truncated.");
+					break;
+				case isc_info_svc_get_users:
+					loop = read_short(p);
+					while (*p != isc_info_end)
+					{
+						switch (*p++)
+						{
+						case isc_spb_sec_username:
+							if (!info.user_name.IsEmpty())
+							{
+								user_info_list_.push_back(info);
+								info = user_info();
+							}
+							info.user_name = read_string(p);
+							loop -= (info.user_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_firstname:
+							info.first_name = read_string(p);
+							loop -= (info.first_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_middlename:
+							info.middle_name = read_string(p);
+							loop -= (info.middle_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_lastname:
+							info.last_name = read_string(p);
+							loop -= (info.last_name.GetCount() + sizeof(unsigned short) + 1);
+							break;
+						case isc_spb_sec_groupid:
+							info.group_id = read_long(p);
+							loop -= (sizeof(unsigned long) + 1);
+							break;
+						case isc_spb_sec_userid:
+							info.user_id = read_long(p);
+							loop -= (sizeof(unsigned long) + 1);
+							break;
+						}
+					}
+					break;
+				}
+			}
+			while (*p);
+
+			if (!info.user_name.IsEmpty())
+			{
+				user_info_list_.push_back(info);
+				info = user_info();
+			}
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		add_user::add_user(Service& svc) :
+				base(svc)
+		{
+			paramBuff_.addParam(isc_action_svc_add_user);
+		}
+
+		void
+		add_user::execute()
+		{
+			svc_ptr_->executeCommand(paramBuff_);
+		}
+
+		void
+		add_user::set_username(const char* name)
+		{
+			paramBuff_.addCluster(isc_spb_sec_username, name);
+		}
+
+		void
+		add_user::set_password(const char* pswd)
+		{
+			paramBuff_.addCluster(isc_spb_sec_password, pswd);
+		}
+
+		void
+		add_user::set_firstname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_firstname, value);
+		}
+
+		void
+		add_user::set_middlename(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_middlename, value);
+		}
+
+		void
+		add_user::set_lastname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_lastname, value);
+		}
+
+		void
+		add_user::set_userid(unsigned long value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_userid, value);
+		}
+
+		void
+		add_user::set_groupid(unsigned long value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_groupid, value);
+		}
+
+		void
+		add_user::set_groupname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_groupname, value);
+		}
+
+		void
+		add_user::set_rolename(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sql_role_name, value);
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		delete_user::delete_user(Service& svc) :
+				base(svc)
+		{
+			paramBuff_.addParam(isc_action_svc_delete_user);
+		}
+
+		void
+		delete_user::execute()
+		{
+			svc_ptr_->executeCommand(paramBuff_);
+		}
+
+		void
+		delete_user::set_username(const char* name)
+		{
+			paramBuff_.addCluster(isc_spb_sec_username, name);
+		}
+
+		void
+		delete_user::set_rolename(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sql_role_name, value);
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		update_user::update_user(Service& svc) :
+				base(svc)
+		{
+			paramBuff_.addParam(isc_action_svc_modify_user);
+		}
+
+		void
+		update_user::execute()
+		{
+			svc_ptr_->executeCommand(paramBuff_);
+		}
+
+		void
+		update_user::set_username(const char* name)
+		{
+			paramBuff_.addCluster(isc_spb_sec_username, name);
+		}
+
+		void
+		update_user::set_password(const char* pswd)
+		{
+			paramBuff_.addCluster(isc_spb_sec_password, pswd);
+		}
+
+		void
+		update_user::set_firstname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_firstname, value);
+		}
+
+		void
+		update_user::set_middlename(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_middlename, value);
+		}
+
+		void
+		update_user::set_lastname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_lastname, value);
+		}
+
+		void
+		update_user::set_userid(unsigned long value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_userid, value);
+		}
+
+		void
+		update_user::set_groupid(unsigned long value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_groupid, value);
+		}
+
+		void
+		update_user::set_groupname(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sec_groupname, value);
+		}
+
+		void
+		update_user::set_rolename(const char* value)
+		{
+			paramBuff_.addCluster(isc_spb_sql_role_name, value);
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		add_license::add_license(Service& svc) :
+				base(svc)
+		{
+		}
+
+		///////////////////////////////////////////////////////////////////////////
+		remove_license::remove_license(Service& svc) :
+				base(svc)
+		{
+		}
+
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	Array::Array(const DataBase& db, const Transaction& tr) 
+	: pDBHandle_(db.getHandleP())
+	, pTRHandle_(tr.getHandleP())
+	{
+		id_.gds_quad_low = 0;
+		id_.gds_quad_high = 0;
+	}
+	
+// ISC_STATUS  ISC_EXPORT isc_array_gen_sdl (ISC_STATUS ISC_FAR *,
+//                       ISC_ARRAY_DESC ISC_FAR *,
+//                       short ISC_FAR *,
+//                       char ISC_FAR *,
+//                       short ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_array_get_slice (ISC_STATUS ISC_FAR *,
+//                         isc_db_handle ISC_FAR *,
+//                         isc_tr_handle ISC_FAR *,
+//                         ISC_QUAD ISC_FAR *,
+//                         ISC_ARRAY_DESC ISC_FAR *,
+//                         void ISC_FAR *,
+//                         ISC_LONG ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_array_lookup_bounds (ISC_STATUS ISC_FAR *,
+//                         isc_db_handle ISC_FAR *,
+//                         isc_tr_handle ISC_FAR *,
+//                         char ISC_FAR *,
+//                         char ISC_FAR *,
+//                         ISC_ARRAY_DESC ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_array_lookup_desc (ISC_STATUS ISC_FAR *,
+//                           isc_db_handle ISC_FAR *,
+//                           isc_tr_handle ISC_FAR *,
+//                           char ISC_FAR *,
+//                           char ISC_FAR *,
+//                           ISC_ARRAY_DESC ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_array_set_desc (ISC_STATUS ISC_FAR *,
+//                        char ISC_FAR *,
+//                        char ISC_FAR *,
+//                        short ISC_FAR *,
+//                        short ISC_FAR *,
+//                        short ISC_FAR *,
+//                        ISC_ARRAY_DESC ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_array_put_slice (ISC_STATUS ISC_FAR *,
+//                         isc_db_handle ISC_FAR *,
+//                         isc_tr_handle ISC_FAR *,
+//                         ISC_QUAD ISC_FAR *,
+//                         ISC_ARRAY_DESC ISC_FAR *,
+//                         void ISC_FAR *,
+//                         ISC_LONG ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_get_slice (ISC_STATUS ISC_FAR *,
+//                       isc_db_handle ISC_FAR *,
+//                       isc_tr_handle ISC_FAR *,
+//                       ISC_QUAD ISC_FAR *,
+//                       short,
+//                       char ISC_FAR *,
+//                       short,
+//                       ISC_LONG ISC_FAR *,
+//                       ISC_LONG,
+//                       void ISC_FAR *,
+//                       ISC_LONG ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_put_slice (ISC_STATUS ISC_FAR *,
+//                       isc_db_handle ISC_FAR *,
+//                       isc_tr_handle ISC_FAR *,
+//                       ISC_QUAD ISC_FAR *,
+//                       short,
+//                       char ISC_FAR *,
+//                       short,
+//                       ISC_LONG ISC_FAR *,
+//                       ISC_LONG,
+//                       void ISC_FAR *);
+//
+
+	///////////////////////////////////////////////////////////////////////////
+	Event::Event()
+	{
+	}
+
+// ISC_STATUS  ISC_EXPORT isc_cancel_events (ISC_STATUS ISC_FAR *,
+//                       isc_db_handle ISC_FAR *,
+//                       ISC_LONG ISC_FAR *);
+//
+// ISC_LONG    ISC_EXPORT_VARARG isc_event_block (char ISC_FAR * ISC_FAR *,
+//                            char ISC_FAR * ISC_FAR *,
+//                            unsigned short, ...);
+//
+// void        ISC_EXPORT isc_event_counts (unsigned ISC_LONG ISC_FAR *,
+//                      short,
+//                      char ISC_FAR *,
+//                      char ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_que_events (ISC_STATUS ISC_FAR *,
+//                        isc_db_handle ISC_FAR *,
+//                        ISC_LONG ISC_FAR *,
+//                        short,
+//                        char ISC_FAR *,
+//                        isc_callback,
+//                        void ISC_FAR *);
+//
+// ISC_STATUS  ISC_EXPORT isc_wait_for_event (ISC_STATUS ISC_FAR *,
+//                        isc_db_handle ISC_FAR *,
+//                        short,
+//                        char ISC_FAR *,
+//                        char ISC_FAR *);
+
+}
diff --git a/bazaar/Firebird/fb.h b/bazaar/Firebird/fb.h
new file mode 100644
index 000000000..5fbac924f
--- /dev/null
+++ b/bazaar/Firebird/fb.h
@@ -0,0 +1,973 @@
+#ifndef _firebird_fb_h_
+#define _firebird_fb_h_
+
+#include <Sql/Sql.h>
+#include <ibase.h>
+
+namespace ibpp
+{
+	using namespace Upp;
+	
+	class DbExc : public SqlExc
+	{
+	public:
+	#ifndef NOAPPSQL
+		DbExc();
+	#endif
+		DbExc(const SqlSession& session) : SqlExc(session), err_num(0) {}
+		DbExc(const Sql& sql) : SqlExc(sql), err_num(0) {}
+		DbExc(const String& desc, int en = 0) : SqlExc(desc), err_num(en) {}
+		DbExc(const char *desc, int en = 0) : SqlExc(desc), err_num(en) {}
+		
+	public:
+		int GetErrNum() const { return err_num; }
+		
+	private:
+		int err_num;
+	};
+	
+	///////////////////////////////////////////////////////////////////////////
+	// To do: parse the status vector by myself.
+	class Error
+	{
+	public:
+		ISC_STATUS* getErrorVector()
+		{
+			return status_vector_;
+		}
+
+	public:
+		long getSQLCode();
+		String getErrorText();
+		void check();
+
+		long get_err_code() const
+		{
+			return status_vector_[1];
+		}
+
+	private:
+		ISC_STATUS  status_vector_[20];
+		long        sqlCode_;
+		char        msg_[1024];
+	};
+
+	extern Error ib_error;
+
+	class dpb
+	{
+	public:
+		dpb();
+
+	public:
+		const char* getBuff() const
+		{
+			return buff_;
+		}
+		short getBuffSize() const
+		{
+			return pos_;
+		}
+
+	public:
+		void addParam(char value);
+		void addCluster(char type, const char* value);
+		void addCluster(char type, short value);
+		void addCluster(char type, bool value);
+		void addCluster(char type, char value);
+		void addCluster(char type, unsigned long value);
+
+	private:
+		char    buff_[1024];
+		short   pos_;
+	};
+
+	// ServiceParamBuff (SPB) differs in some ways from the DatabaseParamBuff (DPB) ...
+	class spb
+	{
+	public:
+		spb(size_t buff_size = 128);
+		~spb();
+
+	public:
+		char* getBuff() const
+		{
+			return buff_ptr_;
+		}
+		short getBuffSize() const
+		{
+			return pos_;
+		}
+		short getBuffMaxSize() const
+		{
+			return buff_size_;
+		}
+
+	public:
+		void addParam(char value);
+		void addCluster(char type, const char* value);
+		void addCluster(char type, unsigned long value);
+
+	public:
+		unsigned long get_long()
+		{
+			return 0;
+		}
+
+	private:
+		char*           buff_ptr_;
+		const size_t    buff_size_;
+		unsigned short  pos_;
+	};
+
+	class DBParamBuff : public dpb
+	{
+	public:
+		DBParamBuff();
+	};
+
+	class DataBase
+	{
+	public:
+		DataBase();
+
+	public:
+		isc_db_handle* getHandleP() const
+		{
+			return &handle_;
+		}
+		isc_db_handle& getHandleRef()
+		{
+			return handle_;
+		}
+
+	public:
+		void attach(const char* name);
+		void dettach();
+
+		void drop();
+		
+		// This method will not create an attached handle. Use the "attach" method instead of this one.
+		void execute_immediate(const String& stmt);
+		
+		void expand_dpb() const;
+		void modify_dpb() const;
+		void getInfo() const;
+
+		void retrieveVersion();
+
+	public:
+		// User validation
+
+		// String user name, up to 255 characters
+		void setUserName(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_user_name, value);
+		}
+		// String password, up to 255 characters
+		void setPassword(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_password, value);
+		}
+		// String encrypted password, up to 255 characters
+		void setEncPassword(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_password_enc, value);
+		}
+		void setRoleName(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_sql_role_name, value);
+		}
+		// String system DBA name, up to 255 characters
+		void setSysUserName(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_sys_user_name, value);
+		}
+		void setLicense(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_license, value);
+		}
+		void setEncryptionKey(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_encrypt_key, value);
+		}
+
+	public:
+		// Environmental control
+
+		// Number of database cache buffers to allocate for use with the database;
+		void setNumBuffers(short value = 2048)
+		{
+			paramBuff_.addCluster(isc_dpb_num_buffers, value);
+		}
+		// Scope of dbkey context. 0 limits scope to the current transaction,
+		// 1 extends scope to the database session
+		void setDBKeyScope(char value)
+		{
+			paramBuff_.addCluster(isc_dpb_dbkey_scope, value);
+		}
+		// 1 - V5.x & V6 compatible; 2 - diagnostic; 3 - V6 only
+		void setSQLDialect(char value)
+		{
+			paramBuff_.addCluster(isc_dpb_sql_dialect, value);
+		}
+		// 1 - V5.x & V6 compatible; 2 - diagnostic; 3 - V6 only
+		void setDBSQLDialect(char value)
+		{
+			paramBuff_.addCluster(isc_dpb_set_db_sql_dialect, value);
+		}
+
+	public:
+		// System management
+
+		// Specifies whether database writes are synchronous or asynchronous.
+		void setSynchWrites(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_force_write, value);
+		}
+		// Specify whether the database should reserves pace on each page for back versions of records when modifications are made
+		void setReserveSpace(bool value = false)
+		{
+			paramBuff_.addCluster(isc_dpb_no_reserve, !value);
+		}
+
+	public:
+		// System management
+		void setAsDamaged(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_damaged, value);
+		}
+		void setVerify(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_verify, value);
+		}
+
+	public:
+		// Shadow control ( !!! Ignored by DB )
+		void setActivateShadow(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_activate_shadow, value);
+		}
+		void setDeleteShadow(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_delete_shadow, value);
+		}
+
+	public:
+		// Replay logging system control
+		void setStartLog(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_begin_log, value);
+		}
+		void setEndLog(bool value)
+		{
+			paramBuff_.addCluster(isc_dpb_quit_log, value);
+		}
+
+	public:
+		// Character set and message file specification
+
+		// Language-specific message file
+		void setMessageFile(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_lc_messages, value);
+		}
+		// Character set to be utilized
+		void setCharSet(const char* value)
+		{
+			paramBuff_.addCluster(isc_dpb_lc_ctype, value);
+		}
+
+	private:
+		mutable isc_db_handle	handle_;
+		DBParamBuff     		paramBuff_;
+
+	public:
+		// Because I cannot make a friend function ...
+		String     dbVersion_;
+		String     odsVersion_;
+	};
+
+	class Transaction
+	{
+	public:
+		Transaction();
+
+	public:
+		isc_tr_handle* getHandleP() const
+		{
+			return &handle_;
+		}
+		isc_tr_handle& getHandleRef()
+		{
+			return handle_;
+		}
+
+	public:
+		// Starts a new transaction against one or more databases.; use a
+		// previously declared and populated TPB
+		void start(const DataBase& db);
+		
+		void start_multiple();
+		// Commits a transactions changes, and ends the transaction
+
+		void commit();
+		
+		// Commits a transactions changes, and preserves the transaction
+		// context for further transaction processing
+		void commit_retaining();
+
+		// Rolls back a transactions changes, and ends the transaction
+		void rollback();
+		// Rolls back a transactions changes but maintains transaction context
+
+		void rollback_retaining();
+
+		// Performs the first phase of a two-phase commit, prior to calling
+		// isc_commit_transaction(); used to coordinate a two-phase commit
+		// with some external event
+		void prepare();
+
+		// Performs the first phase of a two-phase commit, prior to calling
+		// isc_commit_transaction(); used to coordinate a two-phase commit
+		// with some external event. This call accepts a message describing the
+		// external event
+		void prepare2();
+		// Returns information about the specified named transaction.
+		void getInfo();
+
+	public:
+		// InterBase version 3 transaction
+		void setVersion3()
+		{
+			paramBuff_.addParam(isc_tpb_version3);
+		}
+		// Table-locking transaction model. This mode is serializable.
+		void setConsistency()
+		{
+			paramBuff_.addParam(isc_tpb_consistency);
+		}
+		// High throughput, high concurrency transaction with repeat able read
+		// consistency. This mode takes full advantage of the InterBase
+		// multi-generational transaction model [Default].
+		void setConcurrency()
+		{
+			paramBuff_.addParam(isc_tpb_concurrency);
+		}
+		// Concurrent, shared access of a specified table among all transactions; use
+		// in conjunction with isc_tpb_lock_read and isc_tpb_lock_write to
+		// establish the lock option [Default].
+		void setShared()
+		{
+			paramBuff_.addParam(isc_tpb_shared);
+		}
+		// Concurrent, restricted access of a specified table; use in conjunction with
+		// isc_tpb_lock_read and isc_tpb_lock_write to establish the lock option.
+		void setProtected()
+		{
+			paramBuff_.addParam(isc_tpb_protected);
+		}
+		// isc_tpb_wait = Specifies that the transaction is to wait until the conflicting resource is
+		// released before retrying an operation [Default].
+		//
+		// isc_tpb_nowait - Specifies that the transaction is not to wait for the resource to be released,
+		// but instead, an update conflict error should be returned immediately
+		void setWait(bool wait = true)
+		{
+			if (wait)
+			{
+				paramBuff_.addParam(isc_tpb_wait);
+			}
+			else
+			{
+				paramBuff_.addParam(isc_tpb_nowait);
+			}
+		}
+		// Read-only access mode that allows a transaction only to select data from
+		// tables
+		void setReadOnly()
+		{
+			paramBuff_.addParam(isc_tpb_read);
+		}
+		// Read-write access mode of that allows a transaction to select, insert,
+		// update, and delete table data [Default].
+		void setReadWrite()
+		{
+			paramBuff_.addParam(isc_tpb_write);
+		}
+		// Read-only access of a specified table. Use in conjunction with
+		// isc_tpb_shared, isc_tpb_protected, and isc_tpb_exclusive to establish the
+		// lock option.
+		void setLockReadOnly()
+		{
+			paramBuff_.addParam(isc_tpb_lock_read);
+		}
+		// Read-write access of a specified table. Use in conjunction with
+		// isc_tpb_shared, isc_tpb_protected, and isc_tpb_exclusive to establish the
+		// lock option [Default].
+		void setLockReadWrite()
+		{
+			paramBuff_.addParam(isc_tpb_lock_write);
+		}
+		// High throughput, high concurrency transaction that can read changes
+		// committed by other concurrent transactions. Transactions in this mode do
+		// not provide repeatable read.
+		void setReadCommitted()
+		{
+			paramBuff_.addParam(isc_tpb_read_committed);
+		}
+		// Enables an isc_tpb_read_committed transaction to read the most recently
+		// committed version of a record even if other, uncommitted versions are
+		// pending.
+		void setRecVersion()
+		{
+			paramBuff_.addParam(isc_tpb_rec_version);
+		}
+		// Enables an isc_tpb_read_committed transaction to read only the latest
+		// committed version of a record. If an uncommitted version of a record is
+		// pending and isc_tpb_wait is also specified, then the transaction waits for
+		// the pending record to be committed or rolled back before proceeding.
+		// Otherwise, a lock conflict error is reported at once.
+		void setNoRecVersion()
+		{
+			paramBuff_.addParam(isc_tpb_no_rec_version);
+		}
+
+	private:
+		mutable isc_tr_handle	handle_;
+		dpb       				paramBuff_;
+	};
+
+	class SQLDataArray
+	{
+	public:
+		SQLDataArray(size_t size = 0);
+		SQLDataArray(const SQLDataArray& theArray);
+		~SQLDataArray();
+
+	public:
+		XSQLDA* getBuffer() const
+		{
+			return pDA_;
+		}
+		size_t getSize() const
+		{
+			return size_;
+		}
+		int getRequredSize() const
+		{
+			ASSERT(pDA_);
+			return pDA_->sqld;
+		}
+
+	public:
+		// Pos is ZERO-based ...
+		XSQLVAR& operator[](size_t pos)
+		{
+			XSQLVAR* first_ptr = pDA_->sqlvar;
+			return first_ptr[pos];
+		}
+
+	public:
+		void setSize(size_t size);
+
+	private:
+		XSQLDA* pDA_;
+		size_t  size_;
+	};
+
+	class DynamicSQL
+	{
+	public:
+		DynamicSQL(const DataBase& db, const Transaction& tr);
+		~DynamicSQL();
+
+	public:
+		void execute_immediate(const String& stmt);
+		void execute_immediate_no_trans(const String& stmt);
+
+		void execute_immediate_data(const String& stmt);
+
+		// define_da is a data array, which is used to describe output arguments.
+		void prepare(const String& stmt, const SQLDataArray& define_da);
+
+		void execute();
+		
+		void execute2();
+		
+		// Retrieve "in" information.
+		void describe_bind(const SQLDataArray& da);
+
+		// Retrieve "out" information.
+		void describe_define(const SQLDataArray& da);
+
+		void setCursorName(const char* name);
+
+		bool fetch();
+
+		// Like isc_info_sql_stmt_select
+		int getStmtType();
+
+		void close_cursor();
+
+	public:
+		void setINSize(size_t size)
+		{
+			inDataArray_.setSize(size);
+		}
+		XSQLVAR* getINVar(size_t pos) const
+		{
+			ASSERT(pos < inDataArray_.getSize());
+			return &inDataArray_.getBuffer()->sqlvar[pos];
+		}
+		void setOUTSize(size_t size)
+		{
+			outDataArray_.setSize(size);
+		}
+		XSQLVAR* getOUTVar(size_t pos) const
+		{
+			ASSERT(pos < outDataArray_.getSize());
+			return &outDataArray_.getBuffer()->sqlvar[pos];
+		}
+
+		SQLDataArray& GetIn()
+		{
+			return inDataArray_;
+		}
+		SQLDataArray& GetOut()
+		{
+			return outDataArray_;
+		}
+
+	private:
+		// Constructor-destructor
+		void allocate_stmt();
+		void allocate_stmt2();
+
+		void drop_statement();
+
+	private:
+		unsigned short  dialect_;
+
+		isc_db_handle*  pDBHandle_;
+		isc_tr_handle*  pTRHandle_;
+
+		isc_stmt_handle handle_;        // It is a pointer, actualy.
+
+		SQLDataArray    inDataArray_;
+		SQLDataArray    outDataArray_;
+
+		bool            all_data_fetched_; // A workaround for problems that were introduced in v1.5.2.
+	};
+
+	class EmbededSQL
+	{
+	public:
+		EmbededSQL();
+		
+	private:
+	};
+
+	class SegmentBlob;
+	class BlobDescr
+	{
+	public:
+		// Determines the subtype, character set, and segment size of a SegmentBlob, given a table name
+		// and SegmentBlob column name.
+		void get(
+			SegmentBlob& blob,
+			const String& tbl_name,
+			const String& clm_name
+		);
+		// Loads a data structure with default information about a SegmentBlob, including its subtype,
+		// character set, and segment size.
+		void getDefault();
+		// Sets the subtype and character set for a SegmentBlob.
+		void set();
+
+	protected:
+	private:
+		ISC_BLOB_DESC blobDescr_;
+	};
+
+	class SegmentBlob
+	{
+		friend class BlobDescr;
+
+	public:
+		class info
+		{
+			friend class SegmentBlob;
+
+		public:
+			info();
+
+		public:
+			long getLenght() const
+			{
+				return lenght_;
+			}
+			long getMaxSegments() const
+			{
+				return maxSegments_;
+			}
+			long getNumSegments() const
+			{
+				return numSegments_;
+			}
+
+		private:
+			long    lenght_;
+			long    maxSegments_;
+			long    numSegments_;
+			bool    type_segmented;
+		};
+
+	public:
+		SegmentBlob(const DataBase& db, const Transaction& tr);
+		~SegmentBlob();
+
+	public:
+		void open();
+		void create();
+		void close();
+
+		bool getSegment(
+			unsigned short& actualSegLen,
+			unsigned short maxSegLen,
+			char* pSegment
+		);
+		// void addSegment(const String& data);
+		void addSegment(const char* pSegment, unsigned short seg_length);
+
+		void put_segment(const char* data, size_t data_len);
+
+		void cancel();
+		
+		void retrieve_info();
+		
+		const info& getInfo() const { return info_; }
+
+	public:
+		const GDS_QUAD& getID() const
+		{
+			return id_;
+		}
+		GDS_QUAD& getID()
+		{
+			return id_;
+		}
+
+	private:
+		// Not documented ...
+		void open_internal();
+		void open2_internal();
+
+		void setup_open();
+		void setup_close();
+
+		// Not documented ...
+		void create_internal();
+
+		// Creates and opens the SegmentBlob for write access, and optionally specifies the filters to be used
+		// to translate the SegmentBlob from one subtype to another.
+		void create2_internal();
+
+	private:
+		isc_db_handle*  pDBHandle_;
+		isc_tr_handle*  pTRHandle_;
+		isc_blob_handle handle_;        // It is a pointer, actualy.
+
+		GDS_QUAD        id_;    // SegmentBlob ID put into out_sqlda by isc_dsql_fetch()
+		int             stat_;
+		bool            isOpen_;
+		GDS_QUAD        lastID_;
+
+		// Info ...
+		bool            hasInfo_;
+		info            info_;
+	};
+
+	class Array
+	{
+	public:
+		Array(const DataBase& db, const Transaction& tr);
+
+	public:
+		const ISC_QUAD& getID() const
+		{
+			return id_;
+		}
+		ISC_QUAD& getID()
+		{
+			return id_;
+		}
+
+	protected:
+		// isc_array_gen_sdl
+		// isc_array_get_slice
+		// isc_array_lookup_bounds
+		// isc_array_lookup_desc
+		// isc_array_set_desc
+		// isc_array_put_slice
+	private:
+		isc_db_handle*  pDBHandle_;
+		isc_tr_handle*  pTRHandle_;
+
+		ISC_QUAD		id_;
+		ISC_ARRAY_DESC	desc_;
+	};
+
+	class Event
+	{
+	public:
+		Event();
+
+	protected:
+		// isc_event_block
+		// isc_event_counts
+		// isc_que_events
+	private:
+	};
+
+    enum network_protocol_t {
+		np_embedded,
+		np_local,
+		np_TCP_IP,
+		np_NetBEUI,
+		np_IPX_SPX
+		};
+
+	class Service
+	{
+	public:
+		void attach(
+			const char* host = NULL,
+			const char* user = NULL,
+			const char* pswd = NULL,
+			network_protocol_t protocol = np_local
+		);
+
+		void detach();
+
+		void executeCommand(const spb& pb);
+
+		void query(const spb& request, const spb& result);
+
+	private:
+		isc_svc_handle      handle_;
+	};
+
+	class user_info : Moveable<user_info>
+	{
+	public:
+		user_info();
+		user_info(const user_info& info);
+
+	public:
+		unsigned long user_id;
+		unsigned long group_id;
+		String user_name;
+		String first_name;
+		String middle_name;
+		String last_name;
+
+	private:
+		void copy(const user_info& info);
+	};
+
+	class server_info
+	{
+	public:
+		server_info();
+		server_info(const server_info& info);
+
+	public:
+		unsigned long svc_version;
+		unsigned long num_licensed_users;
+		String server_version;
+		String implementation_str;
+		String env_ib_str;
+		String env_lock_str;
+		String env_msg_str;
+		String user_db_path_str;
+
+	private:
+		void copy(const server_info& info);
+	};
+
+	namespace svc_cmd
+	{
+		class base
+		{
+		public:
+			base(Service& svc);
+
+		protected:
+			unsigned long read_long(char*& p) const;
+			unsigned short read_short(char*& p) const;
+			String read_string(char*& p) const;
+
+		protected:
+			Service*    svc_ptr_;
+			spb         paramBuff_;
+		};
+
+		class backup : base
+		{
+		public:
+			backup(Service& svc);
+		};
+
+		class restore : base
+		{
+		public:
+			restore(Service& svc);
+		};
+
+		class set_properties : base
+		{
+		public:
+			set_properties(Service& svc);
+		};
+
+		class repair : base
+		{
+		public:
+			repair(Service& svc);
+		};
+
+		class get_db_stats : base
+		{
+		public:
+			get_db_stats(Service& svc);
+		};
+
+		class get_server_info : base
+		{
+		public:
+			get_server_info(Service& svc);
+
+		public:
+			void execute();
+			const server_info& get_info() const
+			{
+				return info_;
+			}
+
+		public:
+			server_info info_;
+		};
+
+		class get_log : base
+		{
+		public:
+			get_log(Service& svc);
+		};
+
+		class get_user_info : base
+		{
+		public:
+			get_user_info(Service& svc, const String& user_name);
+
+		public:
+			void execute();
+			const user_info& get_info() const
+			{
+				return info_;
+			}
+
+		public:
+			user_info info_;
+			const String user_name_;
+		};
+
+		class get_users : base
+		{
+		public:
+			get_users(Service& svc);
+
+		public:
+			void execute();
+			const Vector<user_info>& get_info() const
+			{
+				return user_info_list_;
+			}
+
+		public:
+			Vector<user_info> user_info_list_;
+		};
+
+		class add_user : base
+		{
+		public:
+			add_user(Service& svc);
+
+		public:
+			void execute();
+
+		public:
+			void set_username(const char* name);
+			void set_password(const char* pswd);
+			void set_firstname(const char* value);
+			void set_middlename(const char* value);
+			void set_lastname(const char* value);
+			void set_userid(unsigned long value);
+			void set_groupid(unsigned long value);
+			void set_groupname(const char* value);
+			void set_rolename(const char* value);
+		};
+
+		class delete_user : base
+		{
+		public:
+			delete_user(Service& svc);
+
+		public:
+			void execute();
+
+		public:
+			void set_username(const char* name);
+			void set_rolename(const char* value);
+		};
+
+		class update_user : base
+		{
+		public:
+			update_user(Service& svc);
+
+		public:
+			void execute();
+
+		public:
+			void set_username(const char* name);
+			void set_password(const char* pswd);
+			void set_firstname(const char* value);
+			void set_middlename(const char* value);
+			void set_lastname(const char* value);
+			void set_userid(unsigned long value);
+			void set_groupid(unsigned long value);
+			void set_groupname(const char* value);
+			void set_rolename(const char* value);
+		};
+
+		class add_license : base
+		{
+		public:
+			add_license(Service& svc);
+		};
+
+		class remove_license : base
+		{
+		public:
+			remove_license(Service& svc);
+		};
+	}
+
+	class Install
+	{
+	};
+
+}
+
+#endif
diff --git a/bazaar/Firebird/init b/bazaar/Firebird/init
new file mode 100644
index 000000000..64205348c
--- /dev/null
+++ b/bazaar/Firebird/init
@@ -0,0 +1,4 @@
+#ifndef _Firebird_icpp_init_stub
+#define _Firebird_icpp_init_stub
+#include "Sql/init"
+#endif
diff --git a/bazaar/FirebirdTest/FirebirdTest.cpp b/bazaar/FirebirdTest/FirebirdTest.cpp
new file mode 100644
index 000000000..d757426d7
--- /dev/null
+++ b/bazaar/FirebirdTest/FirebirdTest.cpp
@@ -0,0 +1,1277 @@
+#include "Firebird/Firebird.h"
+
+using namespace Upp;
+
+
+void TestInt(FBSession& s, const String& field_type)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_long_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_long_table( \n"
+		"   id integer, \n"
+		"   first_field " + field_type + " DEFAULT NULL, \n"
+		"   second_field " + field_type + " DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_long_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, i * 10);
+		stmt.SetParam(2, i * 100);
+		stmt.RunX();
+	}
+
+	stmt.SetStatement(
+		" SET TRANSACTION WAIT ISOLATION LEVEL READ COMMITTED"
+	);
+	stmt.Run();
+	
+	int _0 = -1;
+	int _1 = -1;
+	int _2 = -1;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_long_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == i * 10);
+		ASSERT(_2 == i * 100);
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT.
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		ASSERT(stmt[1] == i * 10);
+		ASSERT(stmt[2] == i * 100);
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_long_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == i * 10);
+		ASSERT(_2 == i * 100);
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == i * 10);
+		ASSERT(_2 == i * 100);
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_long_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_long_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, Null);
+			stmt.SetParam(2, i * 100);
+		} else {
+			stmt.SetParam(1, i * 10);
+			stmt.SetParam(2, Null);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	const Value vNull(Null);
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_long_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		if (i % 2 == 0) {
+			ASSERT(stmt[1] == vNull);
+			ASSERT(stmt[2] == i * 100);
+		} else {
+			ASSERT(stmt[1] == i * 10);
+			ASSERT(stmt[2] == vNull);
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+void TestString(FBSession& s)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_str_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_str_table( \n"
+		"   id integer, \n"
+		"   first_field VARCHAR(255) DEFAULT NULL, \n"
+		"   second_field VARCHAR(255) DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_str_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, FormatInt(i * 10));
+		stmt.SetParam(2, FormatInt(i * 100));
+		stmt.RunX();
+	}
+
+	int _0 = -1;
+	String _1;
+	String _2;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_str_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT.
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		ASSERT(stmt[1] == FormatInt(i * 10));
+		ASSERT(stmt[2] == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_str_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_str_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_str_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, Null);
+			stmt.SetParam(2, FormatInt(i * 100));
+		} else {
+			stmt.SetParam(1, FormatInt(i * 10));
+			stmt.SetParam(2, Null);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	const Value vNull(Null);
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_str_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		if (i % 2 == 0) {
+			ASSERT(stmt[1] == vNull);
+			ASSERT(stmt[2] == FormatInt(i * 100));
+		} else {
+			ASSERT(stmt[1] == FormatInt(i * 10));
+			ASSERT(stmt[2] == vNull);
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+void TestBlob(FBSession& s)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_blob_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_blob_table( \n"
+		"   id integer, \n"
+		"   first_field BLOB DEFAULT NULL, \n"
+		"   second_field BLOB DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_blob_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, FormatInt(i * 10));
+		stmt.SetParam(2, FormatInt(i * 100));
+		stmt.RunX();
+	}
+
+	int _0 = -1;
+	String _1;
+	String _2;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_blob_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT.
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		ASSERT(stmt[1] == FormatInt(i * 10));
+		ASSERT(stmt[2] == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_blob_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == FormatInt(i * 10));
+		ASSERT(_2 == FormatInt(i * 100));
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_blob_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_blob_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, Null);
+			stmt.SetParam(2, FormatInt(i * 100));
+		} else {
+			stmt.SetParam(1, FormatInt(i * 10));
+			stmt.SetParam(2, Null);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	const Value vNull(Null);
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_blob_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		if (i % 2 == 0) {
+			ASSERT(stmt[1] == vNull);
+			ASSERT(stmt[2] == FormatInt(i * 100));
+		} else {
+			ASSERT(stmt[1] == FormatInt(i * 10));
+			ASSERT(stmt[2] == vNull);
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+inline
+bool AreClose(double actual, double expected, double tolerance)
+{
+	return (actual >= (expected - tolerance)) && (actual <= (expected + tolerance));
+}
+
+void TestDouble(FBSession& s, const String& field_type)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_double_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_double_table( \n"
+		"   id integer, \n"
+		"   first_field " + field_type + " DEFAULT NULL, \n"
+		"   second_field " + field_type + " DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_double_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, i * 10.01);
+		stmt.SetParam(2, i * 100.001);
+		stmt.RunX();
+	}
+
+	int _0 = -1;
+	double _1 = -1.0;
+	double _2 = -1.0;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_double_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(AreClose(_1, i * 10.01, 0.005));
+		ASSERT(AreClose(_2, i * 100.001, 0.0005));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT.
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		ASSERT(AreClose(stmt[1], i * 10.01, 0.005));
+		ASSERT(AreClose(stmt[2], i * 100.001, 0.0005));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_double_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(AreClose(_1, i * 10.01, 0.005));
+		ASSERT(AreClose(_2, i * 100.001, 0.0005));
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(AreClose(_1, i * 10.01, 0.005));
+		ASSERT(AreClose(_2, i * 100.001, 0.0005));
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_double_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_double_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	const Value vNull(Null);
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, vNull);
+			stmt.SetParam(2, i * 100.001);
+		} else {
+			stmt.SetParam(1, i * 10.01);
+			stmt.SetParam(2, vNull);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_double_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		if (i % 2 == 0) {
+			ASSERT(stmt[1] == vNull);
+			ASSERT(AreClose(stmt[2], i * 100.001, 0.0005));
+		} else {
+			ASSERT(AreClose(stmt[1], i * 10.01, 0.005));
+			ASSERT(stmt[2] == vNull);
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+void TestDatetime(FBSession& s)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_datetime_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_datetime_table( \n"
+		"   id integer, \n"
+		"   first_field TIMESTAMP DEFAULT NULL, \n"
+		"   second_field TIMESTAMP DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_datetime_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+		stmt.SetParam(2, Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		stmt.RunX();
+	}
+
+	int _0 = -1;
+	Time _1;
+	Time _2;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_datetime_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+		ASSERT(_2 == Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT.
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		ASSERT(stmt[1] == Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+		ASSERT(stmt[2] == Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_datetime_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+		ASSERT(_2 == Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+		ASSERT(_2 == Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_datetime_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_datetime_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, Null);
+			stmt.SetParam(2, Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		} else {
+			stmt.SetParam(1, Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+			stmt.SetParam(2, Null);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	const Value vNull(Null);
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_datetime_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		if (i % 2 == 0) {
+			ASSERT(stmt[1] == vNull);
+			ASSERT(stmt[2] == Time(i+1900+100, i%12+1, i%28+1, i%24, i%60, i%60));
+		} else {
+			ASSERT(stmt[1] == Time(i+1900+10,  i%12+1, i%28+1, i%24, i%60, i%60));
+			ASSERT(stmt[2] == vNull);
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+void TestBool(FBSession& s, const String& field_type, bool str_type = false)
+{
+	int i;
+	Sql stmt(s);
+	stmt.SetStatement(
+	    "DROP TABLE test_bool_table"
+	);
+	stmt.Run();
+	                  
+	// Data definition statement.
+	stmt.SetStatement(
+		" CREATE TABLE test_bool_table( \n"
+		"   id integer, \n"
+		"   first_field " + field_type + " DEFAULT NULL, \n"
+		"   second_field " + field_type + " DEFAULT NULL \n"
+		")"
+	);
+	stmt.Run();
+
+	stmt.SetStatement(
+		" INSERT INTO test_bool_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		stmt.SetParam(1, (i%2 == 0));
+		stmt.SetParam(2, (i%2 == 1));
+		stmt.RunX();
+	}
+
+	int _0 = -1;
+	bool _1 = false;
+	bool _2 = false;
+	
+	Ref r0(_0);
+	Ref r1(_1);
+	Ref r2(_2);
+
+	// SELECT without parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_bool_table ORDER BY id"
+	);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == (i%2 == 0));
+		ASSERT(_2 == (i%2 == 1));
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+
+	if (!str_type)
+	{
+		// Rerun SELECT.
+		stmt.Run();
+		i = 0;
+		while (stmt.Fetch())
+		{
+			ASSERT(stmt[0] == i);
+			ASSERT(stmt[1] == (i%2 == 0));
+			ASSERT(stmt[2] == (i%2 == 1));
+			++i;
+		}
+		ASSERT(i == 100);
+		ASSERT(!stmt.Fetch());
+	}
+
+	// SELECT with parameters.
+	stmt.SetStatement(
+		" SELECT * FROM test_bool_table WHERE id < ? ORDER BY id"
+	);
+	stmt.SetParam(0, 50);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == (i%2 == 0));
+		ASSERT(_2 == (i%2 == 1));
+		++i;
+	}
+	ASSERT(i == 50);
+	ASSERT(!stmt.Fetch());
+
+	// Rerun SELECT with parameters.
+	stmt.SetParam(0, 25);
+	
+	stmt.Run();
+	i = 0;
+	while (stmt.Fetch())
+	{
+		stmt.GetColumn(0, r0);
+		stmt.GetColumn(1, r1);
+		stmt.GetColumn(2, r2);
+
+		ASSERT(_0 == i);
+		ASSERT(_1 == (i%2 == 0));
+		ASSERT(_2 == (i%2 == 1));
+		++i;
+	}
+	ASSERT(i == 25);
+	ASSERT(!stmt.Fetch());
+
+	// Delete all records.
+	stmt.SetStatement(
+		" DELETE FROM test_bool_table"
+	);
+	stmt.Run();
+
+	// Insert data again.
+	stmt.SetStatement(
+		" INSERT INTO test_bool_table \n"
+		" VALUES(?, ?, ?)"
+	);
+		
+	for (i = 0; i < 100; ++i)
+	{
+		stmt.SetParam(0, i);
+		if (i % 2 == 0) {
+			stmt.SetParam(1, Null);
+			stmt.SetParam(2, false);
+		} else {
+			stmt.SetParam(1, true);
+			stmt.SetParam(2, Null);
+		}
+		stmt.RunX();
+	}
+	
+	// Run SELECT.
+	i = 0;
+	const Value vNull(Null);
+	
+	stmt.SetStatement(
+		" SELECT * FROM test_bool_table ORDER BY id"
+	);
+	stmt.Run();
+	
+	while (stmt.Fetch())
+	{
+		ASSERT(stmt[0] == i);
+		
+		if (str_type)
+		{
+			if (i % 2 == 0) {
+				ASSERT(stmt[1] == vNull);
+				ASSERT(stmt[2] == "0");
+			} else {
+				ASSERT(stmt[1] == "1");
+				ASSERT(stmt[2] == vNull);
+			}
+		}
+		else
+		{
+			if (i % 2 == 0) {
+				ASSERT(stmt[1] == vNull);
+				ASSERT(stmt[2] == false);
+			} else {
+				ASSERT(stmt[1] == true);
+				ASSERT(stmt[2] == vNull);
+			}
+		}
+		++i;
+	}
+	ASSERT(i == 100);
+	ASSERT(!stmt.Fetch());
+}
+
+class Exec : public StatementExecutor {
+public:
+	virtual bool Execute(const String& stmt) {
+		Cout() << stmt << EOL; 
+		return true;
+	}
+};
+
+CONSOLE_APP_MAIN
+{
+	const Vector<String>& cmd_line = CommandLine();
+	if (cmd_line.GetCount() > 0 && FileExists(cmd_line[0]))
+	{
+		FBSession s;
+		s.Connect(
+			cmd_line[0],
+			NULL,
+			"SYSDBA",
+			"masterkey"
+			);
+
+#if 0
+		const char* script;
+		RunScript runscript = s.GetRunScript();
+		Exec exec;
+		
+		script =
+			" /* comment */"
+			;
+			
+		script =
+			" /* comment 01 */ \n"
+			" /* comment 02 */"
+			;
+
+		script =
+			" /* SELECT rdb$type_name, rdb$type FROM rdb$types */"
+			;
+
+		script =
+			" -- comment 01 \n"
+			" -- comment 02 "
+			;
+
+		script =
+			" 'string' "
+			;
+
+		script =
+			"'s''t''r'''"
+			;
+
+		script =
+			" DROP PROCEDURE test_procedure_01;"
+			;
+
+		script =
+			" CREATE OR ALTER PROCEDURE test_procedure_01 (in_param integer) returns (out_param integer) \n"
+			" as begin out_param = in_param + 1; end; \n"
+			;
+
+		script =
+			" CREATE OR ALTER PROCEDURE test_procedure_01 (in_param integer) returns (out_param integer) \n"
+			" as begin out_param = in_param + 1; end; \n"
+			" DROP PROCEDURE test_procedure_01;"
+			;
+
+		script =
+			"/* Display an org-chart. \n"
+			"* \n"
+			"*   Parameters: \n"
+			"*       -- \n"
+			"*   Returns: \n"
+			"*       parent department \n"
+			"*       department name \n"
+			"*       department manager \n"
+			"*       manager’s job title \n"
+			"*       number of employees in the department */ \n"
+			"CREATE PROCEDURE ORG_CHART \n"
+			"  RETURNS (HEAD_DEPT CHAR(25), DEPARTMENT CHAR(25), \n"
+			"      MNGR_NAME CHAR(20), TITLE CHAR(5), EMP_CNT INTEGER) \n"
+			"  AS \n"
+			"      DECLARE VARIABLE mngr_no INTEGER; \n"
+			"      DECLARE VARIABLE dno CHAR(3); \n"
+			"  BEGIN \n"
+			"      FOR SELECT H.DEPARTMENT, D.DEPARTMENT, D.MNGR_NO, D.DEPT_NO \n"
+			"          FROM DEPARTMENT D \n"
+			"          LEFT OUTER JOIN DEPARTMENT H ON D.HEAD_DEPT = H.DEPT_NO \n"
+			"          ORDER BY D.DEPT_NO \n"
+			"          INTO :head_dept, :department, :mngr_no, :dno \n"
+			"      DO \n"
+			"          BEGIN \n"
+			"              IF (:mngr_no IS NULL) THEN \n"
+			"                  BEGIN \n"
+			"                      MNGR_NAME = '--TBH--'; \n"
+			"                       TITLE = ''; \n"
+			"                  END \n"
+			"              ELSE \n"
+			"                  SELECT FULL_NAME, JOB_CODE \n"
+			"                       FROM EMPLOYEE \n"
+			"                      WHERE EMP_NO = :mngr_no \n"
+			"                       INTO :mngr_name, :title; \n"
+			"                  SELECT COUNT(EMP_NO) \n"
+			"                       FROM EMPLOYEE \n"
+			"                      WHERE DEPT_NO = :dno \n"
+			"                       INTO :emp_cnt; \n"
+			"                  SUSPEND; \n"
+			"          END \n"
+			"  END; ";
+
+		script =
+			"SET TERM !! ; \n"
+			"SET TERM ; !! \n"
+			;
+
+		script =
+			"SET TERM !! ; \n"
+			"CREATE TRIGGER SAVE_SALARY_CHANGE FOR EMPLOYEE \n"
+			"  AFTER UPDATE AS \n"
+			"  BEGIN \n"
+			"        IF (OLD.SALARY <> NEW.SALARY) THEN \n"
+			"        INSERT INTO SALARY_HISTORY \n"
+			"        (EMP_NO, CHANGE_DATE, UPDATER_ID, OLD_SALARY, PERCENT_CHANGE) \n"
+			"            VALUES (OLD.EMP_NO, ’now’, USER,OLD.SALARY, \n"
+			"             (NEW.SALARY - OLD.SALARY) * 100 / OLD.SALARY); \n"
+			"  END !! \n"
+			"SET TERM ; !!"
+			;
+
+		(*runscript)(script, exec, CNULL);
+#endif
+
+		Sql sql(s);
+		
+#if 1
+		TRANSACTION(sql) {
+		}
+		
+		TestBool(s, "bigint");
+		TRANSACTION(s) {
+			TestBool(s, "bigint");
+		}
+
+		TestBool(s, "integer");
+		TRANSACTION(s) {
+			TestBool(s, "integer");
+		}
+
+		TestBool(s, "numeric(1)");
+		TRANSACTION(s) {
+			TestBool(s, "numeric(1)");
+		}
+	
+		TestBool(s, "double precision");
+		TRANSACTION(s) {
+			TestBool(s, "double precision");
+		}
+	
+		TestBool(s, "varchar(1)", true);
+		TRANSACTION(s) {
+			TestBool(s, "varchar(1)", true);
+		}
+	
+		TestBool(s, "char(1)", true);
+		TRANSACTION(s) {
+			TestBool(s, "char(1)", true);
+		}
+
+		TestInt(s, "INTEGER");
+		TRANSACTION(s) {
+			TestInt(s, "INTEGER");
+		}
+		
+		TestInt(s, "SMALLINT");
+		TRANSACTION(s) {
+			TestInt(s, "SMALLINT");
+		}
+		
+		TestString(s);
+		TRANSACTION(s) {
+			TestString(s);
+		}
+		
+		TestDouble(s, "DOUBLE PRECISION");
+		TRANSACTION(s) {
+			TestDouble(s, "DOUBLE PRECISION");
+		}
+
+		TestDouble(s, "FLOAT");
+		TRANSACTION(s) {
+			TestDouble(s, "FLOAT");
+		}
+
+		TestDouble(s, "DECIMAL(18, 4)");
+		TRANSACTION(s) {
+			TestDouble(s, "DECIMAL(18, 4)");
+		}
+
+		TestDouble(s, "NUMERIC(18, 4)");
+		TRANSACTION(s) {
+			TestDouble(s, "NUMERIC(18, 4)");
+		}
+
+		TestDatetime(s);
+		TRANSACTION(s) {
+			TestDatetime(s);
+		}
+	
+		TestBlob(s);
+		TRANSACTION(s) {
+			TestBlob(s);
+		}
+#endif
+
+#if 0
+		// Should be tested against examples\empbuild\EMPLOYEE.FDB
+		FBSequence seq("CUST_NO_GEN", s);
+		Value seq_v = seq.Get();
+		int seq_i = seq_v;
+	
+		Cout() << "Users:" << EOL;
+		Vector<String> users = s.EnumUsers();
+		for(int i = 0; i < users.GetCount(); ++i)
+			Cout() << users[i] << EOL;
+
+		Cout() << "Views:" << EOL;
+		Vector<String> views = s.EnumViews("");
+		for(int i = 0; i < views.GetCount(); ++i)
+			Cout() << views[i] << EOL;
+
+		Cout() << "Tables:" << EOL;
+		Vector<String> tables = s.EnumTables("");
+		for(int i = 0; i < tables.GetCount(); ++i)
+			Cout() << tables[i] << EOL;
+
+		Cout() << "Sequences:" << EOL;
+		Vector<String> sequences = s.EnumSequences("");
+		for(int i = 0; i < sequences.GetCount(); ++i)
+			Cout() << sequences[i] << EOL;
+
+		Cout() << "PrimaryKey:" << EOL;
+		Vector<String> pk_cols = s.EnumPrimaryKey("", "JOB");
+		for(int i = 0; i < pk_cols.GetCount(); ++i)
+			Cout() << pk_cols[i] << EOL;
+
+		Cout() << "Columns:" << EOL;
+		Vector<SqlColumnInfo> cols = s.EnumColumns("", "JOB");
+		for(int i = 0; i < cols.GetCount(); ++i)
+			Cout() << cols[i].name << EOL;
+
+#endif
+	}
+}
+
diff --git a/bazaar/FirebirdTest/FirebirdTest.upp b/bazaar/FirebirdTest/FirebirdTest.upp
new file mode 100644
index 000000000..432cc918e
--- /dev/null
+++ b/bazaar/FirebirdTest/FirebirdTest.upp
@@ -0,0 +1,12 @@
+description "Firebird/Interbase interface unit test\377";
+
+uses
+	Core,
+	Firebird;
+
+file
+	FirebirdTest.cpp;
+
+mainconfig
+	"" = "";
+
diff --git a/bazaar/FirebirdTest/init b/bazaar/FirebirdTest/init
new file mode 100644
index 000000000..3e32fe4e2
--- /dev/null
+++ b/bazaar/FirebirdTest/init
@@ -0,0 +1,5 @@
+#ifndef _FirebirdTest_icpp_init_stub
+#define _FirebirdTest_icpp_init_stub
+#include "Core/init"
+#include "Firebird/init"
+#endif