diff --git a/Data/PostgreSQL/Makefile b/Data/PostgreSQL/Makefile
index 5882ea9ef..c3efddb2e 100644
--- a/Data/PostgreSQL/Makefile
+++ b/Data/PostgreSQL/Makefile
@@ -8,7 +8,7 @@ include $(POCO_BASE)/build/rules/global
 
 include PostgreSQL.make
 
-objects = Extractor Binder SessionImpl Connector \
+objects = Extractor BinaryExtractor Binder SessionImpl Connector \
 	PostgreSQLStatementImpl PostgreSQLException \
 	SessionHandle StatementExecutor PostgreSQLTypes Utility
 
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/BinaryExtractor.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/BinaryExtractor.h
new file mode 100644
index 000000000..f5701d25b
--- /dev/null
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/BinaryExtractor.h
@@ -0,0 +1,346 @@
+//
+// BinaryExtractor.h
+//
+// Library: Data/PostgreSQL
+// Package: PostgreSQL
+// Module:  Extractor
+//
+// Definition of the BinaryExtractor class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SQL_PostgreSQL_BinaryExtractor_INCLUDED
+#define SQL_PostgreSQL_BinaryExtractor_INCLUDED
+
+
+#include "Poco/Data/PostgreSQL/PostgreSQL.h"
+#include "Poco/Data/PostgreSQL/PostgreSQLTypes.h"
+#include "Poco/Data/PostgreSQL/StatementExecutor.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Types.h"
+#include "Poco/Any.h"
+#include "Poco/DynamicAny.h"
+#include "Poco/Dynamic/Var.h"
+
+
+namespace Poco {
+namespace Data {
+namespace PostgreSQL {
+
+
+class PostgreSQL_API BinaryExtractor: public Poco::Data::AbstractExtractor
+	/// Extracts and converts data values from the result row returned by PostgreSQL.
+	/// If NULL is received, the incoming val value is not changed and false is returned
+{
+public:
+	using Ptr = SharedPtr<BinaryExtractor>;
+
+	BinaryExtractor(StatementExecutor& st);
+		/// Creates the Extractor.
+
+	virtual ~BinaryExtractor();
+		/// Destroys the Extractor.
+
+	virtual bool extract(std::size_t pos, Poco::Int8& val);
+		/// Extracts an Int8.
+
+	virtual bool extract(std::size_t pos, Poco::UInt8& val);
+		/// Extracts an UInt8.
+
+	virtual bool extract(std::size_t pos, Poco::Int16& val);
+		/// Extracts an Int16.
+
+	virtual bool extract(std::size_t pos, Poco::UInt16& val);
+		/// Extracts an UInt16.
+
+	virtual bool extract(std::size_t pos, Poco::Int32& val);
+		/// Extracts an Int32.
+
+	virtual bool extract(std::size_t pos, Poco::UInt32& val);
+		/// Extracts an UInt32.
+
+	virtual bool extract(std::size_t pos, Poco::Int64& val);
+		/// Extracts an Int64.
+
+	virtual bool extract(std::size_t pos, Poco::UInt64& val);
+		/// Extracts an UInt64.
+
+#ifndef POCO_INT64_IS_LONG
+	virtual bool extract(std::size_t pos, long& val);
+		/// Extracts a long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, unsigned long& val);
+		/// Extracts an unsigned long. Returns false if null was received.
+#endif
+
+	virtual bool extract(std::size_t pos, bool& val);
+		/// Extracts a boolean.
+
+	virtual bool extract(std::size_t pos, float& val);
+		/// Extracts a float.
+
+	virtual bool extract(std::size_t pos, double& val);
+		/// Extracts a double.
+
+	virtual bool extract(std::size_t pos, char& val);
+		/// Extracts a single character.
+
+	virtual bool extract(std::size_t pos, std::string& val);
+		/// Extracts a string.
+
+	virtual bool extract(std::size_t pos, Poco::Data::BLOB& val);
+		/// Extracts a BLOB.
+
+	virtual bool extract(std::size_t pos, Poco::Data::CLOB& val);
+		/// Extracts a CLOB.
+
+	virtual bool extract(std::size_t pos, DateTime& val);
+		/// Extracts a DateTime. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Date& val);
+		/// Extracts a Date. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Time& val);
+		/// Extracts a Time. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, UUID& val);
+		/// Extracts a UUID. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Any& val);
+		/// Extracts an Any. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Dynamic::Var& val);
+		/// Extracts a Dynamic::Var. Returns false if null was received.
+
+	virtual bool isNull(std::size_t col, std::size_t row);
+		/// Returns true if the value at [col,row] position is null.
+
+	virtual void reset();
+		/// Resets any information internally cached by the extractor.
+
+	////////////
+	// Not implemented extract functions
+	////////////
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_INT64_IS_LONG
+	virtual bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	virtual bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	virtual bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	virtual bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	virtual bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	virtual bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	virtual bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	virtual bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	virtual bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	virtual bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	virtual bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	virtual bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	virtual bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a character vector.
+
+	virtual bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a character deque.
+
+	virtual bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a character list.
+
+	virtual bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	virtual bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	virtual bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+
+	virtual bool extract(std::size_t pos, std::vector<BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<BLOB>& val);
+		/// Extracts a BLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<CLOB>& val);
+		/// Extracts a CLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	virtual bool extract(std::size_t pos, std::deque<DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	virtual bool extract(std::size_t pos, std::list<DateTime>& val);
+		/// Extracts a DateTime list.
+
+	virtual bool extract(std::size_t pos, std::vector<Date>& val);
+		/// Extracts a Date vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Date>& val);
+		/// Extracts a Date deque.
+
+	virtual bool extract(std::size_t pos, std::list<Date>& val);
+		/// Extracts a Date list.
+
+	virtual bool extract(std::size_t pos, std::vector<Time>& val);
+		/// Extracts a Time vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Time>& val);
+		/// Extracts a Time deque.
+
+	virtual bool extract(std::size_t pos, std::list<Time>& val);
+		/// Extracts a Time list.
+
+	virtual bool extract(std::size_t pos, std::vector<Any>& val);
+		/// Extracts an Any vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Any>& val);
+		/// Extracts an Any deque.
+
+	virtual bool extract(std::size_t pos, std::list<Any>& val);
+		/// Extracts an Any list.
+
+	virtual bool extract(std::size_t pos, std::vector<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var deque.
+
+	virtual bool extract(std::size_t pos, std::list<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var list.
+
+private:
+	const OutputParameter& extractPreamble(std::size_t aPosition) const;
+	bool isColumnNull(const OutputParameter& anOutputParameter) const;
+
+	// Prevent VC8 warning "operator= could not be generated"
+	BinaryExtractor& operator = (const BinaryExtractor&);
+
+private:
+	StatementExecutor& _statementExecutor;
+};
+
+
+//
+// inlines
+//
+inline bool BinaryExtractor::isColumnNull(const OutputParameter& anOutputParameter) const
+{
+	return anOutputParameter.isNull() || 0 == anOutputParameter.pData();
+}
+
+
+} } } // namespace Poco::Data::PostgreSQL
+
+
+#endif // SQL_PostgreSQL_BinaryExtractor_INCLUDED
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/Extractor.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/Extractor.h
index 81596c5ff..dc9a57b14 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/Extractor.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/Extractor.h
@@ -351,6 +351,15 @@ private:
 };
 
 
+//
+// inlines
+//
+inline bool Extractor::isColumnNull(const OutputParameter& anOutputParameter) const
+{
+	return anOutputParameter.isNull() || 0 == anOutputParameter.pData();
+}
+
+
 } } } // namespace Poco::Data::PostgreSQL
 
 
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLStatementImpl.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLStatementImpl.h
index 558de7ab8..2d0ff92f7 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLStatementImpl.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLStatementImpl.h
@@ -21,9 +21,9 @@
 #include "Poco/Data/PostgreSQL/PostgreSQL.h"
 #include "Poco/Data/PostgreSQL/SessionImpl.h"
 #include "Poco/Data/PostgreSQL/Binder.h"
