From 79f7b43dc4738c48c7ef6d093399cfec88733b88 Mon Sep 17 00:00:00 2001
From: Alex Fabijanic <alex@pocoproject.org>
Date: Fri, 24 Jun 2022 05:59:15 +0200
Subject: [PATCH] feat(TypeHandler): DB into() does not compile for more than
 20 members in a tuple #3342

---
 Data/include/Poco/Data/TypeHandler.h | 4090 ++++++++++++++++++++++++--
 1 file changed, 3877 insertions(+), 213 deletions(-)

diff --git a/Data/include/Poco/Data/TypeHandler.h b/Data/include/Poco/Data/TypeHandler.h
index 85684666e..235cbbb26 100644
--- a/Data/include/Poco/Data/TypeHandler.h
+++ b/Data/include/Poco/Data/TypeHandler.h
@@ -79,18 +79,18 @@ class TypeHandler: public AbstractTypeHandler
 	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
 	///			// Note that we advance pos by the number of columns the datatype uses! For string/int this is one.
 	///			poco_assert_dbg (!pBinder.isNull());
-	///			TypeHandler<std::string>::bind(pos++, obj.getLastName(), pBinder, dir);
-	///			TypeHandler<std::string>::bind(pos++, obj.getFirstName(), pBinder, dir);
-	///			TypeHandler<int>::bind(pos++, obj.getAge(), pBinder, dir);
+	///			   TypeHandler<std::string>::bind(pos++, obj.getLastName(), pBinder, dir);
+	///			   TypeHandler<std::string>::bind(pos++, obj.getFirstName(), pBinder, dir);
+	///			   TypeHandler<int>::bind(pos++, obj.getAge(), pBinder, dir);
 	///		}
 	///
 	///		static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPreparator)
 	///		{
 	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
 	///			poco_assert_dbg (!pPreparator.isNull());
-	///			TypeHandler<std::string>::prepare(pos++, obj.getLastName(), pPreparator);
-	///			TypeHandler<std::string>::prepare(pos++, obj.getFirstName(), pPreparator);
-	///			TypeHandler<int>::prepare(pos++, obj.getAge(), pPreparator);
+	///			   TypeHandler<std::string>::prepare(pos++, obj.getLastName(), pPreparator);
+	///			   TypeHandler<std::string>::prepare(pos++, obj.getFirstName(), pPreparator);
+	///			   TypeHandler<int>::prepare(pos++, obj.getAge(), pPreparator);
 	///		}
 	///
 	///		static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt)
@@ -102,9 +102,9 @@ class TypeHandler: public AbstractTypeHandler
 	///			std::string firstName;
 	///			int age = 0;
 	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
-	///			TypeHandler<std::string>::extract(pos++, lastName, defVal.getLastName(), pExt);
-	///			TypeHandler<std::string>::extract(pos++, firstName, defVal.getFirstName(), pExt);
-	///			TypeHandler<int>::extract(pos++, age, defVal.getAge(), pExt);
+	///			   TypeHandler<std::string>::extract(pos++, lastName, defVal.getLastName(), pExt);
+	///			   TypeHandler<std::string>::extract(pos++, firstName, defVal.getFirstName(), pExt);
+	///			   TypeHandler<int>::extract(pos++, age, defVal.getAge(), pExt);
 	///			obj.setLastName(lastName);
 	///			obj.setFirstName(firstName);
 	///			obj.setAge(age);
