mirror/sqlpp11
1
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2026-01-03 03:30:35 -06:00
Code Issues Packages Projects Releases Wiki Activity

Migrated select clauses to returning wrapped asserts

Browse Source 
This helps a lot in testing static asserts (and debuging expressions
with MSVC)
This commit is contained in:
rbock
2016-08-31 21:15:54 +02:00
parent ba40e59ade
commit cf83978118
28 changed files with 326 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/sqlpp11/all_of.h
View File

@@ -27,8 +27,8 @@
#ifndef SQLPP_ALL_OF_H
#define SQLPP_ALL_OF_H
#include <sqlpp11/interpret.h>
#include <sqlpp11/alias.h>
#include <sqlpp11/interpret.h>
#include <sqlpp11/multi_column.h>
#include <sqlpp11/portable_static_assert.h>
@@ -62,7 +62,7 @@ namespace sqlpp
static Context& _(const T&, const Context&)
{
_serialize_check::_();
_serialize_check{};
}
};
}

26
include/sqlpp11/case.h
View File

@@ -27,10 +27,10 @@
#ifndef SQLPP_CASE_H
#define SQLPP_CASE_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h>
#include <sqlpp11/data_types/boolean.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -87,13 +87,13 @@ namespace sqlpp
class case_then_t
{
template <typename Else>
auto _else_impl(const std::true_type&, Else else_) -> case_t<When, Then, Else>
auto _else_impl(consistent_t, Else else_) -> case_t<When, Then, Else>
{
return {_when, _then, else_};
}
template <typename Else>
auto _else_impl(const std::false_type&, Else else_) -> void;
template <typename Check, typename Else>
auto _else_impl(Check, Else else_) -> Check;
public:
case_then_t(When when, Then then) : _when(when), _then(then)
@@ -109,7 +109,6 @@ namespace sqlpp
template <typename Else>
auto else_(Else else_) -> decltype(this->_else_impl(check_case_else_t<Then, Else>{}, else_))
{
check_case_else_t<Then, Else>::_();
return _else_impl(check_case_else_t<Then, Else>{}, else_);
}
@@ -122,13 +121,13 @@ namespace sqlpp
class case_when_t
{
template <typename Then>
auto _then_impl(const std::true_type&, Then t) -> case_then_t<When, wrap_operand_t<Then>>
auto _then_impl(consistent_t, Then t) -> case_then_t<When, wrap_operand_t<Then>>
{
return {_when, t};
}
template <typename Then>
auto _then_impl(const std::false_type&, Then t) -> void;
template <typename Check, typename Then>
auto _then_impl(Check, Then t) -> Check;
public:
case_when_t(When when) : _when(when)
@@ -144,7 +143,6 @@ namespace sqlpp
template <typename Then>
auto then(Then t) -> decltype(this->_then_impl(check_case_then_t<Then>{}, t))
{
check_case_then_t<Then>::_();
return _then_impl(check_case_then_t<Then>{}, t);
}
@@ -174,21 +172,19 @@ namespace sqlpp
namespace detail
{
template <typename When>
auto case_when_impl(const std::true_type&, When when) -> case_when_t<wrap_operand_t<When>>
auto case_when_impl(consistent_t, When when) -> case_when_t<wrap_operand_t<When>>
{
return {when};
}
template <typename When>
auto case_when_impl(const std::false_type&, When when) -> void;
template <typename Check, typename When>
auto case_when_impl(Check, When when) -> Check;
}
template <typename When>
auto case_when(When when) -> decltype(detail::case_when_impl(check_case_when_t<When>{}, when))
{
check_case_when_t<When>::_();
return detail::case_when_impl(typename check_case_when_t<When>::type{}, when);
return detail::case_when_impl(check_case_when_t<When>{}, when);
}
}

4
include/sqlpp11/custom_query.h
View File

@@ -92,14 +92,14 @@ namespace sqlpp
template <typename Db>
auto _run(Db& db) const -> decltype(std::declval<_methods_t>()._run(db, *this))
{
_run_check::_();
_run_check{}; // FIXME: dispatch here?
return _methods_t::_run(db, *this);
}
template <typename Db>
auto _prepare(Db& db) const -> decltype(std::declval<_methods_t>()._prepare(db, *this))
{
_prepare_check::_();
_prepare_check{}; // FIXME: dispatch here?
return _methods_t::_prepare(db, *this);
}

19
include/sqlpp11/dynamic_pre_join.h
View File

@@ -91,10 +91,8 @@ namespace sqlpp
template <typename Expr>
auto on(Expr expr) const -> typename std::conditional<check_dynamic_join_on_t<dynamic_pre_join_t, Expr>::value,
dynamic_join_t<dynamic_pre_join_t, on_t<Expr>>,
bad_statement>::type
check_dynamic_join_on_t<dynamic_pre_join_t, Expr>>::type
{
check_dynamic_join_on_t<dynamic_pre_join_t, Expr>::_();
return {*this, {expr}};
}
@@ -119,40 +117,40 @@ namespace sqlpp
template <typename JoinType, typename Table>
using make_dynamic_pre_join_t = typename std::conditional<check_dynamic_pre_join_t<Table>::value,
dynamic_pre_join_t<JoinType, Table>,
bad_statement>::type;
check_dynamic_pre_join_t<Table>>::type;
template <typename Table>
auto dynamic_join(Table table) -> make_dynamic_pre_join_t<inner_join_t, Table>
{
check_dynamic_pre_join_t<Table>::_();
check_dynamic_pre_join_t<Table>{}; // FIXME: Failure return type?
return {table};
}
template <typename Table>
auto dynamic_inner_join(Table table) -> make_dynamic_pre_join_t<inner_join_t, Table>
{
check_dynamic_pre_join_t<Table>::_();
check_dynamic_pre_join_t<Table>{};
return {table};
}
template <typename Table>
auto dynamic_left_outer_join(Table table) -> make_dynamic_pre_join_t<left_outer_join_t, Table>
{
check_dynamic_pre_join_t<Table>::_();
check_dynamic_pre_join_t<Table>{};
return {table};
}
template <typename Table>
auto dynamic_right_outer_join(Table table) -> make_dynamic_pre_join_t<right_outer_join_t, Table>
{
check_dynamic_pre_join_t<Table>::_();
check_dynamic_pre_join_t<Table>{};
return {table};
}
template <typename Table>
auto dynamic_outer_join(Table table) -> make_dynamic_pre_join_t<outer_join_t, Table>
{
check_dynamic_pre_join_t<Table>::_();
check_dynamic_pre_join_t<Table>{};
return {table};
}
@@ -160,9 +158,8 @@ namespace sqlpp
auto dynamic_cross_join(Table table) ->
typename std::conditional<check_dynamic_pre_join_t<Table>::value,
dynamic_join_t<dynamic_pre_join_t<cross_join_t, Table>, on_t<unconditional_t>>,
bad_statement>::type
check_dynamic_pre_join_t<Table>>::type
{
check_dynamic_pre_join_t<Table>::_();
return {dynamic_pre_join_t<cross_join_t, Table>{table}, {}};
}
}