-#include "Poco/Data/PostgreSQL/Extractor.h"
 #include "Poco/Data/PostgreSQL/StatementExecutor.h"
 #include "Poco/Data/StatementImpl.h"
+#include "Poco/Data/AbstractExtractor.h"
 #include "Poco/SharedPtr.h"
 #include "Poco/Format.h"
 
@@ -89,7 +89,7 @@ private:
 
 	StatementExecutor _statementExecutor;
 	Binder::Ptr       _pBinder;
-	Extractor::Ptr    _pExtractor;
+	AbstractExtractor::Ptr _pExtractor;
 	NextState         _hasNext;
 };
 
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLTypes.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLTypes.h
index 0d3a054fd..489103042 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLTypes.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/PostgreSQLTypes.h
@@ -31,36 +31,37 @@ namespace PostgreSQL {
 /// Oid constants duplicated from PostgreSQL "include/postgresql/server/catalog/pg_type.h"
 /// because PostgreSQL compile time definitions are too onerous to reproduce for this module
 
+const Oid INVALIDOID     = 0;
 
-const Oid BOOLOID		= 16;
+const Oid BOOLOID        = 16;
 
-const Oid INT2OID		= 21;
-const Oid INT4OID		= 23;
-const Oid INT8OID		= 20;
+const Oid INT2OID        = 21;
+const Oid INT4OID        = 23;
+const Oid INT8OID        = 20;
 
-const Oid FLOAT8OID		= 701; // double
-const Oid FLOAT4OID		= 700;
-const Oid NUMERICOID	= 1700;
+const Oid FLOAT8OID      = 701; // double
+const Oid FLOAT4OID      = 700;
+const Oid NUMERICOID     = 1700;
 
-const Oid CHAROID		= 18;
-const Oid BPCHAROID		= 1042; // fixed length char
-const Oid VARCHAROID	= 1043;
+const Oid CHAROID        = 18;
+const Oid BPCHAROID      = 1042; // fixed length char
+const Oid VARCHAROID     = 1043;
 
-const Oid BYTEAOID		= 17; // BLOB
-const Oid TEXTOID		= 25; // CLOB
+const Oid BYTEAOID       = 17; // BLOB
+const Oid TEXTOID        = 25; // CLOB
 
-const Oid DATEOID		= 1082;
-const Oid TIMEOID		= 1083;
-const Oid TIMETZOID		= 1266;
-const Oid TIMESTAMPOID	= 1114;
-const Oid TIMESTAMPZOID	= 1184;
+const Oid DATEOID        = 1082;
+const Oid TIMEOID        = 1083;
+const Oid TIMETZOID      = 1266;
+const Oid TIMESTAMPOID   = 1114;
+const Oid TIMESTAMPTZOID = 1184;
 
 // future use
-const Oid BITOID		= 1560;
-const Oid VARYBITOID	= 1562;
-const Oid CASHOID		= 790;
-const Oid MACADDROID	= 829;
-const Oid UUIDOID		= 2950;
+const Oid BITOID         = 1560;
+const Oid VARYBITOID     = 1562;
+const Oid CASHOID        = 790;
+const Oid MACADDROID     = 829;
+const Oid UUIDOID        = 2950;
 
 
 Poco::Data::MetaColumn::ColumnDataType oidToColumnDataType(const Oid anOID);
@@ -132,7 +133,7 @@ private:
 };
 
 
-using OutputParameterVector = std::vector <OutputParameter>;
+using OutputParameterVector = std::vector<OutputParameter>;
 
 
 class PQConnectionInfoOptionsFree
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionHandle.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionHandle.h
index 983b0d333..597e08945 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionHandle.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionHandle.h
@@ -155,6 +155,9 @@ public:
 	std::string clientEncoding() const;
 		/// returns the client encoding
 
