diff --git a/Data/Data_VS80.vcproj b/Data/Data_VS80.vcproj
index 9698ec5cd..8d486e8f0 100644
--- a/Data/Data_VS80.vcproj
+++ b/Data/Data_VS80.vcproj
@@ -249,6 +249,18 @@
 					RelativePath=".\include\Poco\Data\BLOBStream.h"
 					>
 				</File>
+				<File
+					RelativePath=".\include\Poco\Data\Bulk.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\Poco\Data\BulkBinding.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\Poco\Data\BulkExtraction.h"
+					>
+				</File>
 				<File
 					RelativePath=".\include\Poco\Data\Column.h"
 					>
@@ -281,6 +293,10 @@
 					RelativePath=".\include\Poco\Data\MetaColumn.h"
 					>
 				</File>
+				<File
+					RelativePath=".\include\Poco\Data\Position.h"
+					>
+				</File>
 				<File
 					RelativePath=".\include\Poco\Data\Prepare.h"
 					>
@@ -329,10 +345,6 @@
 					RelativePath=".\include\Poco\Data\StatementImpl.h"
 					>
 				</File>
-				<File
-					RelativePath=".\include\Poco\Data\Step.h"
-					>
-				</File>
 				<File
 					RelativePath=".\include\Poco\Data\Time.h"
 					>
@@ -377,6 +389,10 @@
 					RelativePath=".\src\BLOBStream.cpp"
 					>
 				</File>
+				<File
+					RelativePath=".\src\Bulk.cpp"
+					>
+				</File>
 				<File
 					RelativePath=".\src\Connector.cpp"
 					>
@@ -397,6 +413,10 @@
 					RelativePath=".\src\MetaColumn.cpp"
 					>
 				</File>
+				<File
+					RelativePath=".\src\Position.cpp"
+					>
+				</File>
 				<File
 					RelativePath=".\src\Range.cpp"
 					>
@@ -441,10 +461,6 @@
 					RelativePath=".\src\StatementImpl.cpp"
 					>
 				</File>
-				<File
-					RelativePath=".\src\Step.cpp"
-					>
-				</File>
 				<File
 					RelativePath=".\src\Time.cpp"
 					>
diff --git a/Data/Makefile b/Data/Makefile
index dbb35dbc6..81bcd54bf 100644
--- a/Data/Makefile
+++ b/Data/Makefile
@@ -9,13 +9,12 @@
 include $(POCO_BASE)/build/rules/global
 
 objects = AbstractBinder AbstractBinding AbstractExtraction \
-	AbstractExtractor AbstractPreparation AbstractPrepare \
+	AbstractExtractor AbstractPreparation AbstractPrepare Bulk \
 	Connector BLOB BLOBStream DataException Date Limit MetaColumn \
-	PooledSessionHolder PooledSessionImpl \
+	PooledSessionHolder PooledSessionImpl Position \
 	Range RecordSet Row RowFormatter RowIterator \
 	Session SessionFactory SessionImpl \
-	SessionPool Statement StatementCreator StatementImpl \
-	Step Time
+	SessionPool Statement StatementCreator StatementImpl Time
 
 target         = PocoData
 target_version = $(LIBVERSION)
diff --git a/Data/ODBC/Makefile b/Data/ODBC/Makefile
index 6c77fff19..4893db2e5 100644
--- a/Data/ODBC/Makefile
+++ b/Data/ODBC/Makefile
@@ -17,8 +17,8 @@ $(error No ODBC library found. Please install unixODBC or iODBC and try again)
 endif
 
 objects = Binder ConnectionHandle Connector EnvironmentHandle \
-	Extractor ODBCColumn ODBCException ODBCStatementImpl Parameter Preparation \
-	SessionImpl TypeInfo Unicode Utility 
+	Extractor ODBCColumn ODBCException ODBCStatementImpl \
+	Parameter Preparation SessionImpl TypeInfo Unicode Utility 
 
 target         = PocoODBC
 target_version = $(LIBVERSION)
diff --git a/Data/ODBC/include/Poco/Data/ODBC/Binder.h b/Data/ODBC/include/Poco/Data/ODBC/Binder.h
index a60db404d..9714ece28 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/Binder.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/Binder.h
@@ -81,6 +81,7 @@ public:
 	};
 
 	Binder(const StatementHandle& rStmt,
+		std::size_t maxFieldSize,
 		ParameterBinding dataBinding = PB_IMMEDIATE,
 		TypeInfo* pDataTypes = 0);
 		/// Creates the Binder.
@@ -91,62 +92,119 @@ public:
 	void bind(std::size_t pos, const Poco::Int8& val, Direction dir);
 		/// Binds an Int8.
 
+	void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir);
+		/// Binds an Int8 vector.
+
 	void bind(std::size_t pos, const Poco::UInt8& val, Direction dir);
 		/// Binds an UInt8.
 
+	void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir);
+		/// Binds an UInt8 vector.
+
 	void bind(std::size_t pos, const Poco::Int16& val, Direction dir);
 		/// Binds an Int16.
+	
+	void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir);
+		/// Binds an Int16 vector.
 
 	void bind(std::size_t pos, const Poco::UInt16& val, Direction dir);
 		/// Binds an UInt16.
 
+	void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir);
+		/// Binds an UInt16 vector.
+
 	void bind(std::size_t pos, const Poco::Int32& val, Direction dir);
 		/// Binds an Int32.
 
+	void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir);
+		/// Binds an Int32 vector.
+
 	void bind(std::size_t pos, const Poco::UInt32& val, Direction dir);
 		/// Binds an UInt32.
 
+	void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir);
+		/// Binds an UInt32 vector.
+
 	void bind(std::size_t pos, const Poco::Int64& val, Direction dir);
 		/// Binds an Int64.
 
+	void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir);
+		/// Binds an Int64 vector.
+
 	void bind(std::size_t pos, const Poco::UInt64& val, Direction dir);
 		/// Binds an UInt64.
 
+	void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir);
+		/// Binds an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
 	void bind(std::size_t pos, const long& val, Direction dir);
 		/// Binds a long.
+
+	void bind(std::size_t pos, const std::vector<long>& val, Direction dir);
+		/// Binds a long vector.
 #endif
 
 	void bind(std::size_t pos, const bool& val, Direction dir);
 		/// Binds a boolean.
 
+	void bind(std::size_t pos, const std::vector<bool>& val, Direction dir);
+		/// Binds a boolean vector.
+
 	void bind(std::size_t pos, const float& val, Direction dir);
 		/// Binds a float.
 
+	void bind(std::size_t pos, const std::vector<float>& val, Direction dir);
+		/// Binds a float vector.
+
 	void bind(std::size_t pos, const double& val, Direction dir);
 		/// Binds a double.
 
+	void bind(std::size_t pos, const std::vector<double>& val, Direction dir);
+		/// Binds a double vector.
+
 	void bind(std::size_t pos, const char& val, Direction dir);
 		/// Binds a single character.
 
+	void bind(std::size_t pos, const std::vector<char>& val, Direction dir);
+		/// Binds a character vector.
+
 	void bind(std::size_t pos, const std::string& val, Direction dir);
 		/// Binds a string.
 
+	void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir);
+		/// Binds a string vector.
+
 	void bind(std::size_t pos, const BLOB& val, Direction dir);
 		/// Binds a BLOB. In-bound only.
 
+	void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir);
+		/// Binds a BLOB vector. In-bound only.
+
 	void bind(std::size_t pos, const Date& val, Direction dir);
 		/// Binds a Date.
 
+	void bind(std::size_t pos, const std::vector<Date>& val, Direction dir);
+		/// Binds a Date vector.
+
 	void bind(std::size_t pos, const Time& val, Direction dir);
 		/// Binds a Time.
 
+	void bind(std::size_t pos, const std::vector<Time>& val, Direction dir);
+		/// Binds a Time vector.
+
 	void bind(std::size_t pos, const DateTime& val, Direction dir);
 		/// Binds a DateTime.
 
+	void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir);
+		/// Binds a DateTime vector.
+
 	void bind(std::size_t pos, const NullData& val, Direction dir);
 		/// Binds a null. In-bound only.
 
+	void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir);
+		/// Binds a null vector. In-bound only.
+
 	void setDataBinding(ParameterBinding binding);
 		/// Set data binding type.
 
@@ -164,16 +222,22 @@ public:
 		/// Clears the cached storage.
 
 private:
-	typedef std::vector<SQLLEN*>              LengthVec;
-	typedef std::map<char*, std::string*>     StringMap;
-	typedef std::map<SQL_DATE_STRUCT*, Date*> DateMap;
-	typedef std::map<SQL_TIME_STRUCT*, Time*> TimeMap;
-	typedef std::map<SQL_TIMESTAMP_STRUCT*, DateTime*> TimestampMap;
+	typedef std::vector<SQLLEN*>                            LengthVec;
+	typedef std::vector<std::vector<SQLLEN> >               LengthVecVec;
+	typedef std::vector<char*>                              CharPtrVec;
+	typedef std::vector<bool*>                              BoolPtrVec;
+	typedef std::vector<std::vector<SQL_DATE_STRUCT> >      DateVec;
+	typedef std::vector<std::vector<SQL_TIME_STRUCT> >      TimeVec;
+	typedef std::vector<std::vector<SQL_TIMESTAMP_STRUCT> > DateTimeVec;
+	typedef std::map<char*, std::string*>                   StringMap;
+	typedef std::map<SQL_DATE_STRUCT*, Date*>               DateMap;
+	typedef std::map<SQL_TIME_STRUCT*, Time*>               TimeMap;
+	typedef std::map<SQL_TIMESTAMP_STRUCT*, DateTime*>      TimestampMap;
 
 	void describeParameter(std::size_t pos);
 		/// Sets the description field for the parameter, if needed.
 
-	void bind(std::size_t pos, const char* const &pVal, Direction dir);
+	void bind(std::size_t pos, const char* const& pVal, Direction dir);
 		/// Binds a const char ptr. 
 		/// This is a private no-op in this implementation
 		/// due to security risk.
@@ -185,12 +249,12 @@ private:
 	template <typename T>
 	void bindImpl(std::size_t pos, T& val, SQLSMALLINT cDataType, Direction dir)
 	{
-		_lengthIndicator.push_back(0);
-
 		SQLINTEGER colSize = 0;
 		SQLSMALLINT decDigits = 0;
 		getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
 
+		_lengthIndicator.push_back(0);
+
 		if (Utility::isError(SQLBindParameter(_rStmt, 
 			(SQLUSMALLINT) pos + 1, 
 			toODBCDirection(dir), 
@@ -198,14 +262,50 @@ private:
 			Utility::sqlDataType(cDataType), 
 			colSize,
 			decDigits,
-			(SQLPOINTER) &val, 
-			0, 
-			0)))
+			(SQLPOINTER) &val, 0, 0)))
 		{
 			throw StatementException(_rStmt, "SQLBindParameter()");
 		}
 	}
 
+	template <typename T>
+	void bindImplVec(std::size_t pos, const std::vector<T>& val, SQLSMALLINT cDataType, Direction dir)
+	{
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("std::vector can only be bound immediately.");
+
+		std::size_t length = val.size();
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+		setParamSetSize(pos, length);
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1);
+			_vecLengthIndicator[pos].resize(length, sizeof(T));
+		}
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			cDataType, 
+			Utility::sqlDataType(cDataType), 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &val[0], 
+			0, 
+			&_vecLengthIndicator[pos][0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter()");
+		}
+	}
+
+	void bindImplVecBool(std::size_t pos, 
+		const std::vector<bool>& val, 
+		SQLSMALLINT cDataType, 
+		Direction dir);
+
 	void getColSizeAndPrecision(std::size_t pos, 
 		SQLSMALLINT cDataType, 
 		SQLINTEGER& colSize, 
@@ -218,20 +318,40 @@ private:
 		/// to discover the required values are unsuccesfully exhausted, the values 
 		/// are both set to zero and no exception is thrown.
 
-	void bindNull(std::size_t pos, SQLSMALLINT cDataType);
-		/// Utility function for binding null values.
-		/// For in-bound purposes only.
+	void setParamSetSize(std::size_t pos, std::size_t length);
+		/// Sets the parameter set size. Used for column-wise binding.
+
+	void getColumnOrParameterSize(std::size_t pos, SQLINTEGER& size);
+		/// Fills the column or parameter size into the 'size' argument.
+		/// Does nothing if neither can be obtained from the driver, so
+		/// size should be set to some default value prior to calling this 
+		/// function in order to avoid undefined size value.
+
+	void freeMemory();
+		/// Frees all dynamically allocated memory resources.
 
 	const StatementHandle& _rStmt;
-	LengthVec              _lengthIndicator;
-	ParamMap               _inParams;
-	ParamMap               _outParams;
-	ParameterBinding       _paramBinding;
-	DateMap                _dates;
-	TimeMap                _times;
-	TimestampMap           _timestamps;
-	StringMap              _strings;
-	const TypeInfo*        _pTypeInfo;
+
+	LengthVec        _lengthIndicator;
+	LengthVecVec     _vecLengthIndicator;
+
+	ParamMap         _inParams;
+	ParamMap         _outParams;
+	ParameterBinding _paramBinding;
+	
+	DateMap          _dates;
+	TimeMap          _times;
+	TimestampMap     _timestamps;
+	StringMap        _strings;
+
+	DateVec          _dateVec;
+	TimeVec          _timeVec;
+	DateTimeVec      _dateTimeVec;
+	CharPtrVec       _charPtrs;
+	BoolPtrVec       _boolPtrs;
+	const TypeInfo*  _pTypeInfo;
+	SQLINTEGER       _paramSetSize;
+	std::size_t      _maxFieldSize;
 };
 
 
@@ -244,53 +364,107 @@ inline void Binder::bind(std::size_t pos, const Poco::Int8& val, Direction dir)
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_STINYINT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::UInt8& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_UTINYINT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_UTINYINT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::Int16& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_SSHORT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SSHORT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::UInt16& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_USHORT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_USHORT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::Int32& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_SLONG, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SLONG, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::UInt32& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_ULONG, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_ULONG, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::Int64& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_SBIGINT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SBIGINT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const Poco::UInt64& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_UBIGINT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_UBIGINT, dir);
+}
+
+
 #ifndef POCO_LONG_IS_64_BIT
 inline void Binder::bind(std::size_t pos, const long& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_SLONG, dir);
 }
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<long>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SLONG, dir);
+}
 #endif
 
 
@@ -300,24 +474,48 @@ inline void Binder::bind(std::size_t pos, const float& val, Direction dir)
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<float>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_FLOAT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const double& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_DOUBLE, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<double>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_DOUBLE, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const bool& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_BIT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<bool>& val, Direction dir)
+{
+	bindImplVecBool(pos, val, SQL_C_BIT, dir);
+}
+
+
 inline void Binder::bind(std::size_t pos, const char& val, Direction dir)
 {
 	bindImpl(pos, val, SQL_C_STINYINT, dir);
 }
 
 
+inline void Binder::bind(std::size_t pos, const std::vector<char>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_STINYINT, dir);
+}
+
+
 inline void Binder::setDataBinding(Binder::ParameterBinding binding)
 {
 	_paramBinding = binding;
diff --git a/Data/ODBC/include/Poco/Data/ODBC/Extractor.h b/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
index c22905c93..324f25389 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
@@ -77,73 +77,133 @@ public:
 	bool extract(std::size_t pos, Poco::Int8& val);
 		/// Extracts an Int8.
 
+	bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
 	bool extract(std::size_t pos, Poco::UInt8& val);
 		/// Extracts an UInt8.
 
+	bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
 	bool extract(std::size_t pos, Poco::Int16& val);
 		/// Extracts an Int16.
 
+	bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
 	bool extract(std::size_t pos, Poco::UInt16& val);
 		/// Extracts an UInt16.
 
+	bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
 	bool extract(std::size_t pos, Poco::Int32& val);
 		/// Extracts an Int32.
 
+	bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
 	bool extract(std::size_t pos, Poco::UInt32& val);
 		/// Extracts an UInt32.
 
+	bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
 	bool extract(std::size_t pos, Poco::Int64& val);
 		/// Extracts an Int64.
 
+	bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
 	bool extract(std::size_t pos, Poco::UInt64& val);
 		/// Extracts an UInt64.
 
+	bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
 	bool extract(std::size_t pos, long& val);
 		/// Extracts a long.
+
+	bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
 #endif
 
 	bool extract(std::size_t pos, bool& val);
 		/// Extracts a boolean.
 
+	bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
 	bool extract(std::size_t pos, float& val);
 		/// Extracts a float.
 
+	bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
 	bool extract(std::size_t pos, double& val);
 		/// Extracts a double.
 
+	bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
 	bool extract(std::size_t pos, char& val);
 		/// Extracts a single character.
 
+	bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a single character vector.
+
 	bool extract(std::size_t pos, std::string& val);
 		/// Extracts a string.
 
+	bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
 	bool extract(std::size_t pos, Poco::Data::BLOB& val);
 		/// Extracts a BLOB.
 
+	bool extract(std::size_t pos, std::vector<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB vector.
+
 	bool extract(std::size_t pos, Poco::Data::Date& val);
 		/// Extracts a Date.
 
+	bool extract(std::size_t pos, std::vector<Poco::Data::Date>& val);
+		/// Extracts a Date vector.
+
 	bool extract(std::size_t pos, Poco::Data::Time& val);
 		/// Extracts a Time.
 
+	bool extract(std::size_t pos, std::vector<Poco::Data::Time>& val);
+		/// Extracts a Time vector.
+
 	bool extract(std::size_t pos, Poco::DateTime& val);
 		/// Extracts a DateTime.
+
+	bool extract(std::size_t pos, std::vector<Poco::DateTime>& val);
+		/// Extracts a DateTime vector.
 	
 	bool extract(std::size_t pos, Poco::Any& val);
 		/// Extracts an Any.
 
+	bool extract(std::size_t pos, std::vector<Poco::Any>& val);
+		/// Extracts an Any vector.
+
 	bool extract(std::size_t pos, Poco::DynamicAny& val);
 		/// Extracts a DynamicAny.
 
+	bool extract(std::size_t pos, std::vector<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny vector.
+
 	void setDataExtraction(Preparation::DataExtraction ext);
 		/// Set data extraction mode.
 
 	Preparation::DataExtraction getDataExtraction() const;
 		/// Returns data extraction mode.
 
-	bool isNull(std::size_t pos);
-		/// Returns true if the current row value at pos column is null.
+	bool isNull(std::size_t col, std::size_t row = Preparation::INVALID_ROW);
+		/// Returns true if the value at [col,row] is null.
 
 	void reset();
 		/// Resets the internally cached length indicators. 
@@ -171,13 +231,20 @@ private:
 	bool extractBoundImpl(std::size_t pos, T& val)
 	{
 		if (isNull(pos)) return false;
-
-		poco_assert (typeid(T) == _rPreparation[pos].type());
-
+		poco_assert_dbg (typeid(T) == _rPreparation[pos].type());
 		val = *AnyCast<T>(&_rPreparation[pos]); 
 		return true;
 	}
 
+	template<typename T>
+	bool extractBoundImplVec(std::size_t pos, std::vector<T>& val)
+	{
+		poco_assert_dbg (typeid(std::vector<T>) == _rPreparation[pos].type());
+		std::vector<T>& v = RefAnyCast<std::vector<T> >(_rPreparation[pos]);
+		val.assign(v.begin(), v.end());
+		return true;
+	}
+
 	template<typename T>
 	bool extractManualImpl(std::size_t pos, T& val, SQLSMALLINT cType)
 	{
@@ -271,6 +338,8 @@ private:
 		/// SQLLEN macro (a.k.a. SQLINTEGER) yields 64-bit value, 
 		/// while SQL_NULL_DATA (#define'd as -1 literal) remains 32-bit.
 
+	SQLINTEGER columnSize(std::size_t pos) const;
+
 	const StatementHandle&      _rStmt;
 	Preparation&                _rPreparation;
 	Preparation::DataExtraction _dataExtraction;
@@ -281,8 +350,6 @@ private:
 ///
 /// inlines
 ///
-
-
 inline void Extractor::setDataExtraction(Preparation::DataExtraction ext)
 {
 	_rPreparation.setDataExtraction(_dataExtraction = ext);
@@ -314,6 +381,12 @@ inline bool Extractor::isNullLengthIndicator(SQLLEN val) const
 }
 
 
+inline SQLINTEGER Extractor::columnSize(std::size_t pos) const
+{
+	return (SQLINTEGER) ODBCColumn(_rStmt, pos).length();
+}
+
+
 } } } // namespace Poco::Data::ODBC
 
 
diff --git a/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h b/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
index 729c1e354..095798d0e 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
@@ -206,17 +206,6 @@ inline bool ODBCStatementImpl::nextRowReady() const
 }
 
 
-inline const MetaColumn& ODBCStatementImpl::metaColumn(Poco::UInt32 pos) const
-{
-	std::size_t sz = _columnPtrs.size();
-
-	if (0 == sz || pos > sz - 1)
-		throw InvalidAccessException(format("Invalid column number: %u", pos));
-
-	return *_columnPtrs[pos];
-}
-
-
 } } } // namespace Poco::Data::ODBC
 
 
diff --git a/Data/ODBC/include/Poco/Data/ODBC/Parameter.h b/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
index 3b638dcee..6aa8029bb 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
@@ -82,8 +82,6 @@ public:
 private:
 	Parameter();
 
-	static const int BUFFER_LENGTH = 2048;
-
 	void init();
 
 	SQLSMALLINT _dataType;
diff --git a/Data/ODBC/include/Poco/Data/ODBC/Preparation.h b/Data/ODBC/include/Poco/Data/ODBC/Preparation.h
index 39fb905d1..ca35bbd10 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/Preparation.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/Preparation.h
@@ -76,8 +76,9 @@ class ODBC_API Preparation : public AbstractPreparation
 	/// with respective memory output locations before extracting data. 
 	/// Extraction works in two-phases: first prepare is called once, then extract n-times.
 	/// In ODBC, SQLBindCol/SQLFetch is the preferred method of data retrieval (SQLGetData is available, 
-	/// however with numerous driver implementation dependent limitations). In order to fit this functionality 
-	/// into Poco DataConnectors framework, every ODBC SQL statement instantiates its own Preparation object. 
+	/// however with numerous driver implementation dependent limitations and inferior performance). 
+	/// In order to fit this functionality into Poco DataConnectors framework, every ODBC SQL statement 
+	/// instantiates its own Preparation object. 
 	/// This is done once per statement execution (from StatementImpl::bindImpl()).
 	///
 	/// Preparation object is used to :
@@ -94,12 +95,26 @@ class ODBC_API Preparation : public AbstractPreparation
 	/// 
 {
 public:
+	typedef std::vector<char*> CharArray;
+
 	enum DataExtraction
 	{
 		DE_MANUAL,
 		DE_BOUND
 	};
 
+	static const std::size_t INVALID_ROW;
+
+	enum DataType
+	{
+		DT_BOOL,
+		DT_CHAR,
+		DT_CHAR_ARRAY,
+		DT_DATE,
+		DT_TIME,
+		DT_DATETIME
+	};
+
 	Preparation(const StatementHandle& rStmt, 
 		const std::string& statement, 
 		std::size_t maxFieldSize,
@@ -112,68 +127,128 @@ public:
 	~Preparation();
 		/// Destroys the Preparation.
 
-	void prepare(std::size_t pos, Poco::Int8);
+	void prepare(std::size_t pos, Poco::Int8& val);
 		/// Prepares an Int8.
 
-	void prepare(std::size_t pos, Poco::UInt8);
+	void prepare(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Prepares an Int8 vector.
+
+	void prepare(std::size_t pos, Poco::UInt8& val);
 		/// Prepares an UInt8.
 
-	void prepare(std::size_t pos, Poco::Int16);
+	void prepare(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Prepares an UInt8 vector.
+
+	void prepare(std::size_t pos, Poco::Int16& val);
 		/// Prepares an Int16.
 
-	void prepare(std::size_t pos, Poco::UInt16);
+	void prepare(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Prepares an Int16 vector.
+
+	void prepare(std::size_t pos, Poco::UInt16& val);
 		/// Prepares an UInt16.
 
-	void prepare(std::size_t pos, Poco::Int32);
+	void prepare(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Prepares an UInt16 vector.
+
+	void prepare(std::size_t pos, Poco::Int32& val);
 		/// Prepares an Int32.
 
-	void prepare(std::size_t pos, Poco::UInt32);
+	void prepare(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Prepares an Int32 vector.
+
+	void prepare(std::size_t pos, Poco::UInt32& val);
 		/// Prepares an UInt32.
 
-	void prepare(std::size_t pos, Poco::Int64);
+	void prepare(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Prepares an UInt32 vector.
+
+	void prepare(std::size_t pos, Poco::Int64& val);
 		/// Prepares an Int64.
 
-	void prepare(std::size_t pos, Poco::UInt64);
+	void prepare(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Prepares an Int64 vector.
+
+	void prepare(std::size_t pos, Poco::UInt64& val);
 		/// Prepares an UInt64.
 
+	void prepare(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Prepares an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
-	void prepare(std::size_t pos, long);
+	void prepare(std::size_t pos, long& val);
 		/// Prepares a long.
+
+	void prepare(std::size_t pos, std::vector<long>& val);
+		/// Prepares a long vector.
 #endif
 
-	void prepare(std::size_t pos, bool);
+	void prepare(std::size_t pos, bool& val);
 		/// Prepares a boolean.
 
-	void prepare(std::size_t pos, float);
+	void prepare(std::size_t pos, std::vector<bool>& val);
+		/// Prepares a boolean vector.
+
+	void prepare(std::size_t pos, float& val);
 		/// Prepares a float.
 
-	void prepare(std::size_t pos, double);
+	void prepare(std::size_t pos, std::vector<float>& val);
+		/// Prepares a float vector.
+
+	void prepare(std::size_t pos, double& val);
 		/// Prepares a double.
 
-	void prepare(std::size_t pos, char);
+	void prepare(std::size_t pos, std::vector<double>& val);
+		/// Prepares a double vector.
+
+	void prepare(std::size_t pos, char& val);
 		/// Prepares a single character.
 
-	void prepare(std::size_t pos, const std::string&);
+	void prepare(std::size_t pos, std::vector<char>& val);
+		/// Prepares a single character vector.
+
+	void prepare(std::size_t pos, const std::string& val);
 		/// Prepares a string.
 
-	void prepare(std::size_t pos, const Poco::Data::BLOB&);
+	void prepare(std::size_t pos, const std::vector<std::string>& val);
+		/// Prepares a string vector.
+
+	void prepare(std::size_t pos, const Poco::Data::BLOB& val);
 		/// Prepares a BLOB.
 
-	void prepare(std::size_t pos, const Poco::Data::Date&);
+	void prepare(std::size_t pos, const std::vector<Poco::Data::BLOB>& val);
+		/// Prepares a BLOB vector.
+
+	void prepare(std::size_t pos, const Poco::Data::Date& val);
 		/// Prepares a Date.
 
-	void prepare(std::size_t pos, const Poco::Data::Time&);
+	void prepare(std::size_t pos, const std::vector<Poco::Data::Date>& val);
+		/// Prepares a Date vector.
+
+	void prepare(std::size_t pos, const Poco::Data::Time& val);
 		/// Prepares a Time.
 
-	void prepare(std::size_t pos, const Poco::DateTime&);
+	void prepare(std::size_t pos, const std::vector<Poco::Data::Time>& val);
+		/// Prepares a Time vector.
+
+	void prepare(std::size_t pos, const Poco::DateTime& val);
 		/// Prepares a DateTime.
 
-	void prepare(std::size_t pos, const Poco::Any&);
+	void prepare(std::size_t pos, const std::vector<Poco::DateTime>& val);
+		/// Prepares a DateTime vector.
+
+	void prepare(std::size_t pos, const Poco::Any& val);
 		/// Prepares an Any.
 
-	void prepare(std::size_t pos, const Poco::DynamicAny&);
+	void prepare(std::size_t pos, const std::vector<Poco::Any>& val);
+		/// Prepares an Any vector.
+
+	void prepare(std::size_t pos, const Poco::DynamicAny& val);
 		/// Prepares a DynamicAny.
 
+	void prepare(std::size_t pos, const std::vector<Poco::DynamicAny>& val);
+		/// Prepares a DynamicAny vector.
+
 	std::size_t columns() const;
 		/// Returns the number of columns.
 		/// Resizes the internal storage iff the size is zero.
@@ -192,12 +267,16 @@ public:
 		/// Returned length for variable length fields is the one 
 		/// supported by this implementation, not the underlying DB.
 
-	int actualDataSize(std::size_t pos) const;
-		/// Returns the returned length. This is usually
-		/// equal to the column size, except for variable length fields
-		/// (BLOB and variable length strings).
+	std::size_t actualDataSize(std::size_t col, std::size_t row = INVALID_ROW) const;
+		/// Returns the returned length for the column and row specified. 
+		/// This is usually equal to the column size, except for 
+		/// variable length fields (BLOB and variable length strings).
 		/// For null values, the return value is -1 (SQL_NO_DATA)
 
+	std::size_t bulkSize(std::size_t col = 0) const;
+		/// Returns bulk size. Column argument is optional
+		/// since all columns must be the same size.
+
 	void setDataExtraction(DataExtraction ext);
 		/// Set data extraction mode.
 
@@ -205,201 +284,486 @@ public:
 		/// Returns data extraction mode.
 
 private:
+	typedef std::vector<Poco::Any> ValueVec;
+	typedef std::vector<SQLLEN>    LengthVec;
+	typedef std::vector<LengthVec> LengthLengthVec;
+	typedef std::map<std::size_t, DataType> IndexMap;
+
 	Preparation();
 	Preparation& operator = (const Preparation&);
 
-	void prepareImpl(std::size_t pos);
-		/// Utility function to prepare Any and DynamicAny
+	template <typename T>
+	void prepareImpl(std::size_t pos, const std::vector<T>* pVal = 0)
+		/// Utility function to prepare Any and DynamicAny.
+	{
+		ODBCColumn col(_rStmt, pos);
+
+		switch (col.type())
+		{
+			case MetaColumn::FDT_INT8:
+				if (pVal)
+					return prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT); 
+
+			case MetaColumn::FDT_UINT8:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT);
+
+			case MetaColumn::FDT_INT16:
+				if (pVal)
+					return prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT);
+
+			case MetaColumn::FDT_UINT16:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT);
+
+			case MetaColumn::FDT_INT32:
+				if (pVal)
+					return prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG);
+
+			case MetaColumn::FDT_UINT32:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG);
+
+			case MetaColumn::FDT_INT64:
+				if (pVal)
+					return prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT);
+
+			case MetaColumn::FDT_UINT64:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT);
+
+			case MetaColumn::FDT_BOOL:
+				if (pVal)
+					return prepareVariableLen<bool>(pos, SQL_C_BIT, pVal->size(), DT_BOOL);
+				else
+					return prepareFixedSize<bool>(pos, SQL_C_BIT);
+
+			case MetaColumn::FDT_FLOAT:
+				if (pVal)
+					return prepareFixedSize<float>(pos, SQL_C_FLOAT, pVal->size());
+				else
+					return prepareFixedSize<float>(pos, SQL_C_FLOAT);
+
+			case MetaColumn::FDT_DOUBLE:
+				if (pVal)
+					return prepareFixedSize<double>(pos, SQL_C_DOUBLE, pVal->size());
+				else
+					return prepareFixedSize<double>(pos, SQL_C_DOUBLE);
+
+			case MetaColumn::FDT_STRING:
+				if (pVal)
+					return prepareVariableLenArray(pos, SQL_C_CHAR, maxDataSize(pos), pVal->size(), DT_CHAR_ARRAY);
+				else
+					return prepareVariableLen<char>(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR);
+
+			case MetaColumn::FDT_BLOB:
+				if (pVal)
+					return prepareVariableLenArray(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size(), DT_CHAR_ARRAY);
+				else
+					return prepareVariableLen<char>(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR);
+
+			case MetaColumn::FDT_DATE:
+				if (pVal)
+					return prepareFixedSize<Date>(pos, SQL_C_TYPE_DATE, pVal->size());
+				else
+					return prepareFixedSize<Date>(pos, SQL_C_TYPE_DATE);
+
+			case MetaColumn::FDT_TIME:
+				if (pVal)
+					return prepareFixedSize<Time>(pos, SQL_C_TYPE_TIME, pVal->size());
+				else
+					return prepareFixedSize<Time>(pos, SQL_C_TYPE_TIME);
+
+			case MetaColumn::FDT_TIMESTAMP:
+				if (pVal)
+					return prepareFixedSize<DateTime>(pos, SQL_C_TYPE_TIMESTAMP, pVal->size());
+				else
+					return prepareFixedSize<DateTime>(pos, SQL_C_TYPE_TIMESTAMP);
+
+			default: 
+				throw DataFormatException("Unsupported data type.");
+		}
+	}
 
 	void resize() const;
 		/// Resize the values and lengths vectors.
 
 	template <typename T>
-	void preparePOD(std::size_t pos, SQLSMALLINT valueType)
+	void prepareFixedSize(std::size_t pos, SQLSMALLINT valueType)
+		/// Utility function for preparation of fixed length columns.
 	{
 		poco_assert (DE_BOUND == _dataExtraction);
-		poco_assert (pos >= 0 && pos < _pValues.size());
-
 		std::size_t dataSize = sizeof(T);
 
-		_pValues[pos] = new Poco::Any(T());
-		_pLengths[pos] = new SQLLEN;
-		*_pLengths[pos] = 0;
-
-		T* pVal = AnyCast<T>(_pValues[pos]);
-
-		poco_assert_dbg (pVal);
+		poco_assert (pos < _values.size());
+		_values[pos] = Poco::Any(T());
 
+		T* pVal = AnyCast<T>(&_values[pos]);
 		if (Utility::isError(SQLBindCol(_rStmt, 
 			(SQLUSMALLINT) pos + 1, 
 			valueType, 
-			(SQLPOINTER) pVal, 
+			(SQLPOINTER) pVal,  
 			(SQLINTEGER) dataSize, 
-			_pLengths[pos])))
+			&_lengths[pos])))
 		{
 			throw StatementException(_rStmt, "SQLBindCol()");
 		}
 	}
 
 	template <typename T>