43
include/sqlpp11/from.h
View File

@@ -27,15 +27,15 @@
#ifndef SQLPP_FROM_H
#define SQLPP_FROM_H
#include <sqlpp11/detail/sum.h>
#include <sqlpp11/dynamic_join.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/table_ref.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/detail/sum.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/dynamic_join.h>
namespace sqlpp
{
@@ -116,23 +116,22 @@ namespace sqlpp
}
template <typename DynamicJoin>
auto add(DynamicJoin dynamicJoin) ->
typename std::conditional<check_from_add_t<_impl_t, DynamicJoin>::value, void, bad_statement>::type
auto add(DynamicJoin dynamicJoin) -> typename std::
conditional<check_from_add_t<_impl_t, DynamicJoin>::value, void, check_from_add_t<_impl_t, DynamicJoin>>::type
{
using Check = check_from_add_t<_impl_t, DynamicJoin>;
Check::_();
return _add_impl(dynamicJoin, Check{});
}
private:
template <typename DynamicJoin>
auto _add_impl(DynamicJoin dynamicJoin, const std::true_type&) -> void
auto _add_impl(DynamicJoin dynamicJoin, consistent_t) -> void
{
_data._dynamic_tables.emplace_back(from_table(dynamicJoin));
}
template <typename DynamicJoin>
auto _add_impl(DynamicJoin dynamicJoin, const std::false_type&) -> bad_statement;
template <typename Check, typename DynamicJoin>
auto _add_impl(DynamicJoin dynamicJoin, Check) -> Check;
public:
_data_t _data;
@@ -146,8 +145,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: from{std::forward<Args>(args)...}
_base_t(Args&&... args) : from{std::forward<Args>(args)...}
{
}
@@ -234,8 +232,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_from{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_from{std::forward<Args>(args)...}
{
}
@@ -258,7 +255,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_from_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_from_t, T>;
using _consistency_check = consistent_t;
@@ -266,7 +263,6 @@ namespace sqlpp
auto from(Table table) const -> _new_statement_t<check_from_static_t<Table>, from_t<void, from_table_t<Table>>>
{
using Check = check_from_static_t<Table>;
Check{}._();
return _from_impl<void>(Check{}, table);
}
@@ -275,17 +271,16 @@ namespace sqlpp
-> _new_statement_t<check_from_dynamic_t<_database_t, Table>, from_t<_database_t, from_table_t<Table>>>
{
using Check = check_from_dynamic_t<_database_t, Table>;
Check{}._();
return _from_impl<_database_t>(Check{}, table);
}
private:
template <typename Database, typename Table>
auto _from_impl(const std::false_type&, Table table) const -> bad_statement;
template <typename Database, typename Check, typename Table>
auto _from_impl(Check, Table table) const -> Check;
template <typename Database, typename Table>
auto _from_impl(const std::true_type&, Table table) const
-> _new_statement_t<std::true_type, from_t<Database, from_table_t<Table>>>
auto _from_impl(consistent_t, Table table) const
-> _new_statement_t<consistent_t, from_t<Database, from_table_t<Table>>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
from_data_t<Database, from_table_t<Table>>{from_table(table)}};

58
include/sqlpp11/group_by.h
View File