@@ -343,6 +343,3670 @@ void tupleExtract(std::size_t& pos, TupleType tuple, DefValType defVal, Abstract
 }
 
 
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+	class T34,
+	class T35,
+	class T36,
+	class T37,
+	class T38,
+    class T39>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T35, 35>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T36, 36>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T37, 37>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T38, 38>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T39, 39>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T35, 35>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T36, 36>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T37, 37>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T38, 38>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T39, 39>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+			   TypeHandler<T34>::size() +
+			   TypeHandler<T35>::size() +
+			   TypeHandler<T36>::size() +
+			   TypeHandler<T37>::size() +
+			   TypeHandler<T38>::size() +
+			   TypeHandler<T39>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T35, 35>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T36, 36>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T37, 37>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T38, 38>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T39, 39>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+	class T34,
+	class T35,
+	class T36,
+	class T37,
+    class T38>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T35, 35>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T36, 36>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T37, 37>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T38, 38>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T35, 35>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T36, 36>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T37, 37>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T38, 38>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+			   TypeHandler<T34>::size() +
+			   TypeHandler<T35>::size() +
+			   TypeHandler<T36>::size() +
+			   TypeHandler<T37>::size() +
+			   TypeHandler<T38>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T35, 35>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T36, 36>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T37, 37>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T38, 38>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+	class T34,
+	class T35,
+	class T36,
+    class T37>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T35, 35>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T36, 36>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T37, 37>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T35, 35>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T36, 36>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T37, 37>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+			   TypeHandler<T34>::size() +
+			   TypeHandler<T35>::size() +
+			   TypeHandler<T36>::size() +
+			   TypeHandler<T37>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T35, 35>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T36, 36>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T37, 37>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+	class T34,
+	class T35,
+    class T36>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T35, 35>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T36, 36>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T35, 35>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T36, 36>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+			   TypeHandler<T34>::size() +
+			   TypeHandler<T35>::size() +
+			   TypeHandler<T36>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T35, 35>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T36, 36>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+	class T34,
+    class T35>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T35, 35>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T35, 35>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+			   TypeHandler<T34>::size() +
+   		       TypeHandler<T35>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T35, 35>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+	class T33,
+    class T34>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T34, 34>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T34, 34>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size() +
+    		   TypeHandler<T34>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T34, 34>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+	class T32,
+    class T33>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T33, 33>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T33, 33>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size() +
+			   TypeHandler<T33>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T33, 33>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+	class T31,
+    class T32>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T32, 32>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T32, 32>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+			   TypeHandler<T31>::size() +
+			   TypeHandler<T32>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T32, 32>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+	class T30,
+    class T31>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T31, 31>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T31, 31>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size() +
+		       TypeHandler<T31>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T31, 31>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29,
+    class T30>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T30, 30>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T30, 30>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size() +
+			   TypeHandler<T30>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T30, 30>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28,
+	class T29>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T29, 29>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T29, 29>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size() +
+			   TypeHandler<T29>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T29, 29>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27,
+	class T28>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T28, 28>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T28, 28>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size() +
+			   TypeHandler<T28>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T28, 28>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26,
+	class T27>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T27, 27>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T27, 27>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size() +
+			   TypeHandler<T27>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T27, 27>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25,
+	class T26>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T26, 26>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T26, 26>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size() +
+			   TypeHandler<T26>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T26, 26>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24,
+	class T25>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T25, 25>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T25, 25>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size() +
+			   TypeHandler<T25>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T25, 25>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23,
+	class T24>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T24, 24>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T24, 24>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size() +
+			   TypeHandler<T24>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T24, 24>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+	class T22,
+	class T23>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T23, 23>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T23, 23>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size() +
+			   TypeHandler<T23>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T23, 23>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+	class T21,
+    class T22>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T22, 22>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T22, 22>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+	   		   TypeHandler<T21>::size() +
+			   TypeHandler<T22>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T22, 22>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20,
+  	class T21>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T21, 21>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T21, 21>(pos, tuple, pPreparator);
+
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size() +
+			   TypeHandler<T21>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T21, 21>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18,
+	class T19,
+	class T20>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>
+{
+  public:
+	using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>::CONSTREFTYPE;
+	using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>::REFTYPE;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T20, 20>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T20, 20>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size() +
+			   TypeHandler<T20>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T20, 20>(pos, tuple, defVal, pExt);
+	}
+
+  private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
 template <class T0,
 	class T1,
 	class T2,
@@ -422,25 +4086,25 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size() +
-			TypeHandler<T15>::size() +
-			TypeHandler<T16>::size() +
-			TypeHandler<T17>::size() +
-			TypeHandler<T18>::size() +
-			TypeHandler<T19>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size() +
+			   TypeHandler<T19>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -550,24 +4214,24 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size() +
-			TypeHandler<T15>::size() +
-			TypeHandler<T16>::size() +
-			TypeHandler<T17>::size() +
-			TypeHandler<T18>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size() +
+			   TypeHandler<T18>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -673,23 +4337,23 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size() +
-			TypeHandler<T15>::size() +
-			TypeHandler<T16>::size() +
-			TypeHandler<T17>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size() +
+			   TypeHandler<T17>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -791,22 +4455,22 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size() +
-			TypeHandler<T15>::size() +
-			TypeHandler<T16>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size() +
+			   TypeHandler<T16>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -904,21 +4568,21 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size() +
-			TypeHandler<T15>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size() +
+			   TypeHandler<T15>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1012,20 +4676,20 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size() +
-			TypeHandler<T14>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size() +
+			   TypeHandler<T14>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1115,19 +4779,19 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size() +
-			TypeHandler<T13>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size() +
+			   TypeHandler<T13>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1213,18 +4877,18 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size() +
-			TypeHandler<T12>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size() +
+			   TypeHandler<T12>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1306,17 +4970,17 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size() +
-			TypeHandler<T11>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size() +
+			   TypeHandler<T11>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1394,16 +5058,16 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size() +
-			TypeHandler<T10>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size() +
+			   TypeHandler<T10>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1468,15 +5132,15 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size() +
-			TypeHandler<T9>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size() +
+			   TypeHandler<T9>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1538,14 +5202,14 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size() +
-			TypeHandler<T8>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size() +
+			   TypeHandler<T8>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1604,13 +5268,13 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size() +
-			TypeHandler<T7>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size() +
+			   TypeHandler<T7>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1666,12 +5330,12 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size() +
-			TypeHandler<T6>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size() +
+			   TypeHandler<T6>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1724,11 +5388,11 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size() +
-			TypeHandler<T5>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size() +
+			   TypeHandler<T5>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1778,10 +5442,10 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size() +
-			TypeHandler<T4>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size() +
+			   TypeHandler<T4>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1828,9 +5492,9 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size() +
-			TypeHandler<T3>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size() +
+			   TypeHandler<T3>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1874,8 +5538,8 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size() +
-			TypeHandler<T2>::size();
+			   TypeHandler<T1>::size() +
+			   TypeHandler<T2>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1916,7 +5580,7 @@ public:
 	static std::size_t size()
 	{
 		return TypeHandler<T0>::size() +
-			TypeHandler<T1>::size();
+			   TypeHandler<T1>::size();
 	}
 
 	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
