Added dynamic functions to insert, remove and update

include/sqlpp11/assignment_list.h

@@ -27,39 +27,74 @@
 #ifndef SQLPP_ASSIGNMENT_LIST_H
 #define SQLPP_ASSIGNMENT_LIST_H
 
+#include <vector>
+#include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/set.h>
 #include <sqlpp11/detail/serialize_tuple.h>
-#include <sqlpp11/type_traits.h>
+#include <sqlpp11/detail/serializable.h>
 
 namespace sqlpp
 {
-	template<template<typename> class ProhibitPredicate, typename... Assignment>
+	namespace detail
+	{
+		template<typename Db>
+			struct dynamic_assignment_list
+			{
+				using type = std::vector<detail::serializable_t<Db>>;
+			};
+
+		template<>
+			struct dynamic_assignment_list<void>
+			{
+				using type = std::vector<noop>;
+			};
+	};
+
+	template<typename Database, template<typename> class ProhibitPredicate, typename... Assignments>
 		struct assignment_list_t
 		{
+			using _is_assignment_list = std::true_type;
+			using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
+
 			// check for at least one order expression
-			static_assert(sizeof...(Assignment), "at least one select expression required in set()");
+			static_assert(_is_dynamic::value or sizeof...(Assignments), "at least one assignment expression required in set()");
 
 			// check for duplicate assignments
-			static_assert(not detail::has_duplicates<Assignment...>::value, "at least one duplicate argument detected in set()");
+			static_assert(not detail::has_duplicates<Assignments...>::value, "at least one duplicate argument detected in set()");
 
 			// check for invalid assignments
-			using _assignment_set = typename detail::make_set_if<is_assignment_t, Assignment...>::type;
-			static_assert(_assignment_set::size::value == sizeof...(Assignment), "at least one argument is not an assignment in set()");
+			using _assignment_set = typename detail::make_set_if<is_assignment_t, Assignments...>::type;
+			static_assert(_assignment_set::size::value == sizeof...(Assignments), "at least one argument is not an assignment in set()");
 
 			// check for prohibited assignments
-			using _prohibited_assignment_set = typename detail::make_set_if<ProhibitPredicate, typename Assignment::column_type...>::type;
+			using _prohibited_assignment_set = typename detail::make_set_if<ProhibitPredicate, typename Assignments::column_type...>::type;
 			static_assert(_prohibited_assignment_set::size::value == 0, "at least one assignment is prohibited by its column definition in set()");
 
-			using _is_assignment_list = std::true_type;
+			template<typename Assignment>
+				void add(Assignment&& assignment)
+				{
+					static_assert(is_assignment_t<typename std::decay<Assignment>::type>::value, "set() arguments require to be assigments");
+					static_assert(not ProhibitPredicate<typename std::decay<Assignment>::type::column_type>::value, "set() argument must not be updated");
+					_dynamic_assignments.push_back(std::forward<Assignment>(assignment));
+				}
 
 			template<typename Db>
 				void serialize(std::ostream& os, Db& db) const
 				{
 					os << " SET ";
 					detail::serialize_tuple(os, db, _assignments, ',');
+					bool first = sizeof...(Assignments) == 0;
+					for (const auto& assignment : _dynamic_assignments)
+					{
+						if (not first)
+							os << ',';
+						assignment.serialize(os, db);
+						first = false;
+					}
 				}
 
-			std::tuple<Assignment...> _assignments;
+			std::tuple<Assignments...> _assignments;
+			typename detail::dynamic_assignment_list<Database>::type _dynamic_assignments;
 		};
 
 }

include/sqlpp11/from.h

@@ -42,7 +42,7 @@ namespace sqlpp
 			using _is_from = std::true_type;
 
 			// ensure one argument at least
-			static_assert(sizeof...(TableOrJoin), "at least one table or join argument required in from");
+			static_assert(sizeof...(TableOrJoin), "at least one table or join argument required in from()");
 
 			// check for duplicate arguments
 			static_assert(not detail::has_duplicates<TableOrJoin...>::value, "at least one duplicate argument detected in from()");

include/sqlpp11/insert.h