@@ -27,13 +27,13 @@
#ifndef SQLPP_GROUP_BY_H
#define SQLPP_GROUP_BY_H
#include <tuple>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/expression.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
#include <tuple>
namespace sqlpp
{
@@ -67,9 +67,8 @@ namespace sqlpp
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;
using _provided_aggregates = typename std::conditional<_is_dynamic::value,
detail::type_set<>,
detail::make_type_set_t<Expressions...>>::type;
using _provided_aggregates = typename std::
conditional<_is_dynamic::value, detail::type_set<>, detail::make_type_set_t<Expressions...>>::type;
// Data
using _data_t = group_by_data_t<Database, Expressions...>;
@@ -92,7 +91,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Expression>::value,
"expression uses tables unknown to this statement in group_by::add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expression>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expression>::value, _serialize_check::type::value>;
@@ -121,8 +120,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: group_by{std::forward<Args>(args)...}
_base_t(Args&&... args) : group_by{std::forward<Args>(args)...}
{
}
@@ -148,6 +146,17 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_group_by_args_are_expressions_t,
"arguments for group_by() must be valid expressions");
template <typename... Exprs>
struct check_group_by
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_expression_t<Exprs>::value...>::value, assert_group_by_args_are_expressions_t>>;
};
template <typename... Exprs>
using check_group_by_t = typename check_group_by<Exprs...>::type;
// NO GROUP BY YET
struct no_group_by_t
{
@@ -178,8 +187,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_group_by{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_group_by{std::forward<Args>(args)...}
{
}
@@ -201,47 +209,37 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
// template <typename... T>
// using _check = logic::all_t<is_expression_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<is_expression_t<T>::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_group_by_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_group_by_t, T>;
using _consistency_check = consistent_t;
template <typename... Expressions>
auto group_by(Expressions... expressions) const
-> _new_statement_t<_check<Expressions...>, group_by_t<void, Expressions...>>
-> _new_statement_t<check_group_by_t<Expressions...>, group_by_t<void, Expressions...>>
{
static_assert(sizeof...(Expressions), "at least one expression (e.g. a column) required in group_by()");
static_assert(_check<Expressions...>::value, "at least one argument is not an expression in group_by()");
return _group_by_impl<void>(_check<Expressions...>{}, expressions...);
return _group_by_impl<void>(check_group_by_t<Expressions...>{}, expressions...);
}
template <typename... Expressions>
auto dynamic_group_by(Expressions... expressions) const
-> _new_statement_t<_check<Expressions...>, group_by_t<_database_t, Expressions...>>
-> _new_statement_t<check_group_by_t<Expressions...>, group_by_t<_database_t, Expressions...>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_group_by must not be called in a static statement");
static_assert(_check<Expressions...>::value, "at least one argument is not an expression in group_by()");
return _group_by_impl<_database_t>(_check<Expressions...>{}, expressions...);
return _group_by_impl<_database_t>(check_group_by_t<Expressions...>{}, expressions...);
}
private:
template <typename Database, typename... Expressions>
auto _group_by_impl(const std::false_type&, Expressions... expressions) const -> bad_statement;
template <typename Database, typename Check, typename... Expressions>
auto _group_by_impl(Check, Expressions... expressions) const -> Check;
template <typename Database, typename... Expressions>
auto _group_by_impl(const std::true_type&, Expressions... expressions) const
-> _new_statement_t<std::true_type, group_by_t<Database, Expressions...>>
auto _group_by_impl(consistent_t, Expressions... expressions) const
-> _new_statement_t<consistent_t, group_by_t<Database, Expressions...>>
{
static_assert(not detail::has_duplicates<Expressions...>::value,
"at least one duplicate argument detected in group_by()");

26
include/sqlpp11/having.h
View File

@@ -27,13 +27,13 @@
#ifndef SQLPP_HAVING_H
#define SQLPP_HAVING_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/value.h>
#include <sqlpp11/expression.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/value.h>
namespace sqlpp
{
@@ -92,7 +92,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Expr>::value,
"expression uses tables unknown to this statement in having::add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expr>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expr>::value, _serialize_check::type::value>;
@@ -121,8 +121,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: having{std::forward<Args>(args)...}
_base_t(Args&&... args) : having{std::forward<Args>(args)...}
{
}
@@ -212,8 +211,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_having{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_having{std::forward<Args>(args)...}
{
}
@@ -244,7 +242,7 @@ namespace sqlpp
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_having_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_having_t, T>;
using _consistency_check = consistent_t;
@@ -253,7 +251,6 @@ namespace sqlpp
-> _new_statement_t<check_having_static_t<Expression>, having_t<void, Expression>>
{
using Check = check_having_static_t<Expression>;
Check{}._();
return _having_impl<void>(Check{}, expression);
}
@@ -263,7 +260,6 @@ namespace sqlpp
-> _new_statement_t<check_having_dynamic_t<_database_t, Expression>, having_t<_database_t, Expression>>
{
using Check = check_having_dynamic_t<_database_t, Expression>;
Check{}._();
return _having_impl<_database_t>(Check{}, expression);
}
@@ -275,12 +271,12 @@ namespace sqlpp
}
private:
template <typename Database, typename Expression>
auto _having_impl(const std::false_type&, Expression expression) const -> bad_statement;
template <typename Database, typename Check, typename Expression>
auto _having_impl(Check, Expression expression) const -> Check;
template <typename Database, typename Expression>
auto _having_impl(const std::true_type&, Expression expression) const
-> _new_statement_t<std::true_type, having_t<Database, Expression>>
auto _having_impl(consistent_t, Expression expression) const
-> _new_statement_t<consistent_t, having_t<Database, Expression>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
having_data_t<Database, Expression>{expression}};

28
include/sqlpp11/insert_value_list.h
View File

@@ -27,19 +27,19 @@
#ifndef SQLPP_INSERT_VALUE_LIST_H
#define SQLPP_INSERT_VALUE_LIST_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/portable_static_assert.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/assignment.h>
#include <sqlpp11/column_fwd.h>
#include <sqlpp11/expression_fwd.h>
#include <sqlpp11/assignment.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/insert_value.h>
#include <sqlpp11/simple_column.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/portable_static_assert.h>
#include <sqlpp11/simple_column.h>
#include <sqlpp11/statement.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -96,8 +96,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: default_values{std::forward<Args>(args)...}
_base_t(Args&&... args) : default_values{std::forward<Args>(args)...}
{
}
@@ -264,7 +263,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Assignment>::value,
"add() contains a column from a foreign table");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Assignment>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_assignment_t<Assignment>::value, _serialize_check::type::value>;
@@ -294,8 +293,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: insert_list{std::forward<Args>(args)...}
_base_t(Args&&... args) : insert_list{std::forward<Args>(args)...}
{
}
@@ -400,8 +398,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: values{std::forward<Args>(args)...}
_base_t(Args&&... args) : values{std::forward<Args>(args)...}
{
}
@@ -459,8 +456,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_insert_values{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_insert_values{std::forward<Args>(args)...}
{
}

2
include/sqlpp11/interpretable_list.h
View File

@@ -27,8 +27,8 @@
#ifndef SQLPP_INTERPRETABLE_LIST_H
#define SQLPP_INTERPRETABLE_LIST_H
#include <vector>
#include <sqlpp11/interpretable.h>
#include <vector>
namespace sqlpp
{

43
include/sqlpp11/limit.h
View File

@@ -27,9 +27,9 @@
#ifndef SQLPP_LIMIT_H
#define SQLPP_LIMIT_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -81,8 +81,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: limit{std::forward<Args>(args)...}
_base_t(Args&&... args) : limit{std::forward<Args>(args)...}
{
}
@@ -115,8 +114,7 @@ namespace sqlpp
}
template <typename Limit>
dynamic_limit_data_t(Limit value)
: _initialized(true), _value(wrap_operand_t<Limit>(value))
dynamic_limit_data_t(Limit value) : _initialized(true), _value(wrap_operand_t<Limit>(value))
{
}
@@ -172,8 +170,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: limit{std::forward<Args>(args)...}
_base_t(Args&&... args) : limit{std::forward<Args>(args)...}
{
}
@@ -197,6 +194,15 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_limit_is_integral, "argument for limit() must be an integral expressions");
template <typename T>
struct check_limit
{
using type = static_combined_check_t<static_check_t<is_integral_t<T>::value, assert_limit_is_integral>>;
};
template <typename T>
using check_limit_t = typename check_limit<wrap_operand_t<T>>::type;
struct no_limit_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -226,8 +232,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_limit{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_limit{std::forward<Args>(args)...}
{
}
@@ -249,32 +254,28 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename T>
using _check = is_integral_t<wrap_operand_t<T>>;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_limit_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_limit_t, T>;
using _consistency_check = consistent_t;
template <typename Arg>
auto limit(Arg arg) const -> _new_statement_t<_check<Arg>, limit_t<wrap_operand_t<Arg>>>
auto limit(Arg arg) const -> _new_statement_t<check_limit_t<Arg>, limit_t<wrap_operand_t<Arg>>>
{
static_assert(_check<Arg>::value, "limit requires an integral value or integral parameter");
return _limit_impl(_check<Arg>{}, wrap_operand_t<Arg>{arg});
return _limit_impl(check_limit_t<Arg>{}, wrap_operand_t<Arg>{arg});
}
auto dynamic_limit() const -> _new_statement_t<std::true_type, dynamic_limit_t<_database_t>>
auto dynamic_limit() const -> _new_statement_t<consistent_t, dynamic_limit_t<_database_t>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this), dynamic_limit_data_t<_database_t>{}};
}
private:
template <typename Arg>
auto _limit_impl(const std::false_type&, Arg arg) const -> bad_statement;
template <typename Check, typename Arg>
auto _limit_impl(Check, Arg arg) const -> Check;
template <typename Arg>
auto _limit_impl(const std::true_type&, Arg arg) const -> _new_statement_t<std::true_type, limit_t<Arg>>
auto _limit_impl(consistent_t, Arg arg) const -> _new_statement_t<consistent_t, limit_t<Arg>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this), limit_data_t<Arg>{arg}};
}

