Merge branch 'release/0.25'

Conflicts:
	test_constraints/CMakeLists.txt

include/sqlpp11/basic_expression_operators.h

@@ -32,7 +32,7 @@
 #include <sqlpp11/expression_fwd.h>
 #include <sqlpp11/in_fwd.h>
 #include <sqlpp11/is_null_fwd.h>
-#include <sqlpp11/wrap_operand.h>
+#include <sqlpp11/wrap_operand_fwd.h>
 #include <sqlpp11/detail/logic.h>
 
 namespace sqlpp

include/sqlpp11/eval.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013-2014, Roland Bock
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * 
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_EVAL_H
+#define SQLPP_EVAL_H
+
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/field_spec.h>
+#include <sqlpp11/alias_provider.h>
+#include <sqlpp11/verbatim.h>
+
+namespace sqlpp
+{
+	template<typename Db, typename Expr>
+		struct eval_t
+		{
+			static_assert(is_database<Db>::value, "Db parameter of eval has to be a database connection");
+			static_assert(is_expression_t<Expr>::value, "Expression parameter of eval has to be an sqlpp expression or a string");
+			static_assert(required_tables_of<Expr>::size::value == 0, "Expression cannot be used in eval because it requires tables");
+			using _name_type = alias::a_t::_name_t;
+			using _value_type = value_type_of<Expr>;
+			using _field_spec = field_spec_t<_name_type, _value_type, true, false>;
+			using type = result_field_t<_value_type, Db, _field_spec>;
+		};
+
+	template<typename Db, typename Expr, typename std::enable_if<not std::is_convertible<Expr, std::string>::value, int>::type = 0>
+		auto eval(Db& db, Expr expr) -> typename eval_t<Db, Expr>::type
+		{
+			return db(select(expr.as(alias::a))).front().a;
+		}
+
+	template<typename ValueType, typename Db>
+		auto eval(Db& db, std::string sql_code) -> decltype(eval(db, verbatim<ValueType>(sql_code)))
+		{
+			return eval(db, verbatim<ValueType>(sql_code));
+		}
+}
+
+#endif

include/sqlpp11/functions.h

@@ -41,8 +41,10 @@
 #include <sqlpp11/max.h>
 #include <sqlpp11/avg.h>
 #include <sqlpp11/sum.h>
-#include <sqlpp11/verbatim_table.h> // Csaba Csoma suggests: unsafe_sql instead of verbatim
+#include <sqlpp11/verbatim.h> // Csaba Csoma suggests: unsafe_sql instead of verbatim
+#include <sqlpp11/verbatim_table.h>
 #include <sqlpp11/value_or_null.h>
+#include <sqlpp11/eval.h>
 
 namespace sqlpp
 {
@@ -53,44 +55,6 @@ namespace sqlpp
 			return { t };
 		}
 