@@ -37,12 +37,14 @@
 namespace sqlpp
 {
 	template<
+		typename Database = void,
 		typename Table = noop,
 		typename InsertList = noop
 		>
 	struct insert_t;
 
 	template<
+		typename Database,
 		typename Table,
 		typename InsertList
 		>
@@ -51,19 +53,40 @@ namespace sqlpp
 			static_assert(is_noop<Table>::value or is_table_t<Table>::value, "invalid 'Table' argument");
 			static_assert(is_noop<InsertList>::value or is_insert_list_t<InsertList>::value, "invalid 'InsertList' argument");
 
-			template<typename... Assignment> 
-				using set_insert_list_t = insert_t<Table, insert_list_t<must_not_insert_t, typename std::decay<Assignment>::type...>>;
+			template<typename AssignmentT> 
+				using set_insert_list_t = insert_t<Database, Table, AssignmentT>;
 
 			template<typename... Assignment>
-				set_insert_list_t<Assignment...> set(Assignment&&... assignment)
+				auto set(Assignment&&... assignment)
+				-> set_insert_list_t<insert_list_t<void, must_not_insert_t, typename std::decay<Assignment>::type...>>
+				{
+					static_assert(std::is_same<InsertList, noop>::value, "cannot call set() twice");
+					// FIXME:  Need to check if all required columns are set
+					return {
+							_table,
+							insert_list_t<void, must_not_insert_t, typename std::decay<Assignment>::type...>{std::forward<Assignment>(assignment)...},
+					};
+				}
+
+			template<typename... Assignment>
+				auto dynamic_set(Assignment&&... assignment)
+				-> set_insert_list_t<insert_list_t<Database, must_not_insert_t, typename std::decay<Assignment>::type...>>
 				{
 					static_assert(std::is_same<InsertList, noop>::value, "cannot call set() twice");
 					return {
 							_table,
-							insert_list_t<must_not_insert_t, Assignment...>{std::forward<Assignment>(assignment)...},
+							insert_list_t<Database, must_not_insert_t, typename std::decay<Assignment>::type...>{std::forward<Assignment>(assignment)...},
 					};
 				}
 
+			template<typename Assignment>
+				void add_set(Assignment&& assignment)
+				{
+					static_assert(is_dynamic_t<InsertList>::value, "cannot call add_set() in a non-dynamic set");
+
+					_insert_list.add(std::forward<Assignment>(assignment));
+				}
+
 			template<typename Db>
 				const insert_t& serialize(std::ostream& os, Db& db) const
 				{
@@ -71,10 +94,7 @@ namespace sqlpp
 					_table.serialize(os, db);
 					if (is_noop<InsertList>::value)
 					{
-						if (connector_has_empty_list_insert_t<typename std::decay<Db>::type>::value)
-							os << " () VALUES()";
-						else
-							os << " DEFAULT VALUES";
+						detail::serialize_empty_insert_list(os, db);
 					}
 					else
 						_insert_list.serialize(os, db);
@@ -104,7 +124,13 @@ namespace sqlpp
 		};
 
 	template<typename Table>
-		constexpr insert_t<typename std::decay<Table>::type> insert_into(Table&& table)
+		insert_t<void, typename std::decay<Table>::type> insert_into(Table&& table)
+		{
+			return {std::forward<Table>(table)};
+		}
+
+	template<typename Database, typename Table>
+		insert_t<typename std::decay<Database>::type, typename std::decay<Table>::type> dynamic_insert_into(Database&& db, Table&& table)
 		{
 			return {std::forward<Table>(table)};
 		}

include/sqlpp11/insert_list.h

@@ -27,14 +27,38 @@
 #ifndef SQLPP_INSERT_LIST_H
 #define SQLPP_INSERT_LIST_H
 
+#include <vector>
+#include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/set.h>
 #include <sqlpp11/detail/serialize_tuple.h>
-#include <sqlpp11/type_traits.h>
+#include <sqlpp11/detail/serializable.h>
 
 namespace sqlpp
 {
 	namespace detail
 	{
+		template<typename Db>
+			void serialize_empty_insert_list(std::ostream& os, const Db& db)
+			{
+
+				if (connector_has_empty_list_insert_t<typename std::decay<Db>::type>::value)
+					os << " () VALUES()";
+				else
+					os << " DEFAULT VALUES";
+			}
+
+		template<typename Db>
+			struct dynamic_column_list
+			{
+				using type = std::vector<detail::serializable_t<Db>>;
+			};
+
+		template<>
+			struct dynamic_column_list<void>
+			{
+				using type = std::vector<noop>;
+			};
+
 		template<typename Column>
 			struct insert_column
 			{
@@ -47,26 +71,27 @@ namespace sqlpp
 				Column _column;
 			};
 	}
-	template<template<typename> class ProhibitPredicate, typename... Assignment>
+	template<typename Database, template<typename> class ProhibitPredicate, typename... Assignments>
 		struct insert_list_t
 		{
+			using _is_insert_list = std::true_type;
+			using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
+
 			// check for at least one order expression
-			static_assert(sizeof...(Assignment), "at least one select expression required in set()");
+			static_assert(_is_dynamic::value or sizeof...(Assignments), "at least one select expression required in set()");
 
 			// check for duplicate assignments
-			static_assert(not detail::has_duplicates<Assignment...>::value, "at least one duplicate argument detected in set()");
+			static_assert(not detail::has_duplicates<Assignments...>::value, "at least one duplicate argument detected in set()");
 
 			// check for invalid assignments
-			using _assignment_set = typename detail::make_set_if<is_assignment_t, Assignment...>::type;
-			static_assert(_assignment_set::size::value == sizeof...(Assignment), "at least one argument is not an assignment in set()");
+			using _assignment_set = typename detail::make_set_if<is_assignment_t, Assignments...>::type;
+			static_assert(_assignment_set::size::value == sizeof...(Assignments), "at least one argument is not an assignment in set()");
 
 			// check for prohibited assignments
-			using _prohibited_assignment_set = typename detail::make_set_if<ProhibitPredicate, typename Assignment::column_type...>::type;
+			using _prohibited_assignment_set = typename detail::make_set_if<ProhibitPredicate, typename Assignments::column_type...>::type;
 			static_assert(_prohibited_assignment_set::size::value == 0, "at least one assignment is prohibited by its column definition in set()");
 
-			using _is_insert_list = std::true_type;
-
-			insert_list_t(Assignment... assignment):
+			insert_list_t(Assignments... assignment):
 				_columns({assignment._lhs}...),
 				_values(assignment._rhs...)
 			{}
@@ -77,18 +102,54 @@ namespace sqlpp
 			insert_list_t& operator=(insert_list_t&&) = default;
 			~insert_list_t() = default;
 
+			template<typename Assignment>
+				void add(Assignment&& assignment)
+				{
+					static_assert(is_assignment_t<typename std::decay<Assignment>::type>::value, "set() arguments require to be assigments");
+					static_assert(not ProhibitPredicate<typename std::decay<Assignment>::type>::value, "set() argument must not be used in insert");
+					_dynamic_columns.push_back(std::forward<typename Assignment::column_type>(assignment._lhs));
+					_dynamic_values.push_back(std::forward<typename Assignment::value_type>(assignment._rhs));
+				}
+
 			template<typename Db>
 				void serialize(std::ostream& os, Db& db) const
 				{
-					os << " (";
-					detail::serialize_tuple(os, db, _columns, ',');
-					os << ") VALUES (";
-					detail::serialize_tuple(os, db, _values, ',');
-					os << ")";
+					if (sizeof...(Assignments) + _dynamic_columns.size())
+						detail::serialize_empty_insert_list(os, db);
+					else
+					{
+						os << " (";
+						detail::serialize_tuple(os, db, _columns, ',');
+						{
+							bool first = sizeof...(Assignments) == 0;
+							for (const auto column : _dynamic_columns)
+							{
+								if (not first)
+									os << ',';
+								column.serialize(os, db);
+								first = false;
+							}
+						}
+						os << ") VALUES (";
+						detail::serialize_tuple(os, db, _values, ',');
+						{
+							bool first = sizeof...(Assignments) == 0;
+							for (const auto column : _dynamic_values)
+							{
+								if (not first)
+									os << ',';
+								column.serialize(os, db);
+								first = false;
+							}
+						}
+						os << ")";
+					}
 				}
 
-			std::tuple<detail::insert_column<typename Assignment::column_type>...> _columns;
-			std::tuple<typename Assignment::value_type...> _values;
+			std::tuple<detail::insert_column<typename Assignments::column_type>...> _columns;
+			std::tuple<typename Assignments::value_type...> _values;
+			typename detail::dynamic_column_list<Database>::type _dynamic_columns;
+			typename detail::dynamic_column_list<Database>::type _dynamic_values;
 		};
 
 }

include/sqlpp11/remove.h

@@ -36,6 +36,7 @@
 namespace sqlpp
 {
 	template<
+		typename Database,
 		typename Table,
 		typename Using = noop,
 		typename Where = noop
@@ -43,6 +44,7 @@ namespace sqlpp
 	struct remove_t;
 
 	template<
+		typename Database,
 		typename Table,
 		typename Using,
 		typename Where
@@ -53,13 +55,14 @@ namespace sqlpp
 			static_assert(is_noop<Using>::value or is_using_t<Using>::value, "invalid 'Using' argument");
 			static_assert(is_noop<Where>::value or is_where_t<Where>::value, "invalid 'Where' argument");
 
-			template<typename... Tab> 
-				using set_using_t = remove_t<Table, using_t<typename std::decay<Tab>::type...>, Where>;
-			template<typename Expr> 
-				using set_where_t = remove_t<Table, Using, where_t<typename std::decay<Expr>::type>>;
+			template<typename UsingT> 
+				using set_using_t = remove_t<Database, Table, UsingT, Where>;
+			template<typename WhereT> 
+				using set_where_t = remove_t<Database, Table, Using, WhereT>;
 
 			template<typename... Tab>
-				set_using_t<Tab...> using_(Tab&&... tab)
+				auto using_(Tab&&... tab)
+				-> set_using_t<using_t<typename std::decay<Tab>::type...>>
 				{
 					static_assert(std::is_same<Using, noop>::value, "cannot call using() twice");
 					static_assert(std::is_same<Where, noop>::value, "cannot call using() after where()");
@@ -70,8 +73,28 @@ namespace sqlpp
 					};
 				}
 
+				auto dynamic_using_()
+				-> set_using_t<dynamic_using_t<Database>>
+				{
+					static_assert(std::is_same<Using, noop>::value, "cannot call using() twice");
+					static_assert(std::is_same<Where, noop>::value, "cannot call using() after where()");
+					return {
+							_table,
+							{{}},
+							_where
+					};
+				}
+
+				template<typename Tab>
+				void add_using_(Tab&& table)
+				{
+					static_assert(is_dynamic_t<Using>::value, "cannot call add_using() in a non-dynamic using");
+					_using.add(std::forward<Tab>(table));
+				}
+
 			template<typename Expr>
-				set_where_t<Expr> where(Expr&& where)
+				auto where(Expr&& where)
+				-> set_where_t<where_t<typename std::decay<Expr>::type>>
 				{
 					static_assert(std::is_same<Where, noop>::value, "cannot call where() twice");
 					return {
@@ -81,6 +104,26 @@ namespace sqlpp
 					};
 				}
 
+			auto dynamic_where()
+				-> set_where_t<dynamic_where_t<Database>>
+				{
+					static_assert(std::is_same<Where, noop>::value, "cannot call where() twice");
+					return {
+						_table, 
+							_using, 
+							{{}}, 
+					};
+				}
+
+			template<typename Expr>
+				void add_where(Expr&& expr)
+				{
+					static_assert(is_dynamic_t<Where>::value, "cannot call add_where() in a non-dynamic where");
+
+					_where.add(std::forward<Expr>(expr));
+				}
+
+
 			template<typename Db>
 				const remove_t& serialize(std::ostream& os, Db& db) const
 				{
@@ -112,7 +155,13 @@ namespace sqlpp
 		};
 
 	template<typename Table>
-		constexpr remove_t<typename std::decay<Table>::type> remove_from(Table&& table)
+		constexpr remove_t<void, typename std::decay<Table>::type> remove_from(Table&& table)
+		{
+			return {std::forward<Table>(table)};
+		}
+
+	template<typename Db, typename Table>
+		constexpr remove_t<typename std::decay<Db>::type, typename std::decay<Table>::type> dynamic_remove_from(Db&& db, Table&& table)
 		{
 			return {std::forward<Table>(table)};
 		}

include/sqlpp11/update.h

@@ -36,6 +36,7 @@
 namespace sqlpp
 {
 	template<
+		typename Database = void,
 		typename Table = noop,
 		typename Assignments = noop,
 		typename Where = noop
@@ -43,6 +44,7 @@ namespace sqlpp
 	struct update_t;
 
 	template<
+		typename Database,
 		typename Table,
 		typename Assignments,
 		typename Where
@@ -53,13 +55,14 @@ namespace sqlpp
 			static_assert(is_noop<Assignments>::value or is_assignment_list_t<Assignments>::value, "invalid 'Assignments' arguments");
 			static_assert(is_noop<Where>::value or is_where_t<Where>::value, "invalid 'Where' argument");
 
-			template<typename... Assignment> 
-				using set_assignments_t = update_t<Table, assignment_list_t<must_not_update_t, typename std::decay<Assignment>::type...>, Where>;
-			template<typename Expr> 
-				using set_where_t = update_t<Table, Assignments, where_t<typename std::decay<Expr>::type>>;
+			template<typename AssignmentsT> 
+				using set_assignments_t = update_t<Database, Table, AssignmentsT, Where>;
+			template<typename WhereT> 
+				using set_where_t = update_t<Database, Table, Assignments, WhereT>;
 
 			template<typename... Assignment>
-				set_assignments_t<Assignment...> set(Assignment&&... assignment)
+				auto set(Assignment&&... assignment)
+				-> set_assignments_t<assignment_list_t<void, must_not_update_t, typename std::decay<Assignment>::type...>>
 				{
 					static_assert(std::is_same<Assignments, noop>::value, "cannot call set() twice");
 					return {
@@ -69,8 +72,29 @@ namespace sqlpp
 					};
 				}
 
+			template<typename... Assignment>
+				auto dynamic_set(Assignment&&... assignment)
+				-> set_assignments_t<assignment_list_t<Database, must_not_update_t, typename std::decay<Assignment>::type...>>
+				{
+					static_assert(std::is_same<Assignments, noop>::value, "cannot call set() twice");
+					return {
+							_table,
+								{std::tuple<typename std::decay<Assignment>::type...>{std::forward<Assignment>(assignment)...}},
+							_where,
+					};
+				}
+
+			template<typename Assignment>
+				void add_set(Assignment&& assignment)
+				{
+					static_assert(is_dynamic_t<Assignments>::value, "cannot call add_set() in a non-dynamic set");
+
+					_assignments.add(std::forward<Assignment>(assignment));
+				}
+
 			template<typename Expr>
-				set_where_t<Expr> where(Expr&& where)
+				auto where(Expr&& where)
+				-> set_where_t<where_t<typename std::decay<Expr>::type>>
 				{
 					static_assert(not std::is_same<Assignments, noop>::value, "cannot call where() if set() hasn't been called yet");
 					static_assert(std::is_same<Where, noop>::value, "cannot call where() twice");
@@ -81,6 +105,26 @@ namespace sqlpp
 					};
 				}
 
+			auto dynamic_where()
+				-> set_where_t<dynamic_where_t<Database>>
+				{
+					static_assert(not std::is_same<Assignments, noop>::value, "cannot call where() if set() hasn't been called yet");
+					static_assert(std::is_same<Where, noop>::value, "cannot call where() twice");
+					return {
+						_table, 
+							_assignments, 
+							{{}}, 
+					};
+				}
+
+			template<typename Expr>
+				void add_where(Expr&& expr)
+				{
+					static_assert(is_dynamic_t<Where>::value, "cannot call add_where() in a non-dynamic where");
+
+					_where.add(std::forward<Expr>(expr));
+				}
+
 			template<typename Db>
 				const update_t& serialize(std::ostream& os, Db& db) const
 				{
@@ -112,7 +156,13 @@ namespace sqlpp
 		};
 
 	template<typename Table>
-		constexpr update_t<typename std::decay<Table>::type> update(Table&& table)
+		constexpr update_t<void, typename std::decay<Table>::type> update(Table&& table)
+		{
+			return {std::forward<Table>(table)};
+		}
+
+	template<typename Db, typename Table>
+		constexpr update_t<typename std::decay<Db>::type, typename std::decay<Table>::type> dynamic_update(Db&& db, Table&& table)
 		{
 			return {std::forward<Table>(table)};
 		}

include/sqlpp11/using.h

@@ -27,9 +27,11 @@
 #ifndef SQLPP_USING_H
 #define SQLPP_USING_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/detail/serialize_tuple.h>
 #include <ostream>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/detail/set.h>
+#include <sqlpp11/detail/serialize_tuple.h>
+#include <sqlpp11/detail/serializable.h>
 
 namespace sqlpp
 {
@@ -38,7 +40,15 @@ namespace sqlpp
 		{
 			using _is_using = std::true_type;
 
-			static_assert(sizeof...(Table), "at least one table argument required in using");
+			static_assert(sizeof...(Table), "at least one table argument required in using()");
+
+			// check for duplicate arguments
+			static_assert(not detail::has_duplicates<Table...>::value, "at least one duplicate argument detected in using()");
+
+			// check for invalid arguments
+			using _valid_expressions = typename detail::make_set_if<is_table_t, Table...>::type;
+			static_assert(_valid_expressions::size::value == sizeof...(Table), "at least one argument is not an table in using()");
+
 
 			template<typename Db>
 				void serialize(std::ostream& os, Db& db) const
@@ -49,6 +59,37 @@ namespace sqlpp
 
 			std::tuple<Table...> _tables;
 		};
+
+	template<typename Db>
+	struct dynamic_using_t
+	{
+		using _is_using = std::true_type;
+		using _is_dynamic = std::true_type;
+
+		template<typename Table>
+		void add(Table&& table)
+		{
+			static_assert(is_table_t<typename std::decay<Table>::type>::value, "using arguments require to be tables");
+			_dynamic_tables.push_back(std::forward<Table>(table));
+		}
+
+		void serialize(std::ostream& os, Db& db) const
+		{
+			if (_dynamic_tables.empty())
+				return;
+			os << " USING ";
+			bool first = true;
+			for (const auto& table : _dynamic_tables)
+			{
+				if (not first)
+					os << ',';
+				table.serialize(os, db);
+				first = false;
+			}
+		}
+
+		std::vector<detail::serializable_t<Db>> _dynamic_tables;
+	};
 }
 
 #endif

tests/InsertTest.cpp

@@ -47,6 +47,9 @@ int main()
 
 	insert_into(t).serialize(std::cerr, db); std::cerr << "\n";
 	insert_into(t).set(t.beta = "kirschauflauf").serialize(std::cerr, db); std::cerr << "\n";
+	auto i = dynamic_insert_into(db, t).dynamic_set();
+	i.add_set(t.beta = "kirschauflauf");
+	i.serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).values(7, "wurstwaren", true).serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).values(25, "drei").serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).select(select(t.alpha, t.beta).from(t)).serialize(std::cerr, db);

tests/RemoveTest.cpp

@@ -48,6 +48,10 @@ int main()
 	remove_from(t).serialize(std::cerr, db); std::cerr << "\n";
 	remove_from(t).where(t.beta != "transparent").serialize(std::cerr, db); std::cerr << "\n";
 	remove_from(t).using_(t).serialize(std::cerr, db); std::cerr << "\n";
+	auto r = dynamic_remove_from(db, t).dynamic_using_().dynamic_where();
+	r.add_using_(t);
+	r.add_where(t.beta != "transparent");
+	r.serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).values(7, "wurstwaren", true).serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).values(25, "drei").serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).select(select(t.alpha, t.beta).from(t)).serialize(std::cerr, db);

tests/UpdateTest.cpp

@@ -48,6 +48,10 @@ int main()
 	update(t).serialize(std::cerr, db); std::cerr << "\n";
 	update(t).set(t.gamma = false).serialize(std::cerr, db); std::cerr << "\n";
 	update(t).set(t.gamma = false).where(t.beta != "transparent").serialize(std::cerr, db); std::cerr << "\n";
+	auto u = dynamic_update(db, t).dynamic_set(t.gamma = false).dynamic_where();
+	u.add_set(t.gamma = false);
+	u.serialize(std::cerr, db); std::cerr << "\n";
+
 	//insert_into(t).values(7, "wurstwaren", true).serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).values(25, "drei").serialize(std::cerr, db); std::cerr << "\n";
 	//insert_into(t).columns(t.alpha, t.beta).select(select(t.alpha, t.beta).from(t)).serialize(std::cerr, db);