/* * 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_FUNCTIONS_H #define SQLPP_FUNCTIONS_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Csaba Csoma suggests: unsafe_sql instead of verbatim #include #include #include namespace sqlpp { template auto value(T t) -> wrap_operand_t { static_assert(is_wrapped_value_t>::value, "value() is to be called with non-sql-type like int, or string"); return { t }; } template auto flatten(const Expression& exp, Db& db) -> verbatim_t> { static_assert(not make_parameter_list_t::size::value, "parameters are not allowed in flattened expressions"); auto context = db.get_serializer_context(); serialize(exp, context); return { context.str() }; } template auto is_null(Expression e) -> decltype(e.is_null()) { return e.is_null(); } template auto is_not_null(Expression e) -> decltype(e.is_not_null()) { return e.is_not_null(); } template struct value_list_t // to be used in .in() method { using _traits = make_traits, ::sqlpp::tag::is_expression>; using _recursive_traits = make_recursive_traits<>; using _container_t = Container; value_list_t(_container_t container): _container(container) {} value_list_t(const value_list_t&) = default; value_list_t(value_list_t&&) = default; value_list_t& operator=(const value_list_t&) = default; value_list_t& operator=(value_list_t&&) = default; ~value_list_t() = default; _container_t _container; }; template struct serializer_t> { using T = value_list_t; static Context& _(const T& t, Context& context) { bool first = true; for (const auto& entry: t._container) { if (first) first = false; else context << ','; serialize(value(entry), context); } return context; } }; template auto value_list(Container c) -> value_list_t { static_assert(is_wrapped_value_t>::value, "value_list() is to be called with a container of non-sql-type like std::vector, or std::list(string)"); return { c }; } template constexpr const char* get_sql_name(const T&) { return T::_name_t::_get_name(); } } #endif