@@ -1975,9 +5639,9 @@ class TypeHandler<std::pair<K, V>>: public AbstractTypeHandler
 public:
 	static void bind(std::size_t pos, const std::pair<K, V>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
 	{
-		TypeHandler<K>::bind(pos, obj.first, pBinder, dir);
+			   TypeHandler<K>::bind(pos, obj.first, pBinder, dir);
 		pos += TypeHandler<K>::size();
-		TypeHandler<V>::bind(pos, obj.second, pBinder, dir);
+			   TypeHandler<V>::bind(pos, obj.second, pBinder, dir);
 	}
 
 	static std::size_t size()
@@ -1987,16 +5651,16 @@ public:
 
 	static void extract(std::size_t pos, std::pair<K, V>& obj, const std::pair<K, V>& defVal, AbstractExtractor::Ptr pExt)
 	{
-		TypeHandler<K>::extract(pos, obj.first, defVal.first, pExt);
+			   TypeHandler<K>::extract(pos, obj.first, defVal.first, pExt);
 		pos += TypeHandler<K>::size();
-		TypeHandler<V>::extract(pos, obj.second, defVal.second, pExt);
+			   TypeHandler<V>::extract(pos, obj.second, defVal.second, pExt);
 	}
 
 	static void prepare(std::size_t pos, const std::pair<K, V>& obj, AbstractPreparator::Ptr pPreparator)
 	{
-		TypeHandler<K>::prepare(pos, obj.first, pPreparator);
+			   TypeHandler<K>::prepare(pos, obj.first, pPreparator);
 		pos += TypeHandler<K>::size();
-		TypeHandler<V>::prepare(pos, obj.second, pPreparator);
+			   TypeHandler<V>::prepare(pos, obj.second, pPreparator);
 	}
 
 private:
@@ -2013,7 +5677,7 @@ public:
 	static void bind(std::size_t pos, const Poco::AutoPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
 	{
 		// *obj will trigger a nullpointer exception if empty: this is on purpose
-		TypeHandler<T>::bind(pos, *obj, pBinder, dir);
+			   TypeHandler<T>::bind(pos, *obj, pBinder, dir);
 	}
 
 	static std::size_t size()
@@ -2027,15 +5691,15 @@ public:
 
 		obj = Poco::AutoPtr<T>(new T());
 		if (defVal)
-			TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
+			   TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
 		else
-			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
+			   TypeHandler<T>::extract(pos, *obj, *obj, pExt);
 	}
 
 	static void prepare(std::size_t pos, const Poco::AutoPtr<T>&, AbstractPreparator::Ptr pPreparator)
 	{
 		poco_assert_dbg (!pPreparator.isNull());
-		TypeHandler<T>::prepare(pos, T(), pPreparator);
+			   TypeHandler<T>::prepare(pos, T(), pPreparator);
 	}
 
 private:
@@ -2053,7 +5717,7 @@ public:
 	static void bind(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
 	{
 		// *obj will trigger a nullpointer exception if empty
-		TypeHandler<T>::bind(pos, *obj, pBinder, dir);
+			   TypeHandler<T>::bind(pos, *obj, pBinder, dir);
 	}
 
 	static std::size_t size()
@@ -2067,15 +5731,15 @@ public:
 
 		obj = Poco::SharedPtr<T>(new T());
 		if (defVal)
-			TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
+			   TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
 		else
-			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
+			   TypeHandler<T>::extract(pos, *obj, *obj, pExt);
 	}
 
 	static void prepare(std::size_t pos, const Poco::SharedPtr<T>&, AbstractPreparator::Ptr pPreparator)
 	{
 		poco_assert_dbg (!pPreparator.isNull());
-		TypeHandler<T>::prepare(pos, T(), pPreparator);
+			   TypeHandler<T>::prepare(pos, T(), pPreparator);
 	}
 
 private: