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

Merge branch 'release/0.42'

Browse Source
This commit is contained in:
rbock 2016-09-03 13:19:28 +02:00
commit 781d63673f
47 changed files with 655 additions and 688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -4,6 +4,12 @@ A type safe embedded domain specific language for SQL queries and results in C++
Documentation is found in the [wiki](https://github.com/rbock/sqlpp11/wiki)
Contact:
--------
* Meet me at [CppCon 2016](https://cppcon2016.sched.org/event/7nKk)
* Issues at https://github.com/rbock/sqlpp11/issues
* email at rbock at eudoxos dot de
* [![Join the chat at https://gitter.im/sqlpp11/Lobby](https://badges.gitter.im/sqlpp11/Lobby.svg)](https://gitter.im/sqlpp11/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
Breaking changes in 0.36:
-------------------------
@ -109,9 +115,7 @@ Past talks about sqlpp11 and some coding concepts used within the library:
* [MUC++:](http://www.meetup.com/MUCplusplus/)
* 2014-02-27: [Selected C++11 Template Toffees From sqlpp11, Part1](https://www.youtube.com/watch?v=hXnGFYNbmXg), [Part2](https://www.youtube.com/watch?v=WPCV6dvxZ_U), [Part 3](https://www.youtube.com/watch?v=eB7hd_KjTig), [Part 4](https://www.youtube.com/watch?v=NBfqzcN0_EQ)
You can contact me
* by posting issues at https://github.com/rbock/sqlpp11/issues
* or via email at rbock at eudoxos dot de
Requirements:

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_) -> inconsistent<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) -> inconsistent<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) -> inconsistent<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);
}
}

71
include/sqlpp11/cte.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,
@ -27,16 +27,16 @@
#ifndef SQLPP_CTE_H
#define SQLPP_CTE_H
#include <sqlpp11/table_ref.h>
#include <sqlpp11/select_flags.h>
#include <sqlpp11/result_row.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.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/parameter_list.h>
#include <sqlpp11/result_row.h>
#include <sqlpp11/select_flags.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/table_ref.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@ -133,6 +133,31 @@ namespace sqlpp
using type = member_t<cte_column_spec_t<FieldSpec>, column_t<AliasProvider, cte_column_spec_t<FieldSpec>>>;
};
template <typename Check, typename Union>
struct union_cte_impl
{
using type = Check;
};
template <typename Union>
struct union_cte_impl<consistent_t, Union>
{
using type = Union;
};
template <typename Check, typename Union>
using union_cte_impl_t = typename union_cte_impl<Check, Union>::type;
SQLPP_PORTABLE_STATIC_ASSERT(assert_cte_union_args_are_statements_t, "argument for union() must be a statement");
template <typename... T>
struct check_cte_union
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_statement_t<T>::value...>::value, assert_cte_union_args_are_statements_t>>;
};
template <typename... T>
using check_cte_union_t = typename check_cte_union<T...>::type;
template <typename AliasProvider, typename Statement, typename... FieldSpecs>
struct cte_t : public cte_base<AliasProvider, FieldSpecs>::type...
{
@ -146,21 +171,12 @@ namespace sqlpp
using _column_tuple_t = std::tuple<column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>...>;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2086629
// template <typename... T>
// using _check = logic::all_t<is_statement_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<is_statement_t<T>::value...>
{
};
using _result_row_t = result_row_t<void, FieldSpecs...>;
template <typename Rhs>
auto union_distinct(Rhs rhs) const ->
typename std::conditional<_check<Rhs>::value,
cte_t<AliasProvider, cte_union_t<distinct_t, Statement, Rhs>, FieldSpecs...>,
bad_statement>::type
auto union_distinct(Rhs rhs) const
-> union_cte_impl_t<check_cte_union_t<Rhs>,
cte_t<AliasProvider, cte_union_t<distinct_t, Statement, Rhs>, FieldSpecs...>>
{
static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@ -169,14 +185,13 @@ namespace sqlpp
static_assert(std::is_same<_result_row_t, get_result_row_t<Rhs>>::value,
"both select statements in a union have to have the same result columns (type and name)");
return _union_impl<void, distinct_t>(_check<Rhs>{}, rhs);
return _union_impl<void, distinct_t>(check_cte_union_t<Rhs>{}, rhs);
}
template <typename Rhs>
auto union_all(Rhs rhs) const ->
typename std::conditional<_check<Rhs>::value,
cte_t<AliasProvider, cte_union_t<all_t, Statement, Rhs>, FieldSpecs...>,
bad_statement>::type
auto union_all(Rhs rhs) const
-> union_cte_impl_t<check_cte_union_t<Rhs>,
cte_t<AliasProvider, cte_union_t<all_t, Statement, Rhs>, FieldSpecs...>>
{
static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@ -185,15 +200,15 @@ namespace sqlpp
static_assert(std::is_same<_result_row_t, get_result_row_t<Rhs>>::value,
"both select statements in a union have to have the same result columns (type and name)");
return _union_impl<all_t>(_check<Rhs>{}, rhs);
return _union_impl<all_t>(check_cte_union_t<Rhs>{}, rhs);
}
private:
template <typename Flag, typename Rhs>
auto _union_impl(const std::false_type&, Rhs rhs) const -> bad_statement;
template <typename Flag, typename Check, typename Rhs>
auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
template <typename Flag, typename Rhs>
auto _union_impl(const std::true_type&, Rhs rhs) const
auto _union_impl(consistent_t, Rhs rhs) const
-> cte_t<AliasProvider, cte_union_t<Flag, Statement, Rhs>, FieldSpecs...>
{
return cte_union_t<Flag, Statement, Rhs>{_statement, rhs};

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) -> inconsistent<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 -> inconsistent<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 -> inconsistent<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 -> inconsistent<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}};