43
include/sqlpp11/offset.h
View File

@@ -27,9 +27,9 @@
#ifndef SQLPP_OFFSET_H
#define SQLPP_OFFSET_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -83,8 +83,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: offset{std::forward<Args>(args)...}
_base_t(Args&&... args) : offset{std::forward<Args>(args)...}
{
}
@@ -117,8 +116,7 @@ namespace sqlpp
}
template <typename Offset>
dynamic_offset_data_t(Offset value)
: _initialized(true), _value(wrap_operand_t<Offset>(value))
dynamic_offset_data_t(Offset value) : _initialized(true), _value(wrap_operand_t<Offset>(value))
{
}
@@ -174,8 +172,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: offset{std::forward<Args>(args)...}
_base_t(Args&&... args) : offset{std::forward<Args>(args)...}
{
}
@@ -211,6 +208,15 @@ namespace sqlpp
interpretable_t<Database> _value;
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_offset_is_integral, "argument for offset() must be an integral expressions");
template <typename T>
struct check_offset
{
using type = static_combined_check_t<static_check_t<is_integral_t<T>::value, assert_offset_is_integral>>;
};
template <typename T>
using check_offset_t = typename check_offset<wrap_operand_t<T>>::type;
struct no_offset_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -240,8 +246,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_offset{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_offset{std::forward<Args>(args)...}
{
}
@@ -263,22 +268,18 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename T>
using _check = is_integral_t<wrap_operand_t<T>>;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_offset_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_offset_t, T>;
using _consistency_check = consistent_t;
template <typename Arg>
auto offset(Arg arg) const -> _new_statement_t<_check<Arg>, offset_t<wrap_operand_t<Arg>>>
auto offset(Arg arg) const -> _new_statement_t<check_offset_t<Arg>, offset_t<wrap_operand_t<Arg>>>
{
static_assert(_check<Arg>::value, "offset requires an integral value or integral parameter");
return _offset_impl(_check<Arg>{}, wrap_operand_t<Arg>{arg});
return _offset_impl(check_offset_t<Arg>{}, wrap_operand_t<Arg>{arg});
}
auto dynamic_offset() const -> _new_statement_t<std::true_type, dynamic_offset_t<_database_t>>
auto dynamic_offset() const -> _new_statement_t<consistent_t, dynamic_offset_t<_database_t>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_offset must not be called in a static statement");
@@ -286,11 +287,11 @@ namespace sqlpp
}
private:
template <typename Arg>
auto _offset_impl(const std::false_type&, Arg arg) const -> bad_statement;
template <typename Check, typename Arg>
auto _offset_impl(Check, Arg arg) const -> Check;
template <typename Arg>
auto _offset_impl(const std::true_type&, Arg arg) const -> _new_statement_t<std::true_type, offset_t<Arg>>
auto _offset_impl(consistent_t, Arg arg) const -> _new_statement_t<consistent_t, offset_t<Arg>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this), offset_data_t<Arg>{arg}};
}

55
include/sqlpp11/order_by.h
View File

