3party/sqlpp11
0
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2024-11-16 04:47:18 +08:00
Code Issues Projects Releases Wiki Activity

More re-arrangements and preventing self-compare in in() again

Browse Source
This commit is contained in:
rbock 2016-04-09 10:55:46 +02:00
parent 6c1b190dcc
commit 0fb188c67d
5 changed files with 56 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
include/sqlpp11/basic_expression_operators.h
View File

@ -41,25 +41,26 @@
namespace sqlpp namespace sqlpp
{ {
SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_valid_rhs_operand_t, "invalid rhs operand in comparison"); SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_rhs_is_expression_t, "rhs operand in comparison is not an expression");
SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_rhs_is_valid_operand_t, "invalid rhs operand in comparison");
SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_lhs_rhs_differ_t, "identical lhs and rhs operands in comparison"); SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_lhs_rhs_differ_t, "identical lhs and rhs operands in comparison");
template <typename LhsType, typename RhsType> template <typename LhsType, typename RhsType>
using check_rhs_comparison_operand_t = static_combined_check_t< using check_comparison_t = static_combined_check_t<
static_check_t<(is_expression_t<sqlpp::wrap_operand_t<RhsType>>::value // expressions are OK static_check_t<logic::any_t<is_expression_t<sqlpp::wrap_operand_t<RhsType>>::value,
or is_multi_expression_t<sqlpp::wrap_operand_t<RhsType>>::value>::value,
is_multi_expression_t<sqlpp::wrap_operand_t<RhsType>>::value) // multi-expressions like ANY are assert_comparison_rhs_is_expression_t>,
// OK for comparisons, too static_check_t<value_type_of<LhsType>::template _is_valid_operand<sqlpp::wrap_operand_t<RhsType>>::value,
and assert_comparison_rhs_is_valid_operand_t>,
value_type_of<LhsType>::template _is_valid_operand<
sqlpp::wrap_operand_t<RhsType>>::value, // the correct value type is required, of course
assert_comparison_valid_rhs_operand_t>,
static_check_t<not std::is_same<LhsType, RhsType>::value, assert_comparison_lhs_rhs_differ_t>>; static_check_t<not std::is_same<LhsType, RhsType>::value, assert_comparison_lhs_rhs_differ_t>>;
template <typename LhsType, typename... RhsType> template <typename LhsType, typename... RhsType>
using check_rhs_in_operands_t = static_combined_check_t< using check_in_t = static_combined_check_t<
static_check_t<logic::all_t<is_expression_t<sqlpp::wrap_operand_t<RhsType>>::value...>::value, static_check_t<logic::all_t<is_expression_t<sqlpp::wrap_operand_t<RhsType>>::value...>::value,
assert_comparison_valid_rhs_operand_t>, assert_comparison_rhs_is_expression_t>,
static_check_t<logic::all_t<value_type_of<LhsType>::template _is_valid_operand<
sqlpp::wrap_operand_t<RhsType>>::value...>::value,
assert_comparison_rhs_is_valid_operand_t>,
static_check_t<logic::none_t<std::is_same<LhsType, RhsType>::value...>::value, static_check_t<logic::none_t<std::is_same<LhsType, RhsType>::value...>::value,
assert_comparison_lhs_rhs_differ_t>>; assert_comparison_lhs_rhs_differ_t>>;
@ -104,10 +105,8 @@ namespace sqlpp
template <template <typename Lhs, typename Rhs> class NewExpr, typename T> template <template <typename Lhs, typename Rhs> class NewExpr, typename T>
struct _new_binary_expression struct _new_binary_expression
{ {
using type = new_binary_expression_t<check_rhs_comparison_operand_t<Expr, wrap_operand_t<T>>, using type =
NewExpr, new_binary_expression_t<check_comparison_t<Expr, wrap_operand_t<T>>, NewExpr, Expr, wrap_operand_t<T>>;
Expr,
wrap_operand_t<T>>;
}; };
template <template <typename Lhs, typename Rhs> class NewExpr, typename T> template <template <typename Lhs, typename Rhs> class NewExpr, typename T>
using _new_binary_expression_t = typename _new_binary_expression<NewExpr, T>::type; using _new_binary_expression_t = typename _new_binary_expression<NewExpr, T>::type;
@ -115,7 +114,7 @@ namespace sqlpp
// workaround for msvs bug // workaround for msvs bug
// template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T> // template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T>
// using _new_nary_expression_t = // using _new_nary_expression_t =
// new_nary_expression_t<logic::all_t<check_rhs_comparison_operand_t< // new_nary_expression_t<logic::all_t<check_comparison_t<
// wrap_operand_t<T>>::value...>, // wrap_operand_t<T>>::value...>,
// NewExpr, // NewExpr,
// Expr, // Expr,
@ -123,18 +122,17 @@ namespace sqlpp
template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T> template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T>
struct _new_nary_expression struct _new_nary_expression
{ {
using type = using type = new_nary_expression_t<logic::all_t<check_comparison_t<Expr, wrap_operand_t<T>>::value...>,
new_nary_expression_t<logic::all_t<check_rhs_comparison_operand_t<Expr, wrap_operand_t<T>>::value...>, NewExpr,
NewExpr, Expr,
Expr, wrap_operand_t<T>...>;
wrap_operand_t<T>...>;
}; };
template <typename T> template <typename T>
_new_binary_expression_t<equal_to_t, T> operator==(T t) const _new_binary_expression_t<equal_to_t, T> operator==(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -143,7 +141,7 @@ namespace sqlpp
_new_binary_expression_t<not_equal_to_t, T> operator!=(T t) const _new_binary_expression_t<not_equal_to_t, T> operator!=(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -152,7 +150,7 @@ namespace sqlpp
_new_binary_expression_t<less_than_t, T> operator<(T t) const _new_binary_expression_t<less_than_t, T> operator<(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -161,7 +159,7 @@ namespace sqlpp
_new_binary_expression_t<less_equal_t, T> operator<=(T t) const _new_binary_expression_t<less_equal_t, T> operator<=(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -170,7 +168,7 @@ namespace sqlpp
_new_binary_expression_t<greater_than_t, T> operator>(T t) const _new_binary_expression_t<greater_than_t, T> operator>(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -179,7 +177,7 @@ namespace sqlpp
_new_binary_expression_t<greater_equal_t, T> operator>=(T t) const _new_binary_expression_t<greater_equal_t, T> operator>=(T t) const
{ {
using rhs = wrap_operand_t<T>; using rhs = wrap_operand_t<T>;
check_rhs_comparison_operand_t<Expr, rhs>::_(); check_comparison_t<Expr, rhs>::_();
return {*static_cast<const Expr*>(this), rhs{t}}; return {*static_cast<const Expr*>(this), rhs{t}};
} }
@ -215,7 +213,7 @@ namespace sqlpp
template <typename... T> template <typename... T>
typename _new_nary_expression<in_t, T...>::type in(T... t) const typename _new_nary_expression<in_t, T...>::type in(T... t) const
{ {
check_rhs_in_operands_t<Expr, T...>::_(); check_in_t<Expr, T...>::_();
return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...}; return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
} }
@ -229,7 +227,7 @@ namespace sqlpp
template <typename... T> template <typename... T>
typename _new_nary_expression<not_in_t, T...>::type not_in(T... t) const typename _new_nary_expression<not_in_t, T...>::type not_in(T... t) const
{ {
check_rhs_in_operands_t<Expr, T...>::_(); check_in_t<Expr, T...>::_();
return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...}; return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
} }

18
test_static_asserts/date.cpp
View File

@ -46,7 +46,7 @@ namespace
template <typename Assert, typename Operand> template <typename Assert, typename Operand>
void static_check_comparison(const Operand& operand) void static_check_comparison(const Operand& operand)
{ {
using CheckResult = sqlpp::check_rhs_comparison_operand_t<decltype(t.someDayPoint), Operand>; using CheckResult = sqlpp::check_comparison_t<decltype(t.someDayPoint), Operand>;
using ExpectedCheckResult = std::is_same<CheckResult, Assert>; using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
static_assert(ExpectedCheckResult::value, "Unexpected check result"); static_assert(ExpectedCheckResult::value, "Unexpected check result");
print_type_on_error<CheckResult>(ExpectedCheckResult{}); print_type_on_error<CheckResult>(ExpectedCheckResult{});
@ -73,14 +73,14 @@ namespace
void disallowed_comparands() void disallowed_comparands()
{ {
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(17); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(17);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>('a'); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>('a');
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(std::string("a")); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(std::string("a"));
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t); static_check_comparison<sqlpp::assert_comparison_rhs_is_expression_t>(t);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someBool); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someBool);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someFloat); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someFloat);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someInt); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someInt);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someString); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someString);
} }
} }