+	std::string parameterStatus(const std::string& param) const;
+		/// Returns the value configured on the server for the given parameter.
+
 	int libpqVersion() const;
 		/// returns the version of libpq
 
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionImpl.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionImpl.h
index 60efa7db1..ea68342db 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionImpl.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/SessionImpl.h
@@ -111,6 +111,19 @@ public:
 	bool isAsynchronousCommit(const std::string& aName = std::string()) const;
 		/// is the connection in Asynchronous commit mode?
 
+	void setBinaryExtraction(const std::string& feature, bool enabled);
+		/// Sets the "binaryExtraction" feature. If set, column values received from
+		/// PostgreSQL client will be extracted as binary values. This improves
+		/// extraction performance, but will not work with all types.
+		///
+		/// If not set, all column values will be extracted as strings. This gives
+		/// lower performance, but allows to extract also types not supported
+		/// directly by Poco::Data.
+
+	bool isBinaryExtraction(const std::string& feature = std::string()) const;
+		/// Returns true if binary extraction is enabled, otherwise false.
+		/// See setBinaryExtraction() for more information.
+
 	SessionHandle& handle();
 		/// Get handle
 
@@ -120,7 +133,8 @@ public:
 private:
 	std::string	          _connectorName;
 	mutable SessionHandle _sessionHandle;
-	std::size_t           _timeout;
+	std::size_t           _timeout = 0;
+	bool                  _binaryExtraction = false;
 };
 
 
@@ -159,6 +173,12 @@ inline std::size_t SessionImpl::getConnectionTimeout() const
 }
 
 
+inline bool SessionImpl::isBinaryExtraction(const std::string&) const
+{
+	return _binaryExtraction;
+}
+
+
 } } } // namespace Poco::Data::PostgreSQL
 
 
diff --git a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/StatementExecutor.h b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/StatementExecutor.h
index 039e88ba2..dc30cc572 100644
--- a/Data/PostgreSQL/include/Poco/Data/PostgreSQL/StatementExecutor.h
+++ b/Data/PostgreSQL/include/Poco/Data/PostgreSQL/StatementExecutor.h
@@ -43,7 +43,7 @@ public:
 		STMT_EXECUTED
 	};
 
-	explicit StatementExecutor(SessionHandle& aSessionHandle);
+	explicit StatementExecutor(SessionHandle& aSessionHandle, bool binaryExtraction);
 		/// Creates the StatementExecutor.
 
 	~StatementExecutor();
@@ -90,6 +90,7 @@ private:
 	typedef std::vector<MetaColumn> ColVec;
 
 	SessionHandle& _sessionHandle;
+	bool           _binaryExtraction;
 	State          _state;
 	PGresult*      _pResultHandle;
 	std::string    _SQLStatement;