@@ -27,13 +27,13 @@
#ifndef SQLPP_ORDER_BY_H
#define SQLPP_ORDER_BY_H
#include <tuple>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
#include <tuple>
namespace sqlpp
{
@@ -89,7 +89,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Expression>::value,
"expression uses tables unknown to this statement in order_by::add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expression>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_sort_order_t<Expression>::value, _serialize_check::type::value>;
@@ -118,8 +118,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: order_by{std::forward<Args>(args)...}
_base_t(Args&&... args) : order_by{std::forward<Args>(args)...}
{
}
@@ -145,6 +144,17 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_order_by_args_are_sort_order_expressions_t,
"arguments for order_by() must be sort order expressions");
template <typename... Exprs>
struct check_order_by
{
using type = static_combined_check_t<static_check_t<logic::all_t<is_sort_order_t<Exprs>::value...>::value,
assert_order_by_args_are_sort_order_expressions_t>>;
};
template <typename... Exprs>
using check_order_by_t = typename check_order_by<Exprs...>::type;
// NO ORDER BY YET
struct no_order_by_t
{
@@ -175,8 +185,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: no_order_by{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_order_by{std::forward<Args>(args)...}
{
}
@@ -198,47 +207,37 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
// template <typename... T>
// using _check = logic::all_t<is_sort_order_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<is_sort_order_t<T>::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_order_by_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_order_by_t, T>;
using _consistency_check = consistent_t;
template <typename... Expressions>
auto order_by(Expressions... expressions) const
-> _new_statement_t<_check<Expressions...>, order_by_t<void, Expressions...>>
-> _new_statement_t<check_order_by_t<Expressions...>, order_by_t<void, Expressions...>>
{
static_assert(sizeof...(Expressions), "at least one expression (e.g. a column) required in order_by()");
static_assert(_check<Expressions...>::value, "at least one argument is not a sort order in order_by()");
return _order_by_impl<void>(_check<Expressions...>{}, expressions...);
return _order_by_impl<void>(check_order_by_t<Expressions...>{}, expressions...);
}
template <typename... Expressions>
auto dynamic_order_by(Expressions... expressions) const
-> _new_statement_t<_check<Expressions...>, order_by_t<_database_t, Expressions...>>
-> _new_statement_t<check_order_by_t<Expressions...>, order_by_t<_database_t, Expressions...>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_order_by must not be called in a static statement");
static_assert(_check<Expressions...>::value, "at least one argument is not a sort order in order_by()");
return _order_by_impl<_database_t>(_check<Expressions...>{}, expressions...);
return _order_by_impl<_database_t>(check_order_by_t<Expressions...>{}, expressions...);
}
private:
template <typename Database, typename... Expressions>
auto _order_by_impl(const std::false_type&, Expressions... expressions) const -> bad_statement;
template <typename Database, typename Check, typename... Expressions>
auto _order_by_impl(Check, Expressions... expressions) const -> Check;
template <typename Database, typename... Expressions>
auto _order_by_impl(const std::true_type&, Expressions... expressions) const
-> _new_statement_t<std::true_type, order_by_t<Database, Expressions...>>
auto _order_by_impl(consistent_t, Expressions... expressions) const
-> _new_statement_t<consistent_t, order_by_t<Database, Expressions...>>
{
static_assert(not detail::has_duplicates<Expressions...>::value,
"at least one duplicate argument detected in order_by()");

18
include/sqlpp11/policy_update.h
View File

@@ -27,8 +27,8 @@
#ifndef SQLPP_POLICY_UPDATE_H
#define SQLPP_POLICY_UPDATE_H
#include <sqlpp11/wrong.h>
#include <sqlpp11/bad_statement.h>
#include <sqlpp11/wrong.h>
namespace sqlpp
{
@@ -54,19 +54,19 @@ namespace sqlpp
template <typename Policies, typename Needle, typename Replacement>
using new_statement = typename Policies::template _new_statement_t<Needle, Replacement>;
template <bool, typename Policies, typename Needle, typename Replacement>
template <typename Check, typename Policies, typename Needle, typename Replacement>
struct new_statement_impl
{
using type = Check;
};
template <typename Policies, typename Needle, typename Replacement>
struct new_statement_impl<consistent_t, Policies, Needle, Replacement>
{
using type = typename Policies::template _new_statement_t<Needle, Replacement>;
};
template <typename Policies, typename Needle, typename Replacement>
struct new_statement_impl<false, Policies, Needle, Replacement>
{
using type = bad_statement;
};
template <bool Check, typename Policies, typename Needle, typename Replacement>
template <typename Check, typename Policies, typename Needle, typename Replacement>
using new_statement_t = typename new_statement_impl<Check, Policies, Needle, Replacement>::type;
}

8
include/sqlpp11/portable_static_assert.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2015, Roland Bock
* Copyright (c) 2015-2016, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@@ -34,10 +34,10 @@ namespace sqlpp
#define SQLPP_PORTABLE_STATIC_ASSERT(name, message) \
struct name : std::false_type \
{ \
template <typename T = void> \
static void _() \
template <typename... T> \
name(T&&...) \
{ \
static_assert(wrong_t<T>::value, message); \
static_assert(wrong_t<T...>::value, message); \
} \
}

48
include/sqlpp11/pre_join.h
View File

@@ -29,8 +29,8 @@
#include <sqlpp11/bad_statement.h>
#include <sqlpp11/join_types.h>
#include <sqlpp11/on.h>
#include <sqlpp11/noop.h>
#include <sqlpp11/on.h>
namespace sqlpp
{
@@ -106,20 +106,19 @@ namespace sqlpp
template <typename Expr>
auto on(Expr expr) const -> typename std::conditional<check_join_on_t<pre_join_t, Expr>::value,
join_t<pre_join_t, on_t<Expr>>,
bad_statement>::type
check_join_on_t<pre_join_t, Expr>>::type
{
using Check = check_join_on_t<pre_join_t, Expr>;
Check::_();
return on_impl(Check{}, expr);
}
private:
template <typename Expr>
auto on_impl(const std::false_type&, const Expr&) const -> bad_statement;
template <typename Check, typename Expr>
auto on_impl(Check, const Expr&) const -> Check;
template <typename Expr>
auto on_impl(const std::true_type&, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
auto on_impl(consistent_t, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
{
return {*this, {expr}};
}
@@ -146,51 +145,46 @@ namespace sqlpp
};
template <typename Lhs, typename Rhs>
auto join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
pre_join_t<inner_join_t, Lhs, Rhs>,
bad_statement>::type
auto join(Lhs lhs, Rhs rhs) -> typename std::
conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{}; // FIXME: Failure return type?
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto inner_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
pre_join_t<inner_join_t, Lhs, Rhs>,
bad_statement>::type
auto inner_join(Lhs lhs, Rhs rhs) -> typename std::
conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{};
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto left_outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
pre_join_t<left_outer_join_t, Lhs, Rhs>,
bad_statement>::type
auto left_outer_join(Lhs lhs, Rhs rhs) -> typename std::
conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<left_outer_join_t, Lhs, Rhs>, bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{};
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto right_outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
pre_join_t<right_outer_join_t, Lhs, Rhs>,
bad_statement>::type
auto right_outer_join(Lhs lhs, Rhs rhs) -> typename std::
conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<right_outer_join_t, Lhs, Rhs>, bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{};
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
pre_join_t<outer_join_t, Lhs, Rhs>,
bad_statement>::type
auto outer_join(Lhs lhs, Rhs rhs) -> typename std::
conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<outer_join_t, Lhs, Rhs>, bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{};
return {lhs, rhs};
}
@@ -201,7 +195,7 @@ namespace sqlpp
join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>,
bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
check_pre_join_t<Lhs, Rhs>{};
return {pre_join_t<cross_join_t, Lhs, Rhs>{lhs, rhs}, {}};
}

2
include/sqlpp11/rhs_wrap.h
View File

@@ -27,9 +27,9 @@
#ifndef SQLPP_RHS_WRAP_H
#define SQLPP_RHS_WRAP_H
#include <sqlpp11/tvin.h>
#include <sqlpp11/default_value.h>
#include <sqlpp11/null.h>
#include <sqlpp11/tvin.h>
namespace sqlpp
{

69
include/sqlpp11/select_column_list.h
View File

@@ -27,19 +27,19 @@
#ifndef SQLPP_SELECT_COLUMN_LIST_H
#define SQLPP_SELECT_COLUMN_LIST_H
#include <tuple>
#include <sqlpp11/result_row.h>
#include <sqlpp11/dynamic_select_column_list.h>
#include <sqlpp11/table.h>
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/field_spec.h>
#include <sqlpp11/expression_fwd.h>
#include <sqlpp11/select_pseudo_table.h>
#include <sqlpp11/named_interpretable.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/detail/copy_tuple_args.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/dynamic_select_column_list.h>
#include <sqlpp11/expression_fwd.h>
#include <sqlpp11/field_spec.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/named_interpretable.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/result_row.h>
#include <sqlpp11/select_pseudo_table.h>
#include <sqlpp11/table.h>
#include <tuple>
namespace sqlpp
{
@@ -135,7 +135,7 @@ namespace sqlpp
static_assert(not detail::is_element_of<typename named_expression::_alias_t, column_names>::value,
"a column of this name is present in the select already");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, named_expression>;
_serialize_check::_();
_serialize_check{};
using ok =
logic::all_t<_is_dynamic::value, is_selectable_t<named_expression>::value, _serialize_check::type::value>;
@@ -165,8 +165,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: selected_columns{std::forward<Args>(args)...}
_base_t(Args&&... args) : selected_columns{std::forward<Args>(args)...}
{
}
@@ -249,7 +248,7 @@ namespace sqlpp
template <typename AliasProvider>
_alias_t<AliasProvider> as(const AliasProvider& aliasProvider) const
{
consistency_check_t<_statement_t>::_();
consistency_check_t<_statement_t>{};
static_assert(_statement_t::_can_be_used_as_table(),
"statement cannot be used as table, e.g. due to missing tables");
static_assert(logic::none_t<is_multi_column_t<Columns>::value...>::value,
@@ -302,6 +301,17 @@ namespace sqlpp
copy_tuple_args_t<select_column_list_t, Database, decltype(column_tuple_merge(std::declval<Columns>()...))>;
}
SQLPP_PORTABLE_STATIC_ASSERT(assert_selected_colums_are_selectable_t, "selected columns must be selectable");
template <typename... T>
struct check_selected_columns
{
using type = static_combined_check_t<
static_check_t<logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>::value,
assert_selected_colums_are_selectable_t>>;
};
template <typename... T>
using check_selected_columns_t = typename check_selected_columns<T...>::type;
struct no_select_column_list_t
{
using _traits = make_traits<no_value_t, tag::is_noop, tag::is_missing>;
@@ -335,8 +345,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_selected_columns{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_selected_columns{std::forward<Args>(args)...}
{
}
@@ -358,16 +367,8 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
// template <typename... T>
// using _check = logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>;
template <typename... T>
struct _check : logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>
{
};
template <typename... T>
static constexpr auto _check_tuple(std::tuple<T...>) -> _check<T...>
static constexpr auto _check_tuple(std::tuple<T...>) -> check_selected_columns_t<T...>
{
return {};
}
@@ -375,11 +376,11 @@ namespace sqlpp
template <typename... T>
static constexpr auto _check_args(T... args) -> decltype(_check_tuple(detail::column_tuple_merge(args...)))
{
return _check_tuple(detail::column_tuple_merge(args...));
return {};
}
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_select_column_list_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_select_column_list_t, T>;
using _consistency_check = consistent_t;
@@ -391,7 +392,7 @@ namespace sqlpp
static_assert(decltype(_check_args(args...))::value,
"at least one argument is not a selectable expression in columns()");
return _columns_impl<void>(_check_args(args...), detail::column_tuple_merge(args...));
return _columns_impl<void>(decltype(_check_args(args...)){}, detail::column_tuple_merge(args...));
}
template <typename... Args>
@@ -403,16 +404,16 @@ namespace sqlpp
static_assert(decltype(_check_args(args...))::value,
"at least one argument is not a selectable expression in columns()");
return _columns_impl<_database_t>(_check_args(args...), detail::column_tuple_merge(args...));
return _columns_impl<_database_t>(decltype(_check_args(args...)){}, detail::column_tuple_merge(args...));
}
private:
template <typename Database, typename... Args>
auto _columns_impl(const std::false_type&, std::tuple<Args...> args) const -> bad_statement;
template <typename Database, typename Check, typename... Args>
auto _columns_impl(Check, std::tuple<Args...> args) const -> Check;
template <typename Database, typename... Args>
auto _columns_impl(const std::true_type&, std::tuple<Args...> args) const
-> _new_statement_t<_check<Args...>, select_column_list_t<Database, Args...>>
auto _columns_impl(consistent_t, std::tuple<Args...> args) const
-> _new_statement_t<consistent_t, select_column_list_t<Database, Args...>>
{
static_assert(not detail::has_duplicates<Args...>::value, "at least one duplicate argument detected");
static_assert(not detail::has_duplicates<typename Args::_alias_t...>::value,

56
include/sqlpp11/select_flag_list.h
View File

@@ -27,13 +27,13 @@
#ifndef SQLPP_SELECT_FLAG_LIST_H
#define SQLPP_SELECT_FLAG_LIST_H
#include <tuple>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/select_flags.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/select_flags.h>
#include <sqlpp11/type_traits.h>
#include <tuple>
namespace sqlpp
{
@@ -85,7 +85,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Flag>::value,
"flag uses tables unknown to this statement in select_flags::add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Flag>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_select_flag_t<Flag>::value, _serialize_check::type::value>;
@@ -114,8 +114,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: select_flags{std::forward<Args>(args)...}
_base_t(Args&&... args) : select_flags{std::forward<Args>(args)...}
{
}
@@ -139,6 +138,16 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_select_flags_are_flags_t, "arguments for flags() must be known select flags");
template <typename... Flags>
struct check_select_flags
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_select_flag_t<Flags>::value...>::value, assert_select_flags_are_flags_t>>;
};
template <typename... Flags>
using check_select_flags_t = typename check_select_flags<Flags...>::type;
struct no_select_flag_list_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -168,8 +177,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_select_flags{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_select_flags{std::forward<Args>(args)...}
{
}
@@ -191,45 +199,35 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
// template <typename... T>
// using _check = logic::all_t<is_select_flag_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<detail::is_select_flag_impl<T>::type::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_select_flag_list_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_select_flag_list_t, T>;
using _consistency_check = consistent_t;
template <typename... Flags>
auto flags(Flags... flgs) const -> _new_statement_t<_check<Flags...>, select_flag_list_t<void, Flags...>>
auto flags(Flags... flgs) const
-> _new_statement_t<check_select_flags_t<Flags...>, select_flag_list_t<void, Flags...>>
{
static_assert(_check<Flags...>::value, "at least one argument is not a select flag in select flag list");
return _flags_impl<void>(_check<Flags...>{}, flgs...);
return _flags_impl<void>(check_select_flags_t<Flags...>{}, flgs...);
}
template <typename... Flags>
auto dynamic_flags(Flags... flgs) const
-> _new_statement_t<_check<Flags...>, select_flag_list_t<_database_t, Flags...>>
-> _new_statement_t<check_select_flags_t<Flags...>, select_flag_list_t<_database_t, Flags...>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_flags must not be called in a static statement");
static_assert(_check<Flags...>::value, "at least one argument is not a select flag in select flag list");
return _flags_impl<_database_t>(_check<Flags...>{}, flgs...);
return _flags_impl<_database_t>(check_select_flags_t<Flags...>{}, flgs...);
}
private:
template <typename Database, typename... Flags>
auto _flags_impl(const std::false_type&, Flags... flgs) const -> bad_statement;
template <typename Database, typename Check, typename... Flags>
auto _flags_impl(Check, Flags... flgs) const -> Check;
template <typename Database, typename... Flags>
auto _flags_impl(const std::true_type&, Flags... flgs) const
-> _new_statement_t<std::true_type, select_flag_list_t<Database, Flags...>>
auto _flags_impl(consistent_t, Flags... flgs) const
-> _new_statement_t<consistent_t, select_flag_list_t<Database, Flags...>>
{
static_assert(not detail::has_duplicates<Flags...>::value,
"at least one duplicate argument detected in select flag list");

4
include/sqlpp11/serializer.h
View File

@@ -27,8 +27,8 @@
#ifndef SQLPP_SERIALIZER_H
#define SQLPP_SERIALIZER_H
#include <sqlpp11/wrong.h>
#include <sqlpp11/portable_static_assert.h>
#include <sqlpp11/wrong.h>
namespace sqlpp
{
@@ -41,7 +41,7 @@ namespace sqlpp
static void _(const T&, Context&)
{
_serialize_check::_();
_serialize_check{};
}
};
}

20
include/sqlpp11/statement.h
View File

@@ -27,12 +27,12 @@
#ifndef SQLPP_STATEMENT_H
#define SQLPP_STATEMENT_H
#include <sqlpp11/result.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/prepared_select.h>
#include <sqlpp11/serialize.h>
#include <sqlpp11/noop.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/prepared_select.h>
#include <sqlpp11/result.h>
#include <sqlpp11/serialize.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/detail/get_first.h>
@@ -142,9 +142,8 @@ namespace sqlpp
typename std::conditional<_required_ctes::size::value == 0, consistent_t, assert_no_unknown_ctes_t>::type;
using _table_check =
typename std::conditional<_required_tables::size::value == 0, consistent_t, assert_no_unknown_tables_t>::type;
using _parameter_check = typename std::conditional<detail::type_vector_size<_parameters>::value == 0,
consistent_t,
assert_no_parameters_t>::type;
using _parameter_check = typename std::
conditional<detail::type_vector_size<_parameters>::value == 0, consistent_t, assert_no_parameters_t>::type;
};
}
@@ -235,14 +234,14 @@ namespace sqlpp
template <typename Database>
auto _run(Database& db) const -> decltype(std::declval<_result_methods_t<statement_t>>()._run(db))
{
_run_check::_();
_run_check{}; // FIXME: Dispatch?
return _result_methods_t<statement_t>::_run(db);
}
template <typename Database>
auto _prepare(Database& db) const -> decltype(std::declval<_result_methods_t<statement_t>>()._prepare(db))
{
_prepare_check::_();
_prepare_check{}; // FIXME: Dispatch?
return _result_methods_t<statement_t>::_prepare(db);
}
};
@@ -294,8 +293,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: statement_name{std::forward<Args>(args)...}
_base_t(Args&&... args) : statement_name{std::forward<Args>(args)...}
{
}

4
include/sqlpp11/tvin.h
View File

@@ -29,9 +29,9 @@
// TVIN: Trivial value is NULL
#include <sqlpp11/type_traits.h>
#include <sqlpp11/serialize.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/wrap_operand.h>
namespace sqlpp
@@ -67,7 +67,7 @@ namespace sqlpp
static Context& _(const T&, Context&)
{
_serialize_check::_();
_serialize_check{};
}
};

10
include/sqlpp11/update_list.h
View File

@@ -27,10 +27,10 @@
#ifndef SQLPP_UPDATE_LIST_H
#define SQLPP_UPDATE_LIST_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -89,7 +89,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<Assignment>::value,
"assignment uses tables unknown to this statement in add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Assignment>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_assignment_t<Assignment>::value, _serialize_check::type::value>;
@@ -118,8 +118,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: assignments{std::forward<Args>(args)...}
_base_t(Args&&... args) : assignments{std::forward<Args>(args)...}
{
}
@@ -228,8 +227,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_assignments{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_assignments{std::forward<Args>(args)...}
{
}

14
include/sqlpp11/using.h
View File

@@ -27,11 +27,11 @@
#ifndef SQLPP_USING_H
#define SQLPP_USING_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -81,7 +81,7 @@ namespace sqlpp
static_assert(_is_dynamic::value, "add must not be called for static using()");
static_assert(is_table_t<Table>::value, "invalid table argument in add()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Table>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_table_t<Table>::value, _serialize_check::type::value>;
@@ -110,8 +110,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: using_{std::forward<Args>(args)...}
_base_t(Args&&... args) : using_{std::forward<Args>(args)...}
{
}
@@ -166,8 +165,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_using{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_using{std::forward<Args>(args)...}
{
}

18
include/sqlpp11/where.h
View File

@@ -94,7 +94,7 @@ namespace sqlpp
static_assert(not contains_aggregate_function_t<Expr>::value,
"where expression must not contain aggregate functions");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expr>;
_serialize_check::_();
_serialize_check{};
using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expr>::value, _serialize_check::type::value>;
@@ -307,14 +307,14 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_where_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_where_t, T>;
using _consistency_check =
typename std::conditional<WhereRequired and (Policies::_all_provided_tables::size::value > 0),
assert_where_t,
consistent_t>::type;
auto unconditionally() const -> _new_statement_t<std::true_type, where_t<void, unconditional_t>>
auto unconditionally() const -> _new_statement_t<consistent_t, where_t<void, unconditional_t>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this), where_data_t<void, unconditional_t>{}};
}
@@ -324,8 +324,6 @@ namespace sqlpp
-> _new_statement_t<check_where_static_t<Expression>, where_t<void, Expression>>
{
using Check = check_where_static_t<Expression>;
Check{}._();
return _where_impl<void>(Check{}, expression);
}
@@ -334,8 +332,6 @@ namespace sqlpp
-> _new_statement_t<check_where_dynamic_t<_database_t, Expression>, where_t<_database_t, Expression>>
{
using Check = check_where_dynamic_t<_database_t, Expression>;
Check{}._();
return _where_impl<_database_t>(Check{}, expression);
}
@@ -346,12 +342,12 @@ namespace sqlpp
}
private:
template <typename Database, typename Expression>
auto _where_impl(const std::false_type&, Expression expression) const -> bad_statement;
template <typename Database, typename Check, typename Expression>
auto _where_impl(Check, Expression expression) const -> Check;
template <typename Database, typename Expression>
auto _where_impl(const std::true_type&, Expression expression) const
-> _new_statement_t<std::true_type, where_t<Database, Expression>>
auto _where_impl(consistent_t, Expression expression) const
-> _new_statement_t<consistent_t, where_t<Database, Expression>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
where_data_t<Database, Expression>{expression}};