-	void prepareRaw(std::size_t pos, SQLSMALLINT valueType, std::size_t size)
+	void prepareFixedSize(std::size_t pos, SQLSMALLINT valueType, std::size_t length)
+		/// Utility function for preparation of fixed length columns that are
+		/// bound to a std::vector.
 	{
 		poco_assert (DE_BOUND == _dataExtraction);
-		poco_assert (pos >= 0 && pos < _pValues.size());
+		std::size_t dataSize = sizeof(T);
 
-		T* pChr = new T[size]; 
-		poco_assert_dbg (pChr);
-		memset(pChr, 0, size);
-
-		SharedPtr<T> sp = pChr; 
-		_pValues[pos] = new Any(sp);
-		_pLengths[pos] = new SQLLEN;
-		*_pLengths[pos] = (SQLLEN) size;
+		poco_assert (pos < _values.size());
+		poco_assert (length);
+		_values[pos] = Poco::Any(std::vector<T>(length));
+		_lengths[pos] = 0;
+		poco_assert (0 == _lenLengths[pos].size());
+		_lenLengths[pos].resize(length);
 
+		std::vector<T>& cache = RefAnyCast<std::vector<T> >(_values[pos]);
+		
 		if (Utility::isError(SQLBindCol(_rStmt, 
 			(SQLUSMALLINT) pos + 1, 
 			valueType, 
-			(SQLPOINTER) pChr, 
-			(SQLINTEGER) size, 
-			_pLengths[pos])))
+			(SQLPOINTER) &cache[0], 
+			(SQLINTEGER) dataSize, 
+			&_lenLengths[pos][0])))
 		{
 			throw StatementException(_rStmt, "SQLBindCol()");
 		}
 	}
 
-	const StatementHandle&          _rStmt;
-	mutable std::vector<Poco::Any*> _pValues;
-	mutable std::vector<SQLLEN*>    _pLengths;
-	std::size_t                     _maxFieldSize;
-	DataExtraction                  _dataExtraction;
+	template <typename T>
+	void prepareVariableLen(std::size_t pos, SQLSMALLINT valueType, std::size_t size, DataType dt)
+		/// Utility function for preparation of variable length columns and bool vectors.
+	{
+		poco_assert (DE_BOUND == _dataExtraction);
+		poco_assert (pos < _values.size());
+
+		T* pCache = new T[size]; 
+		poco_assert_dbg (pCache);
+		std::memset(pCache, 0, size);
+
+		_values[pos] = Any(pCache);
+		_lengths[pos] = (SQLLEN) size;
+		_varLengthArrays.insert(IndexMap::value_type(pos, dt));
+
+		if (Utility::isError(SQLBindCol(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			valueType, 
+			(SQLPOINTER) pCache, 
+			(SQLINTEGER) size, 
+			&_lengths[pos])))
+		{
+			throw StatementException(_rStmt, "SQLBindCol()");
+		}
+	}
+
+
+	void prepareVariableLenArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length, DataType dt);
+		/// Utility function for preparation of variable length character and BLOB columns.
+
+
+	void freeMemory() const;
+		/// Utility function. Releases memory allocated for variable length columns.
+
+	template <typename T>
+	void deleteCachedArray(std::size_t pos) const
+	{
+		T* p = Poco::AnyCast<T>(&_values[pos]);
+		delete [] p;
+	}
+
+	const StatementHandle&  _rStmt;
+	mutable ValueVec        _values;
+	mutable LengthVec       _lengths;
+	mutable LengthLengthVec _lenLengths;
+	mutable IndexMap        _varLengthArrays;
+	std::size_t             _maxFieldSize;
+	DataExtraction          _dataExtraction;
 };
 
 
 //
 // inlines
 //
-inline void Preparation::prepare(std::size_t pos, Poco::Int8)
+inline void Preparation::prepare(std::size_t pos, Poco::Int8&)
 {
-	preparePOD<Poco::Int8>(pos, SQL_C_STINYINT);
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::UInt8)
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::Int8>& val)
 {
-	preparePOD<Poco::UInt8>(pos, SQL_C_UTINYINT);
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::Int16)
+inline void Preparation::prepare(std::size_t pos, Poco::UInt8&)
 {
-	preparePOD<Poco::Int16>(pos, SQL_C_SSHORT);
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::UInt16)
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::UInt8>& val)
 {
-	preparePOD<Poco::UInt16>(pos, SQL_C_USHORT);
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::Int32)
+inline void Preparation::prepare(std::size_t pos, Poco::Int16&)
 {
-	preparePOD<Poco::Int32>(pos, SQL_C_SLONG);
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::UInt32)
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::Int16>& val)
 {
-	preparePOD<Poco::UInt32>(pos, SQL_C_ULONG);
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::Int64)
+inline void Preparation::prepare(std::size_t pos, Poco::UInt16&)
 {
-	preparePOD<Poco::Int64>(pos, SQL_C_SBIGINT);
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, Poco::UInt64)
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::UInt16>& val)
 {
-	preparePOD<Poco::UInt64>(pos, SQL_C_UBIGINT);
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, Poco::Int32&)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, Poco::UInt32&)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, Poco::Int64&)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, Poco::UInt64&)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
 }
 
 
 #ifndef POCO_LONG_IS_64_BIT
-inline void Preparation::prepare(std::size_t pos, long)
+inline void Preparation::prepare(std::size_t pos, long&)
 {
-	preparePOD<long>(pos, SQL_C_SLONG);
+	prepareFixedSize<long>(pos, SQL_C_SLONG);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<long>& val)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
 }
 #endif
 
 
-inline void Preparation::prepare(std::size_t pos, bool)
+inline void Preparation::prepare(std::size_t pos, bool&)
 {
-	preparePOD<bool>(pos, SQL_C_BIT);
+	prepareFixedSize<bool>(pos, SQL_C_BIT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, float)
+inline void Preparation::prepare(std::size_t pos, std::vector<bool>& val)
 {
-	preparePOD<float>(pos, SQL_C_FLOAT);
+	prepareVariableLen<bool>(pos, SQL_C_BIT, val.size(), DT_BOOL);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, double)
+inline void Preparation::prepare(std::size_t pos, float&)
 {
-	preparePOD<double>(pos, SQL_C_DOUBLE);
+	prepareFixedSize<float>(pos, SQL_C_FLOAT);
 }
 
 
-inline void Preparation::prepare(std::size_t pos, char)
+inline void Preparation::prepare(std::size_t pos, std::vector<float>& val)
 {
-	preparePOD<char>(pos, SQL_C_STINYINT);
+	prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, double&)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<double>& val)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
+}
+
+
+inline void Preparation::prepare(std::size_t pos, char&)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, std::vector<char>& val)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
 }
 
 
 inline void Preparation::prepare(std::size_t pos, const std::string&)
 {
-	prepareRaw<char>(pos, SQL_C_CHAR, maxDataSize(pos));
+	prepareVariableLen<char>(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<std::string>& val)
+{
+	prepareVariableLenArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size(), DT_CHAR_ARRAY);
 }
 
 
 inline void Preparation::prepare(std::size_t pos, const Poco::Data::BLOB&)
 {
-	prepareRaw<char>(pos, SQL_C_BINARY, maxDataSize(pos));
+	prepareVariableLen<char>(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::Data::BLOB>& val)
+{
+	prepareVariableLenArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size(), DT_CHAR_ARRAY);
 }
 
 
 inline void Preparation::prepare(std::size_t pos, const Poco::Data::Date&)
 {
-	prepareRaw<SQL_DATE_STRUCT>(pos, 
-		SQL_C_TYPE_DATE, 
-		sizeof(SQL_DATE_STRUCT));
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::Data::Date>& val)
+{
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE, val.size());
 }
 
 
 inline void Preparation::prepare(std::size_t pos, const Poco::Data::Time&)
 {
-	prepareRaw<SQL_TIME_STRUCT>(pos, 
-		SQL_C_TYPE_TIME, 
-		sizeof(SQL_TIME_STRUCT));
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::Data::Time>& val)
+{
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME, val.size());
 }
 
 
 inline void Preparation::prepare(std::size_t pos, const Poco::DateTime&)
 {
-	prepareRaw<SQL_TIMESTAMP_STRUCT>(pos, 
-		SQL_C_TYPE_TIMESTAMP, 
-		sizeof(SQL_TIMESTAMP_STRUCT));
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP);
 }
 
 
-inline int Preparation::actualDataSize(std::size_t pos) const
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::DateTime>& val)
 {
-	poco_assert (pos >= 0 && pos < _pValues.size());
-	poco_assert (_pLengths[pos]);
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP, val.size());
+}
 
-	return *_pLengths[pos];
+
+inline void Preparation::prepare(std::size_t pos, const Poco::Any& val)
+{
+	prepareImpl<Poco::Any>(pos);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::Any>& val)
+{
+	prepareImpl<Poco::Any>(pos, &val);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const Poco::DynamicAny& val)
+{
+	prepareImpl<Poco::DynamicAny>(pos);
+}
+
+
+inline void Preparation::prepare(std::size_t pos, const std::vector<Poco::DynamicAny>& val)
+{
+	prepareImpl<Poco::DynamicAny>(pos, &val);
+}
+
+
+inline std::size_t Preparation::actualDataSize(std::size_t col, std::size_t row) const
+{
+	poco_assert (col < _values.size());
+
+	if (INVALID_ROW == row) return _lengths[col];
+	else return _lenLengths[col].at(row);
+}
+
+
+inline std::size_t Preparation::bulkSize(std::size_t col) const
+{
+	poco_assert (col < _lenLengths.size());
+
+	return _lenLengths[col].size();
 }
 
 
@@ -427,6 +791,14 @@ inline Preparation::DataExtraction Preparation::getDataExtraction() const
 }
 
 
+inline Poco::Any& Preparation::operator [] (std::size_t pos)
+{
+	poco_assert (pos < _values.size());
+	
+	return _values[pos];
+}
+
+
 } } } // namespace Poco::Data::ODBC
 
 
diff --git a/Data/ODBC/include/Poco/Data/ODBC/Utility.h b/Data/ODBC/include/Poco/Data/ODBC/Utility.h
index 041af77ad..ec72162ce 100644
--- a/Data/ODBC/include/Poco/Data/ODBC/Utility.h
+++ b/Data/ODBC/include/Poco/Data/ODBC/Utility.h
@@ -97,21 +97,39 @@ public:
 	static void dateSync(Date& dt, const SQL_DATE_STRUCT& ts);
 		/// Transfers data from ODBC SQL_DATE_STRUCT to Poco::DateTime.
 
+	static void dateSync(std::vector<Date>& d, const std::vector<SQL_DATE_STRUCT>& ds);
+		/// Transfers data from ODBC SQL_DATE_STRUCT vector to Poco::DateTime vector.
+
 	static void timeSync(Time& dt, const SQL_TIME_STRUCT& ts);
 		/// Transfers data from ODBC SQL_TIME_STRUCT to Poco::DateTime.
 
+	static void timeSync(std::vector<Time>& t, const std::vector<SQL_TIME_STRUCT>& ts);
+		/// Transfers data from ODBC SQL_TIME_STRUCT vector to Poco::DateTime vector.
+
 	static void dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts);
 		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT to Poco::DateTime.
 
+	static void dateTimeSync(std::vector<Poco::DateTime>& dt, const std::vector<SQL_TIMESTAMP_STRUCT>& ts);
+		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT vector to Poco::DateTime vector.
+
 	static void dateSync(SQL_DATE_STRUCT& ts, const Date& dt);
-	/// Transfers data from Poco::Data::Date to ODBC SQL_DATE_STRUCT.
+		/// Transfers data from Poco::Data::Date to ODBC SQL_DATE_STRUCT.
+
+	static void dateSync(std::vector<SQL_DATE_STRUCT>& ds, const std::vector<Date>& d);
+		/// Transfers data from Poco::Data::Date vector to ODBC SQL_DATE_STRUCT vector.
 
 	static void timeSync(SQL_TIME_STRUCT& ts, const Time& dt);
 		/// Transfers data from Poco::Data::Time to ODBC SQL_TIME_STRUCT.
 
+	static void timeSync(std::vector<SQL_TIME_STRUCT>& ts, const std::vector<Time>& t);
+		/// Transfers data from Poco::Data::Time vector to ODBC SQL_TIME_STRUCT vector.
+
 	static void dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt);
 		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
 
+	static void dateTimeSync(std::vector<SQL_TIMESTAMP_STRUCT>& ts, const std::vector<Poco::DateTime>& dt);
+		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
+
 private:
 	static const TypeInfo _dataTypes;
 		/// C <==> SQL data type mapping
@@ -139,15 +157,15 @@ inline int Utility::sqlDataType(int cDataType)
 }
 
 
-inline void Utility::dateSync(Date& dt, const SQL_DATE_STRUCT& ts)
+inline void Utility::dateSync(Date& d, const SQL_DATE_STRUCT& ts)
 {
-	dt.assign(ts.year, ts.month, ts.day);
+	d.assign(ts.year, ts.month, ts.day);
 }
 
 
-inline void Utility::timeSync(Time& dt, const SQL_TIME_STRUCT& ts)
+inline void Utility::timeSync(Time& t, const SQL_TIME_STRUCT& ts)
 {
-	dt.assign(ts.hour, ts.minute, ts.second);
+	t.assign(ts.hour, ts.minute, ts.second);
 }
 
 
diff --git a/Data/ODBC/src/Binder.cpp b/Data/ODBC/src/Binder.cpp
index 2590040f1..576b0c432 100644
--- a/Data/ODBC/src/Binder.cpp
+++ b/Data/ODBC/src/Binder.cpp
@@ -48,12 +48,15 @@ namespace Data {
 namespace ODBC {
 
 
-Binder::Binder(const StatementHandle& rStmt, 
+Binder::Binder(const StatementHandle& rStmt,
+	std::size_t maxFieldSize,
 	Binder::ParameterBinding dataBinding,
 	TypeInfo* pDataTypes):
 	_rStmt(rStmt),
 	_paramBinding(dataBinding),
-	_pTypeInfo(pDataTypes)
+	_pTypeInfo(pDataTypes),
+	_paramSetSize(0),
+	_maxFieldSize(maxFieldSize)
 {
 }
 
@@ -71,6 +74,42 @@ Binder::~Binder()
 	StringMap::iterator itStr = _strings.begin();
 	StringMap::iterator itStrEnd = _strings.end();
 	for(; itStr != itStrEnd; ++itStr) std::free(itStr->first);
+
+	CharPtrVec::iterator itChr = _charPtrs.begin();
+	CharPtrVec::iterator endChr = _charPtrs.end();
+	for (; itChr != endChr; ++itChr) delete [] *itChr;
+}
+
+
+void Binder::freeMemory()
+{
+	LengthVec::iterator itLen = _lengthIndicator.begin();
+	LengthVec::iterator itLenEnd = _lengthIndicator.end();
+	for(; itLen != itLenEnd; ++itLen) delete *itLen;
+
+	TimeMap::iterator itT = _times.begin();
+	TimeMap::iterator itTEnd = _times.end();
+	for(; itT != itTEnd; ++itT) delete itT->first;
+
+	DateMap::iterator itD = _dates.begin();
+	DateMap::iterator itDEnd = _dates.end();
+	for(; itD != itDEnd; ++itD) delete itD->first;
+
+	TimestampMap::iterator itTS = _timestamps.begin();
+	TimestampMap::iterator itTSEnd = _timestamps.end();
+	for(; itTS != itTSEnd; ++itTS) delete itTS->first;
+
+	StringMap::iterator itStr = _strings.begin();
+	StringMap::iterator itStrEnd = _strings.end();
+	for(; itStr != itStrEnd; ++itStr) std::free(itStr->first);
+
+	CharPtrVec::iterator itChr = _charPtrs.begin();
+	CharPtrVec::iterator endChr = _charPtrs.end();
+	for (; itChr != endChr; ++itChr) std::free(*itChr);
+
+	BoolPtrVec::iterator itBool = _boolPtrs.begin();
+	BoolPtrVec::iterator endBool = _boolPtrs.end();
+	for (; itBool != endBool; ++itBool) delete [] *itBool;
 }
 
 
@@ -81,29 +120,7 @@ void Binder::bind(std::size_t pos, const std::string& val, Direction dir)
 
 	if (isOutBound(dir))
 	{
-		try
-		{
-			Parameter p(_rStmt, pos);
-			size = (SQLUINTEGER) p.columnSize();
-		}
-		catch (StatementException&)
-		{
-			size = DEFAULT_PARAM_SIZE;
-//On Linux, PostgreSQL driver segfaults on SQLGetDescField, so this is disabled for now
-#ifdef POCO_OS_FAMILY_WINDOWS
-			SQLHDESC hIPD = 0;
-			if (!Utility::isError(SQLGetStmtAttr(_rStmt, SQL_ATTR_IMP_PARAM_DESC, &hIPD, SQL_IS_POINTER, 0)))
-			{
-				SQLUINTEGER sz = 0;
-				if (!Utility::isError(SQLGetDescField(hIPD, (SQLSMALLINT) pos + 1, SQL_DESC_LENGTH, &sz, SQL_IS_UINTEGER, 0)) && 
-					sz > 0)
-				{
-					size = sz;
-				}
-			}
-#endif
-		}
-
+		getColumnOrParameterSize(pos, size);
 		char* pChar = (char*) std::calloc(size, sizeof(char));
 		pVal = (SQLPOINTER) pChar;
 		_outParams.insert(ParamMap::value_type(pVal, size));
@@ -115,7 +132,7 @@ void Binder::bind(std::size_t pos, const std::string& val, Direction dir)
 		_inParams.insert(ParamMap::value_type(pVal, size));
 	}
 	else
-		throw IllegalStateException("Parameter must be [in] OR [out] bound.");
+		throw InvalidArgumentException("Parameter must be [in] OR [out] bound.");
 
 	SQLLEN* pLenIn = new SQLLEN;
 	*pLenIn = SQL_NTS;
@@ -141,7 +158,64 @@ void Binder::bind(std::size_t pos, const std::string& val, Direction dir)
 }
 
 
-void Binder::bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir)
+void Binder::bind(std::size_t pos, const std::vector<std::string>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("String vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = 0;
+	getColumnOrParameterSize(pos, size);
+	poco_assert (size > 0);
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), SQL_NTS);
+	}
+
+	if (_charPtrs.size() <= pos)
+		_charPtrs.resize(pos + 1, 0);
+
+	_charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(char));
+	
+	std::size_t strSize;
+	std::size_t offset = 0;
+	std::vector<std::string>::const_iterator it = val.begin();
+	std::vector<std::string>::const_iterator end = val.end();
+	for (; it != end; ++it)
+	{
+		strSize = it->size();
+		if (strSize > size)	
+			throw LengthExceededException("SQLBindParameter(std::vector<std::string>)");
+		std::memcpy(_charPtrs[pos] + offset, it->c_str(), strSize);
+		offset += size;
+	}
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_CHAR, 
+		SQL_LONGVARCHAR, 
+		(SQLUINTEGER) size - 1,
+		0,
+		_charPtrs[pos], 
+		(SQLINTEGER) size, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::vector<std::string>)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const BLOB& val, Direction dir)
 {
 	if (isOutBound(dir) || !isInBound(dir))
 		throw NotImplementedException("BLOB parameter type can only be inbound.");
@@ -175,6 +249,78 @@ void Binder::bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir)
 }
 
 
+void Binder::bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("BLOB vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = 0;
+	getColumnOrParameterSize(pos, size);
+	poco_assert (size > 0);
+
+	if (size == _maxFieldSize)
+	{
+		std::size_t maxSize = 0;
+		std::vector<BLOB>::const_iterator it = val.begin();
+		std::vector<BLOB>::const_iterator end = val.end();
+		for (; it != end; ++it)
+		{
+			std::size_t sz = it->size();
+			if (sz < _maxFieldSize && sz > maxSize)
+				maxSize = sz;
+		}
+		if (maxSize) size = maxSize;
+	}
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), SQL_NTS);
+	}
+
+	if (_charPtrs.size() <= pos)
+		_charPtrs.resize(pos + 1, 0);
+
+	_charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(char));
+	poco_check_ptr (_charPtrs[pos]);
+
+	std::size_t blobSize;
+	std::size_t offset = 0;
+	std::vector<BLOB>::const_iterator it = val.begin();
+	std::vector<BLOB>::const_iterator end = val.end();
+	for (; it != end; ++it)
+	{
+		blobSize = it->size();
+		if (blobSize > size)	
+			throw LengthExceededException("SQLBindParameter(std::vector<BLOB>)");
+		std::memcpy(_charPtrs[pos] + offset, it->rawContent(), blobSize);
+		offset += size;
+	}
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		SQL_PARAM_INPUT, 
+		SQL_C_BINARY, 
+		SQL_LONGVARBINARY, 
+		(SQLUINTEGER) size,
+		0,
+		_charPtrs[pos], 
+		(SQLINTEGER) size, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::vector<BLOB>)");
+	}
+}
+
+
 void Binder::bind(std::size_t pos, const Date& val, Direction dir)
 {
 	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT);
@@ -203,7 +349,51 @@ void Binder::bind(std::size_t pos, const Date& val, Direction dir)
 		0, 
 		_lengthIndicator.back())))
 	{
-		throw StatementException(_rStmt, "SQLBindParameter(BLOB)");
+		throw StatementException(_rStmt, "SQLBindParameter(Date)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const std::vector<Date>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("Date vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT);
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), size);
+	}
+
+	if (_dateVec.size() <= pos) _dateVec.resize(pos + 1);
+	Utility::dateSync(_dateVec[pos], val);
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_DATE, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_DATE, 
+		SQL_DATE, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) &_dateVec[pos][0], 
+		0, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Date[])");
 	}
 }
 
@@ -236,7 +426,51 @@ void Binder::bind(std::size_t pos, const Time& val, Direction dir)
 		0, 
 		_lengthIndicator.back())))
 	{
-		throw StatementException(_rStmt, "SQLBindParameter(BLOB)");
+		throw StatementException(_rStmt, "SQLBindParameter(Time)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const std::vector<Time>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("Time vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIME_STRUCT);
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), size);
+	}
+
+	if (_timeVec.size() <= pos)	_timeVec.resize(pos + 1);
+	Utility::timeSync(_timeVec[pos], val);
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TIME, 
+		SQL_TIME, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) &_timeVec[pos][0], 
+		0, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Time[])");
 	}
 }
 
@@ -251,7 +485,7 @@ void Binder::bind(std::size_t pos, const Poco::DateTime& val, Direction dir)
 
 	SQL_TIMESTAMP_STRUCT* pTS = new SQL_TIMESTAMP_STRUCT;
 	Utility::dateTimeSync(*pTS, val);
-	
+
 	_timestamps.insert(TimestampMap::value_type(pTS, const_cast<DateTime*>(&val)));
 
 	SQLINTEGER colSize = 0;
@@ -269,7 +503,51 @@ void Binder::bind(std::size_t pos, const Poco::DateTime& val, Direction dir)
 		0, 
 		_lengthIndicator.back())))
 	{
-		throw StatementException(_rStmt, "SQLBindParameter(BLOB)");
+		throw StatementException(_rStmt, "SQLBindParameter(DateTime)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("DateTime vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIMESTAMP_STRUCT);
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), size);
+	}
+
+	if (_dateTimeVec.size() <= pos)	_dateTimeVec.resize(pos + 1);
+	Utility::dateTimeSync(_dateTimeVec[pos], val);
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TIMESTAMP, 
+		SQL_TIMESTAMP, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) &_dateTimeVec[pos][0], 
+		0, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Time[])");
 	}
 }
 
@@ -279,34 +557,6 @@ void Binder::bind(std::size_t pos, const NullData& val, Direction dir)
 	if (isOutBound(dir) || !isInBound(dir))
 		throw NotImplementedException("NULL parameter type can only be inbound.");
 
-	switch (val)
-	{
-	case NULL_GENERIC:
-	case NULL_INT8:	     bindNull(pos, SQL_C_STINYINT); break;
-	case NULL_UINT8:     bindNull(pos, SQL_C_UTINYINT); break;
-	case NULL_INT16:     bindNull(pos, SQL_C_SSHORT); break;
-	case NULL_UINT16:    bindNull(pos, SQL_C_USHORT); break;
-	case NULL_INT32:     bindNull(pos, SQL_C_SLONG); break;
-	case NULL_UINT32:    bindNull(pos, SQL_C_ULONG); break;
-	case NULL_INT64:     bindNull(pos, SQL_C_SBIGINT); break;
-	case NULL_UINT64:    bindNull(pos, SQL_C_UBIGINT); break;
-	case NULL_BOOL:      bindNull(pos, SQL_C_BIT); break;
-	case NULL_FLOAT:     bindNull(pos, SQL_C_FLOAT); break;
-	case NULL_DOUBLE:    bindNull(pos, SQL_C_DOUBLE); break;
-	case NULL_STRING:    bindNull(pos, SQL_C_CHAR); break;
-	case NULL_BLOB:      bindNull(pos, SQL_C_BINARY); break;
-	case NULL_DATE:      bindNull(pos, SQL_C_DATE); break;
-	case NULL_TIME:      bindNull(pos, SQL_C_TIME); break;
-	case NULL_TIMESTAMP: bindNull(pos, SQL_C_TIMESTAMP); break;
-
-	default: 
-			throw DataFormatException("Unsupported data type.");
-	}
-}
-
-
-void Binder::bindNull(std::size_t pos, SQLSMALLINT cDataType)
-{
 	_inParams.insert(ParamMap::value_type(0, 0));
 
 	SQLLEN* pLenIn = new SQLLEN;
@@ -316,13 +566,13 @@ void Binder::bindNull(std::size_t pos, SQLSMALLINT cDataType)
 
 	SQLINTEGER colSize = 0;
 	SQLSMALLINT decDigits = 0;
-	getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+	getColSizeAndPrecision(pos, SQL_C_STINYINT, colSize, decDigits);
 
 	if (Utility::isError(SQLBindParameter(_rStmt, 
 		(SQLUSMALLINT) pos + 1, 
 		SQL_PARAM_INPUT, 
-		cDataType, 
-		Utility::sqlDataType(cDataType), 
+		SQL_C_STINYINT, 
+		Utility::sqlDataType(SQL_C_STINYINT), 
 		colSize,
 		decDigits,
 		0, 
@@ -334,6 +584,90 @@ void Binder::bindNull(std::size_t pos, SQLSMALLINT cDataType)
 }
 
 
+void Binder::bind(std::size_t pos, const std::vector<NullData>& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("DateTime vector parameter type can only be inbound.");
+
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	if (0 == val.size())
+		throw InvalidArgumentException("Empty vector not allowed.");
+
+	setParamSetSize(pos, val.size());
+
+	SQLINTEGER size = SQL_NULL_DATA;
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(val.size(), size);
+	}
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		SQL_PARAM_INPUT, 
+		SQL_C_STINYINT, 
+		Utility::sqlDataType(SQL_C_STINYINT), 
+		colSize,
+		decDigits,
+		0, 
+		0, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter()");
+	}
+}
+
+
+void Binder::bindImplVecBool(std::size_t pos, const std::vector<bool>& val, SQLSMALLINT cDataType, Direction dir)
+{
+	if (PB_IMMEDIATE != _paramBinding)
+		throw InvalidAccessException("std::vector can only be bound immediately.");
+
+	std::size_t length = val.size();
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+
+	setParamSetSize(pos, val.size());
+
+	if (_vecLengthIndicator.size() <= pos)
+	{
+		_vecLengthIndicator.resize(pos + 1);
+		_vecLengthIndicator[pos].resize(length, sizeof(bool));
+	}
+
+	if (_boolPtrs.size() <= pos)
+		_boolPtrs.resize(pos + 1);
+
+	_boolPtrs[pos] = new bool[val.size()];
+
+	std::vector<bool>::const_iterator it = val.begin();
+	std::vector<bool>::const_iterator end = val.end();
+	for (int i = 0; it != end; ++it, ++i) _boolPtrs[pos][i] = *it;
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		cDataType, 
+		Utility::sqlDataType(cDataType), 
+		colSize,
+		decDigits,
+		(SQLPOINTER) &_boolPtrs[pos][0], 
+		0, 
+		&_vecLengthIndicator[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter()");
+	}
+}
+
+
 std::size_t Binder::parameterSize(SQLPOINTER pAddr) const
 {
 	ParamMap::const_iterator it = _inParams.find(pAddr);
@@ -370,40 +704,41 @@ void Binder::synchronize()
 {
 	if (_dates.size())
 	{
-		DateMap::iterator itTS = _dates.begin();
-		DateMap::iterator itTSEnd = _dates.end();
-		for(; itTS != itTSEnd; ++itTS) 
-			Utility::dateSync(*itTS->second, *itTS->first);
+		DateMap::iterator it = _dates.begin();
+		DateMap::iterator end = _dates.end();
+		for(; it != end; ++it) 
+			Utility::dateSync(*it->second, *it->first);
 	}
 
 	if (_times.size())
 	{
-		TimeMap::iterator itTS = _times.begin();
-		TimeMap::iterator itTSEnd = _times.end();
-		for(; itTS != itTSEnd; ++itTS) 
-			Utility::timeSync(*itTS->second, *itTS->first);
+		TimeMap::iterator it = _times.begin();
+		TimeMap::iterator end = _times.end();
+		for(; it != end; ++it) 
+			Utility::timeSync(*it->second, *it->first);
 	}
 
 	if (_timestamps.size())
 	{
-		TimestampMap::iterator itTS = _timestamps.begin();
-		TimestampMap::iterator itTSEnd = _timestamps.end();
-		for(; itTS != itTSEnd; ++itTS) 
-			Utility::dateTimeSync(*itTS->second, *itTS->first);
+		TimestampMap::iterator it = _timestamps.begin();
+		TimestampMap::iterator end = _timestamps.end();
+		for(; it != end; ++it) 
+			Utility::dateTimeSync(*it->second, *it->first);
 	}
 
 	if (_strings.size())
 	{
-		StringMap::iterator itStr = _strings.begin();
-		StringMap::iterator itStrEnd = _strings.end();
-		for(; itStr != itStrEnd; ++itStr)
-			itStr->second->assign(itStr->first, strlen(itStr->first));
+		StringMap::iterator it = _strings.begin();
+		StringMap::iterator end = _strings.end();
+		for(; it != end; ++it)
+			it->second->assign(it->first, strlen(it->first));
 	}
 }
 
 
 void Binder::reset()
 {
+	freeMemory();
 	LengthVec().swap(_lengthIndicator);
 	_inParams.clear();
 	_outParams.clear();
@@ -411,6 +746,11 @@ void Binder::reset()
 	_times.clear();
 	_timestamps.clear();
 	_strings.clear();
+	_dateVec.clear();
+	_timeVec.clear();
+	_dateTimeVec.clear();
+	_charPtrs.clear();
+	_boolPtrs.clear();
 }
 
 
@@ -429,27 +769,23 @@ void Binder::getColSizeAndPrecision(std::size_t pos,
 			decDigits = _pTypeInfo->getInfo(cDataType, "MINIMUM_SCALE");
 			return;
 		}
-		else 
-			throw NotFoundException();
-	}catch (NotFoundException&)
-	{ 
-		try
-		{
-			Parameter p(_rStmt, pos);
-			colSize = (SQLINTEGER) p.columnSize();
-			decDigits = (SQLSMALLINT) p.decimalDigits();
-			return;
-		}catch (StatementException&)
-		{
-			try
-			{
-				ODBCColumn c(_rStmt, pos);
-				colSize = (SQLINTEGER) c.length();
-				decDigits = (SQLSMALLINT) c.precision();
-				return;
-			}catch (StatementException&) { }
-		}
-	}
+	} catch (NotFoundException&) { }
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		colSize = (SQLINTEGER) p.columnSize();
+		decDigits = (SQLSMALLINT) p.decimalDigits();
+		return;
+	} catch (StatementException&) { }
+
+	try
+	{
+		ODBCColumn c(_rStmt, pos);
+		colSize = (SQLINTEGER) c.length();
+		decDigits = (SQLSMALLINT) c.precision();
+		return;
+	} catch (StatementException&) { }
 
 	// no success, set to zero and hope for the best
 	// (most drivers do not require these most of the times anyway)