26
include/sqlpp11/bad_statement.h → include/sqlpp11/inconsistent.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* Copyright (c) 2016-2016, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@ -24,20 +24,22 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SQLPP_BAD_STATEMENT_H
#define SQLPP_BAD_STATEMENT_H
#ifndef SQLPP_INCONSISTENT_H
#define SQLPP_INCONSISTENT_H
#include <utility>
namespace sqlpp
{
struct bad_statement
{
static constexpr bool value = false;
template <typename... T>
bad_statement(T&&...)
{
}
};
#if defined(__clang__) || defined(_MSC_VER)
template <typename Check>
using inconsistent = Check;
#else
// This version circumvents an ambiguity problem with gcc
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77449
template <typename Check>
using inconsistent = typename std::enable_if<not std::is_same<consistent_t, Check>::value, Check>::type;
#endif
}
#endif

77
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)...}
{
}
@ -429,6 +426,16 @@ namespace sqlpp
SQLPP_PORTABLE_STATIC_ASSERT(assert_insert_values_t, "insert values required, e.g. set(...) or default_values()");
SQLPP_PORTABLE_STATIC_ASSERT(assert_insert_columns_are_columns, "arguments for columns() must be table columns");
template <typename... Columns>
struct check_insert_columns
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_column_t<Columns>::value...>::value, assert_insert_columns_are_columns>>;
};
template <typename... Columns>
using check_insert_columns_t = typename check_insert_columns<Columns...>::type;
// NO INSERT COLUMNS/VALUES YET
struct no_insert_value_list_t
{
@ -459,8 +466,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)...}
{
}
@ -482,32 +488,23 @@ 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 _column_check = logic::all_t<is_column_t<T>::value...>;
template <typename... T>
struct _column_check : logic::all_t<is_column_t<T>::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_insert_value_list_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_insert_value_list_t, T>;
using _consistency_check = assert_insert_values_t;
auto default_values() const -> _new_statement_t<std::true_type, insert_default_values_t>
auto default_values() const -> _new_statement_t<consistent_t, insert_default_values_t>
{
return {static_cast<const derived_statement_t<Policies>&>(*this), insert_default_values_data_t{}};
}
template <typename... Columns>
auto columns(Columns... cols) const -> _new_statement_t<_column_check<Columns...>, column_list_t<Columns...>>
auto columns(Columns... cols) const
-> _new_statement_t<check_insert_columns_t<Columns...>, column_list_t<Columns...>>
{
static_assert(logic::all_t<is_column_t<Columns>::value...>::value,
"at least one argument is not a column in columns()");
static_assert(sizeof...(Columns), "at least one column required in columns()");
return _columns_impl(_column_check<Columns...>{}, cols...);
return _columns_impl(check_insert_columns_t<Columns...>{}, cols...);
}
template <typename... Assignments>
@ -515,8 +512,6 @@ namespace sqlpp
-> _new_statement_t<check_insert_static_set_t<Assignments...>, insert_list_t<void, Assignments...>>
{
using Check = check_insert_static_set_t<Assignments...>;
Check{}._();
return _set_impl<void>(Check{}, assignments...);
}
@ -526,18 +521,16 @@ namespace sqlpp
insert_list_t<_database_t, Assignments...>>
{
using Check = check_insert_dynamic_set_t<_database_t, Assignments...>;
Check{}._();
return _set_impl<_database_t>(Check{}, assignments...);
}
private:
template <typename... Columns>
auto _columns_impl(const std::false_type&, Columns... cols) const -> bad_statement;
template <typename Check, typename... Columns>
auto _columns_impl(Check, Columns... cols) const -> inconsistent<Check>;
template <typename... Columns>
auto _columns_impl(const std::true_type&, Columns... cols) const
-> _new_statement_t<std::true_type, column_list_t<Columns...>>
auto _columns_impl(consistent_t, Columns... cols) const
-> _new_statement_t<consistent_t, column_list_t<Columns...>>
{
static_assert(not detail::has_duplicates<Columns...>::value,
"at least one duplicate argument detected in columns()");
@ -552,12 +545,12 @@ namespace sqlpp
return {static_cast<const derived_statement_t<Policies>&>(*this), column_list_data_t<Columns...>{cols...}};
}
template <typename Database, typename... Assignments>
auto _set_impl(std::false_type, Assignments... assignments) const -> bad_statement;
template <typename Database, typename Check, typename... Assignments>
auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
template <typename Database, typename... Assignments>
auto _set_impl(std::true_type, Assignments... assignments) const
-> _new_statement_t<std::true_type, insert_list_t<Database, Assignments...>>
auto _set_impl(consistent_t, Assignments... assignments) const
-> _new_statement_t<consistent_t, insert_list_t<Database, Assignments...>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
insert_list_data_t<Database, Assignments...>{assignments...}};

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
{

37
include/sqlpp11/into.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,
@ -27,13 +27,13 @@
#ifndef SQLPP_INTO_H
#define SQLPP_INTO_H
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@ -88,8 +88,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
template <typename... Args>
_base_t(Args&&... args)
: into{std::forward<Args>(args)...}
_base_t(Args&&... args) : into{std::forward<Args>(args)...}
{
}
@ -115,6 +114,15 @@ namespace sqlpp
SQLPP_PORTABLE_STATIC_ASSERT(assert_into_t, "into() required");
SQLPP_PORTABLE_STATIC_ASSERT(assert_into_arg_is_table, "argument for into() must be a table");
template <typename T>
struct check_into
{
using type = static_combined_check_t<static_check_t<is_raw_table_t<T>::value, assert_into_arg_is_table>>;
};
template <typename T>
using check_into_t = typename check_into<wrap_operand_t<T>>::type;
// NO INTO YET
struct no_into_t
{
@ -155,28 +163,23 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename T>
using _check = logic::all_t<is_raw_table_t<T>::value>;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_into_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_into_t, T>;
using _consistency_check = assert_into_t;
template <typename Table>
auto into(Table table) const -> _new_statement_t<_check<Table>, into_t<void, Table>>
auto into(Table table) const -> _new_statement_t<check_into_t<Table>, into_t<void, Table>>
{
static_assert(_check<Table>::value, "argument is not a raw table in into()");
return _into_impl<void>(_check<Table>{}, table);
return _into_impl<void>(check_into_t<Table>{}, table);
}
private:
template <typename Database, typename Table>
auto _into_impl(const std::false_type&, Table table) const -> bad_statement;
template <typename Database, typename Check, typename Table>
auto _into_impl(Check, Table table) const -> inconsistent<Check>;
template <typename Database, typename Table>
auto _into_impl(const std::true_type&, Table table) const
-> _new_statement_t<std::true_type, into_t<Database, Table>>
auto _into_impl(consistent_t, Table table) const -> _new_statement_t<consistent_t, into_t<Database, Table>>
{
static_assert(required_tables_of<into_t<Database, Table>>::size::value == 0,
"argument depends on another table in into()");

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 -> inconsistent<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 -> inconsistent<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 -> inconsistent<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()");

17
include/sqlpp11/policy_update.h
View File

@ -28,7 +28,6 @@
#define SQLPP_POLICY_UPDATE_H
#include <sqlpp11/wrong.h>
#include <sqlpp11/bad_statement.h>
namespace sqlpp
{
@ -54,19 +53,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;
}

11
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,
@ -28,17 +28,20 @@
#define SQLPP_PORTABLE_STATIC_ASSERT_H
#include <sqlpp11/consistent.h>
#include <sqlpp11/inconsistent.h>
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); \
} \
auto begin() const -> void; \
auto end() const -> void; \
}
namespace detail