18
test_static_asserts/date_time.cpp
View File

@ -46,7 +46,7 @@ namespace
template <typename Assert, typename Operand> template <typename Assert, typename Operand>
void static_check_comparison(const Operand& operand) void static_check_comparison(const Operand& operand)
{ {
using CheckResult = sqlpp::check_rhs_comparison_operand_t<decltype(t.someTimePoint), Operand>; using CheckResult = sqlpp::check_comparison_t<decltype(t.someTimePoint), Operand>;
using ExpectedCheckResult = std::is_same<CheckResult, Assert>; using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
static_assert(ExpectedCheckResult::value, "Unexpected check result"); static_assert(ExpectedCheckResult::value, "Unexpected check result");
print_type_on_error<CheckResult>(ExpectedCheckResult{}); print_type_on_error<CheckResult>(ExpectedCheckResult{});
@ -73,14 +73,14 @@ namespace
void disallowed_comparands() void disallowed_comparands()
{ {
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(17); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(17);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>('a'); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>('a');
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(std::string("a")); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(std::string("a"));
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t); static_check_comparison<sqlpp::assert_comparison_rhs_is_expression_t>(t);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someBool); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someBool);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someFloat); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someFloat);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someInt); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someInt);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someString); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someString);
} }
} }

2
test_static_asserts/no_self_compare.cpp
View File

@ -46,7 +46,7 @@ namespace
template <typename Assert, typename Operand> template <typename Assert, typename Operand>
void static_check_self_compare(const Operand& operand) void static_check_self_compare(const Operand& operand)
{ {
using CheckResult = sqlpp::check_rhs_comparison_operand_t<Operand, Operand>; using CheckResult = sqlpp::check_comparison_t<Operand, Operand>;
using ExpectedCheckResult = std::is_same<CheckResult, Assert>; using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
static_assert(ExpectedCheckResult::value, "Unexpected check result"); static_assert(ExpectedCheckResult::value, "Unexpected check result");
print_type_on_error<CheckResult>(ExpectedCheckResult{}); print_type_on_error<CheckResult>(ExpectedCheckResult{});

18
test_static_asserts/text.cpp
View File

@ -46,7 +46,7 @@ namespace
template <typename Assert, typename Operand> template <typename Assert, typename Operand>
void static_check_comparison(const Operand& operand) void static_check_comparison(const Operand& operand)
{ {
using CheckResult = sqlpp::check_rhs_comparison_operand_t<decltype(t.someString), Operand>; using CheckResult = sqlpp::check_comparison_t<decltype(t.someString), Operand>;
using ExpectedCheckResult = std::is_same<CheckResult, Assert>; using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
static_assert(ExpectedCheckResult::value, "Unexpected check result"); static_assert(ExpectedCheckResult::value, "Unexpected check result");
print_type_on_error<CheckResult>(ExpectedCheckResult{}); print_type_on_error<CheckResult>(ExpectedCheckResult{});
@ -73,14 +73,14 @@ namespace
void disallowed_comparands() void disallowed_comparands()
{ {
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(17); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(17);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(17.4); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(17.4);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t); static_check_comparison<sqlpp::assert_comparison_rhs_is_expression_t>(t);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someBool); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someBool);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someFloat); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someFloat);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someInt); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someInt);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someDayPoint); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someDayPoint);
static_check_comparison<sqlpp::assert_comparison_valid_rhs_operand_t>(t.someTimePoint); static_check_comparison<sqlpp::assert_comparison_rhs_is_valid_operand_t>(t.someTimePoint);
} }
template <typename Expected, typename Expression> template <typename Expected, typename Expression>