@@ -459,4 +795,67 @@ void Binder::getColSizeAndPrecision(std::size_t pos,
 }
 
 
+void Binder::getColumnOrParameterSize(std::size_t pos, SQLINTEGER& size)
+{
+	std::size_t colSize = 0;
+	std::size_t paramSize = 0;
+
+	try
+	{
+		ODBCColumn col(_rStmt, pos);
+		colSize = col.length();
+	}
+	catch (StatementException&) { }
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		paramSize = p.columnSize();
+	}
+	catch (StatementException&)
+	{
+		size = DEFAULT_PARAM_SIZE;
+//On Linux, PostgreSQL driver segfaults on SQLGetDescField, so this is disabled for now
+#ifdef POCO_OS_FAMILY_WINDOWS
+		SQLHDESC hIPD = 0;
+		if (!Utility::isError(SQLGetStmtAttr(_rStmt, SQL_ATTR_IMP_PARAM_DESC, &hIPD, SQL_IS_POINTER, 0)))
+		{
+			SQLUINTEGER sz = 0;
+			if (!Utility::isError(SQLGetDescField(hIPD, (SQLSMALLINT) pos + 1, SQL_DESC_LENGTH, &sz, SQL_IS_UINTEGER, 0)) && 
+				sz > 0)
+			{
+				size = sz;
+			}
+		}
+#endif
+	}
+
+	if (colSize > 0 && paramSize > 0)
+		size = colSize < paramSize ? colSize : paramSize;
+	else if (colSize > 0)
+		size = colSize;
+	else if (paramSize > 0)
+		size = paramSize;
+
+	if (size > _maxFieldSize) size = _maxFieldSize;
+}
+
+
+void Binder::setParamSetSize(std::size_t pos, std::size_t length)
+{
+	if (0 == _paramSetSize)
+	{
+		if (Utility::isError(SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, SQL_IS_UINTEGER)) ||  
+			Utility::isError(SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) length, SQL_IS_UINTEGER)))
+				throw StatementException(_rStmt, "SQLSetStmtAttr()");
+
+		if (Utility::isError(SQLGetStmtAttr(_rStmt, SQL_ATTR_PARAMSET_SIZE, &_paramSetSize, 0, 0)))
+			throw StatementException(_rStmt, "SQLGetStmtAttr()");
+	}
+
+	if (_paramSetSize != length)
+		throw InvalidArgumentException("Invalid parameter array length.");
+}
+
+
 } } } // namespace Poco::Data::ODBC
diff --git a/Data/ODBC/src/Extractor.cpp b/Data/ODBC/src/Extractor.cpp
index 47df7f301..744f61506 100644
--- a/Data/ODBC/src/Extractor.cpp
+++ b/Data/ODBC/src/Extractor.cpp
@@ -73,11 +73,29 @@ bool Extractor::extractBoundImpl<std::string>(std::size_t pos, std::string& val)
 	if (isNull(pos)) return false;
 
 	std::size_t dataSize = _rPreparation.actualDataSize(pos);
-	SharedPtr<char>& sp = RefAnyCast<SharedPtr<char> >(_rPreparation[pos]);
+	char* sp = AnyCast<char*>(_rPreparation[pos]);
 	std::size_t len = strlen(sp);
 	if (len < dataSize) dataSize = len;
 	checkDataSize(dataSize);
 	val.assign(sp, dataSize);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<std::string> >(std::size_t pos, 
+	std::vector<std::string>& values)
+{
+	char** pc = AnyCast<char*>(&_rPreparation[pos]);
+	poco_assert_dbg (pc);
+	poco_assert_dbg (_rPreparation.bulkSize() == values.size());
+	std::size_t colWidth = columnSize(pos);
+	std::vector<std::string>::iterator it = values.begin();
+	std::vector<std::string>::iterator end = values.end();
+	for (int row = 0; it != end; ++it, ++row)
+		it->assign(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row));
+
 	return true;
 }
 
@@ -89,8 +107,26 @@ bool Extractor::extractBoundImpl<Poco::Data::BLOB>(std::size_t pos, Poco::Data::
 
 	std::size_t dataSize = _rPreparation.actualDataSize(pos);
 	checkDataSize(dataSize);
-	SharedPtr<char>& sp = RefAnyCast<SharedPtr<char> >(_rPreparation[pos]);
+	char* sp = AnyCast<char*>(_rPreparation[pos]);
 	val.assignRaw(sp, dataSize);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<Poco::Data::BLOB> >(std::size_t pos, 
+	std::vector<Poco::Data::BLOB>& values)
+{
+	char** pc = AnyCast<char*>(&_rPreparation[pos]);
+	poco_assert_dbg (pc);
+	poco_assert_dbg (_rPreparation.bulkSize() == values.size());
+	std::size_t colWidth = columnSize(pos);
+	std::vector<Poco::Data::BLOB>::iterator it = values.begin();
+	std::vector<Poco::Data::BLOB>::iterator end = values.end();
+	for (int row = 0; it != end; ++it, ++row)
+		it->assignRaw(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row));
+
 	return true;
 }
 
@@ -99,12 +135,18 @@ template<>
 bool Extractor::extractBoundImpl<Poco::Data::Date>(std::size_t pos, Poco::Data::Date& val)
 {
 	if (isNull(pos)) return false;
+	SQL_DATE_STRUCT& ds = *AnyCast<SQL_DATE_STRUCT>(&_rPreparation[pos]);
+	Utility::dateSync(val, ds);
+	return true;
+}
 
-	std::size_t dataSize = _rPreparation.actualDataSize(pos);
-	checkDataSize(dataSize);
-	SharedPtr<SQL_DATE_STRUCT>& sp = RefAnyCast<SharedPtr<SQL_DATE_STRUCT> >(_rPreparation[pos]);
-	
-	Utility::dateSync(val, *sp);
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<Poco::Data::Date> >(std::size_t pos, 
+	std::vector<Poco::Data::Date>& val)
+{
+	std::vector<SQL_DATE_STRUCT>& ds = RefAnyCast<std::vector<SQL_DATE_STRUCT> >(_rPreparation[pos]);
+	Utility::dateSync(val, ds);
 	return true;
 }
 
@@ -116,9 +158,19 @@ bool Extractor::extractBoundImpl<Poco::Data::Time>(std::size_t pos, Poco::Data::
 
 	std::size_t dataSize = _rPreparation.actualDataSize(pos);
 	checkDataSize(dataSize);
-	SharedPtr<SQL_TIME_STRUCT>& sp = RefAnyCast<SharedPtr<SQL_TIME_STRUCT> >(_rPreparation[pos]);
-	
-	Utility::timeSync(val, *sp);
+	SQL_TIME_STRUCT& ts = *AnyCast<SQL_TIME_STRUCT>(&_rPreparation[pos]);
+	Utility::timeSync(val, ts);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<Poco::Data::Time> >(std::size_t pos, 
+	std::vector<Poco::Data::Time>& val)
+{
+	std::vector<SQL_TIME_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIME_STRUCT> >(_rPreparation[pos]);
+	Utility::timeSync(val, ds);
 	return true;
 }
 
@@ -130,9 +182,31 @@ bool Extractor::extractBoundImpl<Poco::DateTime>(std::size_t pos, Poco::DateTime
 
 	std::size_t dataSize = _rPreparation.actualDataSize(pos);
 	checkDataSize(dataSize);
-	SharedPtr<SQL_TIMESTAMP_STRUCT>& sp = RefAnyCast<SharedPtr<SQL_TIMESTAMP_STRUCT> >(_rPreparation[pos]);
-	
-	Utility::dateTimeSync(val, *sp);
+	SQL_TIMESTAMP_STRUCT& tss = *AnyCast<SQL_TIMESTAMP_STRUCT>(&_rPreparation[pos]);
+	Utility::dateTimeSync(val, tss);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<Poco::DateTime> >(std::size_t pos, 
+	std::vector<Poco::DateTime>& val)
+{
+	std::vector<SQL_TIMESTAMP_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIMESTAMP_STRUCT> >(_rPreparation[pos]);
+	Utility::dateTimeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::vector<bool> >(std::size_t pos, std::vector<bool>& val)
+{
+	std::size_t length = _rPreparation.getLength();
+	bool* p = AnyCast<bool>(&_rPreparation[pos]);
+	for (int i = 0; i < length; ++i)
+		val.push_back(p[i]);
+
 	return true;
 }
 
@@ -162,8 +236,6 @@ bool Extractor::extractManualImpl<std::string>(std::size_t pos, std::string& val
 			pChar, //returned value
 			CHUNK_SIZE, //buffer length
 			&len); //length indicator
-		
-		_lengths[pos] += len;
 
 		if (SQL_NO_DATA != rc && Utility::isError(rc))
 			throw StatementException(_rStmt, "SQLGetData()");
@@ -172,18 +244,21 @@ bool Extractor::extractManualImpl<std::string>(std::size_t pos, std::string& val
 			throw UnknownDataLengthException("Could not determine returned data length.");
 
 		if (isNullLengthIndicator(len))
+		{
+			_lengths[pos] = len;
 			return false;
+		}
 
 		if (SQL_NO_DATA == rc || !len)
 			break;
 
+		_lengths[pos] += len;
 		fetchedSize = _lengths[pos] > CHUNK_SIZE ? CHUNK_SIZE : _lengths[pos];
 		totalSize += fetchedSize;
-		if (totalSize <= maxSize) val.append(pChar, fetchedSize);
-		else throw DataException(format(FLD_SIZE_EXCEEDED_FMT, 
-				fetchedSize, 
-				maxSize));
-
+		if (totalSize <= maxSize) 
+			val.append(pChar, fetchedSize);
+		else 
+			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, fetchedSize, maxSize));
 	}while (true);
 
 	return true;
@@ -237,9 +312,7 @@ bool Extractor::extractManualImpl<Poco::Data::BLOB>(std::size_t pos,
 		if (totalSize <= maxSize) 
 			val.appendRaw(pChar, fetchedSize);
 		else 
-			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, 
-				fetchedSize, 
-				maxSize));
+			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, fetchedSize, maxSize));
 
 	}while (true);
 
@@ -334,6 +407,16 @@ bool Extractor::extract(std::size_t pos, Poco::Int32& val)
 		return extractManualImpl(pos, val, SQL_C_SLONG);
 	else
 		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
 	
 }
 
@@ -347,6 +430,17 @@ bool Extractor::extract(std::size_t pos, Poco::Int64& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 #ifndef POCO_LONG_IS_64_BIT
 bool Extractor::extract(std::size_t pos, long& val)
 {
@@ -355,6 +449,17 @@ bool Extractor::extract(std::size_t pos, long& val)
 	else
 		return extractBoundImpl(pos, val);
 }
+
+
+bool Extractor::extract(std::size_t pos, std::vector<long>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
 #endif
 
 
@@ -367,6 +472,17 @@ bool Extractor::extract(std::size_t pos, double& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<double>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, std::string& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -376,6 +492,17 @@ bool Extractor::extract(std::size_t pos, std::string& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<std::string>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -385,6 +512,17 @@ bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::BLOB>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Data::Date& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -394,6 +532,17 @@ bool Extractor::extract(std::size_t pos, Poco::Data::Date& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::Date>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Data::Time& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -403,6 +552,17 @@ bool Extractor::extract(std::size_t pos, Poco::Data::Time& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::Time>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::DateTime& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -412,6 +572,17 @@ bool Extractor::extract(std::size_t pos, Poco::DateTime& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::DateTime>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Int8& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -421,6 +592,17 @@ bool Extractor::extract(std::size_t pos, Poco::Int8& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int8>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::UInt8& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -430,6 +612,15 @@ bool Extractor::extract(std::size_t pos, Poco::UInt8& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt8>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Int16& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -439,6 +630,17 @@ bool Extractor::extract(std::size_t pos, Poco::Int16& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int16>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::UInt16& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -448,6 +650,17 @@ bool Extractor::extract(std::size_t pos, Poco::UInt16& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt16>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::UInt32& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -457,6 +670,17 @@ bool Extractor::extract(std::size_t pos, Poco::UInt32& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::UInt64& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -466,6 +690,17 @@ bool Extractor::extract(std::size_t pos, Poco::UInt64& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, bool& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -475,6 +710,17 @@ bool Extractor::extract(std::size_t pos, bool& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<bool>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, float& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -484,6 +730,17 @@ bool Extractor::extract(std::size_t pos, float& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<float>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, char& val)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
@@ -493,32 +750,65 @@ bool Extractor::extract(std::size_t pos, char& val)
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<char>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImplVec(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::Any& val)
 {
 	return extractImpl(pos, val);
 }
 
 
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Any>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
 bool Extractor::extract(std::size_t pos, Poco::DynamicAny& val)
 {
 	return extractImpl(pos, val);
 }
 
 
-bool Extractor::isNull(std::size_t pos)
+bool Extractor::extract(std::size_t pos, std::vector<Poco::DynamicAny>& val)
+{
+	if (Preparation::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct vector extraction only allowed for bound mode.");
+		
+	
+}
+
+
+bool Extractor::isNull(std::size_t col, std::size_t row)
 {
 	if (Preparation::DE_MANUAL == _dataExtraction)
 	{
 		try
 		{
-			return isNullLengthIndicator(_lengths.at(pos));
+			return isNullLengthIndicator(_lengths.at(col));
 		}catch (std::out_of_range& ex)
 		{ 
 			throw RangeException(ex.what()); 
 		}
 	}
 	else
-		return SQL_NULL_DATA == _rPreparation.actualDataSize(pos);
+		return SQL_NULL_DATA == _rPreparation.actualDataSize(col, row);
 }
 
 
@@ -526,11 +816,7 @@ void Extractor::checkDataSize(std::size_t size)
 {
 	std::size_t maxSize = _rPreparation.getMaxFieldSize();
 	if (size > maxSize)
-	{
-		throw DataException(format(FLD_SIZE_EXCEEDED_FMT, 
-			size, 
-			maxSize));
-	}
+		throw DataException(format(FLD_SIZE_EXCEEDED_FMT, size, maxSize));
 }
 
 
diff --git a/Data/ODBC/src/ODBCStatementImpl.cpp b/Data/ODBC/src/ODBCStatementImpl.cpp
index e7abc4a4c..01a9c2681 100644
--- a/Data/ODBC/src/ODBCStatementImpl.cpp
+++ b/Data/ODBC/src/ODBCStatementImpl.cpp
@@ -40,11 +40,9 @@
 #include "Poco/Data/ODBC/ODBCException.h"
 #include "Poco/Data/AbstractPrepare.h"
 #include "Poco/Exception.h"
-#include <limits>
 
 
 #ifdef POCO_OS_FAMILY_WINDOWS
-	#undef max
 	#pragma warning(disable:4312)// 'type cast' : conversion from 'Poco::UInt32' to 'SQLPOINTER' of greater size
 #endif
 
@@ -68,11 +66,6 @@ ODBCStatementImpl::ODBCStatementImpl(SessionImpl& rSession):
 	_nextResponse(0),
 	_prepared(false)
 {
-	if (session().getFeature("autoBind"))
-		SQLSetStmtAttr(_stmt, SQL_ATTR_PARAM_BIND_TYPE, (SQLPOINTER) SQL_PARAM_BIND_BY_COLUMN, 0);
-
-	Poco::UInt32 step = getStep();
-	SQLSetStmtAttr(_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) step, 0);
 }
 
 
@@ -104,7 +97,9 @@ void ODBCStatementImpl::compileImpl()
 		pDT = AnyCast<TypeInfo*>(dti);
 	}catch (NotSupportedException&) { }
 
-	_pBinder = new Binder(_stmt, bind, pDT);
+	std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
+	
+	_pBinder = new Binder(_stmt, maxFieldSize, bind, pDT);
 	
 	// This is a hack to conform to some ODBC drivers behavior (e.g. MS SQLServer) with 
 	// stored procedure calls: driver refuses to report the number of columns, unless all 
@@ -169,6 +164,16 @@ void ODBCStatementImpl::doPrepare()
 		Extractions& extracts = extractions();
 		Extractions::iterator it    = extracts.begin();
 		Extractions::iterator itEnd = extracts.end();
+
+		if (it != itEnd && (*it)->isBulk())
+		{
+			Poco::UInt32 limit = getExtractionLimit();
+			if (limit == Limit::LIMIT_UNLIMITED) 
+				throw InvalidArgumentException("Bulk operation not allowed without limit.");
+			checkError(SQLSetStmtAttr(_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) limit, 0),
+					"SQLSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE)");
+		}
+
 		for (std::size_t pos = 0; it != itEnd; ++it)
 		{
 			AbstractPrepare* pAP = (*it)->createPrepareObject(_preparations[curDataSet], pos);
@@ -199,17 +204,17 @@ void ODBCStatementImpl::doBind(bool clear, bool reset)
 	{
 		Bindings::iterator it    = binds.begin();
 		Bindings::iterator itEnd = binds.end();
-		for (std::size_t pos = 0; it != itEnd && (*it)->canBind(); ++it)
-		{
-			(*it)->bind(pos);
-			pos += (*it)->numOfColumnsHandled();
-		}
 
 		if (reset)
 		{
 			it = binds.begin();
-			for (; it != itEnd && (*it)->canBind(); ++it)
-				(*it)->reset();
+			for (; it != itEnd; ++it) (*it)->reset();
+		}
+
+		for (std::size_t pos = 0; it != itEnd && (*it)->canBind(); ++it)
+		{
+			(*it)->bind(pos);
+			pos += (*it)->numOfColumnsHandled();
 		}
 	}
 }
@@ -292,12 +297,11 @@ bool ODBCStatementImpl::hasNext()
 		if (!nextRowReady())
 		{
 			try { activateNextDataSet(); } 
-			catch (InvalidAccessException&)
+			catch (NoDataException&)
 			{ return false;	}
 
-			try { checkError(SQLMoreResults(_stmt)); } 
-			catch (NoDataException&) 
-			{ return false;	}
+			if (SQL_NO_DATA == SQLMoreResults(_stmt)) 
+				return false;
 
 			addPreparation();
 			doPrepare();
@@ -324,14 +328,20 @@ void ODBCStatementImpl::makeStep()
 
 Poco::UInt32 ODBCStatementImpl::next()
 {
+	std::size_t count = 0;
+
 	if (nextRowReady())
 	{
 		Extractions& extracts = extractions();
 		Extractions::iterator it    = extracts.begin();
 		Extractions::iterator itEnd = extracts.end();
+		std::size_t prevCount = 0;
 		for (std::size_t pos = 0; it != itEnd; ++it)
 		{
-			(*it)->extract(pos);
+			count = (*it)->extract(pos);
+			if (prevCount && count != prevCount)
+				throw IllegalStateException("Different extraction counts");
+			prevCount = count;
 			pos += (*it)->numOfColumnsHandled();
 		}
 		_stepCalled = false;
@@ -342,7 +352,9 @@ Poco::UInt32 ODBCStatementImpl::next()
 			std::string("Iterator Error: trying to access the next value"));
 	}
 
-	return 1u;
+	return static_cast<Poco::UInt32>(count);
+
+	return 0;
 }
 
 
@@ -415,4 +427,15 @@ bool ODBCStatementImpl::isStoredProcedure() const
 }
 
 
+const MetaColumn& ODBCStatementImpl::metaColumn(Poco::UInt32 pos) const
+{
+	std::size_t sz = _columnPtrs.size();
+
+	if (0 == sz || pos > sz - 1)
+		throw InvalidAccessException(format("Invalid column number: %u", pos));
+
+	return *_columnPtrs[pos];
+}
+
+
 } } } // namespace Poco::Data::ODBC
diff --git a/Data/ODBC/src/Preparation.cpp b/Data/ODBC/src/Preparation.cpp
index 375c85ada..b8111bf8b 100644
--- a/Data/ODBC/src/Preparation.cpp
+++ b/Data/ODBC/src/Preparation.cpp
@@ -43,6 +43,9 @@ namespace Data {
 namespace ODBC {
 
 
+const std::size_t Preparation::INVALID_ROW = std::numeric_limits<std::size_t>::max();
+
+
 Preparation::Preparation(const StatementHandle& rStmt, 
 	const std::string& statement, 
 	std::size_t maxFieldSize,
@@ -68,118 +71,73 @@ Preparation::Preparation(const Preparation& other):
 
 Preparation::~Preparation()
 {
-	std::vector<SQLLEN*>::iterator itLen = _pLengths.begin();
-	std::vector<SQLLEN*>::iterator itLenEnd = _pLengths.end();
-	for (; itLen != itLenEnd; ++itLen) delete *itLen;
+	freeMemory();
+}
 
-	std::vector<Poco::Any*>::iterator itVal = _pValues.begin();
-	std::vector<Poco::Any*>::iterator itValEnd = _pValues.end();
-	for (; itVal != itValEnd; ++itVal) delete *itVal;
+
+void Preparation::freeMemory() const
+{
+	IndexMap::iterator it = _varLengthArrays.begin();
+	IndexMap::iterator end = _varLengthArrays.end();
+	for (; it != end; ++it)	
+	{
+		switch (it->second)
+		{
+		case DT_BOOL:
+			deleteCachedArray<bool>(it->first);
+			break;
+		
+		case DT_CHAR:
+			deleteCachedArray<char>(it->first);
+			break;
+
+		case DT_CHAR_ARRAY:
+			std::free(AnyCast<char>(&_values[it->first]));
+			break;
+
+		case DT_DATE:
+			deleteCachedArray<SQL_DATE_STRUCT>(it->first);
+			break;
+
+		case DT_TIME:
+			deleteCachedArray<SQL_TIME_STRUCT>(it->first);
+			break;
+
+		case DT_DATETIME:
+			deleteCachedArray<SQL_TIMESTAMP_STRUCT>(it->first);
+			break;
+		}
+	}
 }
 
 
 std::size_t Preparation::columns() const
 {
-	if (_pValues.empty()) resize();
-	return _pValues.size();
+	if (_values.empty()) resize();
+	return _values.size();
 }
 
 
 void Preparation::resize() const
 {
 	SQLSMALLINT nCol = 0;
-	if (!Utility::isError(SQLNumResultCols(_rStmt, &nCol)) && 
-		0 != nCol)
+	if (!Utility::isError(SQLNumResultCols(_rStmt, &nCol)) && 0 != nCol)
 	{
-		_pValues.resize(nCol, 0);
-		_pLengths.resize(nCol, 0);
-	}
-}
-
-
-Poco::Any& Preparation::operator [] (std::size_t pos)
-{
-	poco_assert (pos >= 0 && pos < _pValues.size());
-	
-	return *_pValues[pos];
-}
-
-
-void Preparation::prepare(std::size_t pos, const Poco::Any&)
-{
-	prepareImpl(pos);
-}
-
-
-void Preparation::prepare(std::size_t pos, const Poco::DynamicAny&)
-{
-	prepareImpl(pos);
-}
-
-
-void Preparation::prepareImpl(std::size_t pos)
-{
-	ODBCColumn col(_rStmt, pos);
-
-	switch (col.type())
-	{
-		case MetaColumn::FDT_INT8:
-			return preparePOD<Poco::Int8>(pos, SQL_C_STINYINT); 
-
-		case MetaColumn::FDT_UINT8:
-			return preparePOD<Poco::UInt8>(pos, SQL_C_UTINYINT);
-
-		case MetaColumn::FDT_INT16:
-			return preparePOD<Poco::Int16>(pos, SQL_C_SSHORT);
-
-		case MetaColumn::FDT_UINT16:
-			return preparePOD<Poco::UInt16>(pos, SQL_C_USHORT);
-
-		case MetaColumn::FDT_INT32:
-			return preparePOD<Poco::Int32>(pos, SQL_C_SLONG);
-
-		case MetaColumn::FDT_UINT32:
-			return preparePOD<Poco::UInt32>(pos, SQL_C_ULONG);
-
-		case MetaColumn::FDT_INT64:
-			return preparePOD<Poco::Int64>(pos, SQL_C_SBIGINT);
-
-		case MetaColumn::FDT_UINT64:
-			return preparePOD<Poco::UInt64>(pos, SQL_C_UBIGINT);
-
-		case MetaColumn::FDT_BOOL:
-			return preparePOD<bool>(pos, SQL_C_BIT);
-
-		case MetaColumn::FDT_FLOAT:
-			return preparePOD<float>(pos, SQL_C_FLOAT);
-
-		case MetaColumn::FDT_DOUBLE:
-			return preparePOD<double>(pos, SQL_C_DOUBLE);
-
-		case MetaColumn::FDT_STRING:
-			return prepareRaw<char>(pos, SQL_C_CHAR, maxDataSize(pos));
-
-		case MetaColumn::FDT_BLOB:
-			return prepareRaw<char>(pos, SQL_C_BINARY, maxDataSize(pos));
-
-		case MetaColumn::FDT_DATE:
-			return prepareRaw<Date>(pos, SQL_C_TYPE_DATE, sizeof(SQL_DATE_STRUCT));
-
-		case MetaColumn::FDT_TIME:
-			return prepareRaw<Time>(pos, SQL_C_TYPE_TIME, sizeof(SQL_TIME_STRUCT));
-
-		case MetaColumn::FDT_TIMESTAMP:
-			return prepareRaw<Time>(pos, SQL_C_TYPE_TIMESTAMP, sizeof(SQL_TIMESTAMP_STRUCT));
-
-		default: 
-			throw DataFormatException("Unsupported data type.");
+		_values.resize(nCol, 0);
+		_lengths.resize(nCol, 0);
+		_lenLengths.resize(nCol);
+		if(_varLengthArrays.size())
+		{
+			freeMemory();
+			_varLengthArrays.clear();
+		}
 	}
 }
 
 
 std::size_t Preparation::maxDataSize(std::size_t pos) const
 {
-	poco_assert (pos >= 0 && pos < _pValues.size());
+	poco_assert_dbg (pos < _values.size());
 
 	std::size_t sz = 0;
 	std::size_t maxsz = getMaxFieldSize();
@@ -195,4 +153,30 @@ std::size_t Preparation::maxDataSize(std::size_t pos) const
 }
 
 
+void Preparation::prepareVariableLenArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length, DataType dt)
+{
+	poco_assert_dbg (DE_BOUND == _dataExtraction);
+	poco_assert_dbg (pos < _values.size());
+	poco_assert_dbg (pos < _lengths.size());
+	poco_assert_dbg (pos < _lenLengths.size());
+
+	char* pArray = (char*) std::calloc(length * size, sizeof(char));
+
+	_values[pos] = Any(pArray);
+	_lengths[pos] = 0;
+	_lenLengths[pos].resize(length);
+	_varLengthArrays.insert(IndexMap::value_type(pos, dt));
+
+	if (Utility::isError(SQLBindCol(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		valueType, 
+		(SQLPOINTER) pArray, 
+		(SQLINTEGER) size, 
+		&_lenLengths[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindCol()");
+	}
+}
+
+
 } } } // namespace Poco::Data::ODBC
diff --git a/Data/ODBC/src/Utility.cpp b/Data/ODBC/src/Utility.cpp
index 4e4f65423..5a3e72c42 100644
--- a/Data/ODBC/src/Utility.cpp
+++ b/Data/ODBC/src/Utility.cpp
@@ -138,6 +138,17 @@ void Utility::dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts)
 }
 
 
+void Utility::dateTimeSync(std::vector<Poco::DateTime>& dt, const std::vector<SQL_TIMESTAMP_STRUCT>& ts)
+{
+	std::size_t size = ts.size();
+	if (dt.size() != size) dt.resize(size);
+	std::vector<Poco::DateTime>::iterator dIt = dt.begin();
+	std::vector<SQL_TIMESTAMP_STRUCT>::const_iterator it = ts.begin();
+	std::vector<SQL_TIMESTAMP_STRUCT>::const_iterator end = ts.end();
+	for (; it != end; ++it, ++dIt) dateTimeSync(*dIt, *it);
+}
+
+
 void Utility::dateSync(SQL_DATE_STRUCT& ds, const Date& d)
 {
 	ds.year = d.year();
@@ -146,6 +157,17 @@ void Utility::dateSync(SQL_DATE_STRUCT& ds, const Date& d)
 }
 
 
+void Utility::dateSync(std::vector<SQL_DATE_STRUCT>& ds, const std::vector<Date>& d)
+{
+	std::size_t size = d.size();
+	if (ds.size() != size) ds.resize(size);
+	std::vector<SQL_DATE_STRUCT>::iterator dIt = ds.begin();
+	std::vector<Date>::const_iterator it = d.begin();
+	std::vector<Date>::const_iterator end = d.end();
+	for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+}
+
+
 void Utility::timeSync(SQL_TIME_STRUCT& ts, const Time& t)
 {
 	ts.hour = t.hour();
@@ -154,6 +176,17 @@ void Utility::timeSync(SQL_TIME_STRUCT& ts, const Time& t)
 }
 
 
+void Utility::timeSync(std::vector<SQL_TIME_STRUCT>& ts, const std::vector<Time>& t)
+{
+	std::size_t size = t.size();
+	if (ts.size() != size) ts.resize(size);
+	std::vector<SQL_TIME_STRUCT>::iterator tIt = ts.begin();
+	std::vector<Time>::const_iterator it = t.begin();
+	std::vector<Time>::const_iterator end = t.end();
+	for (; it != end; ++it, ++tIt) timeSync(*tIt, *it);
+}
+
+
 void Utility::dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt)
 {
 	ts.year = dt.year();
@@ -162,7 +195,42 @@ void Utility::dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt)
 	ts.hour = dt.hour();
 	ts.minute = dt.minute();
 	ts.second = dt.second();
-	ts.fraction = (dt.millisecond() * 1000000) + (dt.microsecond() * 1000);
+	// Fraction support is limited to milliseconds due to MS SQL Server limitation
+	// see http://support.microsoft.com/kb/263872
+	ts.fraction = (dt.millisecond() * 1000000);// + (dt.microsecond() * 1000);
+}
+
+
+void Utility::dateTimeSync(std::vector<SQL_TIMESTAMP_STRUCT>& ts, const std::vector<Poco::DateTime>& dt)
+{
+	std::size_t size = dt.size();
+	if (ts.size() != size) ts.resize(size);
+	std::vector<SQL_TIMESTAMP_STRUCT>::iterator tIt = ts.begin();
+	std::vector<Poco::DateTime>::const_iterator it = dt.begin();
+	std::vector<Poco::DateTime>::const_iterator end = dt.end();
+	for (; it != end; ++it, ++tIt) dateTimeSync(*tIt, *it);
+}
+
+
+void Utility::dateSync(std::vector<Date>& d, const std::vector<SQL_DATE_STRUCT>& ds)
+{
+	std::size_t size = ds.size();
+	if (d.size() != size) d.resize(size);
+	std::vector<Date>::iterator dIt = d.begin();
+	std::vector<SQL_DATE_STRUCT>::const_iterator it = ds.begin();
+	std::vector<SQL_DATE_STRUCT>::const_iterator end = ds.end();
+	for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+}
+
+
+void Utility::timeSync(std::vector<Time>& t, const std::vector<SQL_TIME_STRUCT>& ts)
+{
+	std::size_t size = ts.size();
+	if (t.size() != size) t.resize(size);
+	std::vector<Time>::iterator dIt = t.begin();
+	std::vector<SQL_TIME_STRUCT>::const_iterator it = ts.begin();
+	std::vector<SQL_TIME_STRUCT>::const_iterator end = ts.end();
+	for (; it != end; ++it, ++dIt) timeSync(*dIt, *it);
 }
 
 
diff --git a/Data/ODBC/testsuite/src/ODBCDB2Test.cpp b/Data/ODBC/testsuite/src/ODBCDB2Test.cpp
index 4ccde284b..79ccb3fe7 100644
--- a/Data/ODBC/testsuite/src/ODBCDB2Test.cpp
+++ b/Data/ODBC/testsuite/src/ODBCDB2Test.cpp
@@ -571,7 +571,7 @@ CppUnit::Test* ODBCDB2Test::suite()
 		CppUnit_addTest(pSuite, ODBCDB2Test, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCDB2Test, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCDB2Test, testPrepare);
-		CppUnit_addTest(pSuite, ODBCDB2Test, testStep);
+		CppUnit_addTest(pSuite, ODBCDB2Test, testBulk);
 		CppUnit_addTest(pSuite, ODBCDB2Test, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCDB2Test, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCDB2Test, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp b/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp
index 0eb190c8b..8e540b376 100644
--- a/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp
@@ -391,7 +391,7 @@ CppUnit::Test* ODBCMySQLTest::suite()
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testPrepare);
-		CppUnit_addTest(pSuite, ODBCMySQLTest, testStep);
+		CppUnit_addTest(pSuite, ODBCMySQLTest, testBulk);
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCMySQLTest, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCOracleTest.cpp b/Data/ODBC/testsuite/src/ODBCOracleTest.cpp
index 7681b9d23..d57cab57d 100644
--- a/Data/ODBC/testsuite/src/ODBCOracleTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCOracleTest.cpp
@@ -146,7 +146,7 @@ void ODBCOracleTest::testBarebone()
 		"(First VARCHAR(30),"
 		"Second INTEGER,"
 		"Third NUMBER)";
-/*
+
 	*_pSession << "CREATE OR REPLACE "
 			"PROCEDURE multiResultsProcedure(ret1 OUT SYS_REFCURSOR, "
 			"ret2 OUT SYS_REFCURSOR,"
@@ -185,7 +185,7 @@ void ODBCOracleTest::testBarebone()
 		SQLExecutor::DE_BOUND,
 		MULTI_INSERT,
 		MULTI_SELECT);
-		*/
+
 }
 
 
@@ -224,6 +224,19 @@ void ODBCOracleTest::testBLOB()
 }
 
 
+void ODBCOracleTest::testBulk()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("autoBind", true);
+	_pSession->setFeature("autoExtract", true);
+	recreateMiscTable();
+	_pExecutor->doBulkNoBool(100);
+	recreateMiscTable();
+	_pExecutor->doBulkPerformance(1000);
+}
+
+
 void ODBCOracleTest::testNull()
 {
 	// test for NOT NULL violation exception
@@ -739,6 +752,22 @@ void ODBCOracleTest::recreateNullsTable(const std::string& notNull)
 }
 
 
+void ODBCOracleTest::recreateMiscTable()
+{
+	dropObject("TABLE", "MiscTest");
+	try 
+	{ 
+		session() << "CREATE TABLE MiscTest "
+			"(First VARCHAR(30),"
+			"Second BLOB,"
+			"Third INTEGER,"
+			"Fourth NUMBER,"
+			"Fifth TIMESTAMP)", now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail ("recreateMiscTable()"); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail ("recreateMiscTable()"); }
+}
+
+
 CppUnit::Test* ODBCOracleTest::suite()
 {
 	if (_pSession = init(_driver, _dsn, _uid, _pwd, _connectString))
@@ -771,7 +800,7 @@ CppUnit::Test* ODBCOracleTest::suite()
 		CppUnit_addTest(pSuite, ODBCOracleTest, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCOracleTest, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCOracleTest, testPrepare);
-		CppUnit_addTest(pSuite, ODBCOracleTest, testStep);
+		CppUnit_addTest(pSuite, ODBCOracleTest, testBulk);
 		CppUnit_addTest(pSuite, ODBCOracleTest, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCOracleTest, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCOracleTest, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCOracleTest.h b/Data/ODBC/testsuite/src/ODBCOracleTest.h
index db0947aa0..b828e280a 100644
--- a/Data/ODBC/testsuite/src/ODBCOracleTest.h
+++ b/Data/ODBC/testsuite/src/ODBCOracleTest.h
@@ -56,7 +56,8 @@ public:
 	void testBareboneODBC();
 
 	void testBLOB();
-	
+	void testBulk();
+
 	void testMultipleResults();
 
 	void testStoredProcedure();
@@ -84,6 +85,7 @@ private:
 	void recreateVectorsTable();
 	void recreateAnysTable();
 	void recreateNullsTable(const std::string& notNull = "");
+	void recreateMiscTable();
 
 	static ODBCTest::SessionPtr  _pSession;
 	static ODBCTest::ExecPtr     _pExecutor;
diff --git a/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.cpp b/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.cpp
index 29322893a..bf073727f 100644
--- a/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.cpp
@@ -346,6 +346,19 @@ void ODBCPostgreSQLTest::testStoredFunctionDynamicAny()
 }
 
 
+void ODBCPostgreSQLTest::testBulk()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("autoBind", true);
+	_pSession->setFeature("autoExtract", true);
+	recreateMiscTable();
+	_pExecutor->doBulkStringIntFloat(100);
+	recreateMiscTable();
+	_pExecutor->doBulkPerformance(1000);
+}
+
+
 void ODBCPostgreSQLTest::configurePLPgSQL()
 {
 	try
@@ -518,6 +531,24 @@ void ODBCPostgreSQLTest::recreateBoolTable()
 }
 
 
+void ODBCPostgreSQLTest::recreateMiscTable()
+{
+	dropObject("TABLE", "MiscTest");
+	try 
+	{ 
+		// pgSQL fails with BLOB bulk operations
+		// Mammoth does not bind columns properly
+		session() << "CREATE TABLE MiscTest "
+			"(First VARCHAR(30),"
+			//"Second BYTEA,"
+			"Third INTEGER,"
+			"Fourth FLOAT,"
+			"Fifth TIMESTAMP)", now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail ("recreateMiscTable()"); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail ("recreateMiscTable()"); }
+}
+
+
 CppUnit::Test* ODBCPostgreSQLTest::suite()
 {
 	if (_pSession = init(_driver, _dsn, _uid, _pwd, _connectString))
@@ -550,7 +581,7 @@ CppUnit::Test* ODBCPostgreSQLTest::suite()
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testPrepare);
-		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testStep);
+		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testBulk);
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCPostgreSQLTest, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.h b/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.h
index e39bce601..29ad241fb 100644
--- a/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.h
+++ b/Data/ODBC/testsuite/src/ODBCPostgreSQLTest.h
@@ -64,6 +64,7 @@ public:
 	void testBareboneODBC();
 
 	void testBLOB();
+	void testBulk();
 
 	void testStoredFunction();
 	void testStoredFunctionAny();
@@ -86,7 +87,8 @@ private:
 	void recreateAnysTable();
 	void recreateNullsTable(const std::string& notNull="");
 	void recreateBoolTable();
-	
+	void recreateMiscTable();
+
 	void configurePLPgSQL();
 		/// Configures PL/pgSQL in the database. A reasonable defaults
 		/// for the interpreter location on WIN32 and POSIX platforms are 
diff --git a/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp b/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp
index 45979084f..e0aec58f7 100644
--- a/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp
@@ -112,9 +112,8 @@ void ODBCSQLServerTest::testBareboneODBC()
 		"Fifth FLOAT,"
 		"Sixth DATETIME)";
 
-	//TODO: auto binding fails at SQLExecute() ("String data, right truncated")
-	//executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_IMMEDIATE, SQLExecutor::DE_MANUAL);
-	//executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_IMMEDIATE, SQLExecutor::DE_BOUND);
+	executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_IMMEDIATE, SQLExecutor::DE_MANUAL);
+	executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_IMMEDIATE, SQLExecutor::DE_BOUND);
 	executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_AT_EXEC, SQLExecutor::DE_MANUAL);
 	executor().bareboneODBCTest(dbConnString(), tableCreateString, SQLExecutor::PB_AT_EXEC, SQLExecutor::DE_BOUND);
 