98
include/sqlpp11/pre_join.h
View File

@ -27,10 +27,9 @@
#ifndef SQLPP_PRE_JOIN_H
#define SQLPP_PRE_JOIN_H
#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 +105,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 -> inconsistent<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}};
}
@ -145,64 +143,66 @@ 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
namespace detail
{
check_pre_join_t<Lhs, Rhs>::_();
template <typename JoinType, typename Check, typename Lhs, typename Rhs>
auto join_impl(Check, Lhs lhs, Rhs rhs) -> inconsistent<Check>;
template <typename JoinType, typename Lhs, typename Rhs>
auto join_impl(consistent_t, Lhs lhs, Rhs rhs) -> pre_join_t<JoinType, Lhs, Rhs>;
template <typename JoinType, typename Lhs, typename Rhs>
auto join_impl(Lhs lhs, Rhs rhs) -> decltype(join_impl<JoinType>(check_pre_join_t<Lhs, Rhs>{}, lhs, rhs));
}
template <typename Lhs, typename Rhs>
auto join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<inner_join_t>(lhs, rhs))
{
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto inner_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<inner_join_t>(lhs, rhs))
{
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto left_outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<left_outer_join_t>(lhs, rhs))
{
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto right_outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<right_outer_join_t>(lhs, rhs))
{
check_pre_join_t<Lhs, Rhs>{};
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 outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<outer_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
namespace detail
{
check_pre_join_t<Lhs, Rhs>::_();
template <typename Check, typename Lhs, typename Rhs>
auto cross_join_impl(Check, Lhs lhs, Rhs rhs) -> inconsistent<Check>;
return {lhs, rhs};
template <typename Lhs, typename Rhs>
auto cross_join_impl(consistent_t, Lhs lhs, Rhs rhs)
-> join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>;
template <typename Lhs, typename Rhs>
auto cross_join_impl(Lhs lhs, Rhs rhs) -> decltype(cross_join_impl(check_pre_join_t<Lhs, Rhs>{}, 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 cross_join(Lhs lhs, Rhs rhs) -> decltype(detail::cross_join_impl(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
{
check_pre_join_t<Lhs, Rhs>::_();
return {lhs, rhs};
}
template <typename Lhs, typename Rhs>
auto cross_join(Lhs lhs, Rhs rhs) ->
typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>,
bad_statement>::type
{
check_pre_join_t<Lhs, Rhs>::_();
return {pre_join_t<cross_join_t, Lhs, Rhs>{lhs, rhs}, {}};
}
}

8
include/sqlpp11/result_field_base.h
View File

@ -28,7 +28,6 @@
#define SQLPP_RESULT_FIELD_BASE_H
#include <sqlpp11/alias_operators.h>
#include <sqlpp11/bad_statement.h>
#include <sqlpp11/basic_expression_operators.h>
#include <sqlpp11/exception.h>
#include <sqlpp11/result_field.h>
@ -37,6 +36,8 @@
namespace sqlpp
{
SQLPP_PORTABLE_STATIC_ASSERT(assert_result_field_value_is_safe_t, "result field value needs to be checked for NULL");
template <typename Db, typename FieldSpec, typename StorageType = typename value_type_of<FieldSpec>::_cpp_value_type>
struct result_field_base
{
@ -117,8 +118,9 @@ namespace sqlpp
return _value;
}
operator typename std::conditional<_null_is_trivial or (not _can_be_null::value), _cpp_value_type, bad_statement>::
type() const
operator typename std::conditional<_null_is_trivial or (not _can_be_null::value),
_cpp_value_type,
assert_result_field_value_is_safe_t>::type() const
{
return value();
}

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 -> inconsistent<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 -> inconsistent<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");

3
include/sqlpp11/select_pseudo_table.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,
@ -28,6 +28,7 @@
#define SQLPP_SELECT_PSEUDO_TABLE_H
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/table.h>
namespace sqlpp
{

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{};
}
};
}

41
include/sqlpp11/single_table.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,
@ -27,12 +27,12 @@
#ifndef SQLPP_SINGLE_TABLE_H
#define SQLPP_SINGLE_TABLE_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@ -90,8 +90,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: from{std::forward<Args>(args)...}
_base_t(Args&&... args) : from{std::forward<Args>(args)...}
{
}
@ -115,7 +114,16 @@ namespace sqlpp
};
};
// NO INTO YET
SQLPP_PORTABLE_STATIC_ASSERT(assert_update_table_arg_is_table_t, "argument for update() must be a table");
template <typename Table>
struct check_update_table
{
using type = static_combined_check_t<static_check_t<is_table_t<Table>::value, assert_update_table_arg_is_table_t>>;
};
template <typename Table>
using check_update_table_t = typename check_update_table<Table>::type;
// NO TABLE YET
struct no_single_table_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
@ -154,28 +162,25 @@ namespace sqlpp
}
using _database_t = typename Policies::_database_t;
template <typename T>
using _check = logic::all_t<is_table_t<T>::value>;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_single_table_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_single_table_t, T>;
using _consistency_check = consistent_t;
template <typename Table>
auto single_table(Table table) const -> _new_statement_t<_check<Table>, single_table_t<void, Table>>
auto single_table(Table table) const -> _new_statement_t<check_update_table_t<Table>, single_table_t<void, Table>>
{
static_assert(_check<Table>::value, "argument is not a table in single_table()");
return _single_table_impl<void>(_check<Table>{}, table);
return _single_table_impl<void>(check_update_table_t<Table>{}, table);
}
private:
template <typename Database, typename Table>
auto _single_table_impl(const std::false_type&, Table table) const -> bad_statement;
template <typename Database, typename Check, typename Table>
auto _single_table_impl(Check, Table table) const -> inconsistent<Check>;
template <typename Database, typename Table>
auto _single_table_impl(const std::true_type&, Table table) const
-> _new_statement_t<std::true_type, single_table_t<Database, Table>>
auto _single_table_impl(consistent_t, Table table) const
-> _new_statement_t<consistent_t, single_table_t<Database, Table>>
{
static_assert(required_tables_of<single_table_t<Database, Table>>::size::value == 0,
"argument depends on another table in single_table()");

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{};
}
};

76
include/sqlpp11/union.h
View File

@ -27,16 +27,16 @@
#ifndef SQLPP_UNION_H
#define SQLPP_UNION_H
#include <sqlpp11/union_data.h>
#include <sqlpp11/union_flags.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/expression.h>
#include <sqlpp11/interpret_tuple.h>
#include <sqlpp11/interpretable_list.h>
#include <sqlpp11/result_row.h>
#include <sqlpp11/logic.h>
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/result_row.h>
#include <sqlpp11/statement_fwd.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/union_data.h>
#include <sqlpp11/union_flags.h>
namespace sqlpp
{
@ -45,19 +45,19 @@ namespace sqlpp
using blank_union_t = statement_t<void, no_union_t>;
// There is no order by or limit or offset in union, use it as a pseudo table to do that.
template <bool, typename Union>
template <typename Check, typename Union>
struct union_statement_impl
{
using type = Check;
};
template <typename Union>
struct union_statement_impl<consistent_t, Union>
{
using type = statement_t<void, Union, no_union_t>;
};
template <typename Union>
struct union_statement_impl<false, Union>
{
using type = bad_statement;
};
template <bool Check, typename Union>
template <typename Check, typename Union>
using union_statement_t = typename union_statement_impl<Check, Union>::type;
// UNION(EXPR)
@ -95,8 +95,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: union_{std::forward<Args>(args)...}
_base_t(Args&&... args) : union_{std::forward<Args>(args)...}
{
}
@ -136,6 +135,16 @@ namespace sqlpp
using _result_methods_t = typename Lhs::template _result_methods_t<Statement>;
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_union_args_are_statements_t, "arguments for union() must be statements");
template <typename... T>
struct check_union
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_statement_t<T>::value...>::value, assert_union_args_are_statements_t>>;
};
template <typename... T>
using check_union_t = typename check_union<T...>::type;
// NO UNION YET
struct no_union_t
{
@ -166,8 +175,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: no_union{std::forward<Args>(args)...}
_base_t(Args&&... args) : no_union{std::forward<Args>(args)...}
{
}
@ -189,20 +197,15 @@ 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_statement_t<T>::value...>;
template <typename... T>
using _check = typename logic::all<is_statement_t<T>::value...>::type;
template <typename Check, typename T>
using _new_statement_t = union_statement_t<Check::value, T>;
using _new_statement_t = union_statement_t<Check, T>;
using _consistency_check = consistent_t;
template <typename Rhs>
auto union_distinct(Rhs rhs) const
-> _new_statement_t<_check<Rhs>, union_t<void, union_distinct_t, derived_statement_t<Policies>, Rhs>>
-> _new_statement_t<check_union_t<derived_statement_t<Policies>, Rhs>,
union_t<void, union_distinct_t, derived_statement_t<Policies>, Rhs>>
{
static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@ -215,12 +218,12 @@ namespace sqlpp
"both arguments in a union have to have the same result columns (type and name)");
static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
return _union_impl<void, union_distinct_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
return _union_impl<void, union_distinct_t>(check_union_t<derived_statement_t<Policies>, Rhs>{}, rhs);
}
template <typename Rhs>
auto union_all(Rhs rhs) const
-> _new_statement_t<_check<Rhs>, union_t<void, union_all_t, derived_statement_t<Policies>, Rhs>>
auto union_all(Rhs rhs) const -> _new_statement_t<check_union_t<derived_statement_t<Policies>, Rhs>,
union_t<void, union_all_t, derived_statement_t<Policies>, Rhs>>
{
static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@ -233,20 +236,19 @@ namespace sqlpp
"both arguments in a union have to have the same result columns (type and name)");
static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
return _union_impl<void, union_all_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
return _union_impl<void, union_all_t>(check_union_t<derived_statement_t<Policies>, Rhs>{}, rhs);
}
private:
template <typename Database, typename Flag, typename Rhs>
auto _union_impl(const std::false_type&, Rhs rhs) const -> bad_statement;
template <typename Database, typename Flag, typename Check, typename Rhs>
auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
template <typename Database, typename Flag, typename Rhs>
auto _union_impl(const std::true_type&, Rhs rhs) const
-> _new_statement_t<std::true_type, union_t<Database, Flag, derived_statement_t<Policies>, Rhs>>
auto _union_impl(consistent_t, Rhs rhs) const
-> _new_statement_t<consistent_t, union_t<Database, Flag, derived_statement_t<Policies>, Rhs>>
{
return {blank_union_t{},
union_data_t<Database, Flag, derived_statement_t<Policies>, Rhs>{
static_cast<const derived_statement_t<Policies>&>(*this), rhs}};
return {blank_union_t{}, union_data_t<Database, Flag, derived_statement_t<Policies>, Rhs>{
static_cast<const derived_statement_t<Policies>&>(*this), rhs}};
}
};
};

24
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)...}
{
}
@ -252,7 +250,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_update_list_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_update_list_t, T>;
using _consistency_check = assert_update_assignments_t;
@ -261,8 +259,6 @@ namespace sqlpp
-> _new_statement_t<check_update_static_set_t<Assignments...>, update_list_t<void, Assignments...>>
{
using Check = check_update_static_set_t<Assignments...>;
Check{}._();
return _set_impl<void>(Check{}, assignments...);
}
@ -272,18 +268,16 @@ namespace sqlpp
update_list_t<_database_t, Assignments...>>
{
using Check = check_update_dynamic_set_t<_database_t, Assignments...>;
Check{}._();
return _set_impl<_database_t>(Check{}, assignments...);
}
private:
template <typename Database, typename... Assignments>
auto _set_impl(const std::false_type&, Assignments... assignments) const -> bad_statement;
template <typename Database, typename Check, typename... Assignments>
auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
template <typename Database, typename... Assignments>
auto _set_impl(const std::true_type&, Assignments... assignments) const
-> _new_statement_t<std::true_type, update_list_t<Database, Assignments...>>
auto _set_impl(consistent_t, Assignments... assignments) const
-> _new_statement_t<consistent_t, update_list_t<Database, Assignments...>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
update_list_data_t<Database, Assignments...>{assignments...}};

67
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)...}
{
}
@ -136,6 +135,16 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_using_args_are_tables_t, "arguments for using() must be tables");
template <typename... Tables>
struct check_using
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_table_t<Tables>::value...>::value, assert_using_args_are_tables_t>>;
};
template <typename... Tables>
using check_using_t = typename check_using<Tables...>::type;
// NO USING YET
struct no_using_t
{
@ -166,8 +175,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)...}
{
}
@ -189,52 +197,43 @@ 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_table_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<is_table_t<T>::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_using_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_using_t, T>;
using _consistency_check = consistent_t;
template <typename... Args>
auto using_(Args... args) const -> _new_statement_t<_check<Args...>, using_t<void, Args...>>
template <typename... Tables>
auto using_(Tables... tables) const -> _new_statement_t<check_using_t<Tables...>, using_t<void, Tables...>>
{
static_assert(not detail::has_duplicates<Args...>::value,
static_assert(not detail::has_duplicates<Tables...>::value,
"at least one duplicate argument detected in using()");
static_assert(sizeof...(Args), "at least one table required in using()");
static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
static_assert(sizeof...(Tables), "at least one table required in using()");
return {_using_impl<void>(_check<Args...>{}, args...)};
return {_using_impl<void>(check_using_t<Tables...>{}, tables...)};
}
template <typename... Args>
auto dynamic_using(Args... args) const -> _new_statement_t<_check<Args...>, using_t<_database_t, Args...>>
template <typename... Tables>
auto dynamic_using(Tables... tables) const
-> _new_statement_t<check_using_t<Tables...>, using_t<_database_t, Tables...>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_using must not be called in a static statement");
static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
return {_using_impl<_database_t>(_check<Args...>{}, args...)};
return {_using_impl<_database_t>(check_using_t<Tables...>{}, tables...)};
}
private:
template <typename Database, typename... Args>
auto _using_impl(const std::false_type&, Args... args) const -> bad_statement;
template <typename Database, typename Check, typename... Tables>
auto _using_impl(Check, Tables... tables) const -> inconsistent<Check>;
template <typename Database, typename... Args>
auto _using_impl(const std::true_type&, Args... args) const
-> _new_statement_t<std::true_type, using_t<_database_t, Args...>>
template <typename Database, typename... Tables>
auto _using_impl(consistent_t, Tables... tables) const
-> _new_statement_t<consistent_t, using_t<_database_t, Tables...>>
{
static_assert(not detail::has_duplicates<Args...>::value,
static_assert(not detail::has_duplicates<Tables...>::value,
"at least one duplicate argument detected in using()");
return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Args...>{args...}};
return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Tables...>{tables...}};
}
};
};

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 -> inconsistent<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

2
test_serializer/CustomQuery.cpp
View File

@ -29,7 +29,7 @@
#include <iostream>
SQLPP_ALIAS_PROVIDER(pragma);
SQLPP_ALIAS_PROVIDER(pragma)
int CustomQuery(int, char* [])
{

121
test_static_asserts/aggregates.cpp
View File

@ -23,104 +23,95 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "Sample.h"
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/alias_provider.h>
#include <sqlpp11/select.h>
#include <sqlpp11/functions.h>
#include <sqlpp11/connection.h>
namespace sqlpp
{
namespace test
{
template <typename T>
void print_type_on_error(std::true_type, const T&)
{
}
template <typename T>
void print_type_on_error(std::false_type, const T& t)
{
t._print_me_;
}
template <typename Assert, typename Expression>
void run_check(const Expression&)
{
using Context = MockDb::_serializer_context_t;
using CheckResult = std::is_same<sqlpp::run_check_t<Context, Expression>, Assert>;
static_assert(CheckResult::value, "Unexpected run_check result");
print_type_on_error(CheckResult{}, sqlpp::run_check_t<Context, Expression>{});
}
template <typename Expression>
void run_check(const Expression&)
{
using Context = MockDb::_serializer_context_t;
using CheckResult = std::is_same<sqlpp::run_check_t<Context, Expression>, consistent_t>;
static_assert(CheckResult::value, "Unexpected run_check result");
print_type_on_error(CheckResult{}, sqlpp::run_check_t<Context, Expression>{});
}
}
}
#include <sqlpp11/functions.h>
#include <sqlpp11/select.h>
namespace
{
template <typename T>
void print_type_on_error(std::true_type)
{
}
template <typename T>
void print_type_on_error(std::false_type)
{
T::_print_me_;
}
template <typename Assert, typename Expression>
void static_run_check(const Expression&)
{
using Context = MockDb::_serializer_context_t;
using CheckResult = sqlpp::run_check_t<Context, Expression>;
using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
print_type_on_error<CheckResult>(ExpectedCheckResult{});
static_assert(ExpectedCheckResult::value, "Unexpected check result");
}
SQLPP_ALIAS_PROVIDER(whatever)
using sqlpp::test::run_check;
static constexpr auto t = test::TabBar{};
// If there is no group_by, we can select whatever we want
void no_group_by()
{
run_check(select(all_of(t)).from(t).unconditionally());
run_check(select(t.alpha).from(t).unconditionally());
run_check(select(count(t.alpha)).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(all_of(t)).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally());
}
// If there is a dynamic group_by, we can still select whatever we want
// because there is no way of knowing which expressions might have been added dynamically
void dynamic_group_by()
{
run_check(select(all_of(t)).from(t).unconditionally());
run_check(select(t.alpha).from(t).unconditionally());
run_check(select(count(t.alpha)).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(all_of(t)).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally());
static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally());
}
// If there is a static group_by, selected columns must be made of group_by expressions, or aggregate expression (e.g.
// count(t.id)) or values to be valid
void static_group_by_ok()
{
run_check(select(t.alpha).from(t).unconditionally().group_by(t.alpha));
run_check(select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha));
run_check(select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
run_check(select((t.alpha + t.delta * 17).as(whatever))
.from(t)
.unconditionally()
.group_by(t.alpha, t.alpha + t.delta * 17));
run_check(select((t.beta + "fortytwo").as(whatever)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::consistent_t>(
select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::consistent_t>(
select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
static_run_check<sqlpp::consistent_t>(select((t.alpha + t.delta * 17).as(whatever))
.from(t)
.unconditionally()
.group_by(t.alpha, t.alpha + t.delta * 17));
static_run_check<sqlpp::consistent_t>(
select((t.beta + "fortytwo").as(whatever)).from(t).unconditionally().group_by(t.beta));
run_check(select(avg(t.alpha)).from(t).unconditionally().group_by(t.beta));
run_check(select(count(t.alpha)).from(t).unconditionally().group_by(t.beta));
run_check(select(max(t.alpha)).from(t).unconditionally().group_by(t.beta));
run_check(select(min(t.alpha)).from(t).unconditionally().group_by(t.beta));
run_check(select(sum(t.alpha)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(avg(t.alpha)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(max(t.alpha)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(min(t.alpha)).from(t).unconditionally().group_by(t.beta));
static_run_check<sqlpp::consistent_t>(select(sum(t.alpha)).from(t).unconditionally().group_by(t.beta));
run_check(select((t.alpha + count(t.delta)).as(whatever)).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::consistent_t>(
select((t.alpha + count(t.delta)).as(whatever)).from(t).unconditionally().group_by(t.alpha));
run_check(select(sqlpp::value(1).as(whatever)).from(t).unconditionally().group_by(t.alpha));
run_check(select(sqlpp::value("whatever").as(whatever)).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::consistent_t>(
select(sqlpp::value(1).as(whatever)).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::consistent_t>(
select(sqlpp::value("whatever").as(whatever)).from(t).unconditionally().group_by(t.alpha));
}
// Failures with static group_by and selected non-aggregates or incorrect aggregates
void static_group_by_nok()
{
run_check<sqlpp::assert_no_unknown_aggregates_t>(select(t.beta).from(t).unconditionally().group_by(t.alpha));
run_check<sqlpp::assert_no_unknown_aggregates_t>(
static_run_check<sqlpp::assert_no_unknown_aggregates_t>(select(t.beta).from(t).unconditionally().group_by(t.alpha));
static_run_check<sqlpp::assert_no_unknown_aggregates_t>(
select((t.alpha + t.delta).as(whatever)).from(t).unconditionally().group_by(t.alpha));
run_check<sqlpp::assert_no_unknown_aggregates_t>(
static_run_check<sqlpp::assert_no_unknown_aggregates_t>(
select((t.alpha + t.delta).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
}
}

10
test_static_asserts/case.cpp
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,
@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -52,7 +52,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(sqlpp::case_when(when));
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -66,7 +66,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(sqlpp::case_when(when).then(then));
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -80,7 +80,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(sqlpp::case_when(when).then(then).else_(else_));
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

11
test_static_asserts/from.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -53,8 +53,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(select(t.alpha).from(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -69,8 +68,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(dynamic_select(db, t.alpha).dynamic_from(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -120,8 +118,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(from.add(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

10
test_static_asserts/having.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -53,8 +53,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(select(all_of(t)).from(t).unconditionally().group_by(t.alpha).having(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -70,8 +69,7 @@ namespace
using ReturnType =
decltype(dynamic_select(db, all_of(t)).from(t).unconditionally().group_by(t.alpha).dynamic_having(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -140,7 +138,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(select(all_of(t)).from(t).dynamic_having());
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_where_dynamic_statement_dynamic_t>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

12
test_static_asserts/insert.cpp
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,
@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -53,8 +53,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(insert_into(t).set(assignments...));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -69,8 +68,7 @@ namespace
print_type_on_error<CheckResult>(ExpectedCheckResult{});
using ReturnType = decltype(dynamic_insert_into(db, t).dynamic_set(assignments...));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
static_assert(ExpectedReturnType::value, "Unexpected return type");
print_type_on_error<ReturnType>(ExpectedReturnType{});
}
@ -162,7 +160,7 @@ namespace
print_type_on_error<CheckResult>(ExpectedCheckResult{});
using ReturnType = decltype(insert_into(t).dynamic_set());
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_insert_dynamic_set_statement_dynamic_t>;
static_assert(ExpectedReturnType::value, "Unexpected return type");
print_type_on_error<ReturnType>(ExpectedReturnType{});
}

36
test_static_asserts/join.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -62,12 +62,9 @@ namespace
(Assert::value and sqlpp::is_pre_join_t<JoinType>::value and sqlpp::is_pre_join_t<InnerJoinType>::value and
sqlpp::is_pre_join_t<LeftOuterJoinType>::value and sqlpp::is_pre_join_t<RightOuterJoinType>::value and
sqlpp::is_pre_join_t<OuterJoinType>::value and sqlpp::is_join_t<CrossJoinType>::value) xor
(std::is_same<JoinType, sqlpp::bad_statement>::value and
std::is_same<InnerJoinType, sqlpp::bad_statement>::value and
std::is_same<LeftOuterJoinType, sqlpp::bad_statement>::value and
std::is_same<RightOuterJoinType, sqlpp::bad_statement>::value and
std::is_same<OuterJoinType, sqlpp::bad_statement>::value and
std::is_same<CrossJoinType, sqlpp::bad_statement>::value)>;
(std::is_same<JoinType, Assert>::value and std::is_same<InnerJoinType, Assert>::value and
std::is_same<LeftOuterJoinType, Assert>::value and std::is_same<RightOuterJoinType, Assert>::value and
std::is_same<OuterJoinType, Assert>::value and std::is_same<CrossJoinType, Assert>::value)>;
print_type_on_error<JoinType>(ExpectedReturnType{});
print_type_on_error<InnerJoinType>(ExpectedReturnType{});
print_type_on_error<LeftOuterJoinType>(ExpectedReturnType{});
@ -87,7 +84,7 @@ namespace
using ResultType = decltype(lhs.on(rhs));
using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_join_t<ResultType>::value) xor
std::is_same<ResultType, sqlpp::bad_statement>::value>;
std::is_same<ResultType, Assert>::value>;
print_type_on_error<ResultType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -190,18 +187,15 @@ namespace
using RightOuterJoinType = decltype(sqlpp::dynamic_right_outer_join(table));
using OuterJoinType = decltype(sqlpp::dynamic_outer_join(table));
using CrossJoinType = decltype(sqlpp::dynamic_cross_join(table));
using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_dynamic_pre_join_t<JoinType>::value and
sqlpp::is_dynamic_pre_join_t<InnerJoinType>::value and
sqlpp::is_dynamic_pre_join_t<LeftOuterJoinType>::value and
sqlpp::is_dynamic_pre_join_t<RightOuterJoinType>::value and
sqlpp::is_dynamic_pre_join_t<OuterJoinType>::value and
sqlpp::is_dynamic_join_t<CrossJoinType>::value) xor
(std::is_same<JoinType, sqlpp::bad_statement>::value and
std::is_same<InnerJoinType, sqlpp::bad_statement>::value and
std::is_same<LeftOuterJoinType, sqlpp::bad_statement>::value and
std::is_same<RightOuterJoinType, sqlpp::bad_statement>::value and
std::is_same<OuterJoinType, sqlpp::bad_statement>::value and
std::is_same<CrossJoinType, sqlpp::bad_statement>::value)>;
using ExpectedReturnType = sqlpp::logic::all_t<
(Assert::value and sqlpp::is_dynamic_pre_join_t<JoinType>::value and
sqlpp::is_dynamic_pre_join_t<InnerJoinType>::value and
sqlpp::is_dynamic_pre_join_t<LeftOuterJoinType>::value and
sqlpp::is_dynamic_pre_join_t<RightOuterJoinType>::value and
sqlpp::is_dynamic_pre_join_t<OuterJoinType>::value and sqlpp::is_dynamic_join_t<CrossJoinType>::value) xor
(std::is_same<JoinType, Assert>::value and std::is_same<InnerJoinType, Assert>::value and
std::is_same<LeftOuterJoinType, Assert>::value and std::is_same<RightOuterJoinType, Assert>::value and
std::is_same<OuterJoinType, Assert>::value and std::is_same<CrossJoinType, Assert>::value)>;
print_type_on_error<JoinType>(ExpectedReturnType{});
print_type_on_error<InnerJoinType>(ExpectedReturnType{});
print_type_on_error<LeftOuterJoinType>(ExpectedReturnType{});
@ -221,7 +215,7 @@ namespace
using ResultType = decltype(lhs.on(rhs));
using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_dynamic_join_t<ResultType>::value) xor
std::is_same<ResultType, sqlpp::bad_statement>::value>;
std::is_same<ResultType, Assert>::value>;
print_type_on_error<ResultType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

7
test_static_asserts/unwrapped_bool.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -82,8 +82,7 @@ namespace
void where_check(const Condition& condition)
{
using ReturnType = decltype(sqlpp::where(condition));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -104,7 +103,7 @@ namespace
void where()
{
where_check<sqlpp::consistent_t>(t.gamma);
where_check<sqlpp::bad_statement>(true);
where_check<sqlpp::assert_where_not_cpp_bool_t>(true);
}
}

10
test_static_asserts/update_list.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -53,8 +53,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(update(t).set(expressions...));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -69,8 +68,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(dynamic_update(db, t).dynamic_set(expressions...));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -127,7 +125,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(update(t).dynamic_set());
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_update_dynamic_set_statement_dynamic_t>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

10
test_static_asserts/where.cpp
View File

@ -23,9 +23,9 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "MockDb.h"
#include "Sample.h"
#include <iostream>
#include <sqlpp11/sqlpp11.h>
namespace
@ -52,8 +52,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(remove_from(t).where(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -68,8 +67,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(dynamic_remove_from(db, t).dynamic_where(expression));
using ExpectedReturnType =
sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}
@ -140,7 +138,7 @@ namespace
static_assert(ExpectedCheckResult::value, "Unexpected check result");
using ReturnType = decltype(remove_from(t).dynamic_where());
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_where_dynamic_statement_dynamic_t>;
print_type_on_error<ReturnType>(ExpectedReturnType{});
static_assert(ExpectedReturnType::value, "Unexpected return type");
}

2
tests/CMakeLists.txt
View File

@ -1,4 +1,4 @@
# 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,

6
tests/Insert.cpp
View File

@ -23,12 +23,12 @@
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Sample.h"
#include "MockDb.h"
#include "Sample.h"
#include "is_regular.h"
#include <sqlpp11/insert.h>
#include <sqlpp11/functions.h>
#include <iostream>
#include <sqlpp11/functions.h>
#include <sqlpp11/insert.h>
int Insert(int, char* [])
{

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;