interpret handles order_by(), limit() and offset()

include/sqlpp11/limit.h

@@ -37,26 +37,24 @@ namespace sqlpp
 		struct limit_t
 		{
 			using _is_limit = std::true_type;
-			using _parameter_tuple_t = std::tuple<Limit>;
 			static_assert(std::is_integral<Limit>::value 
 					or (is_parameter_t<Limit>::value and is_numeric_t<Limit>::value), "limit requires an integral value or integral parameter");
 
-			template<typename Db>
-				void serialize(std::ostream& os, Db& db) const
-				{
-					static_assert(Db::_supports_limit, "limit not supported by current database");
-					os << " LIMIT " << _limit;
-				}
-
-			size_t _set_parameter_index(size_t index)
-			{
-				index = set_parameter_index(_limit, index);
-				return index;
-			}
-
 			Limit _limit;
 		};
 
+	template<typename Context, typename Limit>
+		struct interpreter_t<Context, limit_t<Limit>>
+		{
+			using T = limit_t<Limit>;
+
+			static Context& _(const T& t, Context& context)
+			{
+				context << "LIMIT " << t._limit;
+				return context;
+			}
+		};
+
 	struct dynamic_limit_t
 	{
 		using _is_limit = std::true_type;

include/sqlpp11/offset.h

@@ -37,26 +37,24 @@ namespace sqlpp
 		struct offset_t
 		{
 			using _is_offset = std::true_type;
-			using _parameter_tuple_t = std::tuple<Offset>;
 			static_assert(std::is_integral<Offset>::value 
 					or (is_parameter_t<Offset>::value and is_numeric_t<Offset>::value), "offset requires an integral value or integral parameter");
 
-
-			template<typename Db>
-				void serialize(std::ostream& os, Db& db) const
-				{
-					os << " OFFSET " << _offset;
-				}
-
-			size_t _set_parameter_index(size_t index)
-			{
-				index = set_parameter_index(_offset, index);
-				return index;
-			}
-
 			Offset _offset;
 		};
 
+	template<typename Context, typename Offset>
+		struct interpreter_t<Context, offset_t<Offset>>
+		{
+			using T = offset_t<Offset>;
+
+			static Context& _(const T& t, Context& context)
+			{
+				context << "OFFSET " << t._offset;
+				return context;
+			}
+		};
+
 	struct dynamic_offset_t
 	{
 		using _is_offset = std::true_type;

include/sqlpp11/order_by.h

@@ -60,28 +60,29 @@ namespace sqlpp
 					_dynamic_expressions.push_back(std::forward<E>(expr));
 				}
 
-			template<typename Db>
-				void serialize(std::ostream& os, Db& db) const
-				{
-					static_assert(Db::_supports_order_by, "order by not supported by current database");
-					if (sizeof...(Expr) == 0 and _dynamic_expressions.empty())
-						return;
-
-					os << " ORDER BY ";
-					detail::serialize_tuple(os, db, _expressions, ',');
-					_dynamic_expressions.serialize(os, db, sizeof...(Expr) == 0);
-				}
-
-			size_t _set_parameter_index(size_t index)
-			{
-				index = set_parameter_index(_expressions, index);
-				return index;
-			}
-
 			_parameter_tuple_t _expressions;
 			detail::serializable_list<Database> _dynamic_expressions;
 		};
 
+	template<typename Context, typename Database, typename... Expr>
+		struct interpreter_t<Context, order_by_t<Database, Expr...>>
+		{
+			using T = order_by_t<Database, Expr...>;
+
+			static Context& _(const T& t, Context& context)
+			{
+				if (sizeof...(Expr) == 0 and t._dynamic_expressions.empty())
+					return context;
+				context << " ORDER BY ";
+				interpret_tuple(t._expressions, ',', context);
+				if (sizeof...(Expr) and not t._dynamic_expressions.empty())
+					context << ',';
+				interpret_serializable_list(t._dynamic_expressions, ',', context);
+				return context;
+			}
+		};
+
+
 }
 
 #endif

include/sqlpp11/sort_order.h

@@ -40,23 +40,30 @@ namespace sqlpp
 		{
 			using _is_sort_order = std::true_type;
 
-			template<typename Db>
-				void serialize(std::ostream& os, Db& db) const
-				{
-					_expression.serialize(os, db);
-					switch(SortType)
-					{
-					case sort_type::asc:
-						os << " ASC";
-						break;
-					default:
-						os << " DESC";
-						break;
-					}
-				}
-
 			Expression _expression;
 		};
+
+	template<typename Context, typename Expression, sort_type SortType>
+		struct interpreter_t<Context, sort_order_t<Expression, SortType>>
+		{
+			using T = sort_order_t<Expression, SortType>;
+
+			static Context& _(const T& t, Context& context)
+			{
+				interpret(t._expression, context);
+				switch(SortType)
+				{
+				case sort_type::asc:
+					context << " ASC";
+					break;
+				default:
+					context << " DESC";
+					break;
+				}
+				return context;
+			}
+		};
+
 }
 
 #endif

tests/InterpretTest.cpp

@@ -48,6 +48,8 @@ int main()
 	interpret(select(sqlpp::distinct, t.alpha, t.beta).from(t).where(t.alpha == 3), printer).flush();
 	interpret(select(sqlpp::distinct, t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma), printer).flush();
 	interpret(select(sqlpp::distinct, t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")), printer).flush();
+	interpret(select(sqlpp::distinct, t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()), printer).flush();
+	interpret(select(sqlpp::distinct, t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()).limit(17).offset(3), printer).flush();
 
 	return 0;
 }