@@ -611,6 +610,23 @@ void ODBCSQLServerTest::recreateBoolTable()
 }
 
 
+void ODBCSQLServerTest::recreateMiscTable()
+{
+	dropObject("TABLE", "MiscTest");
+	try 
+	{ 
+		session() << "CREATE TABLE MiscTest "
+			"(First VARCHAR(30),"
+			"Second VARBINARY(30),"
+			"Third INTEGER,"
+			"Fourth FLOAT,"
+			"Fifth DATETIME,"
+			"Sixth BIT)", now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail ("recreateMiscTable()"); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail ("recreateMiscTable()"); }
+}
+
+
 CppUnit::Test* ODBCSQLServerTest::suite()
 {
 	if (_pSession = init(_driver, _dsn, _uid, _pwd, _connectString, _db))
@@ -643,7 +659,7 @@ CppUnit::Test* ODBCSQLServerTest::suite()
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testPrepare);
-		CppUnit_addTest(pSuite, ODBCSQLServerTest, testStep);
+		CppUnit_addTest(pSuite, ODBCSQLServerTest, testBulk);
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCSQLServerTest, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCSQLServerTest.h b/Data/ODBC/testsuite/src/ODBCSQLServerTest.h
index 7bd36e7b3..e388a502d 100644
--- a/Data/ODBC/testsuite/src/ODBCSQLServerTest.h
+++ b/Data/ODBC/testsuite/src/ODBCSQLServerTest.h
@@ -89,6 +89,7 @@ private:
 	void recreateAnysTable();
 	void recreateNullsTable(const std::string& notNull = "");
 	void recreateBoolTable();
+	void recreateMiscTable();
 
 	static SessionPtr  _pSession;
 	static ExecPtr     _pExecutor;
diff --git a/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp b/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp
index 2ae604d77..4a7b5b6b2 100644
--- a/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp
@@ -141,6 +141,19 @@ void ODBCSQLiteTest::testNull()
 }
 
 
+void ODBCSQLiteTest::testBulk()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("autoBind", true);
+	_pSession->setFeature("autoExtract", true);
+	recreateMiscTable();
+	_pExecutor->doBulkStringIntFloat(100);
+	recreateMiscTable();
+	_pExecutor->doBulkPerformance(1000);
+}
+
+
 void ODBCSQLiteTest::dropObject(const std::string& type, const std::string& name)
 {
 	try
@@ -262,6 +275,23 @@ void ODBCSQLiteTest::recreateNullsTable(const std::string& notNull)
 }
 
 
+void ODBCSQLiteTest::recreateMiscTable()
+{
+	dropObject("TABLE", "MiscTest");
+	try 
+	{ 
+		// SQLite fails with BLOB bulk operations
+		session() << "CREATE TABLE MiscTest "
+			"(First VARCHAR(30),"
+			//"Second BLOB,"
+			"Third INTEGER,"
+			"Fourth REAL,"
+			"Fifth DATETIME)", now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail ("recreateMiscTable()"); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail ("recreateMiscTable()"); }
+}
+
+
 CppUnit::Test* ODBCSQLiteTest::suite()
 {
 	if (_pSession = init(_driver, _dsn, _uid, _pwd, _connectString))
@@ -294,7 +324,7 @@ CppUnit::Test* ODBCSQLiteTest::suite()
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testLimitPrepare);
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testLimitZero);
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testPrepare);
-		CppUnit_addTest(pSuite, ODBCSQLiteTest, testStep);
+		CppUnit_addTest(pSuite, ODBCSQLiteTest, testBulk);
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testSetSimple);
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testSetComplex);
 		CppUnit_addTest(pSuite, ODBCSQLiteTest, testSetComplexUnique);
diff --git a/Data/ODBC/testsuite/src/ODBCSQLiteTest.h b/Data/ODBC/testsuite/src/ODBCSQLiteTest.h
index f052aa0c6..6bf10027a 100644
--- a/Data/ODBC/testsuite/src/ODBCSQLiteTest.h
+++ b/Data/ODBC/testsuite/src/ODBCSQLiteTest.h
@@ -54,6 +54,7 @@ public:
 
 	void testBareboneODBC();
 	void testNull();
+	void testBulk();
 
 	static CppUnit::Test* suite();
 
@@ -69,14 +70,15 @@ private:
 	void recreateVectorsTable();
 	void recreateAnysTable();
 	void recreateNullsTable(const std::string& notNull = "");
+	void recreateMiscTable();
 
-	static ODBCTest::SessionPtr  _pSession;
-	static ODBCTest::ExecPtr     _pExecutor;
-	static std::string _driver;
-	static std::string _dsn;
-	static std::string _uid;
-	static std::string _pwd;
-	static std::string _connectString;
+	static ODBCTest::SessionPtr _pSession;
+	static ODBCTest::ExecPtr    _pExecutor;
+	static std::string          _driver;
+	static std::string          _dsn;
+	static std::string          _uid;
+	static std::string          _pwd;
+	static std::string          _connectString;
 };
 
 
diff --git a/Data/ODBC/testsuite/src/ODBCTest.cpp b/Data/ODBC/testsuite/src/ODBCTest.cpp
index 32f978396..a55f1f0e9 100644
--- a/Data/ODBC/testsuite/src/ODBCTest.cpp
+++ b/Data/ODBC/testsuite/src/ODBCTest.cpp
@@ -407,27 +407,16 @@ void ODBCTest::testPrepare()
 }
 
 
-void ODBCTest::testStep()
+void ODBCTest::testBulk()
 {
 	if (!_pSession) fail ("Test not available.");
 
-	for (int i = 0; i < 8;)
-	{
-		recreateIntsTable();
-		_pSession->setFeature("autoBind", bindValue(i));
-		_pSession->setFeature("autoExtract", bindValue(i+1));
-		std::string mode = bindValue(i+1) ? "auto" : "manual";
-		std::cout << "Extraction: " << mode << std::endl;
-		_pExecutor->doStep(1000, 1);
-		recreateIntsTable();
-		_pExecutor->doStep(1000, 10);
-		recreateIntsTable();
-		_pExecutor->doStep(1000, 100);
-		recreateIntsTable();
-		_pExecutor->doStep(1000, 1000);
-
-		i += 2;
-	}
+	_pSession->setFeature("autoBind", true);
+	_pSession->setFeature("autoExtract", true);
+	recreateMiscTable();
+	_pExecutor->doBulk(100);
+	recreateMiscTable();
+	_pExecutor->doBulkPerformance(1000);
 }
 
 
diff --git a/Data/ODBC/testsuite/src/ODBCTest.h b/Data/ODBC/testsuite/src/ODBCTest.h
index bdf3c81e9..e08fcd8fc 100644
--- a/Data/ODBC/testsuite/src/ODBCTest.h
+++ b/Data/ODBC/testsuite/src/ODBCTest.h
@@ -91,7 +91,7 @@ public:
 	virtual void testLimitPrepare();
 	virtual void testLimitZero();
 	virtual void testPrepare();
-	virtual void testStep();
+	virtual void testBulk();
 
 	virtual void testSetSimple();
 	virtual void testSetComplex();
@@ -165,6 +165,7 @@ protected:
 	virtual void recreateAnysTable() { /* no-op */ };
 	virtual void recreateNullsTable(const std::string& notNull="") { /* no-op */ };
 	virtual void recreateBoolTable() { /* no-op */ };
+	virtual void recreateMiscTable() { /* no-op */ };
 
 	static SessionPtr init(const std::string& driver,
 		std::string& dsn,
@@ -182,8 +183,8 @@ protected:
 
 	bool bindValue(int i);
 
-	Poco::Data::Session&           session();
-	SQLExecutor&                   executor();
+	Poco::Data::Session& session();
+	SQLExecutor& executor();
 
 	const std::string& dsn();
 	const std::string& uid();
diff --git a/Data/ODBC/testsuite/src/SQLExecutor.cpp b/Data/ODBC/testsuite/src/SQLExecutor.cpp
index 94be31b27..59d1550d5 100644
--- a/Data/ODBC/testsuite/src/SQLExecutor.cpp
+++ b/Data/ODBC/testsuite/src/SQLExecutor.cpp
@@ -39,6 +39,7 @@
 #include "Poco/DynamicAny.h"
 #include "Poco/DateTime.h"
 #include "Poco/Stopwatch.h"
+#include "Poco/NumberFormatter.h"
 #include "Poco/Exception.h"
 #include "Poco/Data/Date.h"
 #include "Poco/Data/Time.h"
@@ -46,6 +47,8 @@
 #include "Poco/Data/StatementImpl.h"
 #include "Poco/Data/RecordSet.h"
 #include "Poco/Data/RowIterator.h"
+#include "Poco/Data/BulkExtraction.h"
+#include "Poco/Data/BulkBinding.h"
 #include "Poco/Data/ODBC/Connector.h"
 #include "Poco/Data/ODBC/Utility.h"
 #include "Poco/Data/ODBC/Diagnostics.h"
@@ -72,8 +75,10 @@ using Poco::AnyCast;
 using Poco::DynamicAny;
 using Poco::DateTime;
 using Poco::Stopwatch;
+using Poco::NumberFormatter;
 using Poco::NotFoundException;
 using Poco::InvalidAccessException;
+using Poco::InvalidArgumentException;
 using Poco::BadCastException;
 using Poco::RangeException;
 
@@ -107,7 +112,7 @@ struct Person
 	const std::string& operator () () const
 		/// This method is required so we can extract data to a map!
 	{
-		// we choose the lastName as examplary key
+		// we choose the lastName as the key
 		return lastName;
 	}
 };
@@ -134,7 +139,7 @@ public:
 		pBinder->bind(pos++, obj.age, dir);
 	}
 
-	static void prepare(std::size_t pos, const Person& obj, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, Person& obj, AbstractPreparation* pPrepare)
 	{
 		// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
 		poco_assert_dbg (pPrepare != 0);
@@ -163,8 +168,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -294,48 +297,49 @@ void SQLExecutor::bareboneODBCTest(const std::string& dbConnString,
 			sixth.hour = 5;
 			sixth.minute = 34;
 			sixth.second = 59;
-			//some DBMS do not support this (e.g. MS SQL Server), hence 0
-			sixth.fraction = 0;
+			// Fraction support is limited to milliseconds due to MS SQL Server limitation
+			// see http://support.microsoft.com/kb/263872
+			sixth.fraction = 997000000;
 
-			SQLLEN li = SQL_NTS;
+			SQLLEN li[3] = { SQL_NTS, SQL_NTS, 0 };
 			SQLINTEGER size = (SQLINTEGER) str[0].size();
 
 			if (SQLExecutor::PB_AT_EXEC == bindMode)
-				li = SQL_LEN_DATA_AT_EXEC(size);
+				li[0] = SQL_LEN_DATA_AT_EXEC(size);
 
 			rc = SQLBindParameter(hstmt, 
 				(SQLUSMALLINT) 1, 
 				SQL_PARAM_INPUT, 
 				SQL_C_CHAR, 
-				SQL_VARCHAR, 
+				SQL_LONGVARCHAR, 
 				(SQLUINTEGER) size,
 				0,
 				(SQLPOINTER) str[0].c_str(), 
 				size, 
-				&li);
+				&li[0]);
 			poco_odbc_check_stmt (rc, hstmt);
 
 			size = (SQLINTEGER) str[1].size();
 			if (SQLExecutor::PB_AT_EXEC == bindMode)
-				li = SQL_LEN_DATA_AT_EXEC(size);
-			else li = SQL_NTS;
+				li[1] = SQL_LEN_DATA_AT_EXEC(size);
+			else li[1] = SQL_NTS;
 
 			rc = SQLBindParameter(hstmt, 
 				(SQLUSMALLINT) 2, 
 				SQL_PARAM_INPUT, 
 				SQL_C_CHAR, 
-				SQL_VARCHAR, 
+				SQL_LONGVARCHAR, 
 				(SQLUINTEGER) size,
 				0,
 				(SQLPOINTER) str[1].c_str(), 
 				size, 
-				&li);
+				&li[1]);
 			poco_odbc_check_stmt (rc, hstmt);
 
 			size = (SQLINTEGER) str[2].size();
 			if (SQLExecutor::PB_AT_EXEC == bindMode)
-				li = SQL_LEN_DATA_AT_EXEC(size);
-			else li = size;
+				li[2] = SQL_LEN_DATA_AT_EXEC(size);
+			else li[2] = size;
 
 			rc = SQLBindParameter(hstmt, 
 				(SQLUSMALLINT) 3, 
@@ -346,7 +350,7 @@ void SQLExecutor::bareboneODBCTest(const std::string& dbConnString,
 				0,
 				(SQLPOINTER) str[2].data(), 
 				size, 
-				&li);
+				&li[2]);
 			poco_odbc_check_stmt (rc, hstmt);
 
 			rc = SQLBindParameter(hstmt, 
@@ -584,6 +588,7 @@ void SQLExecutor::bareboneODBCTest(const std::string& dbConnString,
 				assert (5 == sixth.hour);
 				assert (34 == sixth.minute);
 				assert (59 == sixth.second);
+				assert (997000000 == sixth.fraction);
 			}
 
 			rc = SQLCloseCursor(hstmt);
@@ -830,23 +835,22 @@ void SQLExecutor::simpleAccess()
 	int count = 0;
 	std::string result;
 
-	count = 0;
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(age), now;  }
-	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
-	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now;  }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(age), now;  }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
+	count = 0;
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now;  }
+	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
-	try { *_pSession << "SELECT LastName FROM PERSON", into(result), now;  }
+	try { session() << "SELECT LastName FROM PERSON", into(result), now;  }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (lastName == result);
 
-	try { *_pSession << "SELECT Age FROM PERSON", into(count), now;  }
+	try { session() << "SELECT Age FROM PERSON", into(count), now;  }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == age);
@@ -859,22 +863,22 @@ void SQLExecutor::complexType()
 	Person p1("LN1", "FN1", "ADDR1", 1);
 	Person p2("LN2", "FN2", "ADDR2", 2);
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(p1), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(p1), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(p2), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(p2), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	Person c1;
-	try { *_pSession << "SELECT * FROM PERSON WHERE LastName = 'LN1'", into(c1), now; }
+	try { session() << "SELECT * FROM PERSON WHERE LastName = 'LN1'", into(c1), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (c1 == p1);
@@ -900,11 +904,11 @@ void SQLExecutor::simpleAccessVector()
 	int count = 0;
 	std::string result;
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
@@ -913,7 +917,7 @@ void SQLExecutor::simpleAccessVector()
 	std::vector<std::string> firstNamesR;
 	std::vector<std::string> addressesR;
 	std::vector<int> agesR;
-	try { *_pSession << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
+	try { session() << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ages == agesR);
@@ -930,18 +934,18 @@ void SQLExecutor::complexTypeVector()
 	people.push_back(Person("LN1", "FN1", "ADDR1", 1));
 	people.push_back(Person("LN2", "FN2", "ADDR2", 2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	std::vector<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == people);
@@ -959,8 +963,8 @@ void SQLExecutor::insertVector()
 	int count = 100;
 
 	{
-		Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(str)));
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(str)));
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 0);
@@ -968,13 +972,13 @@ void SQLExecutor::insertVector()
 		try { stmt.execute(); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 4);
 	}
 	count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 4);
@@ -988,7 +992,7 @@ void SQLExecutor::insertEmptyVector()
 
 	try
 	{
-		*_pSession << "INSERT INTO Strings VALUES (?)", use(str), now;
+		session() << "INSERT INTO Strings VALUES (?)", use(str), now;
 		fail("empty collections should not work");
 	}
 	catch (Poco::Exception&)
@@ -1016,11 +1020,11 @@ void SQLExecutor::simpleAccessList()
 	int count = 0;
 	std::string result;
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
@@ -1029,7 +1033,7 @@ void SQLExecutor::simpleAccessList()
 	std::list<std::string> firstNamesR;
 	std::list<std::string> addressesR;
 	std::list<int> agesR;
-	try { *_pSession << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
+	try { session() << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ages == agesR);
@@ -1046,18 +1050,18 @@ void SQLExecutor::complexTypeList()
 	people.push_back(Person("LN1", "FN1", "ADDR1", 1));
 	people.push_back(Person("LN2", "FN2", "ADDR2", 2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	std::list<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == people);
@@ -1075,8 +1079,8 @@ void SQLExecutor::insertList()
 	int count = 100;
 
 	{
-		Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(str)));
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(str)));
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 0);
@@ -1084,13 +1088,13 @@ void SQLExecutor::insertList()
 		try { stmt.execute(); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 4);
 	}
 	count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 4);
@@ -1104,7 +1108,7 @@ void SQLExecutor::insertEmptyList()
 
 	try
 	{
-		*_pSession << "INSERT INTO Strings VALUES (?)", use(str), now;
+		session() << "INSERT INTO Strings VALUES (?)", use(str), now;
 		fail("empty collections should not work");
 	}
 	catch (Poco::Exception&)
@@ -1132,11 +1136,11 @@ void SQLExecutor::simpleAccessDeque()
 	int count = 0;
 	std::string result;
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
@@ -1145,7 +1149,7 @@ void SQLExecutor::simpleAccessDeque()
 	std::deque<std::string> firstNamesR;
 	std::deque<std::string> addressesR;
 	std::deque<int> agesR;
-	try { *_pSession << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
+	try { session() << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ages == agesR);
@@ -1162,18 +1166,18 @@ void SQLExecutor::complexTypeDeque()
 	people.push_back(Person("LN1", "FN1", "ADDR1", 1));
 	people.push_back(Person("LN2", "FN2", "ADDR2", 2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	std::deque<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == people);
@@ -1191,8 +1195,8 @@ void SQLExecutor::insertDeque()
 	int count = 100;
 
 	{
-		Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(str)));
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(str)));
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 0);
@@ -1200,13 +1204,13 @@ void SQLExecutor::insertDeque()
 		try { stmt.execute(); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-		try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+		try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 		catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 		catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 		assert (count == 4);
 	}
 	count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 4);
@@ -1220,7 +1224,7 @@ void SQLExecutor::insertEmptyDeque()
 
 	try
 	{
-		*_pSession << "INSERT INTO Strings VALUES (?)", use(str), now;
+		session() << "INSERT INTO Strings VALUES (?)", use(str), now;
 		fail("empty collections should not work");
 	}
 	catch (Poco::Exception&)
@@ -1233,7 +1237,7 @@ void SQLExecutor::insertSingleBulk()
 {
 	std::string funct = "insertSingleBulk()";
 	int x = 0;
-	Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(x)));
+	Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(x)));
 
 	for (x = 0; x < 100; ++x)
 	{
@@ -1241,12 +1245,12 @@ void SQLExecutor::insertSingleBulk()
 		assert (i == 0);
 	}
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 100);
 
-	try { *_pSession << "SELECT SUM(str) FROM Strings", into(count), now; }
+	try { session() << "SELECT SUM(str) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == ((0+99)*100/2));
@@ -1259,17 +1263,17 @@ void SQLExecutor::floats()
 	float data = 1.5f;
 	float ret = 0.0f;
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
-	try { *_pSession << "SELECT str FROM Strings", into(ret), now; }
+	try { session() << "SELECT str FROM Strings", into(ret), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ret == data);
@@ -1282,17 +1286,17 @@ void SQLExecutor::doubles()
 	double data = 1.5;
 	double ret = 0.0;
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
-	try { *_pSession << "SELECT str FROM Strings", into(ret), now; }
+	try { session() << "SELECT str FROM Strings", into(ret), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ret == data);
@@ -1307,16 +1311,16 @@ void SQLExecutor::insertSingleBulkVec()
 	for (int x = 0; x < 100; ++x)
 		data.push_back(x);
 
-	Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(data)));
+	Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(data)));
 	stmt.execute();
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	assert (count == 100);
-	try { *_pSession << "SELECT SUM(str) FROM Strings", into(count), now; }
+	try { session() << "SELECT SUM(str) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == ((0+99)*100/2));
@@ -1332,12 +1336,12 @@ void SQLExecutor::limits()
 		data.push_back(x);
 	}
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	std::vector<int> retData;
-	try { *_pSession << "SELECT * FROM Strings", into(retData), limit(50), now; }
+	try { session() << "SELECT * FROM Strings", into(retData), limit(50), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (retData.size() == 50);
@@ -1357,12 +1361,12 @@ void SQLExecutor::limitZero()
 		data.push_back(x);
 	}
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	std::vector<int> retData;
-	try { *_pSession << "SELECT * FROM Strings", into(retData), limit(0), now; }// stupid test, but at least we shouldn't crash
+	try { session() << "SELECT * FROM Strings", into(retData), limit(0), now; }// stupid test, but at least we shouldn't crash
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (retData.size() == 0);
@@ -1378,12 +1382,12 @@ void SQLExecutor::limitOnce()
 		data.push_back(x);
 	}
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	std::vector<int> retData;
-	Statement stmt = (*_pSession << "SELECT * FROM Strings", into(retData), limit(50), now);
+	Statement stmt = (session() << "SELECT * FROM Strings", into(retData), limit(50), now);
 	assert (!stmt.done());
 	assert (retData.size() == 50);
 	stmt.execute();
@@ -1409,12 +1413,12 @@ void SQLExecutor::limitPrepare()
 		data.push_back(x);
 	}
 
-	try { *_pSession << "INSERT INTO Strings VALUES (?)", use(data), now; }
+	try { session() << "INSERT INTO Strings VALUES (?)", use(data), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	std::vector<int> retData;
-	Statement stmt = (*_pSession << "SELECT * FROM Strings", into(retData), limit(50));
+	Statement stmt = (session() << "SELECT * FROM Strings", into(retData), limit(50));
 	assert (retData.size() == 0);
 	assert (!stmt.done());
 
@@ -1450,38 +1454,470 @@ void SQLExecutor::prepare()
 	}
 
 	{
-		Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(data)));
+		Statement stmt((session() << "INSERT INTO Strings VALUES (?)", use(data)));
 	}
 	// stmt should not have been executed when destroyed
 	int count = 100;
-	try { *_pSession << "SELECT COUNT(*) FROM Strings", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Strings", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 0);
 }
 
 