diff --git a/Data/PostgreSQL/src/BinaryExtractor.cpp b/Data/PostgreSQL/src/BinaryExtractor.cpp
new file mode 100644
index 000000000..f63481db0
--- /dev/null
+++ b/Data/PostgreSQL/src/BinaryExtractor.cpp
@@ -0,0 +1,1071 @@
+//
+// BinaryExtractor.cpp
+//
+// Library: Data/PostgreSQL
+// Package: PostgreSQL
+// Module:  Extractor
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/PostgreSQL/BinaryExtractor.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/NumberParser.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/ByteOrder.h"
+#include <limits>
+
+
+namespace Poco {
+namespace Data {
+namespace PostgreSQL {
+
+
+namespace
+{
+	template<typename T>
+	static T fromNetwork(T value)
+	{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+		return value;
+#else
+		T flip = value;
+		std::size_t halfSize = sizeof(T) / 2;
+		char* flipP = reinterpret_cast<char*>(&flip);
+
+		for (std::size_t i = 0; i < halfSize; i++)
+		{
+			std::swap(flipP[i], flipP[sizeof(T) - i - 1]);
+		}
+		return flip;
+#endif
+	}
+
+	template <typename T>
+	bool readBinaryValue(const OutputParameter& param, T& value)
+	{
+		throw Poco::NotImplementedException("readBinaryValue", typeid(value).name());
+	}
+
+	bool readBinaryValue(const OutputParameter& param, bool& value)
+	{
+		if (param.size() < 1) return false;
+
+		value = *param.pData() != 0;
+		return true;
+	}
+
+	bool readBinaryValue(const OutputParameter& param, Poco::Int16& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		Poco::Int16 tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = Poco::ByteOrder::fromNetwork(tempValue);
+		return true;
+	}
+
+	bool readBinaryValue(const OutputParameter& param, Poco::Int32& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		Poco::Int32 tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = Poco::ByteOrder::fromNetwork(tempValue);
+		return true;
+	}
+
+	bool readBinaryValue(const OutputParameter& param, Poco::Int64& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		Poco::Int64 tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = Poco::ByteOrder::fromNetwork(tempValue);
+		return true;
+	}
+
+#ifndef POCO_INT64_IS_LONG
+	bool readBinaryValue(const OutputParameter& param, long& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		Poco::Int64 tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = Poco::ByteOrder::fromNetwork(tempValue);
+		return true;
+	}
+#endif
+
+	bool readBinaryValue(const OutputParameter& param, float& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		float tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = fromNetwork(tempValue);
+		return true;
+	}
+
+	bool readBinaryValue(const OutputParameter& param, double& value)
+	{
+		if (param.size() < sizeof(value)) return false;
+
+		double tempValue;
+		std::memcpy(&tempValue, param.pData(), sizeof(tempValue));
+		value = fromNetwork(tempValue);
+		return true;
+	}
+
+	bool readDate(const OutputParameter& param, Poco::Data::Date& date)
+	{
+		const Poco::Int64 PG_EPOCH = 946684800000000; // Microseconds between Postgres Epoch (2000-01-01) and Unix Epoch (1970-01-01)
+		Poco::Int32 pgDate; // days since 2000-01-01
+		if (readBinaryValue(param, pgDate))
+		{
+			Poco::Timestamp ts(PG_EPOCH + Poco::Timestamp::resolution()*86400*pgDate);
+			Poco::DateTime dt(ts);
+			date.assign(dt.year(), dt.month(), dt.day());
+			return true;
+		}
+		return false;
+	}
+
+	bool readTime(const OutputParameter& param, Poco::Data::Time& time)
+	{
+		Poco::Int64 pgTime; // microseconds since midnight
+		if (readBinaryValue(param, pgTime))
+		{
+			Poco::Timestamp ts(pgTime);
+			Poco::DateTime dt(ts);
+			time.assign(dt.hour(), dt.minute(), dt.second());
+			return true;
+		}
+		return false;
+	}
+
+	bool readDateTime(const OutputParameter& param, Poco::DateTime& dateTime)
+	{
+		const Poco::Int64 PG_EPOCH = 946684800000000; // Microseconds between Postgres Epoch (2000-01-01) and Unix Epoch (1970-01-01)
+		Poco::Int64 pgDateTime;
+		if (readBinaryValue(param, pgDateTime))
+		{
+			pgDateTime += PG_EPOCH;
+			Poco::Timestamp ts(pgDateTime);
+			dateTime = ts;
+			return true;
+		}
+		return false;
+	}
+
+	bool readUUID(const OutputParameter& param, Poco::UUID& uuid)
+	{
+		if (param.size() == 16)
+		{
+			uuid.copyFrom(param.pData());
+			return true;
+		}
+		return false;
+	}
+
+	bool readVar(const OutputParameter& param, Poco::Dynamic::Var& var)
+	{
+		const Oid oid = param.internalFieldType();
+		bool success = false;
+
+		switch (oid)
+		{
+		case BOOLOID:
+			{
+				bool value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+		case INT2OID:
+			{
+				Poco::Int16 value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+		case INT4OID:
+			{
+				Poco::Int32 value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+		case INT8OID:
+			{
+				Poco::Int64 value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+
+		// floating point
+		case FLOAT8OID:
+			{
+				double value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+		case FLOAT4OID:
+			{
+				float value;
+				success = readBinaryValue(param, value);
+				if (success) var = value;
+				break;
+			}
+		case NUMERICOID:
+			throw PostgreSQLException("Cannot extract numeric value in binary extraction mode");
+
+		// character strings
+		case CHAROID:
+		case BPCHAROID:
+		case VARCHAROID:
+		default:
+			{
+				success = true;
+				std::string value(param.pData(), param.size());
+				var = value;
+				break;
+			}
+		// BLOB, CLOB
+		case BYTEAOID:
+			{
+				success = true;
+				Poco::Data::BLOB value(reinterpret_cast<const unsigned char*>(param.pData()), param.size());
+				var = value;
+				break;
+			}
+		case TEXTOID:
+			{
+				success = true;
+				Poco::Data::CLOB value(param.pData(), param.size());
+				var = value;
+				break;
+			}
+		// date
+		case DATEOID:
+			{
+				Date value;
+				success = readDate(param, value);
+				if (success) var = value;
+				break;
+			}
+		// time
+		case TIMEOID:
+		case TIMETZOID:
+			{
+				Time value;
+				success = readTime(param, value);
+				if (success) var = value;
+				break;
+			}
+		//timestamp
+		case TIMESTAMPOID:
+		case TIMESTAMPTZOID:
+			{
+				DateTime value;
+				success = readDateTime(param, value);
+				if (success) var = value;
+				break;
+			}
+		case UUIDOID:
+			{
+				UUID uuid;
+				success = readUUID(param, uuid);
+				if (success) var = uuid;
+				break;
+			}
+		}
+
+		return success;
+	}
+
+	template <typename T>
+	bool readAndConvertBinaryValue(const OutputParameter& param, Oid expectedType, T& value)
+	{
+		if (param.internalFieldType() == expectedType)
+		{
+			return readBinaryValue(param, value);
+		}
+		else
+		{
+			Poco::Dynamic::Var var;
+			if (readVar(param, var))
+			{
+				value = var.convert<T>();
+				return true;
+			}
+			else return false;
+		}
+	}
+
+	bool readAndConvertStringValue(const OutputParameter& param, std::string& value)
+	{
+		const Oid oid = param.internalFieldType();
+		switch (oid)
+		{
+		case CHAROID:
+		case BPCHAROID:
+		case VARCHAROID:
+		case TEXTOID:
+		case BYTEAOID:
+			value.assign(param.pData(), param.size());
+			return true;
+		default:
+			{
+				Poco::Dynamic::Var var;
+				if (readVar(param, var))
+				{
+					value = var.convert<std::string>();
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+}
+
+
+BinaryExtractor::BinaryExtractor(StatementExecutor& st /*, ResultMetadata& md */):
+	_statementExecutor(st)
+{
+}
+
+
+BinaryExtractor::~BinaryExtractor()
+{
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Int8& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::UInt8& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Int16& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INT2OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::UInt16& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Int32& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INT4OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::UInt32& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Int64& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INT8OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::UInt64& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+#ifndef POCO_INT64_IS_LONG
+bool BinaryExtractor::extract(std::size_t pos, long& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INT8OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, unsigned long& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, INVALIDOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+#endif
+
+
+bool BinaryExtractor::extract(std::size_t pos, bool& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, BOOLOID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, float& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, FLOAT4OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, double& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+	if (isColumnNull(outputParameter) || !readAndConvertBinaryValue(outputParameter, FLOAT8OID, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, char& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	std::string str;
+	if (isColumnNull(outputParameter) || !readAndConvertStringValue(outputParameter, str))
+	{
+		return false;
+	}
+	val = str.empty() ? 0 : str[0];
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, std::string& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter) || !readAndConvertStringValue(outputParameter, val))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Data::BLOB& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == BYTEAOID)
+	{
+		val = Poco::Data::BLOB(reinterpret_cast<const unsigned char*>(outputParameter.pData()), outputParameter.size()); // don't share contents with _default
+		return true;
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Poco::Data::CLOB& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == TEXTOID)
+	{
+		val = Poco::Data::CLOB(outputParameter.pData(), outputParameter.size()); // don't share contents with _default
+		return true;
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, DateTime& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == TIMESTAMPOID || outputParameter.internalFieldType() == TIMESTAMPTZOID)
+	{
+		return readDateTime(outputParameter, val);
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Date& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == DATEOID)
+	{
+		return readDate(outputParameter, val);
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Time& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == TIMEOID || outputParameter.internalFieldType() == TIMETZOID)
+	{
+		return readTime(outputParameter, val);
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, UUID& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+
+	if (outputParameter.internalFieldType() == UUIDOID)
+	{
+		return readUUID(outputParameter, val);
+	}
+	else return false;
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Any& val)
+{
+	throw PostgreSQLException("BinaryExtractor: extraction to Poco::Any is not supported");
+}
+
+
+bool BinaryExtractor::extract(std::size_t pos, Dynamic::Var& val)
+{
+	const OutputParameter& outputParameter = extractPreamble(pos);
+
+	if (isColumnNull(outputParameter))
+	{
+		return false;
+	}
+	return readVar(outputParameter, val);
+}
+
+
+bool BinaryExtractor::isNull(std::size_t col, std::size_t /*row*/)
+{
+	const OutputParameter& outputParameter = extractPreamble(col);
+
+	if (isColumnNull(outputParameter))
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+void BinaryExtractor::reset()
+{
+	AbstractExtractor::reset();
+}
+
+
+const OutputParameter& BinaryExtractor::extractPreamble(std::size_t aPosition) const
+{
+	if (_statementExecutor.columnsReturned() <= aPosition)
+	{
+		throw PostgreSQLException("BinaryExtractor: attempt to extract more parameters than query result contains");
+	}
+
+	return _statementExecutor.resultColumn(aPosition);
+}
+
+
+//////////////
+// Not implemented
+//////////////
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::Int8>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::Int8>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::Int8>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::UInt8>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::UInt8>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::UInt8>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::Int16>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::Int16>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::Int16>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::UInt16>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::UInt16>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::UInt16>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::Int32>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::Int32>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::Int32>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::UInt32>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::UInt32>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::UInt32>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::Int64>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::Int64>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::Int64>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Poco::UInt64>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Poco::UInt64>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Poco::UInt64>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+#ifndef POCO_INT64_IS_LONG
+bool BinaryExtractor::extract(std::size_t, std::vector<long>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<long>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<long>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+#endif
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<bool>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<bool>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<bool>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<float>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<float>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<float>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<double>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<double>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<double>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<char>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<char>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<char>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<std::string>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<std::string>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<std::string>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<BLOB>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<BLOB>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<BLOB>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<CLOB>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<CLOB>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<CLOB>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<DateTime>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<DateTime>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<DateTime>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Date>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Date>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Date>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Time>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Time>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Time>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Any>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Any>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Any>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::vector<Dynamic::Var>&)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::deque<Dynamic::Var>&)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool BinaryExtractor::extract(std::size_t, std::list<Dynamic::Var>&)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+} } } // namespace Poco::Data::PostgreSQL
diff --git a/Data/PostgreSQL/src/Extractor.cpp b/Data/PostgreSQL/src/Extractor.cpp
index 6b655812a..f11fab7b0 100644
--- a/Data/PostgreSQL/src/Extractor.cpp
+++ b/Data/PostgreSQL/src/Extractor.cpp
@@ -28,7 +28,7 @@ namespace PostgreSQL {
 
 
 Extractor::Extractor(StatementExecutor& st /*, ResultMetadata& md */):
-	_statementExecutor (st)
+	_statementExecutor(st)
 {
 }
 
@@ -40,8 +40,7 @@ Extractor::~Extractor()
 
 bool Extractor::extract(std::size_t pos, Poco::Int8& val)
 {
-
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	int tempVal = 0;
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParse(outputParameter.pData(), tempVal))
@@ -56,7 +55,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int8& val)
 
 bool Extractor::extract(std::size_t pos, Poco::UInt8& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	unsigned int tempVal = 0;
 	if (isColumnNull(outputParameter)|| !Poco::NumberParser::tryParseUnsigned(outputParameter.pData(), tempVal))
@@ -71,7 +70,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt8& val)
 
 bool Extractor::extract(std::size_t pos, Poco::Int16& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	int tempVal = 0;
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParse(outputParameter.pData(), tempVal))
@@ -86,7 +85,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int16& val)
 
 bool Extractor::extract(std::size_t pos, Poco::UInt16& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	unsigned int tempVal = 0;
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParseUnsigned(outputParameter.pData(), tempVal))
@@ -101,7 +100,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt16& val)
 
 bool Extractor::extract(std::size_t pos, Poco::Int32& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParse(outputParameter.pData(), val))
 	{
@@ -114,7 +113,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int32& val)
 
 bool Extractor::extract(std::size_t pos, Poco::UInt32& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParseUnsigned(outputParameter.pData(), val))
 	{
@@ -127,7 +126,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt32& val)
 
 bool Extractor::extract(std::size_t pos, Poco::Int64& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParse64(outputParameter.pData(), val))
 	{
@@ -140,7 +139,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int64& val)
 
 bool Extractor::extract(std::size_t pos, Poco::UInt64& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParseUnsigned64(outputParameter.pData(), val))
 	{
@@ -154,7 +153,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt64& val)
 #ifndef POCO_INT64_IS_LONG
 bool Extractor::extract(std::size_t pos, long& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	Poco::Int64 tempVal = 0;
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParse64(outputParameter.pData(), tempVal))
@@ -169,7 +168,7 @@ bool Extractor::extract(std::size_t pos, long& val)
 
 bool Extractor::extract(std::size_t pos, unsigned long& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	Poco::UInt64 tempVal = 0;
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParseUnsigned64(outputParameter.pData(), tempVal))
@@ -185,7 +184,7 @@ bool Extractor::extract(std::size_t pos, unsigned long& val)
 
 bool Extractor::extract(std::size_t pos, bool& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if	(isColumnNull(outputParameter))
 	{
@@ -200,7 +199,7 @@ bool Extractor::extract(std::size_t pos, bool& val)
 
 bool Extractor::extract(std::size_t pos, float& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	double tempVal = 0.0;
 	if	(isColumnNull(outputParameter) || !Poco::NumberParser::tryParseFloat(outputParameter.pData(), tempVal))
@@ -215,7 +214,7 @@ bool Extractor::extract(std::size_t pos, float& val)
 
 bool Extractor::extract(std::size_t pos, double& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter) || !Poco::NumberParser::tryParseFloat(outputParameter.pData(), val))
 	{
@@ -228,7 +227,7 @@ bool Extractor::extract(std::size_t pos, double& val)
 
 bool Extractor::extract(std::size_t pos, char& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -242,7 +241,7 @@ bool Extractor::extract(std::size_t pos, char& val)
 
 bool Extractor::extract(std::size_t pos, std::string& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -256,7 +255,7 @@ bool Extractor::extract(std::size_t pos, std::string& val)
 
 bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -291,7 +290,7 @@ bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val)
 
 bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -305,7 +304,7 @@ bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val)
 
 bool Extractor::extract(std::size_t pos, DateTime& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -314,7 +313,7 @@ bool Extractor::extract(std::size_t pos, DateTime& val)
 
 	int tzd = -1;
 	DateTime dateTime;
-	if (!DateTimeParser::tryParse("%Y-%m-%d %H:%M:%s", outputParameter.pData(), dateTime, tzd))
+	if (!DateTimeParser::tryParse(outputParameter.pData(), dateTime, tzd))
 	{
 		return false;
 	}
@@ -327,7 +326,7 @@ bool Extractor::extract(std::size_t pos, DateTime& val)
 
 bool Extractor::extract(std::size_t pos, Date& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -348,7 +347,7 @@ bool Extractor::extract(std::size_t pos, Date& val)
 
 bool Extractor::extract(std::size_t pos, Time& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -372,7 +371,7 @@ bool Extractor::extract(std::size_t pos, Time& val)
 
 bool Extractor::extract(std::size_t pos, UUID& val)
 {
-	OutputParameter outputParameter = extractPreamble(pos);
+	const OutputParameter& outputParameter = extractPreamble(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -397,7 +396,7 @@ bool Extractor::extract(std::size_t pos, Dynamic::Var& val)
 
 bool Extractor::isNull(std::size_t col, std::size_t /*row*/)
 {
-	OutputParameter outputParameter = extractPreamble(col);
+	const OutputParameter& outputParameter = extractPreamble(col);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -425,15 +424,9 @@ const OutputParameter& Extractor::extractPreamble(std::size_t aPosition) const
 }
 
 
-bool Extractor::isColumnNull(const OutputParameter& anOutputParameter) const
-{
-	return anOutputParameter.isNull() || 0 == anOutputParameter.pData();
-}
-
-
 bool Extractor::extractToDynamic(std::size_t pos, Dynamic::Var& val)
 {
-	OutputParameter outputParameter = _statementExecutor.resultColumn(pos);
+	const OutputParameter& outputParameter = _statementExecutor.resultColumn(pos);
 
 	if (isColumnNull(outputParameter))
 	{
@@ -525,7 +518,7 @@ bool Extractor::extractToDynamic(std::size_t pos, Dynamic::Var& val)
 		}
 	//timestamp
 	case TIMESTAMPOID:
-	case TIMESTAMPZOID:
+	case TIMESTAMPTZOID:
 		{
 			DateTime dt;
 			success = extract(pos, dt);
diff --git a/Data/PostgreSQL/src/PostgreSQLStatementImpl.cpp b/Data/PostgreSQL/src/PostgreSQLStatementImpl.cpp
index dfca79a5e..60493e941 100644
--- a/Data/PostgreSQL/src/PostgreSQLStatementImpl.cpp
+++ b/Data/PostgreSQL/src/PostgreSQLStatementImpl.cpp
@@ -13,7 +13,8 @@
 
 
 #include "Poco/Data/PostgreSQL/PostgreSQLStatementImpl.h"
-
+#include "Poco/Data/PostgreSQL/Extractor.h"
+#include "Poco/Data/PostgreSQL/BinaryExtractor.h"
 
 namespace Poco {
 namespace Data {
@@ -22,11 +23,14 @@ namespace PostgreSQL {
 
 PostgreSQLStatementImpl::PostgreSQLStatementImpl(SessionImpl& aSessionImpl):
 	Poco::Data::StatementImpl(aSessionImpl),
-	_statementExecutor(aSessionImpl.handle()),
+	_statementExecutor(aSessionImpl.handle(), aSessionImpl.isBinaryExtraction()),
 	_pBinder(new Binder),
-	_pExtractor(new Extractor (_statementExecutor)),
 	_hasNext(NEXT_DONTKNOW)
 {
+	if (aSessionImpl.isBinaryExtraction())
+		_pExtractor = new BinaryExtractor(_statementExecutor);
+	else
+		_pExtractor = new Extractor(_statementExecutor);
 }
 
 
diff --git a/Data/PostgreSQL/src/PostgreSQLTypes.cpp b/Data/PostgreSQL/src/PostgreSQLTypes.cpp
index 6254da21c..93d96395a 100644
--- a/Data/PostgreSQL/src/PostgreSQLTypes.cpp
+++ b/Data/PostgreSQL/src/PostgreSQLTypes.cpp
@@ -90,7 +90,7 @@ Poco::Data::MetaColumn::ColumnDataType oidToColumnDataType(const Oid anOID)
 	case TIMESTAMPOID:
 		cdt = Poco::Data::MetaColumn::FDT_TIMESTAMP;
 		break;
-	case TIMESTAMPZOID:
+	case TIMESTAMPTZOID:
 		cdt = Poco::Data::MetaColumn::FDT_TIMESTAMP;
 		break;
 
diff --git a/Data/PostgreSQL/src/SessionHandle.cpp b/Data/PostgreSQL/src/SessionHandle.cpp
index 61df66552..3bc4aa843 100644
--- a/Data/PostgreSQL/src/SessionHandle.cpp
+++ b/Data/PostgreSQL/src/SessionHandle.cpp
@@ -493,6 +493,23 @@ std::string SessionHandle::clientEncoding() const
 }
 
 
+std::string SessionHandle::parameterStatus(const std::string& param) const
+{
+	Poco::FastMutex::ScopedLock mutexLocker(_sessionMutex);
+
+	if (!isConnectedNoLock())
+	{
+		throw NotConnectedException();
+	}
+
+	const char* pValue = PQparameterStatus(_pConnection, param.c_str());
+	if (pValue)
+		return std::string(pValue);
+	else
+		return std::string();
+}
+
+
 int SessionHandle::libpqVersion() const
 {
 	return PQlibVersion();
diff --git a/Data/PostgreSQL/src/SessionImpl.cpp b/Data/PostgreSQL/src/SessionImpl.cpp
index 09f3bb193..778616acc 100644
--- a/Data/PostgreSQL/src/SessionImpl.cpp
+++ b/Data/PostgreSQL/src/SessionImpl.cpp
@@ -99,7 +99,7 @@ void SessionImpl::open(const std::string& aConnectionString)
 		}
 	}
 
-	poco_assert_dbg (! connectionString().empty());
+	poco_assert_dbg (!connectionString().empty());
 
 	unsigned int timeout = static_cast<unsigned int>(getLoginTimeout());
 
@@ -140,6 +140,10 @@ void SessionImpl::open(const std::string& aConnectionString)
 	addFeature("asynchronousCommit",
 		&SessionImpl::setAutoCommit,
 		&SessionImpl::isAutoCommit);
+
+	addFeature("binaryExtraction",
+		&SessionImpl::setBinaryExtraction,
+		&SessionImpl::isBinaryExtraction);
 }
 
 
@@ -244,4 +248,13 @@ bool SessionImpl::hasTransactionIsolation(Poco::UInt32 aTI) const
 }
 
 
+void SessionImpl::setBinaryExtraction(const std::string& feature, bool enabled)
+{
+	if (enabled && _sessionHandle.parameterStatus("integer_datetimes") != "on")
+		throw PostgreSQLException("binary extraction is not supported with this server (ingeger_datetimes must be enabled on the server)");
+
+	_binaryExtraction = enabled;
+}
+
+
 } } } // namespace Poco::Data::PostgreSQL
diff --git a/Data/PostgreSQL/src/StatementExecutor.cpp b/Data/PostgreSQL/src/StatementExecutor.cpp
index 8f2d89c9b..7d9d3f7b0 100644
--- a/Data/PostgreSQL/src/StatementExecutor.cpp
+++ b/Data/PostgreSQL/src/StatementExecutor.cpp
@@ -72,8 +72,9 @@ namespace Data {
 namespace PostgreSQL {
 
 
-StatementExecutor::StatementExecutor(SessionHandle& sessionHandle):
+StatementExecutor::StatementExecutor(SessionHandle& sessionHandle, bool binaryExtraction):
 	_sessionHandle(sessionHandle),
+	_binaryExtraction(binaryExtraction),
 	_state(STMT_INITED),
 	_pResultHandle(0),
 	_countPlaceholdersInSQLStatement(0),
@@ -248,11 +249,12 @@ void StatementExecutor::execute()
 	{
 		Poco::FastMutex::ScopedLock mutexLocker(_sessionHandle.mutex());
 
-		ptrPGResult = PQexecPrepared (_sessionHandle,
+		ptrPGResult = PQexecPrepared(_sessionHandle,
 			_preparedStatementName.c_str(), (int)_countPlaceholdersInSQLStatement,
 			_inputParameterVector.size() != 0 ? &pParameterVector[ 0 ] : 0,
 			_inputParameterVector.size() != 0 ? &parameterLengthVector[ 0 ] : 0,
-			_inputParameterVector.size() != 0 ? &parameterFormatVector[ 0 ] : 0, 0);
+			_inputParameterVector.size() != 0 ? &parameterFormatVector[ 0 ] : 0,
+			_binaryExtraction ? 1 : 0);
 	}
 
 	// Don't setup to auto clear the result (ptrPGResult).  It is required to retrieve the results later.
diff --git a/Data/PostgreSQL/testsuite/src/PostgreSQLTest.cpp b/Data/PostgreSQL/testsuite/src/PostgreSQLTest.cpp
index f57afc263..4e788a018 100644
--- a/Data/PostgreSQL/testsuite/src/PostgreSQLTest.cpp
+++ b/Data/PostgreSQL/testsuite/src/PostgreSQLTest.cpp
@@ -647,6 +647,7 @@ void PostgreSQLTest::testBLOB()
 	catch (DataException&) { }
 }
 
+
 void PostgreSQLTest::testCLOBStmt()
 {
 	if (!_pSession) fail ("Test not available.");
@@ -655,6 +656,7 @@ void PostgreSQLTest::testCLOBStmt()
 	_pExecutor->clobStmt();
 }
 
+
 void PostgreSQLTest::testBLOBStmt()
 {
 	if (!_pSession) fail ("Test not available.");
@@ -663,6 +665,7 @@ void PostgreSQLTest::testBLOBStmt()
 	_pExecutor->blobStmt();
 }
 
+
 void PostgreSQLTest::testUnsignedInts()
 {
 	if (!_pSession) fail ("Test not available.");
@@ -698,6 +701,7 @@ void PostgreSQLTest::testUUID()
 	_pExecutor->uuids();
 }
 
+
 void PostgreSQLTest::testTuple()
 {
 	if (!_pSession) fail ("Test not available.");
@@ -888,10 +892,133 @@ void PostgreSQLTest::testTupleWithNullable()
 
 	assertTrue (result[5].get<1>() == std::string("B"));
 	assertTrue (result[5].get<2>() == null);
-
 }
 
 
+void PostgreSQLTest::testBinarySimpleAccess()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonTable();
+	_pExecutor->simpleAccess();
+}
+
+
+void PostgreSQLTest::testBinaryComplexType()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonTable();
+	_pExecutor->complexType();
+}
+
+
+void PostgreSQLTest::testBinarySimpleAccessVector()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonTable();
+	_pExecutor->simpleAccessVector();
+}
+
+
+void PostgreSQLTest::testBinaryComplexTypeVector()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonTable();
+	_pExecutor->complexTypeVector();
+}
+
+
+void PostgreSQLTest::testBinaryInts()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreateUnsignedIntsTable();
+	_pExecutor->unsignedInts();
+}
+
+
+void PostgreSQLTest::testBinaryFloat()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreateFloatsTable();
+	_pExecutor->floats();
+}
+
+
+void PostgreSQLTest::testBinaryDouble()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreateFloatsTable();
+	_pExecutor->doubles();
+}
+
+
+void PostgreSQLTest::testBinaryUUID()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreateUUIDsTable();
+	_pExecutor->uuids();
+}
+
+
+void PostgreSQLTest::testBinaryDateTime()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonDateTimeTable();
+	_pExecutor->dateTime();
+	recreatePersonDateTable();
+	_pExecutor->date();
+	recreatePersonTimeTable();
+	_pExecutor->time();
+}
+
+
+void PostgreSQLTest::testBinaryCLOBStmt()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonCLOBTable();
+	_pExecutor->clobStmt();
+}
+
+
+void PostgreSQLTest::testBinaryBLOBStmt()
+{
+	if (!_pSession) fail ("Test not available.");
+
+	_pSession->setFeature("binaryExtraction", true);
+
+	recreatePersonBLOBTable();
+	_pExecutor->blobStmt();
+}
+
 void PostgreSQLTest::dropTable(const std::string& tableName)
 {
 	try
@@ -994,6 +1121,14 @@ void PostgreSQLTest::recreateFloatsTable()
 }
 
 
+void PostgreSQLTest::recreateDoublesTable()
+{
+	dropTable("Strings");
+	try { *_pSession << "CREATE TABLE Strings (str DOUBLE)", now; }
+	catch(ConnectionException& ce){ std::cout << ce.displayText() << std::endl; fail ("recreateDoublesTable()"); }
+	catch(StatementException& se){ std::cout << se.displayText() << std::endl; fail ("recreateDoublesTable()"); }
+}
+
 void PostgreSQLTest::recreateUUIDsTable()
 {
 	dropTable("Strings");
@@ -1055,6 +1190,7 @@ void PostgreSQLTest::tearDown()
 {
 	dropTable("Person");
 	dropTable("Strings");
+	_pSession->setFeature("binaryExtraction", false);
 }
 
 
@@ -1135,6 +1271,19 @@ CppUnit::Test* PostgreSQLTest::suite()
 	CppUnit_addTest(pSuite, PostgreSQLTest, testNullableInt);
 	CppUnit_addTest(pSuite, PostgreSQLTest, testNullableString);
 	CppUnit_addTest(pSuite, PostgreSQLTest, testTupleWithNullable);
+
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinarySimpleAccess);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryComplexType);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinarySimpleAccessVector);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryComplexTypeVector);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryInts);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryFloat);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryDouble);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryUUID);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryDateTime);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryCLOBStmt);
+	CppUnit_addTest(pSuite, PostgreSQLTest, testBinaryBLOBStmt);
+
 	CppUnit_addTest(pSuite, PostgreSQLTest, testSessionTransaction);
 	CppUnit_addTest(pSuite, PostgreSQLTest, testTransaction);
 	CppUnit_addTest(pSuite, PostgreSQLTest, testReconnect);