-	template<typename ValueType> // Csaba Csoma suggests: unsafe_sql instead of verbatim
-		struct verbatim_t: public ValueType::template expression_operators<verbatim_t<ValueType>>,
-		public alias_operators<verbatim_t<ValueType>>
-	{
-		using _traits = make_traits<ValueType, ::sqlpp::tag::is_expression>;
-		struct _recursive_traits : public make_recursive_traits<>
-		{
-			using _can_be_null = std::true_type; // since we do not know what's going on inside the verbatim, we assume it can be null
-		};
-
-		verbatim_t(std::string verbatim): _verbatim(verbatim) {}
-		verbatim_t(const verbatim_t&) = default;
-		verbatim_t(verbatim_t&&) = default;
-		verbatim_t& operator=(const verbatim_t&) = default;
-		verbatim_t& operator=(verbatim_t&&) = default;
-		~verbatim_t() = default;
-
-		std::string _verbatim;
-	};
-
-	template<typename Context, typename ValueType>
-		struct serializer_t<Context, verbatim_t<ValueType>>
-		{
-			using T = verbatim_t<ValueType>;
-
-			static Context& _(const T& t, Context& context)
-			{
-				context << t._verbatim;
-				return context;
-			}
-		};
-
-	template<typename ValueType, typename StringType>
-		auto verbatim(StringType s) -> verbatim_t<ValueType>
-		{
-			return { s };
-		}
-
 	template<typename Expression, typename Db>
 		auto flatten(const Expression& exp, Db& db) -> verbatim_t<value_type_of<Expression>>
 		{

include/sqlpp11/result_field.h

@@ -32,7 +32,7 @@
 
 namespace sqlpp
 {
-	template<typename ValueType, typename Db, typename Field>
+	template<typename ValueType, typename Db, typename FieldSpec>
 		struct result_field_t
 		{
 			static_assert(wrong_t<result_field_t>::value, "Missing specialization for result_field_t");

include/sqlpp11/select_column_list.h

@@ -310,7 +310,7 @@ namespace sqlpp
 						{
 							_statement_t::_check_consistency();
 
-							return {{}, get_dynamic_names(), db.prepare_select(_get_statement())};
+							return {make_parameter_list_t<_statement_t>{}, get_dynamic_names(), db.prepare_select(_get_statement())};
 						}
 				};
 

include/sqlpp11/verbatim.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2013-2014, Roland Bock
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * 
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_VERBATIM_H
+#define SQLPP_VERBATIM_H
+
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/serialize.h>
+
+namespace sqlpp
+{
+	template<typename ValueType> // Csaba Csoma suggests: unsafe_sql instead of verbatim
+		struct verbatim_t: public ValueType::template expression_operators<verbatim_t<ValueType>>,
+		public alias_operators<verbatim_t<ValueType>>
+	{
+		using _traits = make_traits<ValueType, ::sqlpp::tag::is_expression>;
+		struct _recursive_traits : public make_recursive_traits<>
+		{
+			using _can_be_null = std::true_type; // since we do not know what's going on inside the verbatim, we assume it can be null
+		};
+
+		verbatim_t(std::string verbatim): _verbatim(verbatim) {}
+		verbatim_t(const verbatim_t&) = default;
+		verbatim_t(verbatim_t&&) = default;
+		verbatim_t& operator=(const verbatim_t&) = default;
+		verbatim_t& operator=(verbatim_t&&) = default;
+		~verbatim_t() = default;
+
+		std::string _verbatim;
+	};
+
+	template<typename Context, typename ValueType>
+		struct serializer_t<Context, verbatim_t<ValueType>>
+		{
+			using T = verbatim_t<ValueType>;
+
+			static Context& _(const T& t, Context& context)
+			{
+				context << t._verbatim;
+				return context;
+			}
+		};
+
+	template<typename ValueType, typename StringType>
+		auto verbatim(StringType s) -> verbatim_t<ValueType>
+		{
+			return { s };
+		}
+
+}
+
+#endif

include/sqlpp11/where.h

@@ -181,7 +181,7 @@ namespace sqlpp
 		};
 
 	// NO WHERE YET
-	template<bool Required>
+	template<bool WhereRequired>
 		struct no_where_t
 		{
 			using _traits = make_traits<no_value_t, ::sqlpp::tag::is_where>;
@@ -224,7 +224,9 @@ namespace sqlpp
 
 					static void _check_consistency()
 					{
-						static_assert(Required ? wrong_t<_methods_t>::value : true, "where expression required, e.g. where(true)");
+						static constexpr bool _tables_provided = (Policies::_all_provided_tables::size::value > 0);
+						static constexpr bool _required = WhereRequired and _tables_provided;
+						static_assert(not _required, "where expression required, e.g. where(true)");
 					}
 
 					template<typename... Args>

include/sqlpp11/wrap_operand.h

@@ -28,8 +28,10 @@
 #define SQLPP_DETAIL_WRAP_OPERAND_H
 
 #include <string>
+#include <sqlpp11/wrap_operand_fwd.h>
 #include <sqlpp11/serializer.h>
 #include <sqlpp11/type_traits.h>
+#include <sqlpp11/basic_expression_operators.h>
 
 namespace sqlpp
 {
@@ -38,7 +40,7 @@ namespace sqlpp
 	struct floating_point;
 	struct text;
 
-	struct boolean_operand
+	struct boolean_operand: public alias_operators<boolean_operand>
 	{
 		using _traits = make_traits<::sqlpp::boolean, ::sqlpp::tag::is_expression, ::sqlpp::tag::is_wrapped_value>;
 		using _recursive_traits = make_recursive_traits<>;
@@ -76,7 +78,7 @@ namespace sqlpp
 			}
 		};
 
-	struct integral_operand
+	struct integral_operand: public alias_operators<integral_operand>
 	{
 		using _traits = make_traits<::sqlpp::integral, ::sqlpp::tag::is_expression, ::sqlpp::tag::is_wrapped_value>;
 		using _recursive_traits = make_recursive_traits<>;
@@ -115,7 +117,7 @@ namespace sqlpp
 		};
 
 
-	struct floating_point_operand
+	struct floating_point_operand: public alias_operators<floating_point_operand>
 	{
 		using _traits = make_traits<::sqlpp::floating_point, ::sqlpp::tag::is_expression, ::sqlpp::tag::is_wrapped_value>;
 		using _recursive_traits = make_recursive_traits<>;
@@ -153,7 +155,7 @@ namespace sqlpp
 			}
 		};
 
-	struct text_operand
+	struct text_operand: public alias_operators<text_operand>
 	{
 		using _traits = make_traits<::sqlpp::text, ::sqlpp::tag::is_expression, ::sqlpp::tag::is_wrapped_value>;
 		using _recursive_traits = make_recursive_traits<>;
@@ -191,7 +193,7 @@ namespace sqlpp
 			}
 		};
 
-	template<typename T, typename Enable = void>
+	template<typename T, typename Enable>
 		struct wrap_operand
 		{
 			using type = T;
@@ -221,11 +223,6 @@ namespace sqlpp
 			using type = text_operand;
 		};
 
-	// FIXME: Need to allow std::ref arguments
-
-	template<typename T>
-		using wrap_operand_t = typename wrap_operand<T>::type;
-
 }
 
 #endif

include/sqlpp11/wrap_operand_fwd.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2013-2014, Roland Bock
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * 
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_DETAIL_WRAP_OPERAND_FWD_H
+#define SQLPP_DETAIL_WRAP_OPERAND_FWD_H
+
+namespace sqlpp
+{
+	template<typename T, typename Enable = void>
+		struct wrap_operand;
+
+	template<typename T>
+		using wrap_operand_t = typename wrap_operand<T>::type;
+
+}
+
+#endif

test_constraints/CMakeLists.txt

@@ -24,8 +24,8 @@ function(test_constraint name pattern)
 
 endfunction(test_constraint)
 
-
 test_constraint(no_conversion_operator_if_null_not_trivial "int i = row.alpha")
 test_constraint(require_insert "required column is missing")
 test_constraint(must_not_insert "one assignment is prohibited")
+test_constraint(must_not_update "one assignment is prohibited")
 

tests/SelectTest.cpp

@@ -92,5 +92,7 @@ int main()
 	printer.reset();
 	std::cerr << serialize(stat, printer).str() << std::endl;
 
+	select(sqlpp::value(7).as(t.alpha));
+
 	return 0;
 }