-void SQLExecutor::doStep(Poco::UInt32 dataSize, Poco::UInt32 stepSize)
+void SQLExecutor::doBulk(Poco::UInt32 size)
 {
-	std::string funct = "step()";
-	std::vector<int> data(dataSize, 1);
+	std::string funct = "doBulk()";
+	std::vector<int> ints(size, 1);
+	std::vector<std::string> strings(size);
+	std::vector<BLOB> blobs(size);
+	std::vector<double> floats(size);
+	std::vector<DateTime> dateTimes(size);
+	std::vector<bool> bools;
 	
-	Statement stmt((*_pSession << "INSERT INTO Strings VALUES (?)", use(data)));
-	stmt.execute();
+	for (int i = 0; i < size; ++i)
+	{
+		ints[i] = i;
+		strings[i] = "xyz" + NumberFormatter::format(i);
+		blobs[i] = "abc" + NumberFormatter::format(i);
+		floats[i] = i + .5;
+		bools.push_back(0 == i % 2);
+	}
 
-	data.clear();
-	assert (0 == data.size());
-	Stopwatch sw;
-	sw.start();
-	try { *_pSession << "SELECT * FROM Strings", into(data), step(stepSize), now; }
+	try 
+	{
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?,?,?)", 
+			use(strings), 
+			use(blobs), 
+			use(ints),
+			use(floats),
+			use(dateTimes),
+			use(bools), now;
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try { session() << "DELETE FROM MiscTest", now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	sw.stop();
 
-	std::cout << stepSize << '/' << sw.elapsed() / 1000.0 << " [ms]" << std::endl;
+	try 
+	{
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?,?,?)", 
+			use(strings, bulk), 
+			use(blobs, bulk), 
+			use(ints, bulk),
+			use(floats, bulk),
+			use(dateTimes, bulk),
+			use(bools, bulk), now;
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	ints.clear();
+	strings.clear();
+	blobs.clear();
+	floats.clear();
+	dateTimes.clear();
+	bools.clear();
+	
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest ORDER BY Third", 
+			into(strings), 
+			into(blobs), 
+			into(ints), 
+			into(floats),
+			into(dateTimes),
+			into(bools),
+			now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	std::string number = NumberFormatter::format(size - 1);
+	assert (size == ints.size());
+	assert (0 == ints[0]);
+	assert (ints.size() - 1 == ints[ints.size() - 1]);
+	assert (std::string("xyz0") == strings[0]);
+	assert (std::string("xyz") + number == strings[strings.size()-1]);
+	assert (BLOB("abc0") == blobs[0]);
+	BLOB blob("abc");
+	blob.appendRaw(number.c_str(), number.size());
+	assert (blob == blobs[blobs.size()-1]);
+	assert (.5 == floats[0]);
+	assert (floats.size() - 1 + .5 == floats[floats.size() - 1]);
+	assert (bools[0]);
+	assert (!bools[1]);
+	assert (bools[2]);
+	assert (!bools[3]);
 
-	assert (dataSize == data.size());
-	assert (1 == data[data.size()-1]);
+	ints.clear();
+
+	try 
+	{ 
+		session() << "SELECT First FROM MiscTest", into(ints, bulk(size)), limit(size+1), now; 
+		fail ("must fail");
+	}
+	catch(InvalidArgumentException&){ }
+
+	try 
+	{ 
+		session() << "SELECT First FROM MiscTest", into(ints), bulk(size), now; 
+		fail ("must fail");
+	}
+	catch(InvalidAccessException&){ }
+
+	ints.clear();
+	strings.clear();
+	blobs.clear();
+	floats.clear();
+	dateTimes.clear();
+	bools.clear();
+	
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest ORDER BY Third", 
+			bulk(size),
+			into(strings),
+			into(blobs),
+			into(ints),
+			into(floats),
+			into(dateTimes),
+			into(bools),
+			now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	assert (size == ints.size());
+	assert (0 == ints[0]);
+	assert (ints.size() - 1 == ints[ints.size()-1]);
+	assert (std::string("xyz0") == strings[0]);
+	assert (std::string("xyz") + number == strings[strings.size()-1]);
+	assert (BLOB("abc0") == blobs[0]);
+	blob.assignRaw("abc", 3);
+	blob.appendRaw(number.c_str(), number.size());
+	assert (blob == blobs[blobs.size()-1]);
+	assert (.5 == floats[0]);
+	assert (floats.size() - 1 + .5 == floats[floats.size() - 1]);
+	assert (bools[0]);
+	assert (!bools[1]);
+	assert (bools[2]);
+	assert (!bools[3]);
+}
+
+
+void SQLExecutor::doBulkPerformance(Poco::UInt32 size)
+{
+	std::string funct = "doBulk()";
+	std::vector<int> ints(size, 1);
+	std::vector<std::string> strings(size, "abc");
+	std::vector<double> floats(size, .5);
+	std::vector<DateTime> dateTimes(size);
+	
+	Stopwatch sw;
+	try 
+	{
+		sw.start();
+		session() << "INSERT INTO MiscTest (First, Third, Fourth, Fifth) VALUES (?,?,?,?)", 
+			use(strings), 
+			use(ints),
+			use(floats),
+			use(dateTimes), now;
+		sw.stop();
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	double time = sw.elapsed() / 1000.0;
+
+	try { session() << "DELETE FROM MiscTest", now; }
+	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try 
+	{
+		sw.restart();
+		session() << "INSERT INTO MiscTest (First, Third, Fourth, Fifth) VALUES (?,?,?,?)", 
+			use(strings, bulk), 
+			use(ints, bulk),
+			use(floats, bulk),
+			use(dateTimes, bulk), now;
+		sw.stop();
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	double bulkTime = sw.elapsed() / 1000.0;
+
+	double speedup;
+	if (0.0 == bulkTime)
+	{
+		if (0.0 == time) speedup = 1.0;
+		else speedup = time;
+	}
+	else
+		speedup = time / bulkTime;
+
+	std::cout << "INSERT => Size:" << size 
+		<< ", Time: " << time 
+		<< ", Bulk Time: " << bulkTime 
+		<< " [ms], Speedup: " << speedup 
+		<< 'x' << std::endl;
+
+	ints.clear();
+	strings.clear();
+	floats.clear();
+	dateTimes.clear();
+
+	try 
+	{ 
+		sw.restart();
+		session() << "SELECT First, Third, Fourth, Fifth FROM MiscTest", 
+			into(strings), 
+			into(ints), 
+			into(floats),
+			into(dateTimes),
+			now; 
+		sw.stop();
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	time = sw.elapsed() / 1000.0;
+
+	assert (ints.size() == size);
+
+	ints.clear();
+	strings.clear();
+	floats.clear();
+	dateTimes.clear();
+	
+	try 
+	{ 
+		sw.restart();
+		session() << "SELECT First, Third, Fourth, Fifth FROM MiscTest", 
+			bulk(size),
+			into(strings),
+			into(ints),
+			into(floats),
+			into(dateTimes),
+			now; 
+		sw.stop();
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	bulkTime = sw.elapsed() / 1000.0;
+
+	assert (ints.size() == size);
+
+	if (0.0 == bulkTime)
+	{
+		if (0.0 == time) speedup = 1.0;
+		else speedup = time;
+	}
+	else
+		speedup = time / bulkTime;
+
+	std::cout << "SELECT => Size:" << size 
+		<< ", Time: " << time 
+		<< ", Bulk Time: " << bulkTime 
+		<< " [ms], Speedup: " << speedup 
+		<< 'x' << std::endl;
+}
+
+
+void SQLExecutor::doBulkNoBool(Poco::UInt32 size)
+{
+	std::string funct = "doBulk()";
+	std::vector<int> ints(size, 1);
+	std::vector<std::string> strings(size);
+	std::vector<BLOB> blobs(size);
+	std::vector<double> floats(size);
+	std::vector<DateTime> dateTimes(size);
+	
+	for (int i = 0; i < size; ++i)
+	{
+		ints[i] = i;
+		strings[i] = "xyz" + NumberFormatter::format(i);
+		blobs[i] = "abc" + NumberFormatter::format(i);
+		floats[i] = i + .5;
+	}
+
+	try 
+	{
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?,?)", 
+			use(strings), 
+			use(blobs), 
+			use(ints),
+			use(floats),
+			use(dateTimes), now;
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try { session() << "DELETE FROM MiscTest", now; }
+	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try 
+	{
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?,?)", 
+			use(strings, bulk), 
+			use(blobs, bulk), 
+			use(ints, bulk),
+			use(floats, bulk),
+			use(dateTimes, bulk), now;
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	ints.clear();
+	strings.clear();
+	blobs.clear();
+	floats.clear();
+	
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest ORDER BY First", 
+			into(strings), 
+			into(blobs), 
+			into(ints), 
+			into(floats),
+			into(dateTimes),
+			now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	std::string number = NumberFormatter::format(size - 1);
+	assert (size == ints.size());
+	assert (0 == ints[0]);
+	assert (ints.size() - 1 == ints[ints.size() - 1]);
+	assert (std::string("xyz0") == strings[0]);
+	assert (std::string("xyz") + number == strings[strings.size()-1]);
+	assert (BLOB("abc0") == blobs[0]);
+	BLOB blob("abc");
+	blob.appendRaw(number.c_str(), number.size());
+	assert (blob == blobs[blobs.size()-1]);
+	assert (.5 == floats[0]);
+	assert (floats.size() - 1 + .5 == floats[floats.size() - 1]);
+
+	ints.clear();
+
+	try 
+	{ 
+		session() << "SELECT First FROM MiscTest", into(ints, bulk(size)), limit(size+1), now; 
+		fail ("must fail");
+	}
+	catch(InvalidArgumentException&){ }
+
+	try 
+	{ 
+		session() << "SELECT First FROM MiscTest", into(ints), bulk(size), now; 
+		fail ("must fail");
+	}
+	catch(InvalidAccessException&){ }
+
+	ints.clear();
+	strings.clear();
+	blobs.clear();
+	floats.clear();
+	
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest ORDER BY First", 
+			bulk(size),
+			into(strings),
+			into(blobs),
+			into(ints),
+			into(floats),
+			into(dateTimes),
+			now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+	
+	assert (size == ints.size());
+	assert (0 == ints[0]);
+	assert (ints.size() - 1 == ints[ints.size()-1]);
+	assert (std::string("xyz0") == strings[0]);
+	assert (std::string("xyz") + number == strings[strings.size()-1]);
+	assert (BLOB("abc0") == blobs[0]);
+	blob.assignRaw("abc", 3);
+	blob.appendRaw(number.c_str(), number.size());
+	assert (blob == blobs[blobs.size()-1]);
+	assert (.5 == floats[0]);
+	assert (floats.size() - 1 + .5 == floats[floats.size() - 1]);
+}
+
+
+void SQLExecutor::doBulkStringIntFloat(Poco::UInt32 size)
+{
+	std::string funct = "doBulk()";
+	std::vector<int> ints(size, 1);
+	std::vector<double> floats(size, .5);
+	std::vector<std::string> strings(size, "xwyz");
+	std::vector<DateTime> dateTimes(size);
+
+	try 
+	{ 
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?)", 
+			use(strings), 
+			use(ints), 
+			use(floats), 
+			use(dateTimes), now;
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try { session() << "DELETE FROM MiscTest", now; }
+	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	try 
+	{ 
+		session() << "INSERT INTO MiscTest VALUES (?,?,?,?)", 
+			use(strings, bulk), 
+			use(ints, bulk), 
+			use(floats, bulk), 
+			use(dateTimes, bulk), now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	ints.clear();
+	strings.clear();
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest", 
+			into(strings), 
+			into(ints), 
+			into(floats), 
+			into(dateTimes), now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	assert (size == ints.size());
+	assert (1 == ints[ints.size()-1]);
+
+	ints.clear();
+
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest", into(ints, bulk(size)), limit(size+1), now; 
+		fail ("must fail");
+	}
+	catch(InvalidArgumentException&){ }
+
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest", into(ints), bulk(size), now; 
+		fail ("must fail");
+	}
+	catch(InvalidAccessException&){ }
+
+	ints.clear();
+	try 
+	{ 
+		session() << "SELECT * FROM MiscTest", 
+			into(strings, bulk(size)), 
+			into(ints, bulk(size)), 
+			into(floats, bulk(size)), 
+			into(dateTimes, bulk(size)), now; 
+	} catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
+	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
+
+	assert (size == ints.size());
+	assert (1 == ints[ints.size()-1]);
 }
 
 
@@ -1504,10 +1940,10 @@ void SQLExecutor::setSimple()
 	int count = 0;
 	std::string result;
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
@@ -1516,7 +1952,7 @@ void SQLExecutor::setSimple()
 	std::set<std::string> firstNamesR;
 	std::set<std::string> addressesR;
 	std::set<int> agesR;
-	try { *_pSession << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
+	try { session() << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ages == agesR);
@@ -1533,17 +1969,17 @@ void SQLExecutor::setComplex()
 	people.insert(Person("LN1", "FN1", "ADDR1", 1));
 	people.insert(Person("LN2", "FN2", "ADDR2", 2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	std::set<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == people);
@@ -1562,17 +1998,17 @@ void SQLExecutor::setComplexUnique()
 	Person p2("LN2", "FN2", "ADDR2", 2);
 	people.push_back(p2);
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 5);
 
 	std::set<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == 2);
@@ -1599,10 +2035,10 @@ void SQLExecutor::multiSetSimple()
 	int count = 0;
 	std::string result;
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastNames), use(firstNames), use(addresses), use(ages), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
@@ -1611,7 +2047,7 @@ void SQLExecutor::multiSetSimple()
 	std::multiset<std::string> firstNamesR;
 	std::multiset<std::string> addressesR;
 	std::multiset<int> agesR;
-	try { *_pSession << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
+	try { session() << "SELECT * FROM PERSON", into(lastNamesR), into(firstNamesR), into(addressesR), into(agesR), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ages.size() == agesR.size());
@@ -1633,17 +2069,17 @@ void SQLExecutor::multiSetComplex()
 	Person p2("LN2", "FN2", "ADDR2", 2);
 	people.insert(p2);
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 5);
 
 	std::multiset<Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == people.size());
@@ -1659,17 +2095,17 @@ void SQLExecutor::mapComplex()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN2", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 
 	std::map<std::string, Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == people);
@@ -1688,17 +2124,17 @@ void SQLExecutor::mapComplexUnique()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN2", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 5);
 
 	std::map<std::string, Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == 2);
@@ -1717,17 +2153,17 @@ void SQLExecutor::multiMapComplex()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN2", p2));
 	
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 5);
 
 	std::multimap<std::string, Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), now; }
+	try { session() << "SELECT * FROM PERSON", into(result), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == people.size());
@@ -1741,18 +2177,18 @@ void SQLExecutor::selectIntoSingle()
 	Person p1("LN1", "FN1", "ADDR1", 1);
 	Person p2("LN2", "FN2", "ADDR2", 2);
 	people.insert(std::make_pair("LN1", p1));
-	people.insert(std::make_pair("LN1", p2));
+	people.insert(std::make_pair("LN2", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), limit(1), now; }// will return 1 object into one single result
+	try { session() << "SELECT * FROM PERSON ORDER BY LastName", into(result), limit(1), now; }// will return 1 object into one single result
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result == p1);
@@ -1766,19 +2202,19 @@ void SQLExecutor::selectIntoSingleStep()
 	Person p1("LN1", "FN1", "ADDR1", 1);
 	Person p2("LN2", "FN2", "ADDR2", 2);
 	people.insert(std::make_pair("LN1", p1));
-	people.insert(std::make_pair("LN1", p2));
+	people.insert(std::make_pair("LN2", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
-	Statement stmt = (*_pSession << "SELECT * FROM PERSON", into(result), limit(1)); 
+	Statement stmt = (session() << "SELECT * FROM PERSON", into(result), limit(1)); 
 	stmt.execute();
 	assert (result == p1);
 	assert (!stmt.done());
@@ -1795,20 +2231,20 @@ void SQLExecutor::selectIntoSingleFail()
 	Person p1("LN1", "FN1", "ADDR1", 1);
 	Person p2("LN2", "FN2", "ADDR2", 2);
 	people.insert(std::make_pair("LN1", p1));
-	people.insert(std::make_pair("LN1", p2));
+	people.insert(std::make_pair("LN2", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), limit(2, true), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), limit(2, true), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
 	try
 	{
-		*_pSession << "SELECT * FROM PERSON", into(result), limit(1, true), now; // will fail now
+		session() << "SELECT * FROM PERSON", into(result), limit(1, true), now; // will fail now
 		fail("hardLimit is set: must fail");
 	}
 	catch(Poco::Data::LimitException&)
@@ -1826,19 +2262,19 @@ void SQLExecutor::lowerLimitOk()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
 	try
 	{
-		*_pSession << "SELECT * FROM PERSON", into(result), lowerLimit(2), now; // will return 2 objects into one single result but only room for one!
+		session() << "SELECT * FROM PERSON", into(result), lowerLimit(2), now; // will return 2 objects into one single result but only room for one!
 		fail("Not enough space for results");
 	}
 	catch(Poco::Exception&)
@@ -1856,17 +2292,17 @@ void SQLExecutor::singleSelect()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
-	Statement stmt = (*_pSession << "SELECT * FROM PERSON", into(result), limit(1));
+	Statement stmt = (session() << "SELECT * FROM PERSON", into(result), limit(1));
 	stmt.execute();
 	assert (result == p1);
 	assert (!stmt.done());
@@ -1885,18 +2321,18 @@ void SQLExecutor::lowerLimitFail()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
 	try
 	{
-		*_pSession << "SELECT * FROM PERSON", into(result), lowerLimit(3), now; // will fail
+		session() << "SELECT * FROM PERSON", into(result), lowerLimit(3), now; // will fail
 		fail("should fail. not enough data");
 	}
 	catch(Poco::Exception&)
@@ -1914,16 +2350,16 @@ void SQLExecutor::combinedLimits()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	std::vector <Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), lowerLimit(2), upperLimit(2), now; }// will return 2 objects
+	try { session() << "SELECT * FROM PERSON", into(result), lowerLimit(2), upperLimit(2), now; }// will return 2 objects
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == 2);
@@ -1942,16 +2378,16 @@ void SQLExecutor::ranges()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	std::vector <Person> result;
-	try { *_pSession << "SELECT * FROM PERSON", into(result), range(2, 2), now; }// will return 2 objects
+	try { session() << "SELECT * FROM PERSON", into(result), range(2, 2), now; }// will return 2 objects
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (result.size() == 2);
@@ -1969,18 +2405,18 @@ void SQLExecutor::combinedIllegalLimits()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
 	try
 	{
-		*_pSession << "SELECT * FROM PERSON", into(result), lowerLimit(3), upperLimit(2), now;
+		session() << "SELECT * FROM PERSON", into(result), lowerLimit(3), upperLimit(2), now;
 		fail("lower > upper is not allowed");
 	}
 	catch(LimitException&)
@@ -1998,18 +2434,18 @@ void SQLExecutor::illegalRange()
 	people.insert(std::make_pair("LN1", p1));
 	people.insert(std::make_pair("LN1", p2));
 
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(people), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 2);
 	Person result;
 	try
 	{
-		*_pSession << "SELECT * FROM PERSON", into(result), range(3, 2), now;
+		session() << "SELECT * FROM PERSON", into(result), range(3, 2), now;
 		fail("lower > upper is not allowed");
 	}
 	catch(LimitException&)
@@ -2022,13 +2458,13 @@ void SQLExecutor::emptyDB()
 {
 	std::string funct = "emptyDB()";
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 0);
 
 	Person result;
-	Statement stmt = (*_pSession << "SELECT * FROM PERSON", into(result), limit(1));
+	Statement stmt = (session() << "SELECT * FROM PERSON", into(result), limit(1));
 	stmt.execute();
 	assert (result.firstName.empty());
 	assert (stmt.done());
@@ -2044,17 +2480,17 @@ void SQLExecutor::blob(int bigSize)
 
 	BLOB img("0123456789", 10);
 	int count = 0;
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(img), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(img), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
 	BLOB res;
 	assert (res.size() == 0);