diff --git a/Data/PostgreSQL/testsuite/src/PostgreSQLTest.h b/Data/PostgreSQL/testsuite/src/PostgreSQLTest.h
index 3898328c2..a7c3d9d00 100644
--- a/Data/PostgreSQL/testsuite/src/PostgreSQLTest.h
+++ b/Data/PostgreSQL/testsuite/src/PostgreSQLTest.h
@@ -96,6 +96,18 @@ public:
 	void testNullableString();
 	void testTupleWithNullable();
 
+	void testBinarySimpleAccess();
+	void testBinaryComplexType();
+	void testBinarySimpleAccessVector();
+	void testBinaryComplexTypeVector();
+	void testBinaryInts();
+	void testBinaryFloat();
+	void testBinaryDouble();
+	void testBinaryUUID();
+	void testBinaryDateTime();
+	void testBinaryBLOBStmt();
+	void testBinaryCLOBStmt();
+
 	void testSessionTransaction();
 	void testTransaction();
 
@@ -119,6 +131,7 @@ private:
 	void recreateIntsTable();
 	void recreateUnsignedIntsTable();
 	void recreateFloatsTable();
+	void recreateDoublesTable();
 	void recreateUUIDsTable();
 	void recreateTuplesTable();
 	void recreateVectorsTable();