Added run and prepare to noop, allowing void custom queries

include/sqlpp11/custom_query.h

@@ -96,19 +96,20 @@ namespace sqlpp
 
 	template<typename... Parts>
 		auto custom_query(Parts... parts)
-		-> custom_query_t<void, Parts...>
+		-> custom_query_t<void, wrap_operand_t<Parts>...>
 		{
 			static_assert(sizeof...(Parts) > 0, "custom query requires at least one argument");
-			return custom_query_t<void, Parts...>(parts...);
+			return custom_query_t<void, wrap_operand_t<Parts>...>(parts...);
 		}
 
 	template<typename Database, typename... Parts>
-		auto dynamic_custom_query(const Database&, Parts...)
-		-> custom_query_t<Database, Parts...>
+		auto dynamic_custom_query(const Database&, Parts... parts)
+		-> custom_query_t<Database, wrap_operand_t<Parts>...>
 		{
 			static_assert(sizeof...(Parts) > 0, "custom query requires at least one query argument");
 			static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
-			return { };
+
+			return custom_query_t<Database, wrap_operand_t<Parts>...>(parts...);
 		}
 }
 #endif

include/sqlpp11/noop.h

@@ -30,6 +30,7 @@
 #include <type_traits>
 #include <sqlpp11/no_value.h>
 #include <sqlpp11/serializer.h>
+#include <sqlpp11/prepared_execute.h>
 
 namespace sqlpp
 {
@@ -42,7 +43,52 @@ namespace sqlpp
 
 		template<typename Statement>
 			struct _result_methods_t
-			{};
+			{
+				using _statement_t = Statement;
+
+				const _statement_t& _get_statement() const
+				{
+					return static_cast<const _statement_t&>(*this);
+				}
+
+				// Execute
+				template<typename Db, typename Composite>
+					auto _run(Db& db, const Composite& composite) const	-> void
+					{
+						Composite::_check_consistency();
+						static_assert(_statement_t::_get_static_no_of_parameters() == 0, "cannot run execute directly with parameters, use prepare instead");
+
+						return db.execute(composite);
+					}
+
+				template<typename Db>
+					auto _run(Db& db) const -> void
+					{
+						_statement_t::_check_consistency();
+
+						static_assert(_statement_t::_get_static_no_of_parameters() == 0, "cannot run insert directly with parameters, use prepare instead");
+						return db.execute(_get_statement());
+					}
+
+				// Prepare
+				template<typename Db, typename Composite>
+					auto _prepare(Db& db, const Composite& composite) const
+					-> prepared_execute_t<Db, Composite>
+					{
+						Composite::_check_consistency();
+
+						return {{}, db.prepare_execute(composite)};
+					}
+
+				template<typename Db>
+					auto _prepare(Db& db) const
+					-> prepared_execute_t<Db, _statement_t>
+					{
+						_statement_t::_check_consistency();
+
+						return {{}, db.prepare_execute(_get_statement())};
+					}
+			};
 	};
 
 	template<typename Context>

include/sqlpp11/prepared_execute.h

@@ -0,0 +1,58 @@
+/*
+ * 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_PREPARED_EXECUTE_H
+#define SQLPP_PREPARED_EXECUTE_H
+
+#include <sqlpp11/parameter_list.h>
+#include <sqlpp11/result.h>
+
+namespace sqlpp
+{
+	template<typename Db, typename Statement>
+		struct prepared_execute_t
+		{
+			using _parameter_list_t = make_parameter_list_t<Statement>;
+			using _prepared_statement_t = typename Db::_prepared_statement_t;
+
+			auto _run(Db& db) const
+				-> size_t
+				{
+					return db.run_prepared_execute(*this);
+				}
+
+			void _bind_params() const
+			{
+				params._bind(_prepared_statement);
+			}
+
+			_parameter_list_t params;
+			mutable _prepared_statement_t _prepared_statement;
+		};
+
+}
+
+#endif

include/sqlpp11/verbatim.h

@@ -27,6 +27,7 @@
 #ifndef SQLPP_VERBATIM_H
 #define SQLPP_VERBATIM_H
 
+#include <sqlpp11/no_value.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serialize.h>
 
@@ -71,6 +72,11 @@ namespace sqlpp
 			return { s };
 		}
 
+	auto verbatim(std::string s) -> verbatim_t<no_value_t>
+	{
+		return { s };
+	}
+
 }
 
 #endif

tests/CustomQueryTest.cpp

@@ -37,10 +37,15 @@ int main()
 	test::TabFoo f; 
 	test::TabBar t;
 
-	auto c = custom_query(select(all_of(t)).from(t));
+	auto c = custom_query(select(all_of(t)).from(t), sqlpp::verbatim("INTO"), t);
+	std::cerr << serialize(c, printer).str() << std::endl;
 	db(c);
 
 	auto p = db.prepare(custom_query(select(all_of(t)).from(t).where(t.alpha > sqlpp::parameter(t.alpha))));
 
+	printer.reset();
+	auto x = custom_query(sqlpp::verbatim<sqlpp::boolean>("PRAGMA writeable_schema") == true);
+	std::cerr << serialize(x, printer).str() << std::endl;
+
 	return 0;
 }