-	try { *_pSession << "SELECT Image FROM Person", into(res), now; }
+	try { session() << "SELECT Image FROM Person", into(res), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (res == img);
@@ -2065,15 +2501,15 @@ void SQLExecutor::blob(int bigSize)
 
 	assert (big.size() == bigSize);
 
-	try { *_pSession << "DELETE FROM PERSON", now; }
+	try { session() << "DELETE FROM PERSON", now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "INSERT INTO PERSON VALUES(?,?,?,?)", use(lastName), use(firstName), use(address), use(big), now; }
+	try { session() << "INSERT INTO PERSON VALUES(?,?,?,?)", use(lastName), use(firstName), use(address), use(big), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	try { *_pSession << "SELECT Image FROM Person", into(res), now; }
+	try { session() << "SELECT Image FROM Person", into(res), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (res == big);
@@ -2089,16 +2525,16 @@ void SQLExecutor::blobStmt()
 	BLOB blob("0123456789", 10);
 
 	int count = 0;
-	Statement ins = (*_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(blob));
+	Statement ins = (session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(blob));
 	ins.execute();
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
 	BLOB res;
 	poco_assert (res.size() == 0);
-	Statement stmt = (*_pSession << "SELECT Image FROM Person", into(res));
+	Statement stmt = (session() << "SELECT Image FROM Person", into(res));
 	try { stmt.execute(); }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
@@ -2115,21 +2551,21 @@ void SQLExecutor::dateTime()
 
 	DateTime born(1965, 6, 18, 5, 35, 1);
 	int count = 0;
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(born), now; }
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(born), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
 	DateTime res;
-	try { *_pSession << "SELECT Born FROM Person", into(res), now; }
+	try { session() << "SELECT Born FROM Person", into(res), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (res == born);
 
-	Statement stmt = (*_pSession << "SELECT Born FROM Person", now);
+	Statement stmt = (session() << "SELECT Born FROM Person", now);
 	RecordSet rset(stmt);
 
 	res = rset["Born"].convert<DateTime>();
@@ -2146,7 +2582,7 @@ void SQLExecutor::date()
 
 	Date bornDate(1965, 6, 18);
 	int count = 0;
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", 
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", 
 		use(lastName), 
 		use(firstName), 
 		use(address), 
@@ -2154,19 +2590,19 @@ void SQLExecutor::date()
 		now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
 	Date d;
 	Time t;
-	try { *_pSession << "SELECT BornDate FROM Person", into(d), now; }
+	try { session() << "SELECT BornDate FROM Person", into(d), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (d == bornDate);
 
-	Statement stmt = (*_pSession << "SELECT BornDate FROM Person", now);
+	Statement stmt = (session() << "SELECT BornDate FROM Person", now);
 	RecordSet rset(stmt);
 
 	DateTime dt1 = rset["BornDate"].convert<DateTime>();
@@ -2185,7 +2621,7 @@ void SQLExecutor::time()
 
 	Time bornTime (5, 35, 1);
 	int count = 0;
-	try { *_pSession << "INSERT INTO PERSON VALUES (?,?,?,?)", 
+	try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", 
 		use(lastName), 
 		use(firstName), 
 		use(address), 
@@ -2193,19 +2629,19 @@ void SQLExecutor::time()
 		now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	try { *_pSession << "SELECT COUNT(*) FROM PERSON", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM PERSON", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (count == 1);
 
 	Date d;
 	Time t;
-	try { *_pSession << "SELECT BornTime FROM Person", into(t), now; }
+	try { session() << "SELECT BornTime FROM Person", into(t), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (t == bornTime);
 
-	Statement stmt = (*_pSession << "SELECT BornTime FROM Person", now);
+	Statement stmt = (session() << "SELECT BornTime FROM Person", now);
 	RecordSet rset(stmt);
 
 	DateTime dt2 = rset["BornTime"].convert<DateTime>();
@@ -2220,13 +2656,13 @@ void SQLExecutor::tuples()
 	std::string funct = "tuples()";
 	TupleType t(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
 
-	try { *_pSession << "INSERT INTO Tuples VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", use(t), now; }
+	try { session() << "INSERT INTO Tuples VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", use(t), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	TupleType ret(-10,-11,-12,-13,-14,-15,-16,-17,-18,-19);
 	assert (ret != t);
-	try { *_pSession << "SELECT * FROM Tuples", into(ret), now; }
+	try { session() << "SELECT * FROM Tuples", into(ret), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ret == t);
@@ -2245,18 +2681,18 @@ void SQLExecutor::tupleVector()
 	v.push_back(t10);
 	v.push_back(t100);
 
-	try { *_pSession << "INSERT INTO Tuples VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", use(v), now; }
+	try { session() << "INSERT INTO Tuples VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", use(v), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	int count = 0;
-	try { *_pSession << "SELECT COUNT(*) FROM Tuples", into(count), now; }
+	try { session() << "SELECT COUNT(*) FROM Tuples", into(count), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (v.size() == count);
 
 	std::vector<Tuple<int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int> > ret;
-	try { *_pSession << "SELECT * FROM Tuples", into(ret), now; }
+	try { session() << "SELECT * FROM Tuples", into(ret), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	assert (ret == v);
@@ -2272,13 +2708,13 @@ void SQLExecutor::internalExtraction()
 	v.push_back(Tuple<int, double, std::string>(3, 3.5f, "5"));
 	v.push_back(Tuple<int, double, std::string>(4, 4.5f, "6"));
 
-	try { *_pSession << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
+	try { session() << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	try 
 	{ 
-		Statement stmt = (*_pSession << "SELECT * FROM Vectors", now);
+		Statement stmt = (session() << "SELECT * FROM Vectors", now);
 		RecordSet rset(stmt);
 
 		assert (3 == rset.columnCount());
@@ -2331,7 +2767,7 @@ void SQLExecutor::internalExtraction()
 		for (int i = 1; it != end; ++it, ++i)
 			assert (*it == i);
 
-		rset = (*_pSession << "SELECT COUNT(*) AS cnt FROM Vectors", now);
+		rset = (session() << "SELECT COUNT(*) AS cnt FROM Vectors", now);
 
 		//various results for COUNT(*) are received from different drivers
 		try
@@ -2365,7 +2801,7 @@ void SQLExecutor::internalExtraction()
 		try	{ rset.value<std::string>(0,0); fail ("must fail"); }
 		catch (BadCastException&) {	}
 		
-		stmt = (*_pSession << "DELETE FROM Vectors", now);
+		stmt = (session() << "DELETE FROM Vectors", now);
 		rset = stmt;
 
 		try { rset.column<int, std::vector<int> >(0); fail ("must fail"); }
@@ -2390,7 +2826,7 @@ void SQLExecutor::internalStorageType()
 	v.push_back(Tuple<int, double, std::string>(3, 3.5f, "5"));
 	v.push_back(Tuple<int, double, std::string>(4, 4.5f, "6"));
 
-	try { *_pSession << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
+	try { session() << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
@@ -2401,7 +2837,7 @@ void SQLExecutor::internalStorageType()
 
 		for (; it != end; ++it)
 		{
-			Statement stmt = (*_pSession << "SELECT * FROM Vectors", *it, now);
+			Statement stmt = (session() << "SELECT * FROM Vectors", *it, now);
 			RecordSet rset(stmt);
 
 			assert (3 == rset.columnCount());
@@ -2421,21 +2857,21 @@ void SQLExecutor::internalStorageType()
 
 			try
 			{
-				stmt = (*_pSession << "SELECT * FROM Vectors", now, *it);
+				stmt = (session() << "SELECT * FROM Vectors", now, *it);
 				fail ("must fail");
 			}
 			catch(InvalidAccessException&){}
 
 			try
 			{
-				stmt = (*_pSession << "SELECT * FROM Vectors", into(v), now, *it);
+				stmt = (session() << "SELECT * FROM Vectors", into(v), now, *it);
 				fail ("must fail");
 			}
 			catch(InvalidAccessException&){}
 
 			try
 			{
-				stmt = (*_pSession << "SELECT * FROM Vectors", into(v), *it, now);
+				stmt = (session() << "SELECT * FROM Vectors", into(v), *it, now);
 				fail ("must fail");
 			}
 			catch(InvalidAccessException&){}
@@ -2450,7 +2886,7 @@ void SQLExecutor::notNulls(const std::string& sqlState)
 {
 	try
 	{
-		*_pSession << "INSERT INTO NullTest (i,r,v) VALUES (?,?,?)", use(null), use(null), use(null), now;
+		session() << "INSERT INTO NullTest (i,r,v) VALUES (?,?,?)", use(null), use(null), use(null), now;
 		fail ("must fail");
 	}catch (StatementException& se) 
 	{ 
@@ -2465,11 +2901,11 @@ void SQLExecutor::nulls()
 {
 	std::string funct = "nulls()";
 
-	try { *_pSession << "INSERT INTO NullTest (i,r,v) VALUES (?,?,?)", use(null), use(null), use(null), now; }
+	try { session() << "INSERT INTO NullTest (i,r,v) VALUES (?,?,?)", use(null), use(null), use(null), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	RecordSet rs(*_pSession, "SELECT * FROM NullTest");
+	RecordSet rs(session(), "SELECT * FROM NullTest");
 	assert (1 == rs.rowCount());
 	rs.moveFirst();
 	assert (rs.isNull("i"));
@@ -2477,7 +2913,7 @@ void SQLExecutor::nulls()
 	assert (rs.isNull("r"));
 	assert (rs.isNull("v"));
 	assert (rs["v"] == "");
-	try { *_pSession << "DELETE FROM NullTest", now; }
+	try { session() << "DELETE FROM NullTest", now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
@@ -2485,10 +2921,10 @@ void SQLExecutor::nulls()
 	double f = 1.2;
 	std::string s = "123";
 
-	try { *_pSession << "INSERT INTO NullTest (i, r, v) VALUES (?,?,?)", use(i), use(f), use(s), now; }
+	try { session() << "INSERT INTO NullTest (i, r, v) VALUES (?,?,?)", use(i), use(f), use(s), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	rs = (*_pSession << "SELECT * FROM NullTest", now);
+	rs = (session() << "SELECT * FROM NullTest", now);
 	assert (1 == rs.rowCount());
 	rs.moveFirst();
 	assert (!rs.isNull("i"));
@@ -2497,15 +2933,15 @@ void SQLExecutor::nulls()
 	assert (!rs.isNull("r"));
 	assert (rs["v"] == "123");
 	
-	try { *_pSession << "UPDATE NullTest SET v = ? WHERE i = ?", use(null), use(i), now; }
+	try { session() << "UPDATE NullTest SET v = ? WHERE i = ?", use(null), use(i), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 	i = 2;
 	f = 3.4;
-	try { *_pSession << "INSERT INTO NullTest (i, r, v) VALUES (?,?,?)", use(i), use(null), use(null), now; }
+	try { session() << "INSERT INTO NullTest (i, r, v) VALUES (?,?,?)", use(i), use(null), use(null), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
-	rs = (*_pSession << "SELECT i, r, v FROM NullTest ORDER BY i ASC", now);
+	rs = (session() << "SELECT i, r, v FROM NullTest ORDER BY i ASC", now);
 	assert (2 == rs.rowCount());
 	rs.moveFirst();
 	assert (!rs.isNull("i"));
@@ -2532,11 +2968,11 @@ void SQLExecutor::rowIterator()
 	v.push_back(Tuple<int, double, std::string>(3, 3.5f, "5"));
 	v.push_back(Tuple<int, double, std::string>(4, 4.5f, "6"));
 
-	try { *_pSession << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
+	try { session() << "INSERT INTO Vectors VALUES (?,?,?)", use(v), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
-	RecordSet rset(*_pSession, "SELECT * FROM Vectors");
+	RecordSet rset(session(), "SELECT * FROM Vectors");
 
 	std::ostringstream osLoop;
 	RecordSet::Iterator it = rset.begin();
@@ -2559,24 +2995,24 @@ void SQLExecutor::stdVectorBool()
 	std::string funct = "stdVectorBool()";
 
 	bool b = false;
-	try { *_pSession << "INSERT INTO BoolTest VALUES (?)", use(b), now; }
+	try { session() << "INSERT INTO BoolTest VALUES (?)", use(b), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	b = true;
-	*_pSession << "SELECT * FROM BoolTest", into(b), now;
+	session() << "SELECT * FROM BoolTest", into(b), now;
 	assert (false == b);
-	*_pSession << "DELETE FROM BoolTest", now;
+	session() << "DELETE FROM BoolTest", now;
 
 	b = true;
-	try { *_pSession << "INSERT INTO BoolTest VALUES (?)", use(b), now; }
+	try { session() << "INSERT INTO BoolTest VALUES (?)", use(b), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	b = false;
-	*_pSession << "SELECT * FROM BoolTest", into(b), now;
+	session() << "SELECT * FROM BoolTest", into(b), now;
 	assert (true == b);
-	*_pSession << "DELETE FROM BoolTest", now;
+	session() << "DELETE FROM BoolTest", now;
 
 	std::vector<bool> v;
 	v.push_back(true);
@@ -2584,12 +3020,12 @@ void SQLExecutor::stdVectorBool()
 	v.push_back(false);
 	v.push_back(true);
 
-	try { *_pSession << "INSERT INTO BoolTest VALUES (?)", use(v), now; }
+	try { session() << "INSERT INTO BoolTest VALUES (?)", use(v), now; }
 	catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
 	catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
 
 	v.clear();
-	*_pSession << "SELECT * FROM BoolTest", into(v), now;
+	session() << "SELECT * FROM BoolTest", into(v), now;
 
 	assert (4 == v.size());
 	std::vector<bool>::iterator it = v.begin();
@@ -2599,13 +3035,13 @@ void SQLExecutor::stdVectorBool()
 		t += *it ? 1 : 0;
 	assert (2 == t);
 
-	try { *_pSession << "SELECT * FROM BoolTest WHERE b = ?", out(v), now; fail("must fail"); }
+	try { session() << "SELECT * FROM BoolTest WHERE b = ?", out(v), now; fail("must fail"); }
 	catch (BindingException&) { }
 
-	try { *_pSession << "SELECT * FROM BoolTest WHERE b = ?", io(v), now; fail("must fail"); }
+	try { session() << "SELECT * FROM BoolTest WHERE b = ?", io(v), now; fail("must fail"); }
 	catch (BindingException&) { }
 
-	RecordSet rset(*_pSession, "SELECT * FROM BoolTest");
+	RecordSet rset(session(), "SELECT * FROM BoolTest");
 
 	t = 0;
 	for (int i = 0; i < 4; ++i)
@@ -2616,7 +3052,7 @@ void SQLExecutor::stdVectorBool()
 
 void SQLExecutor::asynchronous(int rowCount)
 {
-	Session tmp = *_pSession;
+	Session tmp = session();
 
 	std::vector<int> data(rowCount);
 	Statement stmt = (tmp << "INSERT INTO Strings VALUES(?)", use(data));
@@ -2705,7 +3141,7 @@ void SQLExecutor::any()
 	Any f = 42.5;
 	Any s = std::string("42");
 
-	Session tmp = *_pSession;
+	Session tmp = session();
 
 	tmp << "INSERT INTO Anys VALUES (?, ?, ?)", use(i), use(f), use(s), now;
 
@@ -2729,7 +3165,7 @@ void SQLExecutor::dynamicAny()
 	DynamicAny f = 42.5;
 	DynamicAny s = "42";
 
-	Session tmp = *_pSession;
+	Session tmp = session();
 	tmp << "INSERT INTO Anys VALUES (?, ?, ?)", use(i), use(f), use(s), now;
 
 	int count = 0;
@@ -2748,21 +3184,24 @@ void SQLExecutor::dynamicAny()
 
 void SQLExecutor::multipleResults(const std::string& sql)
 {
-	typedef Tuple<std::string, std::string, std::string, int> Person;
+	typedef Tuple<std::string, std::string, std::string, Poco::UInt32> Person;
 	std::vector<Person> people;
 	people.push_back(Person("Simpson", "Homer", "Springfield", 42));
 	people.push_back(Person("Simpson", "Bart", "Springfield", 12));
 	people.push_back(Person("Simpson", "Lisa", "Springfield", 10));
-	*_pSession << "INSERT INTO Person VALUES (?, ?, ?, ?)", use(people), now;
+	session() << "INSERT INTO Person VALUES (?, ?, ?, ?)", use(people), now;
 
 	Person pHomer, pLisa;
-	int aHomer(42), aLisa(10), aBart(0);
+	int aHomer = 42, aLisa = 10;
+	Poco::UInt32 aBart = 0;
 
+	Poco::UInt32 pos1 = 1;
+	int pos2 = 2;
 	try {
-	*_pSession << sql
-		, into(pHomer), use(aHomer)
-		, into(aBart, 1)
-		, into(pLisa, 2), use(aLisa)
+	session() << sql
+		, into(pHomer, from(0)), use(aHomer)
+		, into(aBart, pos1)
+		, into(pLisa, pos2), use(aLisa)
 		, now;
 	} catch (StatementException& ex)
 	{
diff --git a/Data/ODBC/testsuite/src/SQLExecutor.h b/Data/ODBC/testsuite/src/SQLExecutor.h
index 0855e1e58..4a4d2d974 100644
--- a/Data/ODBC/testsuite/src/SQLExecutor.h
+++ b/Data/ODBC/testsuite/src/SQLExecutor.h
@@ -140,7 +140,10 @@ public:
 	void limitPrepare();
 	void limitZero();
 	void prepare();
-	void doStep(Poco::UInt32 dataSize, Poco::UInt32 stepSize);
+	void doBulk(Poco::UInt32 size);
+	void doBulkPerformance(Poco::UInt32 size);
+	void doBulkNoBool(Poco::UInt32 size);
+	void doBulkStringIntFloat(Poco::UInt32 size);
 
 	void setSimple();
 	void setComplex();
@@ -194,8 +197,17 @@ private:
 	static const std::string MULTI_INSERT;
 	static const std::string MULTI_SELECT;
 
+	Poco::Data::Session& session();
+
 	Poco::Data::Session* _pSession;
 };
 
 
+inline Poco::Data::Session& SQLExecutor::session()
+{
+	poco_check_ptr (_pSession);
+	return *_pSession;
+}
+
+
 #endif // SQLExecutor_INCLUDED
diff --git a/Data/SQLite/include/Poco/Data/SQLite/Extractor.h b/Data/SQLite/include/Poco/Data/SQLite/Extractor.h
index 7f0a4c9f1..4034d183b 100644
--- a/Data/SQLite/include/Poco/Data/SQLite/Extractor.h
+++ b/Data/SQLite/include/Poco/Data/SQLite/Extractor.h
@@ -135,7 +135,7 @@ public:
 	bool extract(std::size_t pos, Poco::DynamicAny& val);
 		/// Extracts a DynamicAny.
 
-	bool isNull(std::size_t pos);
+	bool isNull(std::size_t pos, std::size_t row = -1);
 		/// Returns true if the current row value at pos column is null.
 		/// Because of the loss of information about null-ness of the 
 		/// underlying database values due to the nature of SQLite engine, 
@@ -148,6 +148,8 @@ public:
 		/// bool value in the pair is true if the null indicator has 
 		/// been set and the second bool value in the pair is true if
 		/// the column is actually null.
+		/// The row argument, needed for connectors with bulk capabilities,
+		/// is ignored in this implementation.
 
 	void reset();
 		/// Clears the cached nulls indicator vector.
diff --git a/Data/SQLite/src/Extractor.cpp b/Data/SQLite/src/Extractor.cpp
index 7f9c7d4f8..86041e700 100644
--- a/Data/SQLite/src/Extractor.cpp
+++ b/Data/SQLite/src/Extractor.cpp
@@ -251,7 +251,7 @@ bool Extractor::extract(std::size_t pos, Poco::DynamicAny& val)
 }
 
 
-bool Extractor::isNull(std::size_t pos)
+bool Extractor::isNull(std::size_t pos, std::size_t)
 {
 	if (pos >= _nulls.size())
 		_nulls.resize(pos + 1);
diff --git a/Data/SQLite/testsuite/src/SQLiteTest.cpp b/Data/SQLite/testsuite/src/SQLiteTest.cpp
index 3a94a5733..6a43de06a 100644
--- a/Data/SQLite/testsuite/src/SQLiteTest.cpp
+++ b/Data/SQLite/testsuite/src/SQLiteTest.cpp
@@ -33,12 +33,12 @@
 #include "SQLiteTest.h"
 #include "CppUnit/TestCaller.h"
 #include "CppUnit/TestSuite.h"
-#include "Poco/Data/Common.h"
 #include "Poco/Data/Date.h"
 #include "Poco/Data/Time.h"
 #include "Poco/Data/BLOB.h"
 #include "Poco/Data/Statement.h"
 #include "Poco/Data/RecordSet.h"
+#include "Poco/Data/SessionFactory.h"
 #include "Poco/Data/SQLite/Connector.h"
 #include "Poco/Data/SQLite/SQLiteException.h"
 #include "Poco/Data/TypeHandler.h"
@@ -117,7 +117,7 @@ public:
 		pBinder->bind(pos++, obj.age, dir);
 	}
 
-	static void prepare(std::size_t pos, const Person& obj, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, Person& obj, AbstractPreparation* pPrepare)
 	{
 		// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
 		poco_assert_dbg (pPrepare != 0);
diff --git a/Data/include/Poco/Data/AbstractBinder.h b/Data/include/Poco/Data/AbstractBinder.h
index 8c06b798b..1df448f17 100644
--- a/Data/include/Poco/Data/AbstractBinder.h
+++ b/Data/include/Poco/Data/AbstractBinder.h
@@ -41,40 +41,29 @@
 
 
 #include "Poco/Data/Data.h"
+#include <vector>
 #include <cstddef>
 
 
 namespace Poco {
 
+
 class DateTime;
 class Any;
 class DynamicAny;
 
+
 namespace Data {
 
+
 class Date;
 class Time;
 class BLOB;
 
+
 enum NullData
 {
-	NULL_GENERIC = 0,
-	NULL_INT8,
-	NULL_UINT8,
-	NULL_INT16,
-	NULL_UINT16,
-	NULL_INT32,
-	NULL_UINT32,
-	NULL_INT64,
-	NULL_UINT64,
-	NULL_BOOL,
-	NULL_FLOAT,
-	NULL_DOUBLE,
-	NULL_STRING,
-	NULL_BLOB,
-	NULL_DATE,
-	NULL_TIME,
-	NULL_TIMESTAMP
+	NULL_GENERIC = 0
 };
 
 
@@ -82,8 +71,7 @@ static const NullData null = NULL_GENERIC;
 
 
 class Data_API AbstractBinder
-	/// Interface for Binding data types to placeholders. The default placeholder format 
-	/// in the SQL query is ":name".
+	/// Interface for Binding data types to placeholders.
 {
 public:
 	enum Direction
@@ -103,65 +91,122 @@ public:
 	virtual void bind(std::size_t pos, const Poco::Int8& val, Direction dir = PD_IN) = 0;
 		/// Binds an Int8.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 vector.
+
 	virtual void bind(std::size_t pos, const Poco::UInt8& val, Direction dir = PD_IN) = 0;
 		/// Binds an UInt8.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 vector.
+
 	virtual void bind(std::size_t pos, const Poco::Int16& val, Direction dir = PD_IN) = 0;
 		/// Binds an Int16.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 vector.
+
 	virtual void bind(std::size_t pos, const Poco::UInt16& val, Direction dir = PD_IN) = 0;
 		/// Binds an UInt16.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 vector.
+
 	virtual void bind(std::size_t pos, const Poco::Int32& val, Direction dir = PD_IN) = 0;
 		/// Binds an Int32.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 vector.
+
 	virtual void bind(std::size_t pos, const Poco::UInt32& val, Direction dir = PD_IN) = 0;
 		/// Binds an UInt32.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 vector.
 		
 	virtual void bind(std::size_t pos, const Poco::Int64& val, Direction dir = PD_IN) = 0;
 		/// Binds an Int64.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 vector.
+
 	virtual void bind(std::size_t pos, const Poco::UInt64& val, Direction dir = PD_IN) = 0;
 		/// Binds an UInt64.
 
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
 	virtual void bind(std::size_t pos, const long& val, Direction dir = PD_IN) = 0;
 		/// Binds a long.
+
+	virtual void bind(std::size_t pos, const std::vector<long>& val, Direction dir = PD_IN);
+		/// Binds a long vector.
 #endif
 
 	virtual void bind(std::size_t pos, const bool& val, Direction dir = PD_IN) = 0;
 		/// Binds a boolean.
 
+	virtual void bind(std::size_t pos, const std::vector<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean vector.
+
 	virtual void bind(std::size_t pos, const float& val, Direction dir = PD_IN) = 0;
 		/// Binds a float.
 
+	virtual void bind(std::size_t pos, const std::vector<float>& val, Direction dir = PD_IN);
+		/// Binds a float vector.
+
 	virtual void bind(std::size_t pos, const double& val, Direction dir = PD_IN) = 0;
 		/// Binds a double.
 
+	virtual void bind(std::size_t pos, const std::vector<double>& val, Direction dir = PD_IN);
+		/// Binds a double vector.
+
 	virtual void bind(std::size_t pos, const char& val, Direction dir = PD_IN) = 0;
 		/// Binds a single character.
 
-	virtual void bind(std::size_t pos, const char* const &pVal, Direction dir = PD_IN) = 0;
+	virtual void bind(std::size_t pos, const std::vector<char>& val, Direction dir = PD_IN);
+		/// Binds a character vector.
+
+	virtual void bind(std::size_t pos, const char* const& pVal, Direction dir = PD_IN) = 0;
 		/// Binds a const char ptr.
 
 	virtual void bind(std::size_t pos, const std::string& val, Direction dir = PD_IN) = 0;
 		/// Binds a string.
 
+	virtual void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string vector.
+
 	virtual void bind(std::size_t pos, const BLOB& val, Direction dir = PD_IN) = 0;
 		/// Binds a BLOB.
 
+	virtual void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB vector.
+
 	virtual void bind(std::size_t pos, const DateTime& val, Direction dir = PD_IN) = 0;
 		/// Binds a DateTime.
 
+	virtual void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime vector.
+
 	virtual void bind(std::size_t pos, const Date& val, Direction dir = PD_IN) = 0;
 		/// Binds a Date.
 
+	virtual void bind(std::size_t pos, const std::vector<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date vector.
+
 	virtual void bind(std::size_t pos, const Time& val, Direction dir = PD_IN) = 0;
 		/// Binds a Time.
 
+	virtual void bind(std::size_t pos, const std::vector<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time vector.
+
 	virtual void bind(std::size_t pos, const NullData& val, Direction dir = PD_IN) = 0;
 		/// Binds a null.
 
+	virtual void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null vector.
+
 	void bind(std::size_t pos, const Any& val, Direction dir = PD_IN);
 		/// Binds an Any.
 	
diff --git a/Data/include/Poco/Data/AbstractBinding.h b/Data/include/Poco/Data/AbstractBinding.h
index 1f7065f4d..ec2cde02c 100644
--- a/Data/include/Poco/Data/AbstractBinding.h
+++ b/Data/include/Poco/Data/AbstractBinding.h
@@ -64,7 +64,7 @@ public:
 		PD_IN_OUT = AbstractBinder::PD_IN_OUT
 	};
 
-	AbstractBinding(const std::string& name = "", Direction direction = PD_IN);
+	AbstractBinding(const std::string& name = "", Direction direction = PD_IN, Poco::UInt32 bulkSize = 0);
 		/// Creates the AbstractBinding.
 
 	virtual ~AbstractBinding();
@@ -86,7 +86,7 @@ public:
 		/// Returns the number of rows that the binding handles.
 		///
 		/// The trivial case will be one single row but 
-		/// for collection data types (ie vector) it can be larger.
+		/// for collection data types it can be larger.
 
 	virtual bool canBind() const = 0;
 		/// Returns true if we have enough data to bind
@@ -103,10 +103,17 @@ public:
 	const std::string& name() const;
 		/// Returns the name for this binding.
 
+	bool isBulk() const;
+		/// Returns true if extraction is bulk.
+
+	Poco::UInt32 bulkSize() const;
+		/// Returns the size of the bulk binding.
+
 private:
 	AbstractBinder* _pBinder;
-	std::string _name;
-	Direction _direction;
+	std::string     _name;
+	Direction       _direction;
+	Poco::UInt32    _bulkSize;
 };
 
 
@@ -135,6 +142,18 @@ inline AbstractBinder::Direction AbstractBinding::getDirection() const
 }
 
 
+inline bool AbstractBinding::isBulk() const
+{
+	return _bulkSize > 0;
+}
+
+
+inline Poco::UInt32 AbstractBinding::bulkSize() const
+{
+	return _bulkSize;
+}
+
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/AbstractExtraction.h b/Data/include/Poco/Data/AbstractExtraction.h
index 440724296..47a2c0860 100644
--- a/Data/include/Poco/Data/AbstractExtraction.h
+++ b/Data/include/Poco/Data/AbstractExtraction.h
@@ -63,7 +63,7 @@ class Data_API AbstractExtraction: public Poco::RefCountedObject
 {
 public:
 	AbstractExtraction(Poco::UInt32 limit = Limit::LIMIT_UNLIMITED,
-		Poco::UInt32 position = 0);
+		Poco::UInt32 position = 0, bool bulk = false);
 		/// Creates the AbstractExtraction. A limit value equal to EXTRACT_UNLIMITED (0xffffffffu) 
 		/// means that we extract as much data as possible during one execute.
 		/// Otherwise the limit value is used to partition data extracting to a limited amount of rows.
@@ -95,13 +95,14 @@ public:
 	virtual std::size_t numOfRowsAllowed() const = 0;
 		/// Returns the upper limit on number of rows that the extraction will handle.
 
-	virtual void extract(std::size_t pos) = 0;
+	virtual std::size_t extract(std::size_t pos) = 0;
 		/// Extracts a value from the param, starting at the given column position.
+		/// Returns the number of rows extracted.
 
 	virtual void reset() = 0;
 		/// Resets the extractor so that it can be re-used.
 
-	virtual AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const = 0;
+	virtual AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) = 0;
 		/// Creates a Prepare object for the extracting object
 
 	void setLimit(Poco::UInt32 limit);
@@ -118,10 +119,14 @@ public:
 		/// null values and be able to later provide information about them.
 		/// Here, this function throws NotImplementedException.
 
+	bool isBulk() const;
+		/// Returns true if this is bulk extraction.
+
 private:
 	AbstractExtractor* _pExtractor;
 	Poco::UInt32       _limit;
 	Poco::UInt32       _position;
+	bool               _bulk;
 };
 
 
@@ -169,6 +174,12 @@ inline Poco::UInt32 AbstractExtraction::position() const
 }
 
 
+inline bool AbstractExtraction::isBulk() const
+{
+	return _bulk;
+}
+
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/AbstractExtractor.h b/Data/include/Poco/Data/AbstractExtractor.h
index 465f4f48c..df15bb296 100644
--- a/Data/include/Poco/Data/AbstractExtractor.h
+++ b/Data/include/Poco/Data/AbstractExtractor.h
@@ -41,6 +41,7 @@
 
 
 #include "Poco/Data/Data.h"
+#include <vector>
 #include <cstddef>
 
 
@@ -74,67 +75,127 @@ public:
 	virtual bool extract(std::size_t pos, Poco::Int8& val) = 0;
 		/// Extracts an Int8. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
 	virtual bool extract(std::size_t pos, Poco::UInt8& val) = 0;
 		/// Extracts an UInt8. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8vector .
+
 	virtual bool extract(std::size_t pos, Poco::Int16& val) = 0;
 		/// Extracts an Int16. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
 	virtual bool extract(std::size_t pos, Poco::UInt16& val) = 0;
 		/// Extracts an UInt16. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
 	virtual bool extract(std::size_t pos, Poco::Int32& val) = 0;
 		/// Extracts an Int32. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
 	virtual bool extract(std::size_t pos, Poco::UInt32& val) = 0;
 		/// Extracts an UInt32. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
 	virtual bool extract(std::size_t pos, Poco::Int64& val) = 0;
 		/// Extracts an Int64. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
 	virtual bool extract(std::size_t pos, Poco::UInt64& val) = 0;
 		/// Extracts an UInt64. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
 	virtual bool extract(std::size_t pos, long& val) = 0;
 		/// Extracts a long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
 #endif
 
 	virtual bool extract(std::size_t pos, bool& val) = 0;
 		/// Extracts a boolean. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
 	virtual bool extract(std::size_t pos, float& val) = 0;
 		/// Extracts a float. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
 	virtual bool extract(std::size_t pos, double& val) = 0;
 		/// Extracts a double. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
 	virtual bool extract(std::size_t pos, char& val) = 0;
 		/// Extracts a single character. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a character vector.
+
 	virtual bool extract(std::size_t pos, std::string& val) = 0;
 		/// Extracts a string. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
 	virtual bool extract(std::size_t pos, BLOB& val) = 0;
 		/// Extracts a BLOB. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<BLOB>& val);
+		/// Extracts a BLOB vector.
+
 	virtual bool extract(std::size_t pos, DateTime& val) = 0;
 		/// Extracts a DateTime. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<DateTime>& val);
+		/// Extracts a DateTime vector.
+
 	virtual bool extract(std::size_t pos, Date& val) = 0;
 		/// Extracts a Date. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Date>& val);
+		/// Extracts a Date vector.
+
 	virtual bool extract(std::size_t pos, Time& val) = 0;
 		/// Extracts a Time. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Time>& val);
+		/// Extracts a Time vector.
+
 	virtual bool extract(std::size_t pos, Any& val) = 0;
 		/// Extracts an Any. Returns false if null was received.
 
+	virtual bool extract(std::size_t pos, std::vector<Any>& val);
+		/// Extracts an Any vector.
+
 	virtual bool extract(std::size_t pos, DynamicAny& val) = 0;
 		/// Extracts a DynamicAny. Returns false if null was received.
 
-	virtual bool isNull(std::size_t pos) = 0;
-		/// Returns true if the current row value at pos column is null.
+	virtual bool extract(std::size_t pos, std::vector<DynamicAny>& val);
+		/// Extracts a DynamicAny vector.
+
+	virtual bool isNull(std::size_t col, std::size_t row = -1) = 0;
+		/// Returns true if the value at [col,row] position is null.
 
 	virtual void reset();
 		/// Resets any information internally cached by the extractor.
diff --git a/Data/include/Poco/Data/AbstractPreparation.h b/Data/include/Poco/Data/AbstractPreparation.h
index 7f8a5012a..5445db0fc 100644
--- a/Data/include/Poco/Data/AbstractPreparation.h
+++ b/Data/include/Poco/Data/AbstractPreparation.h
@@ -42,6 +42,7 @@
 
 #include "Poco/Data/Data.h"
 #include "Poco/RefCountedObject.h"
+#include <vector>
 #include <cstddef>
 
 
@@ -64,80 +65,171 @@ class BLOB;
 class Data_API AbstractPreparation: public Poco::RefCountedObject
 	/// Interface used for database preparation where we first have to register all data types (and memory output locations)
 	/// before extracting data, i.e. extract works as two-pase extract: first we call prepare once, then extract n-times.
-	/// Only some database connectors will need to implement this interface.
-	/// Note that the values in the interface serve only the purpose of type distinction.
+	/// There are cases (bulk operations using std::vector storage) when extract is called only once.
+	/// The value passed to a prepare() call is not be used by the prepare, serving only as an indication of the data type
+	/// being prepared. 
+	/// Implementing this interface is not mandatory for a connector. Connectors that only extract data after SQL execution 
+	/// (e.g. SQLite) do not need this functionality at all.
 {
 public:
-	AbstractPreparation();
+	AbstractPreparation(Poco::UInt32 length = 1u);
 		/// Creates the AbstractPreparation.
 
 	virtual ~AbstractPreparation();
 		/// Destroys the AbstractPreparation.
 
-	virtual void prepare(std::size_t pos, Poco::Int8) = 0;
+	virtual void prepare(std::size_t pos, Poco::Int8&) = 0;
 		/// Prepares an Int8.
 
-	virtual void prepare(std::size_t pos, Poco::UInt8) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Prepares an Int8 vector.
+
+	virtual void prepare(std::size_t pos, Poco::UInt8&) = 0;
 		/// Prepares an UInt8.
 
-	virtual void prepare(std::size_t pos, Poco::Int16) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Prepares an UInt8 vector.
+
+	virtual void prepare(std::size_t pos, Poco::Int16&) = 0;
 		/// Prepares an Int16.
 
-	virtual void prepare(std::size_t pos, Poco::UInt16) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Prepares an Int16 vector.
+
+	virtual void prepare(std::size_t pos, Poco::UInt16&) = 0;
 		/// Prepares an UInt16.
 
-	virtual void prepare(std::size_t pos, Poco::Int32) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Prepares an UInt16 vector.
+
+	virtual void prepare(std::size_t pos, Poco::Int32&) = 0;
 		/// Prepares an Int32.
 
-	virtual void prepare(std::size_t pos, Poco::UInt32) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Prepares an Int32 vector.
+
+	virtual void prepare(std::size_t pos, Poco::UInt32&) = 0;
 		/// Prepares an UInt32.
 
-	virtual void prepare(std::size_t pos, Poco::Int64) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Prepares an UInt32 vector.
+
+	virtual void prepare(std::size_t pos, Poco::Int64&) = 0;
 		/// Prepares an Int64.
 
-	virtual void prepare(std::size_t pos, Poco::UInt64) = 0;
+	virtual void prepare(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Prepares an Int64 vector.
+
+	virtual void prepare(std::size_t pos, Poco::UInt64&) = 0;
 		/// Prepares an UInt64.
 
+	virtual void prepare(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Prepares an UInt64 vector.
+
 #ifndef POCO_LONG_IS_64_BIT
-	virtual void prepare(std::size_t pos, long) = 0;
+	virtual void prepare(std::size_t pos, long&) = 0;
 		/// Prepares a long.
+
+	virtual void prepare(std::size_t pos, std::vector<long>& val);
+		/// Prepares a long vector.
 #endif
 
-	virtual void prepare(std::size_t pos, bool) = 0;
+	virtual void prepare(std::size_t pos, bool&) = 0;
 		/// Prepares a boolean.
 
-	virtual void prepare(std::size_t pos, float) = 0;
+	virtual void prepare(std::size_t pos, std::vector<bool>& val);
+		/// Prepares a boolean vector.
+
+	virtual void prepare(std::size_t pos, float&) = 0;
 		/// Prepares a float.
 
-	virtual void prepare(std::size_t pos, double) = 0;
+	virtual void prepare(std::size_t pos, std::vector<float>& val);
+		/// Prepares a float vector.
+
+	virtual void prepare(std::size_t pos, double&) = 0;
 		/// Prepares a double.
 
-	virtual void prepare(std::size_t pos, char) = 0;
+	virtual void prepare(std::size_t pos, std::vector<double>& val);
+		/// Prepares a double vector.
+
+	virtual void prepare(std::size_t pos, char&) = 0;
 		/// Prepares a single character.
 
-	virtual void prepare(std::size_t pos, const std::string& ) = 0;
+	virtual void prepare(std::size_t pos, std::vector<char>& val);
+		/// Prepares a character vector.
+
+	virtual void prepare(std::size_t pos, const std::string&) = 0;
 		/// Prepares a string.
 
+	virtual void prepare(std::size_t pos, const std::vector<std::string>& val);
+		/// Prepares a string vector.
+
 	virtual void prepare(std::size_t pos, const BLOB&) = 0;
 		/// Prepares a BLOB.
 
+	virtual void prepare(std::size_t pos, const std::vector<BLOB>& val);
+		/// Prepares a BLOB vector.
+
 	virtual void prepare(std::size_t pos, const DateTime&) = 0;
 		/// Prepares a DateTime.
 
+	virtual void prepare(std::size_t pos, const std::vector<DateTime>& val);
+		/// Prepares a DateTime vector.
+
 	virtual void prepare(std::size_t pos, const Date&) = 0;
 		/// Prepares a Date.
 
+	virtual void prepare(std::size_t pos, const std::vector<Date>& val);
+		/// Prepares a Date vector.
+
 	virtual void prepare(std::size_t pos, const Time&) = 0;
 		/// Prepares a Time.
 
+	virtual void prepare(std::size_t pos, const std::vector<Time>& val);
+		/// Prepares a Time vector.
+
 	virtual void prepare(std::size_t pos, const Any&) = 0;
 		/// Prepares an Any.
 
+	virtual void prepare(std::size_t pos, const std::vector<Any>& val);
+		/// Prepares an Any vector.
+
 	virtual void prepare(std::size_t pos, const DynamicAny&) = 0;
 		/// Prepares a DynamicAny.
+
+	virtual void prepare(std::size_t pos, const std::vector<DynamicAny>& val);
+		/// Prepares a DynamicAny vector.
+
+	void setLength(Poco::UInt32 length);
+		/// Sets the length of prepared data.
+		/// Needed only for data lengths greater than 1 (i.e. for
+		/// bulk operations).
+
+	Poco::UInt32 getLength() const;
+		/// Returns the length of prepared data. Defaults to 1.
+		/// The length is greater than one for bulk operations.
+
+private:
+	Poco::UInt32 _length;
 };
 
 
+///
+/// inlines
+///
+inline void AbstractPreparation::setLength(Poco::UInt32 length)
+{
+	_length = length;
+}
+
+
+inline Poco::UInt32 AbstractPreparation::getLength() const
+{
+	return _length;
+}
+
+
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/Binding.h b/Data/include/Poco/Data/Binding.h
index 1bb8e7c72..084174d14 100644
--- a/Data/include/Poco/Data/Binding.h
+++ b/Data/include/Poco/Data/Binding.h
@@ -113,7 +113,9 @@ class Binding<std::vector<T> >: public AbstractBinding
 	/// Specialization for std::vector.
 {
 public:
-	explicit Binding(const std::vector<T>& val, const std::string& name = "", Direction direction = PD_IN): 
+	explicit Binding(const std::vector<T>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
 		AbstractBinding(name, direction), 
 		_val(val), 
 		_begin(val.begin()), 
@@ -148,6 +150,7 @@ public:
 	{
 		poco_assert_dbg(getBinder() != 0);
 		poco_assert_dbg(canBind());
+		
 		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
 		++_begin;
 	}
@@ -181,7 +184,9 @@ class Binding<std::vector<bool> >: public AbstractBinding
 	/// Only IN binding is supported.
 {
 public:
-	explicit Binding(const std::vector<bool>& val, const std::string& name = "", Direction direction = PD_IN): 
+	explicit Binding(const std::vector<bool>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
 		AbstractBinding(name, direction), 
 		_val(val), 
 		_deq(_val.begin(), _val.end()),
@@ -203,7 +208,7 @@ public:
 
 	std::size_t numOfColumnsHandled() const
 	{
-		return TypeHandler<bool>::size();
+		return 1u;
 	}
 
 	std::size_t numOfRowsHandled() const
@@ -222,6 +227,7 @@ public:
 		poco_assert_dbg(canBind());
 		TypeHandler<bool>::bind(pos, *_begin, getBinder(), getDirection());
 		++_begin;
+
 	}
 
 	void reset()
@@ -584,9 +590,7 @@ template <typename T>
 Binding<T>* use(const T& t, const std::string& name = "")
 	/// Convenience function for a more compact Binding creation.
 {
-	Binding<T>* pB = new Binding<T>(t, name, AbstractBinding::PD_IN);
-	poco_check_ptr (pB);
-	return pB;
+	return new Binding<T>(t, name, AbstractBinding::PD_IN);
 }
 
 
@@ -594,9 +598,7 @@ template <typename T>
 Binding<T>* in(const T& t, const std::string& name = "")
 	/// Convenience function for a more compact Binding creation.
 {
-	Binding<T>* pB = new Binding<T>(t, name, AbstractBinding::PD_IN);
-	poco_check_ptr (pB);
-	return pB;
+	return new Binding<T>(t, name, AbstractBinding::PD_IN);
 }
 
 
@@ -604,9 +606,7 @@ template <typename T>
 Binding<T>* out(T& t, const std::string& name = "")
 	/// Convenience function for a more compact Binding creation.
 {
-	Binding<T>* pB = new Binding<T>(t, name, AbstractBinding::PD_OUT);
-	poco_check_ptr (pB);
-	return pB;
+	return new Binding<T>(t, name, AbstractBinding::PD_OUT);
 }
 
 
@@ -614,9 +614,7 @@ template <typename T>
 Binding<T>* io(T& t, const std::string& name = "")
 	/// Convenience function for a more compact Binding creation.
 {
-	Binding<T>* pB = new Binding<T>(t, name, AbstractBinding::PD_IN_OUT);
-	poco_check_ptr (pB);
-	return pB;
+	return new Binding<T>(t, name, AbstractBinding::PD_IN_OUT);
 }
 
 
diff --git a/Data/include/Poco/Data/Bulk.h b/Data/include/Poco/Data/Bulk.h
new file mode 100644
index 000000000..e6400efb1
--- /dev/null
+++ b/Data/include/Poco/Data/Bulk.h
@@ -0,0 +1,109 @@
+//
+// BulkExtraction.h
+//
+// $Id: //poco/Main/Data/include/Poco/Data/Bulk.h#9 $
+//
+// Library: Data
+// Package: DataCore
+// Module:  Bulk
+//
+// Definition of the BulkExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#ifndef Data_Bulk_INCLUDED
+#define Data_Bulk_INCLUDED
+
+
+#include "Poco/Data/Limit.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Bulk
+{
+public:
+	Bulk(const Limit& limit);
+		/// Creates the Bulk.
+
+	Bulk(Poco::UInt32 value);
+		/// Creates the Bulk.
+
+	~Bulk();
+		/// Destroys the bulk.
+
+	const Limit& limit() const;
+		/// Returns the limit asociated with this bulk object.
+
+	Poco::UInt32 size() const;
+		/// Returns the value of the limit asociated with 
+		/// this bulk object.
+	
+private:
+	Bulk();
+
+	Limit _limit;
+};
+
+
+///
+/// inlines
+///
+inline const Limit& Bulk::limit() const 
+{ 
+	return _limit; 
+}
+
+
+inline Poco::UInt32 Bulk::size() const 
+{ 
+	return _limit.value(); 
+}
+
+
+template <typename T>
+inline Bulk bulk(const T& limit)
+	/// Convenience function for creation of bulk.
+{
+	return Bulk(limit);
+}
+
+
+inline void bulk()
+	/// Dummy bulk function. Used for bulk binding creation
+	/// (see BulkBinding.h).
+{
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Bulk_INCLUDED
diff --git a/Data/include/Poco/Data/BulkBinding.h b/Data/include/Poco/Data/BulkBinding.h
new file mode 100644
index 000000000..e220e05b6
--- /dev/null
+++ b/Data/include/Poco/Data/BulkBinding.h
@@ -0,0 +1,131 @@
+//
+// BulkBinding.h
+//
+// $Id: //poco/Main/Data/include/Poco/Data/BulkBinding.h#6 $
+//
+// Library: Data
+// Package: DataCore
+// Module:  BulkBinding
+//
+// Definition of the BulkBinding class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#ifndef Data_BulkBinding_INCLUDED
+#define Data_BulkBinding_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinding.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/TypeHandler.h"
+#include <vector>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class T>
+class BulkBinding: public AbstractBinding
+	/// A BulkBinding maps a value to a column. 
+	/// Bulk binding support is provided only for std::vector.
+{
+public:
+	explicit BulkBinding(const T& val, Poco::UInt32 bulkSize, const std::string& name = "", Direction direction = PD_IN): 
+		AbstractBinding(name, direction, bulkSize), 
+		_val(val), 
+		_bound(false)
+		/// Creates the BulkBinding.
+	{
+		if (0 == _val.size())
+			throw InvalidArgumentException("Zero size containers not allowed.");
+	}
+
+	~BulkBinding()
+		/// Destroys the BulkBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _val.size();
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(getBinder() != 0);
+		TypeHandler<T>::bind(pos, _val, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		getBinder()->reset();
+	}
+
+private:
+	const T& _val;
+	bool     _bound;
+};
+
+
+typedef void (*BulkFnType)();
+
+template <typename T> 
+BulkBinding<std::vector<T> >* use(const std::vector<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation.
+{
+	return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+BulkBinding<std::vector<T> >* in(const std::vector<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation.
+{
+	return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_BulkBinding_INCLUDED
diff --git a/Data/include/Poco/Data/BulkExtraction.h b/Data/include/Poco/Data/BulkExtraction.h
new file mode 100644
index 000000000..ce035ee05
--- /dev/null
+++ b/Data/include/Poco/Data/BulkExtraction.h
@@ -0,0 +1,168 @@
+//
+// BulkExtraction.h
+//
+// $Id: //poco/Main/Data/include/Poco/Data/BulkExtraction.h#9 $
+//
+// Library: Data
+// Package: DataCore
+// Module:  BulkExtraction
+//
+// Definition of the BulkExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#ifndef Data_BulkExtraction_INCLUDED
+#define Data_BulkExtraction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractExtraction.h"
+#include "Poco/Data/Bulk.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class T>
+class BulkExtraction: public AbstractExtraction
+	/// Specialization for bulk extraction of values from a query result set.
+	/// Bulk extraction support is provided only for following STL containers:
+	/// - std::vector
+	/// - std::deque
+	/// - std::list
+{
+public:
+	BulkExtraction(T& result, Poco::UInt32 limit, Poco::UInt32 position = 0): 
+		AbstractExtraction(limit, position, true),
+		_rResult(result), 
+		_default()
+	{
+		if (static_cast<Poco::UInt32>(result.size()) != limit)
+			result.resize(limit);
+	}
+
+	virtual ~BulkExtraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _rResult.size();
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t col)
+	{
+		AbstractExtractor* pExt = getExtractor();
+		TypeHandler<T>::extract(col, _rResult, _default, pExt);
+		typename T::iterator it = _rResult.begin();
+		typename T::iterator end = _rResult.end();
+		for (int row = 0; it !=end; ++it, ++row)
+			_nulls.push_back(pExt->isNull(col, row));
+
+		return _rResult.size();
+	}
+
+	virtual void reset()
+	{
+	}
+
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t col)
+	{
+		Poco::UInt32 limit = getLimit();
+		if (limit != _rResult.size()) _rResult.resize(limit);
+		pPrep->setLength(limit);
+		return new Prepare<T>(pPrep, col, _rResult);
+	}
+
+protected:
+	const T& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	T&               _rResult;
+	T                _default; // copy the default
+	std::deque<bool> _nulls;
+};
+
+
+template <typename T> 
+BulkExtraction<std::vector<T> >* into(std::vector<T>& t, const Bulk& bulk)
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::vector bulk extraction support.
+{
+	return new BulkExtraction<std::vector<T> >(t, bulk.size());
+}
+
+
+template <typename T> 
+BulkExtraction<std::deque<T> >* into(std::deque<T>& t, const Bulk& bulk)
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::deque bulk extraction support.
+{
+	return new BulkExtraction<std::deque<T> >(t, bulk.size());
+}
+
+
+template <typename T> 
+BulkExtraction<std::list<T> >* into(std::list<T>& t, const Bulk& bulk)
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::list bulk extraction support.
+{
+	return new BulkExtraction<std::list<T> >(t, bulk.size());
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_BulkExtraction_INCLUDED
diff --git a/Data/include/Poco/Data/DataException.h b/Data/include/Poco/Data/DataException.h
index 2f112c07c..34342a39b 100644
--- a/Data/include/Poco/Data/DataException.h
+++ b/Data/include/Poco/Data/DataException.h
@@ -57,10 +57,10 @@ POCO_DECLARE_EXCEPTION(Data_API, BindingException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, ExtractException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, LimitException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, NotSupportedException, DataException)
-POCO_DECLARE_EXCEPTION(Data_API, NotImplementedException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, SessionUnavailableException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, SessionPoolExhaustedException, DataException)
 POCO_DECLARE_EXCEPTION(Data_API, NoDataException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, LengthExceededException, DataException)
 
 
 } } // namespace Poco::Data
diff --git a/Data/include/Poco/Data/Extraction.h b/Data/include/Poco/Data/Extraction.h
index 7d8aa1fee..712b9a9e3 100644
--- a/Data/include/Poco/Data/Extraction.h
+++ b/Data/include/Poco/Data/Extraction.h
@@ -45,6 +45,7 @@
 #include "Poco/Data/Prepare.h"
 #include "Poco/Data/TypeHandler.h"
 #include "Poco/Data/Column.h"
+#include "Poco/Data/Position.h"
 #include "Poco/Data/DataException.h"
 #include <set>
 #include <vector>
@@ -63,8 +64,8 @@ class Extraction: public AbstractExtraction
 	/// Concrete Data Type specific extraction of values from a query result set.
 {
 public:
-	Extraction(T& result, Poco::UInt32 position = 0):
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(T& result, const Position& pos = Position(0)):
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(), 
 		_extracted(false)
@@ -73,8 +74,8 @@ public:
 	{
 	}
 
-	Extraction(T& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(T& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def), 
 		_extracted(false)
@@ -108,13 +109,14 @@ public:
 		return _null;
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		if (_extracted) throw ExtractException("value already extracted");
 		_extracted = true;
 		AbstractExtractor* pExt = getExtractor();
 		TypeHandler<T>::extract(pos, _rResult, _default, pExt);
 		_null = pExt->isNull(pos);
+		return 1u;
 	}
 
 	void reset()
@@ -122,14 +124,14 @@ public:
 		_extracted = false;
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
-		return new Prepare<T>(pPrep, pos, _default);
+		return new Prepare<T>(pPrep, pos, _rResult);
 	}
 
 private:
 	T&   _rResult;
-	T    _default;   // copy the default
+	T    _default;
 	bool _extracted;
 	bool _null;
 };
@@ -140,18 +142,21 @@ class Extraction<std::vector<T> >: public AbstractExtraction
 	/// Vector Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::vector<T>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::vector<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
+
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::vector<T>& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::vector<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	virtual ~Extraction()
@@ -184,24 +189,20 @@ public:
 		}
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		AbstractExtractor* pExt = getExtractor();
-
-		// for vector specialization, a temporary must be used to
-		// allow for extraction of bool values
-		T tmp = _default;
-		TypeHandler<T>::extract(pos, tmp, _default, pExt);
-		_rResult.push_back(tmp);
-		
+		_rResult.push_back(_default);
+		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
 		_nulls.push_back(pExt->isNull(pos));
+		return 1u;
 	}
 
 	virtual void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<T>(pPrep, pos, _default);
 	}
@@ -215,28 +216,115 @@ protected:
 
 private:
 	std::vector<T>&  _rResult;
-	T                _default; // copy the default
+	T                _default;
 	std::deque<bool> _nulls;
 };
 
 
+template <>
+class Extraction<std::vector<bool> >: public AbstractExtraction
+	/// Vector bool specialization for extraction of values from a query result set.
+{
+public:
+	Extraction(std::vector<bool>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::vector<bool>& result, const bool& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	virtual ~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<bool>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _rResult.size();
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		AbstractExtractor* pExt = getExtractor();
+
+		bool tmp = _default;
+		TypeHandler<bool>::extract(pos, tmp, _default, pExt);
+		_rResult.push_back(tmp);
+		_nulls.push_back(pExt->isNull(pos));
+		return 1u;
+	}
+
+	virtual void reset()
+	{
+	}
+
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
+	{
+		return new Prepare<bool>(pPrep, pos, _default);
+	}
+
+protected:
+
+	const std::vector<bool>& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	std::vector<bool>& _rResult;
+	bool               _default;
+	std::deque<bool>   _nulls;
+};
+
+
 template <class T>
 class Extraction<std::list<T> >: public AbstractExtraction
 	/// List Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::list<T>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::list<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::list<T>& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::list<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	virtual ~Extraction()
@@ -269,19 +357,20 @@ public:
 		}
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		AbstractExtractor* pExt = getExtractor();
 		_rResult.push_back(_default);
 		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
 		_nulls.push_back(pExt->isNull(pos));
+		return 1u;
 	}
 
 	virtual void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<T>(pPrep, pos, _default);
 	}
@@ -295,7 +384,7 @@ protected:
 
 private:
 	std::list<T>&    _rResult;
-	T                _default; // copy the default
+	T                _default;
 	std::deque<bool> _nulls;
 };
 
@@ -305,18 +394,20 @@ class Extraction<std::deque<T> >: public AbstractExtraction
 	/// Deque Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::deque<T>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::deque<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::deque<T>& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::deque<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	virtual ~Extraction()
@@ -349,19 +440,20 @@ public:
 		}
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		AbstractExtractor* pExt = getExtractor();
 		_rResult.push_back(_default);
 		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
 		_nulls.push_back(pExt->isNull(pos));
+		return 1u;
 	}
 
 	virtual void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<T>(pPrep, pos, _default);
 	}
@@ -375,7 +467,7 @@ protected:
 
 private:
 	std::deque<T>&   _rResult;
-	T                _default; // copy the default
+	T                _default;
 	std::deque<bool> _nulls;
 };
 
@@ -393,8 +485,8 @@ class InternalExtraction: public Extraction<C>
 	/// InternalExtraction objects can not be copied or assigned.
 {
 public:
-	explicit InternalExtraction(C& result, Column<T,C>* pColumn, Poco::UInt32 position = 0): 
-		Extraction<C>(result, T(), position), 
+	explicit InternalExtraction(C& result, Column<T,C>* pColumn, const Position& pos = Position(0)): 
+		Extraction<C>(result, T(), pos), 
 		_pColumn(pColumn)
 		/// Creates InternalExtraction.
 	{
@@ -447,18 +539,22 @@ class Extraction<std::set<T> >: public AbstractExtraction
 	/// Set Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::set<T>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	typedef typename std::set<T>::iterator Iterator;
+
+	Extraction(std::set<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::set<T>& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::set<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	~Extraction()
@@ -480,25 +576,26 @@ public:
 		return getLimit();
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		T tmp;
 		TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
 		_rResult.insert(tmp);
+		return 1u;
 	}
 
 	void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<T>(pPrep, pos, _default);
 	}
 
 private:
 	std::set<T>& _rResult;
-	T            _default; // copy the default
+	T            _default;
 };
 
 
@@ -507,18 +604,20 @@ class Extraction<std::multiset<T> >: public AbstractExtraction
 	/// Multiset Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::multiset<T>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::multiset<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::multiset<T>& result, const T& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::multiset<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	~Extraction()
@@ -540,25 +639,26 @@ public:
 		return getLimit();
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		T tmp;
 		TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
 		_rResult.insert(tmp);
+		return 1u;
 	}
 
 	void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<T>(pPrep, pos, _default);
 	}
 
 private:
 	std::multiset<T>& _rResult;
-	T                 _default; // copy the default
+	T                 _default;
 };
 
 
@@ -567,18 +667,20 @@ class Extraction<std::map<K, V> >: public AbstractExtraction
 	/// Map Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::map<K, V>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::map<K, V>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::map<K, V>& result, const V& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::map<K, V>& result, const V& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	~Extraction()
@@ -600,18 +702,19 @@ public:
 		return getLimit();
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		V tmp;
 		TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
 		_rResult.insert(std::make_pair(tmp(), tmp));
+		return 1u;
 	}
 
 	void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<V>(pPrep, pos, _default);
 	}
@@ -619,7 +722,7 @@ public:
 
 private:
 	std::map<K, V>& _rResult;
-	V               _default; // copy the default
+	V               _default;
 };
 
 
@@ -628,18 +731,20 @@ class Extraction<std::multimap<K, V> >: public AbstractExtraction
 	/// Multimap Data Type specialization for extraction of values from a query result set.
 {
 public:
-	Extraction(std::multimap<K, V>& result, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::multimap<K, V>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default()
 	{
+		_rResult.clear();
 	}
 
-	Extraction(std::multimap<K, V>& result, const V& def, Poco::UInt32 position = 0): 
-		AbstractExtraction(Limit::LIMIT_UNLIMITED, position),
+	Extraction(std::multimap<K, V>& result, const V& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
 		_rResult(result), 
 		_default(def)
 	{
+		_rResult.clear();
 	}
 
 	~Extraction()
@@ -661,38 +766,40 @@ public:
 		return getLimit();
 	}
 
-	void extract(std::size_t pos)
+	std::size_t extract(std::size_t pos)
 	{
 		V tmp;
 		TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
 		_rResult.insert(std::make_pair(tmp(), tmp));
+		return 1u;
 	}
 
 	void reset()
 	{
 	}
 
-	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) const
+	AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos)
 	{
 		return new Prepare<V>(pPrep, pos, _default);
 	}
 
 private:
 	std::multimap<K, V>& _rResult;
-	V                    _default; // copy the default
+	V                    _default;
 };
 
 
 template <typename T> 
-Extraction<T>* into(T& t, Poco::UInt32 pos = 0)
+Extraction<T>* into(T& t, const Position& pos = 0)
 	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with multiple recordset support.
 {
 	return new Extraction<T>(t, pos);
 }
 
 
 template <typename T> 
-Extraction<T>* into(T& t, Poco::UInt32 pos, const T& def)
+Extraction<T>* into(T& t, const Position& pos, const T& def)
 	/// Convenience function to allow for a more compact creation of an extraction object with the given default
 {
 	return new Extraction<T>(t, def, pos);
diff --git a/Data/include/Poco/Data/Limit.h b/Data/include/Poco/Data/Limit.h
index 8b872129f..c8b0c3b73 100644
--- a/Data/include/Poco/Data/Limit.h
+++ b/Data/include/Poco/Data/Limit.h
@@ -77,6 +77,12 @@ public:
 	bool isLowerLimit() const;
 		/// Returns true if the limit is a lower limit, otherwise it is an upperLimit
 
+	bool operator == (const Limit& other) const;
+		/// Equality operator.
+
+	bool operator != (const Limit& other) const;
+		/// Inequality operator.
+
 private:
 	Poco::UInt32 _value;
 	bool         _hardLimit;
@@ -105,6 +111,22 @@ inline bool Limit::isLowerLimit() const
 }
 
 
+inline bool Limit::operator == (const Limit& other) const
+{
+	return other._value == _value &&
+		other._hardLimit == _hardLimit &&
+		other._isLowerLimit == _isLowerLimit;
+}
+
+
+inline bool Limit::operator != (const Limit& other) const
+{
+	return other._value != _value ||
+		other._hardLimit != _hardLimit ||
+		other._isLowerLimit != _isLowerLimit;
+}
+
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/Step.h b/Data/include/Poco/Data/Position.h
similarity index 65%
rename from Data/include/Poco/Data/Step.h
rename to Data/include/Poco/Data/Position.h
index 7d2b65eac..109d3bfdd 100644
--- a/Data/include/Poco/Data/Step.h
+++ b/Data/include/Poco/Data/Position.h
@@ -1,13 +1,13 @@
 //
-// Step.h
+// PositionExtraction.h
 //
-// $Id: //poco/Main/Data/include/Poco/Data/Step.h#7 $
+// $Id: //poco/Main/Data/include/Poco/Data/Position.h#9 $
 //
 // Library: Data
 // Package: DataCore
-// Module:  Step
+// Module:  Position
 //
-// Definition of the Step class.
+// Definition of the PositionExtraction class.
 //
 // Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
 // and Contributors.
@@ -36,59 +36,56 @@
 //
 
 
-#ifndef Data_Step_INCLUDED
-#define Data_Step_INCLUDED
+#ifndef Data_Position_INCLUDED
+#define Data_Position_INCLUDED
 
 
-#include "Poco/Data/Data.h"
+#include "Poco/Data/Limit.h"
 
 
 namespace Poco {
 namespace Data {
 
 
-class Data_API Step
-	/// Step stores information how many rows should be returned at evry advance through the recordset.
+class Data_API Position
+	/// Utility class wrapping unsigned integer. Used to
+	/// indicate the recordset position in batch SQL statements.
 {
 public:
-	enum
-	{
-		DEFAULT_STEP = 1u
-	};
+	Position(Poco::UInt32 value);
+		/// Creates the Position.
 
-	Step(Poco::UInt32 value = 1u);
-		/// Creates the Step. 
-		///
-		/// Value contains the step and defaults to DEFAULT_STEP.
-
-	~Step();
-		/// Destroys the Step.
+	~Position();
+		/// Destroys the Position.
 
 	Poco::UInt32 value() const;
-		/// Returns the value of the limit
-
+		/// Returns the position value.
+	
 private:
+	Position();
+
 	Poco::UInt32 _value;
 };
 
 
-//
-// inlines
-//
-inline Poco::UInt32 Step::value() const
-{
-	return _value;
+///
+/// inlines
+///
+inline Poco::UInt32 Position::value() const 
+{ 
+	return _value; 
 }
 
 
-template <typename T> 
-Step step(T step)
+template <typename T>
+inline Position from(const T& value)
+	/// Convenience function for creation of position.
 {
-	return Step(static_cast<Poco::UInt32>(step));
+	return Position(value);
 }
 
 
 } } // namespace Poco::Data
 
 
-#endif // Data_Step_INCLUDED
+#endif // Data_Position_INCLUDED
diff --git a/Data/include/Poco/Data/Prepare.h b/Data/include/Poco/Data/Prepare.h
index 5cca9e7a1..d3bb2c9e4 100644
--- a/Data/include/Poco/Data/Prepare.h
+++ b/Data/include/Poco/Data/Prepare.h
@@ -44,11 +44,7 @@
 #include "Poco/Data/AbstractPrepare.h"
 #include "Poco/Data/TypeHandler.h"
 #include <cstddef>
-#include <map>
-#include <set>
 #include <vector>
-#include <list>
-#include <deque>
 
 
 namespace Poco {
@@ -60,7 +56,10 @@ class Prepare: public AbstractPrepare
 	/// Class for calling the appropriate AbstractPreparation method.
 {
 public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
+	Prepare(AbstractPreparation* pPrepare, std::size_t pos, T& val): 
+		AbstractPrepare(pPrepare), 
+		_pos(pos), 
+		_val(val)
 		/// Creates the Prepare.
 	{
 	}
@@ -78,16 +77,21 @@ public:
 
 private:
 	std::size_t _pos;
-	const T&    _val;
+	T&          _val;
 };
 
 
 template<typename T>
 class Prepare<std::vector<T> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
+	/// Prepare specialization for std::vector.
+	/// This specialization is needed for bulk operations to enforce
+	/// the whole vector preparation, rather than only individual contained values.
 {
 public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
+	Prepare(AbstractPreparation* pPrepare, std::size_t pos, std::vector<T>& val = std::vector<T>()): 
+		AbstractPrepare(pPrepare), 
+		_pos(pos), 
+		_val(val)
 		/// Creates the Prepare.
 	{
 	}
@@ -100,174 +104,12 @@ public:
 	void prepare()
 		/// Prepares data.
 	{
-		TypeHandler<T>::prepare(_pos, _val, preparation());
+		TypeHandler<std::vector<T> >::prepare(_pos, _val, preparation());
 	}
 
 private:
-	std::size_t _pos;
-	const T&    _val;
-};
-
-
-template<typename T>
-class Prepare<std::list<T> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<T>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const T&    _val;
-};
-
-
-template<typename T>
-class Prepare<std::deque<T> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<T>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const T&    _val;
-};
-
-
-template<typename T>
-class Prepare<std::set<T> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<T>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const T&    _val;
-};
-
-
-template<typename T>
-class Prepare<std::multiset<T> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const T& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<T>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const T&    _val;
-};
-
-
-template<typename K, typename V>
-class Prepare<std::map<K, V> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const V& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<V>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const V&    _val;
-};
-
-
-template<typename K, typename V>
-class Prepare<std::multimap<K, V> >: public AbstractPrepare
-	/// Class for calling the appropriate AbstractPreparation method.
-{
-public:
-	Prepare(AbstractPreparation* pPrepare, std::size_t pos, const V& val): AbstractPrepare(pPrepare), _pos(pos), _val(val)
-		/// Creates the Prepare.
-	{
-	}
-
-	~Prepare()
-		/// Destroys the Prepare.
-	{
-	}
-
-	void prepare()
-		/// Prepares data.
-	{
-		TypeHandler<V>::prepare(_pos, _val, preparation());
-	}
-
-private:
-	std::size_t _pos;
-	const V&    _val;
+	std::size_t     _pos;
+	std::vector<T>& _val;
 };
 
 
diff --git a/Data/include/Poco/Data/Statement.h b/Data/include/Poco/Data/Statement.h
index e739c2b77..acfab024b 100644
--- a/Data/include/Poco/Data/Statement.h
+++ b/Data/include/Poco/Data/Statement.h
@@ -43,7 +43,7 @@
 #include "Poco/Data/Data.h"
 #include "Poco/Data/StatementImpl.h"
 #include "Poco/Data/Range.h"
-#include "Poco/Data/Step.h"
+#include "Poco/Data/Bulk.h"
 #include "Poco/SharedPtr.h"
 #include "Poco/Mutex.h"
 #include "Poco/ActiveMethod.h"
@@ -171,15 +171,24 @@ public:
 	}
 
 	Statement& operator , (Manipulator manip);
-		/// Handles manipulators, such as now.
+		/// Handles manipulators, such as now, async, etc.
 
 	Statement& operator , (AbstractBinding* info);
-		/// Registers the Binding at the Statement
+		/// Registers the Binding at the Statement.
 
 	Statement& operator , (AbstractExtraction* extract);
 		/// Registers objects used for extracting data at the Statement.
-		/// the position argument is used by connectors that support multilple
-		/// recordsets to specify which recordset this extraction belongs to.
+
+	Statement& operator , (const Bulk& bulk);
+		/// Sets the bulk execution mode (both binding and extraction) for this 
+		/// statement.Statement must not have any extracors or binders set at the 
+		/// time when this operator is applied. 
+		/// Failure to adhere to the above constraint shall result in 
+		/// InvalidAccessException.
+		/// Additionally, any binding buffers passed to the statement later 
+		/// through use() or in() must be of the same size (determined by size 
+		/// of the bulk passed to this function). Since they are resized automatically
+		/// by the framework, the extraction buffers do not have to adhere to this.
 
 	Statement& operator , (const Limit& extrLimit);
 		/// Sets a limit on the maximum number of rows a select is allowed to return.
@@ -191,14 +200,8 @@ public:
 		///
 		/// Set per default to Limit::LIMIT_UNLIMITED which disables the range.
 
-	Statement& operator , (const Step& extrStep);
-		/// Sets a an extraction step (the number of rows a select is allowed to return 
-		/// on every fetch attempt).
-		///
-		/// Set per default to Step::DEFAULT_STEP (1 row at a time).
-
 	std::string toString() const;
-		/// Creates a string from the accumulated SQL statement
+		/// Creates a string from the accumulated SQL statement.
 
 	ResultType execute();
 		/// Executes the statement synchronously or asynchronously. 
@@ -296,85 +299,77 @@ private:
 // Manipulators
 //
 
-void Data_API now(Statement& statement);
+inline void Data_API now(Statement& statement)
 	/// Enforces immediate execution of the statement.
 	/// If _isAsync flag has been set, execution is invoked asynchronously.
+{
+	statement.execute();
+}
 
 
-void Data_API sync(Statement& statement);
+inline void Data_API sync(Statement& statement)
 	/// Sets the _isAsync flag to false, signalling synchronous execution.
 	/// Synchronous execution is default, so specifying this manipulator
 	/// only makes sense if async() was called for the statement before.
+{
+	statement.setAsync(false);
+}
 
 
-void Data_API async(Statement& statement);
-	/// Sets the _isAsync flag to true, signalling asynchronous execution.
+inline void Data_API async(Statement& statement)
+	/// Sets the _async flag to true, signalling asynchronous execution.
+{
+	statement.setAsync(true);
+}
 
 
-void Data_API deque(Statement& statement);
+inline void Data_API deque(Statement& statement)
 	/// Sets the internal storage to std::deque.
 	/// std::deque is default storage, so specifying this manipulator
 	/// only makes sense if list() or deque() were called for the statement before.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("deque");
+}
 
 
-void Data_API vector(Statement& statement);
+inline void Data_API vector(Statement& statement)
 	/// Sets the internal storage to std::vector.
-	
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
 
-void Data_API list(Statement& statement);
+	statement.setStorage("vector");
+}
+
+
+inline void Data_API list(Statement& statement)
 	/// Sets the internal storage to std::list.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("list");
+}
 
 
-void Data_API reset(Statement& statement);
+inline void Data_API reset(Statement& statement)
 	/// Sets all internal settings to their respective default values.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("deque");
+	statement.setAsync(false);
+}
 
 
 //
 // inlines
 //
 
-inline Statement& Statement::operator , (Manipulator manip)
-{
-	manip(*this);
-	return *this;
-}
-
-
-inline Statement& Statement::operator , (AbstractBinding* info)
-{
-	_pImpl->addBinding(info);
-	return *this;
-}
-
-
-inline Statement& Statement::operator , (AbstractExtraction* extract)
-{
-	_pImpl->addExtract(extract);
-	return *this;
-}
-
-
-inline Statement& Statement::operator , (const Limit& extrLimit)
-{
-	_pImpl->setExtractionLimit(extrLimit);
-	return *this;
-}
-
-
-inline Statement& Statement::operator , (const Range& extrRange)
-{
-	_pImpl->setExtractionLimit(extrRange.lower());
-	_pImpl->setExtractionLimit(extrRange.upper());
-	return *this;
-}
-
-
-inline Statement& Statement::operator , (const Step& extrStep)
-{
-	_pImpl->setStep(extrStep.value());
-	return *this;
-}
-
 
 inline std::string Statement::toString() const
 {
@@ -460,6 +455,7 @@ inline void swap(Statement& s1, Statement& s2)
 }
 
 
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/StatementImpl.h b/Data/include/Poco/Data/StatementImpl.h
index 4d584aa9d..4328539ab 100644
--- a/Data/include/Poco/Data/StatementImpl.h
+++ b/Data/include/Poco/Data/StatementImpl.h
@@ -44,6 +44,7 @@
 #include "Poco/Data/AbstractBinding.h"
 #include "Poco/Data/AbstractExtraction.h"
 #include "Poco/Data/Range.h"
+#include "Poco/Data/Bulk.h"
 #include "Poco/Data/Column.h"
 #include "Poco/Data/Extraction.h"
 #include "Poco/Data/SessionImpl.h"
@@ -86,6 +87,14 @@ public:
 		STORAGE_UNKNOWN_IMPL
 	};
 
+	enum BulkType
+	{
+		BULK_UNDEFINED,
+		BULK_BINDING,
+		BULK_EXTRACTION,
+		BULK_FORBIDDEN
+	};
+
 	static const std::string DEQUE;
 	static const std::string VECTOR;
 	static const std::string LIST;
@@ -133,12 +142,6 @@ public:
 	Storage getStorage() const;
 		/// Returns the storage type for this statement.
 
-	void setStep(Poco::UInt32 step);
-		/// Sets the step for this statement;
-
-	Poco::UInt32 getStep() const;
-		/// Returns the step type for this statement.
-
 	std::size_t extractionCount() const;
 		/// Returns the number of extraction storage buffers associated
 		/// with the statement.
@@ -168,7 +171,7 @@ protected:
 		/// returns the number of rows retreved.
 		///
 		/// Will throw, if the resultset is empty.
-		/// Expects the statement to be compiled and bound
+		/// Expects the statement to be compiled and bound.
 
 	virtual bool canBind() const = 0;
 		/// Returns if another bind is possible.
@@ -254,6 +257,12 @@ protected:
 	Poco::UInt32 activateNextDataSet();
 		/// Returns the next data set, or -1 if the last data set was reached.
 
+	Poco::UInt32 getExtractionLimit();
+		/// Returns the extraction limit value.
+
+	const Limit& extractionLimit() const;
+		/// Returns the extraction limit.
+
 private:
 	void compile();
 		/// Compiles the statement, if not yet compiled. doesn't bind yet
@@ -319,6 +328,31 @@ private:
 	bool isNull(std::size_t col, std::size_t row) const;
 		/// Returns true if the value in [col, row] is null.
 		
+	void forbidBulk();
+		/// Forbids bulk operations.
+
+	void setBulkBinding();
+		/// Sets the bulk binding flag.
+
+	void setBulkExtraction(const Bulk& l);
+		/// Sets the bulk extraction flag and extraction limit.
+
+	bool bulkBindingAllowed() const;
+		/// Returns true if statement can be set to bind data in bulk.
+		/// Once bulk binding is set for a statement, it can be
+		/// neither altered nor mixed with non-bulk mode binding.
+
+	bool bulkExtractionAllowed() const;
+		/// Returns true if statement can be set to extract data in bulk.
+		/// Once bulk extraction is set for a statement, it can be
+		/// neither altered nor mixed with non-bulk mode extraction.
+
+	bool isBulkBinding() const;
+		/// Returns true if statement is set to bind data in bulk.
+
+	bool isBulkExtraction() const;
+		/// Returns true if statement is set to extract data in bulk.
+
 	StatementImpl(const StatementImpl& stmt);
 	StatementImpl& operator = (const StatementImpl& stmt);
 
@@ -332,7 +366,8 @@ private:
 	AbstractBindingVec       _bindings;
 	AbstractExtractionVecVec _extractors;
 	Poco::UInt32             _curDataSet;
-	Poco::UInt32             _step;
+	BulkType                 _bulkBinding;
+	BulkType                 _bulkExtraction;
 
 	friend class Statement; 
 };
@@ -411,18 +446,6 @@ inline StatementImpl::Storage StatementImpl::getStorage() const
 }
 
 
-inline void StatementImpl::setStep(Poco::UInt32 step)
-{
-	_step = step;
-}
-
-
-inline Poco::UInt32 StatementImpl::getStep() const
-{
-	return _step;
-}
-
-
 inline std::size_t StatementImpl::extractionCount() const
 {
 	return extractions().size();
@@ -459,6 +482,57 @@ inline Poco::UInt32 StatementImpl::currentDataSet() const
 }
 
 
+inline Poco::UInt32 StatementImpl::getExtractionLimit()
+{
+	return _extrLimit.value();
+}
+
+
+inline const Limit& StatementImpl::extractionLimit() const
+{
+	return _extrLimit;
+}
+
+
+inline void StatementImpl::forbidBulk()
+{
+	_bulkBinding = BULK_FORBIDDEN;
+	_bulkExtraction = BULK_FORBIDDEN;
+}
+
+
+inline void StatementImpl::setBulkBinding()
+{
+	_bulkBinding = BULK_BINDING;
+}
+
+
+inline bool StatementImpl::bulkBindingAllowed() const
+{
+	return BULK_UNDEFINED == _bulkBinding ||
+		BULK_BINDING == _bulkBinding;
+}
+
+
+inline bool StatementImpl::bulkExtractionAllowed() const
+{
+	return BULK_UNDEFINED == _bulkExtraction ||
+		BULK_EXTRACTION == _bulkExtraction;
+}
+
+
+inline bool StatementImpl::isBulkBinding() const
+{
+	return BULK_BINDING == _bulkBinding;
+}
+
+
+inline bool StatementImpl::isBulkExtraction() const
+{
+	return BULK_EXTRACTION == _bulkExtraction;
+}
+
+
 } } // namespace Poco::Data
 
 
diff --git a/Data/include/Poco/Data/TypeHandler.h b/Data/include/Poco/Data/TypeHandler.h
index b8d54ca38..263a3345f 100644
--- a/Data/include/Poco/Data/TypeHandler.h
+++ b/Data/include/Poco/Data/TypeHandler.h
@@ -52,8 +52,21 @@ namespace Poco {
 namespace Data {
 
 
+class AbstractTypeHandler
+	/// Parent class for type handlers. 
+	/// The reason for this class is to prevent instantiations of type handlers.
+	/// For documentation on type handlers, see TypeHandler class.
+{
+protected:
+	AbstractTypeHandler();
+	~AbstractTypeHandler();
+	AbstractTypeHandler(const AbstractTypeHandler&);
+	AbstractTypeHandler& operator = (const AbstractTypeHandler&);
+};
+
+
 template <class T>
-class TypeHandler
+class TypeHandler: public AbstractTypeHandler
 	/// Converts Rows to a Type and the other way around. Provide template specializations to support your own complex types.
 	///
 	/// Take as example the following (simplified) class:
@@ -66,7 +79,7 @@ class TypeHandler
 	///        [....] // public set/get methods, a default constructor, optional < operator (for set, multiset) or function operator (for map, multimap)
 	///    };
 	///
-	/// The TypeHandler must provide a costum bind, size, prepare and extract method:
+	/// The TypeHandler must provide a custom bind, size, prepare and extract method:
 	///    
 	///    template <>
 	///    class TypeHandler<struct Person>
@@ -132,19 +145,16 @@ public:
 	static void extract(std::size_t pos, T& obj, const T& defVal, AbstractExtractor* pExt)
 	{
 		poco_assert_dbg (pExt != 0);
-		if (!pExt->extract(pos, obj))
-			obj = defVal;
+		if (!pExt->extract(pos, obj)) obj = defVal;
 	}
 
-	static void prepare(std::size_t pos, const T& obj, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, T& obj, AbstractPreparation* pPrepare)
 	{
 		poco_assert_dbg (pPrepare != 0);
 		pPrepare->prepare(pos, obj);
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator = (const TypeHandler&);
 };
@@ -204,7 +214,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<19>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -280,8 +290,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -336,7 +344,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<18>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -409,8 +417,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -463,7 +469,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<17>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -533,8 +539,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -585,7 +589,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<16>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -652,8 +656,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -702,7 +704,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<15>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -766,8 +768,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -814,7 +814,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<14>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -875,8 +875,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -921,7 +919,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<13>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -979,8 +977,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1023,7 +1019,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<12>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1078,8 +1074,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1120,7 +1114,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<11>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1172,8 +1166,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1212,7 +1204,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<10>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1261,8 +1253,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1290,7 +1280,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<9>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1336,8 +1326,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1364,7 +1352,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<8>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1407,8 +1395,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1434,7 +1420,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<7>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1474,8 +1460,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1500,7 +1484,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<6>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1537,8 +1521,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1562,7 +1544,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<5>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1596,8 +1578,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1620,7 +1600,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<4>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1651,8 +1631,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1674,7 +1652,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<3>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1702,8 +1680,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1724,7 +1700,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<2>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1749,8 +1725,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1770,7 +1744,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<1>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1792,8 +1766,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
@@ -1812,7 +1784,7 @@ public:
 		pBinder->bind(pos++, tuple.template get<0>(), dir);
 	}
 
-	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparation* pPrepare)
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparation* pPrepare)
 	{
 		poco_assert (pPrepare != 0);
 		pPrepare->prepare(pos++, tuple.template get<0>());
@@ -1832,8 +1804,6 @@ public:
 	}
 
 private:
-	TypeHandler();
-	~TypeHandler();
 	TypeHandler(const TypeHandler&);
 	TypeHandler& operator=(const TypeHandler&);
 };
diff --git a/Data/src/AbstractBinder.cpp b/Data/src/AbstractBinder.cpp
index f2ef1ff4f..35a998ece 100644
--- a/Data/src/AbstractBinder.cpp
+++ b/Data/src/AbstractBinder.cpp
@@ -35,10 +35,13 @@
 
 
 #include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Data/BLOB.h"
 #include "Poco/Data/DataException.h"
+#include "Poco/DateTime.h"
 #include "Poco/Any.h"
 #include "Poco/DynamicAny.h"
-#include "Poco/Data/BLOB.h"
 
 
 namespace Poco {
@@ -55,40 +58,162 @@ AbstractBinder::~AbstractBinder()
 }
 
 
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+	
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+void AbstractBinder::bind(std::size_t pos, const std::vector<long>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+#endif
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<bool>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<float>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<double>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<char>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<std::string>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Date>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Time>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<NullData>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
 void AbstractBinder::bind(std::size_t pos, const Any& val, Direction dir)
 {
-	if(val.type() == typeid(Int32))
+	const std::type_info& type = val.type();
+
+	if(type == typeid(Int32))
 		bind(pos, RefAnyCast<Int32>(val), dir);
-	else if(val.type() == typeid(std::string))
+	else if(type == typeid(std::string))
 		bind(pos, RefAnyCast<std::string>(val), dir);
-	else if (val.type() == typeid(bool))
+	else if (type == typeid(bool))
 		bind(pos, RefAnyCast<bool>(val), dir);
-	else if(val.type() == typeid(char))
+	else if(type == typeid(char))
 		bind(pos, RefAnyCast<char>(val), dir);
-	else if(val.type() == typeid(Int8))
+	else if(type == typeid(Int8))
 		bind(pos, RefAnyCast<Int8>(val), dir);
-	else if(val.type() == typeid(UInt8))
+	else if(type == typeid(UInt8))
 		bind(pos, RefAnyCast<UInt8>(val), dir);
-	else if(val.type() == typeid(Int16))
+	else if(type == typeid(Int16))
 		bind(pos, RefAnyCast<Int16>(val), dir);
-	else if(val.type() == typeid(UInt16))
+	else if(type == typeid(UInt16))
 		bind(pos, RefAnyCast<UInt16>(val), dir);
-	else if(val.type() == typeid(UInt32))
+	else if(type == typeid(UInt32))
 		bind(pos, RefAnyCast<UInt32>(val), dir);
-	else if(val.type() == typeid(Int64))
+	else if(type == typeid(Int64))
 		bind(pos, RefAnyCast<Int64>(val), dir);
-	else if(val.type() == typeid(UInt64))
+	else if(type == typeid(UInt64))
 		bind(pos, RefAnyCast<UInt64>(val), dir);
-	else if(val.type() == typeid(float))
+	else if(type == typeid(float))
 		bind(pos, RefAnyCast<float>(val), dir);
-	else if(val.type() == typeid(double))
+	else if(type == typeid(double))
 		bind(pos, RefAnyCast<double>(val), dir);
-	else if(val.type() == typeid(DateTime))
+	else if(type == typeid(DateTime))
 		bind(pos, RefAnyCast<DateTime>(val), dir);
-	else if(val.type() == typeid(BLOB))
+	else if(type == typeid(Date))
+		bind(pos, RefAnyCast<Date>(val), dir);
+	else if(type == typeid(Time))
+		bind(pos, RefAnyCast<Time>(val), dir);
+	else if(type == typeid(BLOB))
 		bind(pos, RefAnyCast<BLOB>(val), dir);
 #ifndef POCO_LONG_IS_64_BIT
-	else if(val.type() == typeid(long))
+	else if(type == typeid(long))
 		bind(pos, RefAnyCast<long>(val), dir);
 #endif
 	else
@@ -98,38 +223,44 @@ void AbstractBinder::bind(std::size_t pos, const Any& val, Direction dir)
 
 void AbstractBinder::bind(std::size_t pos, const DynamicAny& val, Direction dir)
 {
-	if(val.type() == typeid(Int32))
+	const std::type_info& type = val.type();
+
+	if(type == typeid(Int32))
 		bind(pos, val.extract<Int32>(), dir);
-	else if(val.type() == typeid(std::string))
+	else if(type == typeid(std::string))
 		bind(pos, val.extract<std::string>(), dir);
-	else if (val.type() == typeid(bool))
+	else if (type == typeid(bool))
 		bind(pos, val.extract<bool>(), dir);
-	else if(val.type() == typeid(char))
+	else if(type == typeid(char))
 		bind(pos, val.extract<char>(), dir);
-	else if(val.type() == typeid(Int8))
+	else if(type == typeid(Int8))
 		bind(pos, val.extract<Int8>(), dir);
-	else if(val.type() == typeid(UInt8))
+	else if(type == typeid(UInt8))
 		bind(pos, val.extract<UInt8>(), dir);
-	else if(val.type() == typeid(Int16))
+	else if(type == typeid(Int16))
 		bind(pos, val.extract<Int16>(), dir);
-	else if(val.type() == typeid(UInt16))
+	else if(type == typeid(UInt16))
 		bind(pos, val.extract<UInt16>(), dir);
-	else if(val.type() == typeid(UInt32))
+	else if(type == typeid(UInt32))
 		bind(pos, val.extract<UInt32>(), dir);
-	else if(val.type() == typeid(Int64))
+	else if(type == typeid(Int64))
 		bind(pos, val.extract<Int64>(), dir);
-	else if(val.type() == typeid(UInt64))
+	else if(type == typeid(UInt64))
 		bind(pos, val.extract<UInt64>(), dir);
-	else if(val.type() == typeid(float))
+	else if(type == typeid(float))
 		bind(pos, val.extract<float>(), dir);
-	else if(val.type() == typeid(double))
+	else if(type == typeid(double))
 		bind(pos, val.extract<double>(), dir);
-	else if(val.type() == typeid(DateTime))
+	else if(type == typeid(DateTime))
 		bind(pos, val.extract<DateTime>(), dir);
-	else if(val.type() == typeid(BLOB))
+	else if(type == typeid(Date))
+		bind(pos, val.extract<Date>(), dir);
+	else if(type == typeid(Time))
+		bind(pos, val.extract<Time>(), dir);
+	else if(type == typeid(BLOB))
 		bind(pos, val.extract<BLOB>(), dir);
 #ifndef POCO_LONG_IS_64_BIT
-	else if(val.type() == typeid(long))
+	else if(type == typeid(long))
 		bind(pos, val.extract<long>(), dir);
 #endif
 	else
diff --git a/Data/src/AbstractBinding.cpp b/Data/src/AbstractBinding.cpp
index 47f0daefb..526507c6e 100644
--- a/Data/src/AbstractBinding.cpp
+++ b/Data/src/AbstractBinding.cpp
@@ -41,10 +41,13 @@ namespace Poco {
 namespace Data {
 
 
-AbstractBinding::AbstractBinding(const std::string& name, Direction direction): 
+AbstractBinding::AbstractBinding(const std::string& name, 
+	Direction direction, 
+	Poco::UInt32 bulkSize): 
 	_pBinder(0),
 	_name(name),
-	_direction(direction)
+	_direction(direction),
+	_bulkSize(bulkSize)
 {
 }
 
diff --git a/Data/src/AbstractExtraction.cpp b/Data/src/AbstractExtraction.cpp
index 3f08aae86..5703a687e 100644
--- a/Data/src/AbstractExtraction.cpp
+++ b/Data/src/AbstractExtraction.cpp
@@ -42,10 +42,12 @@ namespace Data {
 
 
 AbstractExtraction::AbstractExtraction(Poco::UInt32 limit,
-	Poco::UInt32 position): 
+	Poco::UInt32 position,
+	bool bulk): 
 	_pExtractor(0), 
 	_limit(limit),
-	_position(position)
+	_position(position),
+	_bulk(bulk)
 {
 }
 
diff --git a/Data/src/AbstractExtractor.cpp b/Data/src/AbstractExtractor.cpp
index 2fe55147b..9abe3f77d 100644
--- a/Data/src/AbstractExtractor.cpp
+++ b/Data/src/AbstractExtractor.cpp
@@ -35,6 +35,7 @@
 
 
 #include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Exception.h"
 
 
 namespace Poco {
@@ -51,4 +52,126 @@ AbstractExtractor::~AbstractExtractor()
 }
 
 
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+bool AbstractExtractor::extract(std::size_t pos, std::vector<long>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+#endif
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<bool>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<float>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<double>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<char>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<std::string>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<BLOB>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<DateTime>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Date>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Time>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Any>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<DynamicAny>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
 } } // namespace Poco::Data
diff --git a/Data/src/AbstractPreparation.cpp b/Data/src/AbstractPreparation.cpp
index d28ee989b..e9b63b525 100644
--- a/Data/src/AbstractPreparation.cpp
+++ b/Data/src/AbstractPreparation.cpp
@@ -41,7 +41,8 @@ namespace Poco {
 namespace Data {
 
 
-AbstractPreparation::AbstractPreparation()
+AbstractPreparation::AbstractPreparation(Poco::UInt32 length): 
+	_length(length)
 {
 }
 
@@ -51,4 +52,126 @@ AbstractPreparation::~AbstractPreparation()
 }
 
 
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+void AbstractPreparation::prepare(std::size_t pos, std::vector<long>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+#endif
+
+
+ void AbstractPreparation::prepare(std::size_t pos, std::vector<bool>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, std::vector<float>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, std::vector<double>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, std::vector<char>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<std::string>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<BLOB>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<DateTime>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<Date>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<Time>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+ void AbstractPreparation::prepare(std::size_t pos, const std::vector<Any>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
+void AbstractPreparation::prepare(std::size_t pos, const std::vector<DynamicAny>& val)
+{
+	throw NotImplementedException("std::vector preparation must be implemented.");
+}
+
+
 } } // namespace Poco::Data
diff --git a/Data/src/Bulk.cpp b/Data/src/Bulk.cpp
new file mode 100644
index 000000000..0ec9e352f
--- /dev/null
+++ b/Data/src/Bulk.cpp
@@ -0,0 +1,59 @@
+//
+// Bulk.cpp
+//
+// $Id: //poco/Main/Data/src/Bulk.cpp#7 $
+//
+// Library: Data
+// Package: DataCore
+// Module:  Bulk
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/Data/Bulk.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Bulk::Bulk(const Limit& limit): _limit(limit.value(), false, false)
+{
+}
+
+
+Bulk::Bulk(Poco::UInt32 value): _limit(value, false, false)
+{
+}
+
+
+Bulk::~Bulk()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/Data/src/DataException.cpp b/Data/src/DataException.cpp
index ff499095c..59bc29625 100644
--- a/Data/src/DataException.cpp
+++ b/Data/src/DataException.cpp
@@ -51,10 +51,10 @@ POCO_IMPLEMENT_EXCEPTION(BindingException, DataException, "Binding error")
 POCO_IMPLEMENT_EXCEPTION(ExtractException, DataException, "Extraction error")
 POCO_IMPLEMENT_EXCEPTION(LimitException, DataException, "Limit error")
 POCO_IMPLEMENT_EXCEPTION(NotSupportedException, DataException, "Feature or property not supported")
-POCO_IMPLEMENT_EXCEPTION(NotImplementedException, DataException, "Feature or property not implemented")
 POCO_IMPLEMENT_EXCEPTION(SessionUnavailableException, DataException, "Session is unavailable")
 POCO_IMPLEMENT_EXCEPTION(SessionPoolExhaustedException, DataException, "No more sessions available from the session pool")
 POCO_IMPLEMENT_EXCEPTION(NoDataException, DataException, "No data found")
+POCO_IMPLEMENT_EXCEPTION(LengthExceededException, DataException, "Data too long")
 
 
 } } // namespace Poco::Data
diff --git a/Data/src/Step.cpp b/Data/src/Position.cpp
similarity index 86%
rename from Data/src/Step.cpp
rename to Data/src/Position.cpp
index 18253f8a2..59c004335 100644
--- a/Data/src/Step.cpp
+++ b/Data/src/Position.cpp
@@ -1,11 +1,11 @@
 //
-// Step.cpp
+// Position.cpp
 //
-// $Id: //poco/Main/Data/src/Step.cpp#5 $
+// $Id: //poco/Main/Data/src/Position.cpp#7 $
 //
 // Library: Data
 // Package: DataCore
-// Module:  Step
+// Module:  Position
 //
 // Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
 // and Contributors.
@@ -34,20 +34,19 @@
 //
 
 
-#include "Poco/Data/Step.h"
+#include "Poco/Data/Position.h"
 
 
 namespace Poco {
 namespace Data {
 
 
-Step::Step(Poco::UInt32 value):
-	_value(value)
+Position::Position(Poco::UInt32 value): _value(value)
 {
 }
 
 
-Step::~Step()
+Position::~Position()
 {
 }
 
diff --git a/Data/src/Statement.cpp b/Data/src/Statement.cpp
index 5b12c9f36..6afed8e5b 100644
--- a/Data/src/Statement.cpp
+++ b/Data/src/Statement.cpp
@@ -38,6 +38,7 @@
 #include "Poco/Data/DataException.h"
 #include "Poco/Data/Extraction.h"
 #include "Poco/Data/Session.h"
+#include "Poco/Data/Bulk.h"
 #include "Poco/Any.h"
 #include "Poco/Tuple.h"
 #include "Poco/ActiveMethod.h"
@@ -189,58 +190,84 @@ const std::string& Statement::getStorage() const
 }
 
 
-void now(Statement& statement)
+Statement& Statement::operator , (Manipulator manip)
 {
-	statement.execute();
+	manip(*this);
+	return *this;
 }
 
 
-void sync(Statement& statement)
+Statement& Statement::operator , (AbstractBinding* pBind)
 {
-	statement.setAsync(false);
+	if (pBind->isBulk())
+	{
+		if(_pImpl->bulkBindingAllowed())
+			_pImpl->setBulkBinding();
+		else
+			throw InvalidAccessException("Bulk and non-bulk binding modes can not be mixed.");
+	}
+	else _pImpl->forbidBulk();
+
+	_pImpl->addBinding(pBind);
+	return *this;
 }
 
 
-void async(Statement& statement)
+Statement& Statement::operator , (AbstractExtraction* pExtract)
 {
-	statement.setAsync(true);
+	if (pExtract->isBulk())
+	{
+		if(_pImpl->bulkExtractionAllowed())
+		{
+			Bulk b(pExtract->getLimit());
+			_pImpl->setBulkExtraction(b);
+		}
+		else
+			throw InvalidAccessException("Bulk and non-bulk extraction modes can not be mixed.");
+	}
+	else _pImpl->forbidBulk();
+
+	_pImpl->addExtract(pExtract);
+	return *this;
 }
 
 
-void vector(Statement& statement)
+Statement& Statement::operator , (const Limit& extrLimit)
 {
-	if (!statement.canModifyStorage())
-		throw InvalidAccessException("Storage not modifiable.");
+	if (_pImpl->isBulkExtraction() && _pImpl->extractionLimit() != extrLimit)
+		throw InvalidArgumentException("Limit for bulk extraction already set.");
 
-	statement.setStorage("vector");
+	_pImpl->setExtractionLimit(extrLimit);
+	return *this;
 }
 
 
-void list(Statement& statement)
+Statement& Statement::operator , (const Range& extrRange)
 {
-	if (!statement.canModifyStorage())
-		throw InvalidAccessException("Storage not modifiable.");
+	if (_pImpl->isBulkExtraction())
+		throw InvalidAccessException("Can not set range for bulk extraction.");
 
-	statement.setStorage("list");
+	_pImpl->setExtractionLimit(extrRange.lower());
+	_pImpl->setExtractionLimit(extrRange.upper());
+	return *this;
 }
 
 
-void deque(Statement& statement)
+Statement& Statement::operator , (const Bulk& bulk)
 {
-	if (!statement.canModifyStorage())
-		throw InvalidAccessException("Storage not modifiable.");
+	if (0 == _pImpl->extractions().size() && 
+		0 == _pImpl->bindings().size() &&
+		_pImpl->bulkExtractionAllowed() &&
+		_pImpl->bulkBindingAllowed())
+	{
+		Limit l(_pImpl->getExtractionLimit(), false, false);
+		_pImpl->setBulkExtraction(bulk);
+		_pImpl->setBulkBinding();
+	}
+	else
+		throw InvalidAccessException("Can not set bulk operations.");
 
-	statement.setStorage("deque");
-}
-
-
-void reset(Statement& statement)
-{
-	if (!statement.canModifyStorage())
-		throw InvalidAccessException("Storage not modifiable.");
-
-	statement.setStorage("deque");
-	statement.setAsync(false);
+	return *this;
 }
 
 
diff --git a/Data/src/StatementImpl.cpp b/Data/src/StatementImpl.cpp
index 9b761bea2..daa7837b7 100644
--- a/Data/src/StatementImpl.cpp
+++ b/Data/src/StatementImpl.cpp
@@ -59,7 +59,6 @@ const std::string StatementImpl::LIST = "list";
 const std::string StatementImpl::DEQUE = "deque";
 const std::string StatementImpl::UNKNOWN = "unknown";
 
-
 StatementImpl::StatementImpl(SessionImpl& rSession):
 	_state(ST_INITIALIZED),
 	_extrLimit(upperLimit((Poco::UInt32) Limit::LIMIT_UNLIMITED, false)),
@@ -70,7 +69,8 @@ StatementImpl::StatementImpl(SessionImpl& rSession):
 	_ostr(),
 	_bindings(),
 	_curDataSet(0),
-	_step(1u)
+	_bulkBinding(BULK_UNDEFINED),
+	_bulkExtraction(BULK_UNDEFINED)
 {
 	_extractors.resize(1);
 }
@@ -94,9 +94,8 @@ Poco::UInt32 StatementImpl::execute()
 		lim = executeWithLimit();
 		
 	if (lim < _lowerLimit)
-	{
 		throw LimitException("Did not receive enough data.");
-	}
+
 	return lim;
 }
 
@@ -106,16 +105,17 @@ Poco::UInt32 StatementImpl::executeWithLimit()
 	poco_assert (_state != ST_DONE);
 	compile();
 	Poco::UInt32 count = 0;
+	Poco::UInt32 limit = _extrLimit.value();
 	do
 	{
 		bind();
-		while (hasNext() && count < _extrLimit.value())
+		while (count < limit && hasNext()) 
 			count += next();
-	} while (canBind());
-
-	if (!canBind() && (!hasNext() || _extrLimit.value() == 0))
+	} while (count < limit && canBind());
+	
+	if (!canBind() && (!hasNext() || limit == 0))
 		_state = ST_DONE;
-	else if (hasNext() && _extrLimit.value() == count && _extrLimit.isHardLimit())
+	else if (hasNext() && limit == count && _extrLimit.isHardLimit())
 		throw LimitException("HardLimit reached. We got more data than we asked for");
 	else
 		_state = ST_PAUSED;
@@ -176,12 +176,8 @@ void StatementImpl::bind()
 	{
 		if (!hasNext())
 		{
-			if (canBind())
-			{
-				bindImpl();
-			}
-			else
-				_state = ST_DONE;
+			if (canBind()) bindImpl();
+			else _state = ST_DONE;
 		}
 	}
 }
@@ -203,6 +199,17 @@ void StatementImpl::setExtractionLimit(const Limit& extrLimit)
 }
 
 
+void StatementImpl::setBulkExtraction(const Bulk& b)
+{
+	Poco::UInt32 limit = getExtractionLimit();
+	if (Limit::LIMIT_UNLIMITED != limit && b.size() != limit)
+		throw InvalidArgumentException("Can not set limit for statement.");
+
+	setExtractionLimit(b.limit());
+	_bulkExtraction = BULK_EXTRACTION;
+}
+
+
 void StatementImpl::fixupExtraction()
 {
 	Poco::Data::AbstractExtractionVec::iterator it    = extractions().begin();
@@ -339,7 +346,7 @@ Poco::UInt32 StatementImpl::activateNextDataSet()
 	if (_curDataSet + 1 < dataSetCount())
 		return ++_curDataSet;
 	else
-		throw InvalidAccessException("End of data sets reached.");
+		throw NoDataException("End of data sets reached.");
 }
 
 
diff --git a/Data/testsuite/src/DataTest.cpp b/Data/testsuite/src/DataTest.cpp
index 62d7fe5f5..74f0559c5 100644
--- a/Data/testsuite/src/DataTest.cpp
+++ b/Data/testsuite/src/DataTest.cpp
@@ -65,6 +65,7 @@ using Poco::InvalidAccessException;
 using Poco::RangeException;
 using Poco::NotFoundException;
 using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
 
 
 DataTest::DataTest(const std::string& name): CppUnit::TestCase(name)
@@ -1026,16 +1027,34 @@ void DataTest::testDateAndTime()
 	Date d1(2007, 6, 15);
 	d1.assign(d.year() - 1, d.month(), d.day());
 	assert (d1 < d); assert (d1 != d);
-	d1.assign(d.year(), d.month() - 1, d.day());
-	assert (d1 < d); assert (d1 != d);
-	d1.assign(d.year(), d.month(), d.day() - 1);
+	if (d.month() > 1)
+		d1.assign(d.year(), d.month() - 1, d.day());
+	else
+		d1.assign(d.year() - 1, 12, d.day());
+	
 	assert (d1 < d); assert (d1 != d);
+
+	if (d.day() > 1)
+	{
+		d1.assign(d.year(), d.month(), d.day() - 1);
+		assert (d1 < d); assert (d1 != d);
+	}
+
 	d1.assign(d.year() + 1, d.month(), d.day());
 	assert (d1 > d); assert (d1 != d);
-	d1.assign(d.year(), d.month() + 1, d.day());
-	assert (d1 > d); assert (d1 != d);
-	d1.assign(d.year(), d.month(), d.day() + 1);
+	
+	if (d.month() < 12)
+		d1.assign(d.year(), d.month() + 1, d.day());
+	else
+		d1.assign(d.year() + 1, 1, d.day());
 	assert (d1 > d); assert (d1 != d);
+
+	if (d.day() < dt.daysOfMonth(dt.year(), dt.month()))
+	{
+		d1.assign(d.year(), d.month(), d.day() + 1);
+		assert (d1 > d); assert (d1 != d);
+	}
+	
 	d1.assign(d.year(), d.month(), d.day());
 	assert (d1 == d);
 
diff --git a/Data/testsuite/src/Extractor.h b/Data/testsuite/src/Extractor.h
index 50bdf4dac..1946005ce 100644
--- a/Data/testsuite/src/Extractor.h
+++ b/Data/testsuite/src/Extractor.h
@@ -116,7 +116,7 @@ public:
 	bool extract(std::size_t pos, Poco::DateTime& val);
 		/// Extracts a DateTime.
 
-	bool isNull(std::size_t pos);
+	bool isNull(std::size_t col, std::size_t row = -1);
 		/// Returns true if the current row value at pos column is null.
 
 	void reset();
@@ -128,7 +128,7 @@ inline void Extractor::reset()
 }
 
 
-inline bool Extractor::isNull(std::size_t pos)
+inline bool Extractor::isNull(std::size_t col, std::size_t row)
 {
 	return false;
 }
diff --git a/Data/testsuite/src/Preparation.cpp b/Data/testsuite/src/Preparation.cpp
index e25a782bc..c592924ea 100644
--- a/Data/testsuite/src/Preparation.cpp
+++ b/Data/testsuite/src/Preparation.cpp
@@ -50,69 +50,69 @@ Preparation::~Preparation()
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::Int8)
+void Preparation::prepare(std::size_t pos, Poco::Int8&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::UInt8)
+void Preparation::prepare(std::size_t pos, Poco::UInt8&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::Int16)
+void Preparation::prepare(std::size_t pos, Poco::Int16&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::UInt16)
+void Preparation::prepare(std::size_t pos, Poco::UInt16&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::Int32)
+void Preparation::prepare(std::size_t pos, Poco::Int32&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::UInt32)
+void Preparation::prepare(std::size_t pos, Poco::UInt32&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::Int64)
+void Preparation::prepare(std::size_t pos, Poco::Int64&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, Poco::UInt64)
+void Preparation::prepare(std::size_t pos, Poco::UInt64&)
 {
 }
 
 
 #ifndef POCO_LONG_IS_64_BIT
-void Preparation::prepare(std::size_t pos, long)
+void Preparation::prepare(std::size_t pos, long&)
 {
 }
 #endif
 
 
-void Preparation::prepare(std::size_t pos, bool)
+void Preparation::prepare(std::size_t pos, bool&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, float)
+void Preparation::prepare(std::size_t pos, float&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, double)
+void Preparation::prepare(std::size_t pos, double&)
 {
 }
 
 
-void Preparation::prepare(std::size_t pos, char)
+void Preparation::prepare(std::size_t pos, char&)
 {
 }
 
diff --git a/Data/testsuite/src/Preparation.h b/Data/testsuite/src/Preparation.h
index 0c5da7e4a..16c975837 100644
--- a/Data/testsuite/src/Preparation.h
+++ b/Data/testsuite/src/Preparation.h
@@ -55,45 +55,45 @@ public:
 	~Preparation();
 		/// Destroys the Preparation.
 
-	void prepare(std::size_t pos, Poco::Int8);
+	void prepare(std::size_t pos, Poco::Int8&);
 		/// Prepares an Int8.
 
-	void prepare(std::size_t pos, Poco::UInt8);
+	void prepare(std::size_t pos, Poco::UInt8&);
 		/// Prepares an UInt8.
 
-	void prepare(std::size_t pos, Poco::Int16);
+	void prepare(std::size_t pos, Poco::Int16&);
 		/// Prepares an Int16.
 
-	void prepare(std::size_t pos, Poco::UInt16);
+	void prepare(std::size_t pos, Poco::UInt16&);
 		/// Prepares an UInt16.
 
-	void prepare(std::size_t pos, Poco::Int32);
+	void prepare(std::size_t pos, Poco::Int32&);
 		/// Prepares an Int32.
 
-	void prepare(std::size_t pos, Poco::UInt32);
+	void prepare(std::size_t pos, Poco::UInt32&);
 		/// Prepares an UInt32.
 
-	void prepare(std::size_t pos, Poco::Int64);
+	void prepare(std::size_t pos, Poco::Int64&);
 		/// Prepares an Int64.
 
-	void prepare(std::size_t pos, Poco::UInt64);
+	void prepare(std::size_t pos, Poco::UInt64&);
 		/// Prepares an UInt64.
 
 #ifndef POCO_LONG_IS_64_BIT
-	void prepare(std::size_t pos, long);
+	void prepare(std::size_t pos, long&);
 		/// Prepares a long.
 #endif
 
-	void prepare(std::size_t pos, bool);
+	void prepare(std::size_t pos, bool&);
 		/// Prepares a boolean.
 
-	void prepare(std::size_t pos, float);
+	void prepare(std::size_t pos, float&);
 		/// Prepares a float.
 
-	void prepare(std::size_t pos, double);
+	void prepare(std::size_t pos, double&);
 		/// Prepares a double.
 
-	void prepare(std::size_t pos, char);
+	void prepare(std::size_t pos, char&);
 		/// Prepares a single character.
 
 	void prepare(std::size_t pos, const std::string&);