20
include/sqlpp11/with.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* Copyright (c) 2013-2016, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@@ -29,15 +29,15 @@
#include <sqlpp11/assignment.h>
#include <sqlpp11/column_fwd.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/expression.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/policy_update.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/cte.h>
@@ -96,8 +96,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: with{std::forward<Args>(args)...}
_base_t(Args&&... args) : with{std::forward<Args>(args)...}
{
}
@@ -151,8 +150,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_with{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_with{std::forward<Args>(args)...}
{
}
@@ -183,7 +181,7 @@ namespace sqlpp
template <typename Statement>
auto operator()(Statement statement)
-> new_statement_t<true, typename Statement::_policies_t, no_with_t, with_t<Database, Expressions...>>
-> new_statement_t<consistent_t, typename Statement::_policies_t, no_with_t, with_t<Database, Expressions...>>
{
// FIXME need checks here
// check that no cte refers to any of the ctes to the right

28
tests/CMakeLists.txt
View File

@@ -30,21 +30,21 @@ target_compile_options(sqlpp11_testing INTERFACE -Wall -Wextra -pedantic)
endif ()
set(test_names
BooleanExpression
CustomQuery
DateTime
Interpret
Insert
Remove
Update
#BooleanExpression
#CustomQuery
#DateTime
#Interpret
#Insert
#Remove
#Update
Select
SelectType
Function
Prepared
Minimalistic
Result
Union
With
#SelectType
#Function
#Prepared
#Minimalistic
#Result
#Union
#With
)
create_test_sourcelist(test_sources test_main.cpp ${test_names})

20
tests/MockDb.h
View File

@@ -26,13 +26,13 @@
#ifndef SQLPP_MOCK_DB_H
#define SQLPP_MOCK_DB_H
#include <sstream>
#include <iostream>
#include <sqlpp11/schema.h>
#include <sqlpp11/connection.h>
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/schema.h>
#include <sqlpp11/serialize.h>
#include <sqlpp11/serializer_context.h>
#include <sqlpp11/connection.h>
#include <sstream>
template <bool enforceNullResultTreatment>
struct MockDbT : public sqlpp::connection
@@ -111,18 +111,17 @@ struct MockDbT : public sqlpp::connection
// Directly executed statements start here
template <typename T>
auto _run(const T& t, const std::true_type&) -> decltype(t._run(*this))
auto _run(const T& t, ::sqlpp::consistent_t) -> decltype(t._run(*this))
{
return t._run(*this);
}
template <typename T>
auto _run(const T& t, const std::false_type&) -> void;
template <typename Check, typename T>
auto _run(const T& t, Check) -> Check;
template <typename T>
auto operator()(const T& t) -> decltype(this->_run(t, sqlpp::run_check_t<_serializer_context_t, T>{}))
{
sqlpp::run_check_t<_serializer_context_t, T>::_();
return _run(t, sqlpp::run_check_t<_serializer_context_t, T>{});
}
@@ -182,18 +181,17 @@ struct MockDbT : public sqlpp::connection
using _prepared_statement_t = std::nullptr_t;
template <typename T>
auto _prepare(const T& t, const std::true_type&) -> decltype(t._prepare(*this))
auto _prepare(const T& t, ::sqlpp::consistent_t) -> decltype(t._prepare(*this))
{
return t._prepare(*this);
}
template <typename T>
auto _prepare(const T& t, const std::false_type&) -> void;
template <typename Check, typename T>
auto _prepare(const T& t, Check) -> Check;
template <typename T>
auto prepare(const T& t) -> decltype(this->_prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{}))
{
sqlpp::prepare_check_t<_serializer_context_t, T>::_();
return _prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{});
}

4
tests/Select.cpp
View File

@@ -122,8 +122,8 @@ int Select(int, char* [])
.group_by(t.alpha)
.order_by(t.gamma.asc())
.having(t.gamma)
.limit(7)
.offset(19);
.offset(19)
.limit(7);
printer.reset();
std::cerr << serialize(stat, printer).str() << std::endl;