mirror/sqlpp11
1
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2026-02-18 04:08:47 -06:00
Code Issues Packages Projects Releases Wiki Activity

fixed build for msvs 2015 update 1

Browse Source
This commit is contained in:
sliser
2015-12-15 18:20:33 +03:00
parent 833eeccd61
commit a6f506b57f
28 changed files with 366 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
include/sqlpp11/basic_expression_operators.h
View File

@@ -124,11 +124,14 @@ namespace sqlpp
wrap_operand_t<T>>;
template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T>
using _new_nary_expression_t =
struct _new_nary_expression
{
using type =
new_nary_expression_t<logic::all_t<check_rhs_comparison_operand_t<ValueType, wrap_operand_t<T>>::value...>,
NewExpr,
Expr,
wrap_operand_t<T>...>;
};
template <typename T>
_new_binary_expression_t<equal_to_t, T> operator==(T t) const
@@ -206,17 +209,17 @@ namespace sqlpp
// Hint: use value_list wrapper for containers...
template <typename... T>
_new_nary_expression_t<in_t, T...> in(T... t) const
typename _new_nary_expression<in_t, T...>::type in(T... t) const
{
check_rhs_in_arguments_t<ValueType, wrap_operand_t<T>...>::_();
return {*static_cast<const Expr*>(this), wrap_operand_t<T>{t}...};
return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
}
template <typename... T>
_new_nary_expression_t<not_in_t, T...> not_in(T... t) const
typename _new_nary_expression<not_in_t, T...>::type not_in(T... t) const
{
check_rhs_in_arguments_t<ValueType, wrap_operand_t<T>...>::_();
return {*static_cast<const Expr*>(this), wrap_operand_t<T>{t}...};
return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
}
template <typename Defer = void>

6
include/sqlpp11/column.h
View File

@@ -104,11 +104,11 @@ namespace sqlpp
}
};
template <typename Context, typename... Args>
struct serializer_t<Context, column_t<Args...>>
template <typename Context, typename Args1, typename Args2>
struct serializer_t<Context, column_t<Args1, Args2>>
{
using _serialize_check = consistent_t;
using T = column_t<Args...>;
using T = column_t<Args1, Args2>;
static Context& _(const T&, Context& context)
{

10
include/sqlpp11/cte.h
View File

@@ -123,9 +123,15 @@ namespace sqlpp
template <typename AliasProvider, typename Statement>
using make_cte_t = typename make_cte_impl<AliasProvider, Statement, get_result_row_t<Statement>>::type;
template <typename AliasProvider, typename FieldSpec>
struct cte_base
{
using type = member_t<cte_column_spec_t<FieldSpec>, column_t<AliasProvider, cte_column_spec_t<FieldSpec>>>;
};
template <typename AliasProvider, typename Statement, typename... FieldSpecs>
struct cte_t
: public member_t<cte_column_spec_t<FieldSpecs>, column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>>...
: public cte_base<AliasProvider, FieldSpecs>::type...
{
using _traits = make_traits<no_value_t, tag::is_cte, tag::is_table>; // FIXME: is table? really?
using _nodes = detail::type_vector<>;
@@ -138,7 +144,7 @@ namespace sqlpp
using _column_tuple_t = std::tuple<column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>...>;
template <typename... T>
using _check = logic::all_t<is_statement_t<T>::value...>;
struct _check : logic::all_t<is_statement_t<T>::value...>{};
using _result_row_t = result_row_t<void, FieldSpecs...>;

2
include/sqlpp11/data_types/text/like.h
View File

@@ -45,7 +45,7 @@ namespace sqlpp
struct _alias_t
{
static constexpr const char _literal[] = "like_";
static constexpr const char _literal[6] = "like_";
using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
template <typename T>
struct _member_t

15
include/sqlpp11/detail/type_set.h
View File

@@ -246,6 +246,21 @@ namespace sqlpp
template <template <typename> class Transformation, typename T>
using transform_set_t = typename transform_set<Transformation, T>::type;
template <typename T>
struct make_name_of_set
{
static_assert(wrong_t<make_name_of_set>::value, "invalid argument for transform_set");
};
template <typename... E>
struct make_name_of_set<type_set<E...>>
{
using type = make_type_set_t<typename E::_alias_t::_name_t...>;
};
template <typename T>
using make_name_of_set_t = typename make_name_of_set<T>::type;
}
}

6
include/sqlpp11/expression_fwd.h
View File

@@ -236,9 +236,15 @@ namespace sqlpp
};
}
template <typename Expr>
using lhs = detail::lhs_impl<Expr>;
template <typename Expr>
using lhs_t = typename detail::lhs_impl<Expr>::type;
template <typename Expr>
using rhs = detail::rhs_impl<Expr>;
template <typename Expr>
using rhs_t = typename detail::rhs_impl<Expr>::type;
}

22
include/sqlpp11/extra_tables.h
View File

@@ -63,7 +63,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -72,7 +75,10 @@ namespace sqlpp
{
using _data_t = extra_tables_data_t<Tables...>;
_impl_t<Policies> extra_tables;
template<typename ...Args>
_base_t(Args&& ...args) : extra_tables{std::forward<Args>(args)...} {}
_impl_t<Policies> extra_tables;
_impl_t<Policies>& operator()()
{
return extra_tables;
@@ -105,7 +111,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -114,6 +123,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_extra_tables{std::forward<Args>(args)...} {}
_impl_t<Policies> no_extra_tables;
_impl_t<Policies>& operator()()
{
@@ -134,7 +146,7 @@ namespace sqlpp
using _new_statement_t = new_statement_t<Check::value, Policies, no_extra_tables_t, T>;
template <typename... T>
using _check = logic::all_t<is_table_t<T>::value...>;
struct _check : logic::all_t<is_table_t<T>::value...>{};
using _consistency_check = consistent_t;
@@ -159,7 +171,7 @@ namespace sqlpp
static constexpr std::size_t _number_of_tables = detail::sum(provided_tables_of<Tables>::size::value...);
using _unique_tables = detail::make_joined_set_t<provided_tables_of<Tables>...>;
using _unique_table_names = detail::transform_set_t<name_of, _unique_tables>;
using _unique_table_names = detail::make_name_of_set_t<_unique_tables>;
static_assert(_number_of_tables == _unique_tables::size::value,
"at least one duplicate table detected in extra_tables()");
static_assert(_number_of_tables == _unique_table_names::size::value,

22
include/sqlpp11/from.h
View File

@@ -71,14 +71,17 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Table>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Table>
void add(Table table)
{
static_assert(_is_dynamic::value, "from::add() must not be called for static from()");
static_assert(is_table_t<Table>::value, "invalid table argument in from::add()");
using _known_tables =
detail::make_joined_set_t<provided_tables_of<Tables>...>; // Hint: Joins contain more than one table
using _known_table_names = detail::transform_set_t<name_of, _known_tables>;
using _known_table_names = detail::make_name_of_set_t<_known_tables>;
static_assert(not detail::is_element_of<typename Table::_alias_t, _known_table_names>::value,
"Must not use the same table name twice in from()");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Table>;
@@ -109,6 +112,9 @@ namespace sqlpp
{
using _data_t = from_data_t<Database, Tables...>;
template<typename ...Args>
_base_t(Args&& ...args) : from{std::forward<Args>(args)...} {}
_impl_t<Policies> from;
_impl_t<Policies>& operator()()
{
@@ -142,7 +148,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -151,6 +160,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_from{std::forward<Args>(args)...} {}
_impl_t<Policies> no_from;
_impl_t<Policies>& operator()()
{
@@ -170,7 +182,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_table_t<T>::value...>;
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_from_t, T>;
@@ -208,7 +220,7 @@ namespace sqlpp
static constexpr std::size_t _number_of_tables = detail::sum(provided_tables_of<Tables>::size::value...);
using _unique_tables = detail::make_joined_set_t<provided_tables_of<Tables>...>;
using _unique_table_names = detail::transform_set_t<name_of, _unique_tables>;
using _unique_table_names = detail::make_name_of_set_t<_unique_tables>;
static_assert(_number_of_tables == _unique_tables::size::value,
"at least one duplicate table detected in from()");
static_assert(_number_of_tables == _unique_table_names::size::value,

18
include/sqlpp11/group_by.h
View File

@@ -86,7 +86,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Expression>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Expression>
void add_ntc(Expression expression)
{
add<Expression, std::false_type>(expression);
@@ -127,6 +130,9 @@ namespace sqlpp
{
using _data_t = group_by_data_t<Database, Expressions...>;
template<typename ...Args>
_base_t(Args&& ...args) : group_by{std::forward<Args>(args)...} {}
_impl_t<Policies> group_by;
_impl_t<Policies>& operator()()
{
@@ -162,7 +168,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -171,6 +180,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_group_by{std::forward<Args>(args)...} {}
_impl_t<Policies> no_group_by;
_impl_t<Policies>& operator()()
{
@@ -190,7 +202,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_expression_t<T>::value...>;
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>;

18
include/sqlpp11/having.h
View File

@@ -82,7 +82,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Expression>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Expression>
void add_ntc(Expression expression)
{
add<Expression, std::false_type>(expression);
@@ -123,6 +126,9 @@ namespace sqlpp
{
using _data_t = having_data_t<Database, Expressions...>;
template<typename ...Args>
_base_t(Args&& ...args) : having{std::forward<Args>(args)...} {}
_impl_t<Policies> having;
_impl_t<Policies>& operator()()
{
@@ -158,7 +164,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -167,6 +176,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_having{std::forward<Args>(args)...} {}
_impl_t<Policies> no_having;
_impl_t<Policies>& operator()()
{
@@ -186,7 +198,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_expression_t<T>::value...>;
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_having_t, T>;

64
include/sqlpp11/insert_value_list.h
View File

@@ -78,7 +78,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -87,7 +90,10 @@ namespace sqlpp
{
using _data_t = insert_default_values_data_t;
_impl_t<Policies> default_values;
template<typename ...Args>
_base_t(Args&& ...args) : default_values{std::forward<Args>(args)...} {}
_impl_t<Policies> default_values;
_impl_t<Policies>& operator()()
{
return default_values;
@@ -142,27 +148,33 @@ namespace sqlpp
SQLPP_PORTABLE_STATIC_ASSERT(assert_insert_dynamic_set_statement_dynamic_t,
"dynamic_set must not be called in a static statement");
template <typename Expr>
struct must_not_insert
{
static const bool value = must_not_insert_t<lhs_t<Expr>>::value;
};
template <typename... Assignments>
using check_insert_set_t = static_combined_check_t<
static_check_t<logic::all_t<is_assignment_t<Assignments>::value...>::value, assert_insert_set_assignments_t>,
static_check_t<not detail::has_duplicates<lhs_t<Assignments>...>::value, assert_insert_set_no_duplicates_t>,
static_check_t<logic::none_t<must_not_insert_t<lhs_t<Assignments>>::value...>::value,
static_check_t<logic::all_t<detail::is_assignment_impl<Assignments>::type::value...>::value, assert_insert_set_assignments_t>,
static_check_t<not detail::has_duplicates<typename lhs<Assignments>::type...>::value, assert_insert_set_no_duplicates_t>,
static_check_t<logic::none_t<must_not_insert<Assignments>::value...>::value,
assert_insert_set_prohibited_t>,
static_check_t<sizeof...(Assignments) == 0 or
detail::make_joined_set_t<required_tables_of<lhs_t<Assignments>>...>::size::value == 1,
detail::make_joined_set_t<required_tables_of<typename lhs<Assignments>::type>...>::size::value == 1,
assert_insert_set_one_table_t>>;
template <typename... Assignments>
using check_insert_static_set_t =
struct check_insert_static_set_t :
static_combined_check_t<check_insert_set_t<Assignments...>,
static_check_t<sizeof...(Assignments) != 0, assert_insert_static_set_count_args_t>,
static_check_t<detail::have_all_required_columns<lhs_t<Assignments>...>::value,
assert_insert_static_set_all_required_t>>;
static_check_t<detail::have_all_required_columns<typename lhs<Assignments>::type...>::value,
assert_insert_static_set_all_required_t>>{};
template <typename Database, typename... Assignments>
using check_insert_dynamic_set_t = static_combined_check_t<
struct check_insert_dynamic_set_t : static_combined_check_t<
static_check_t<not std::is_same<Database, void>::value, assert_insert_dynamic_set_statement_dynamic_t>,
check_insert_set_t<Assignments...>>;
check_insert_set_t<Assignments...>>{};
SQLPP_PORTABLE_STATIC_ASSERT(
assert_no_unknown_tables_in_insert_assignments_t,
@@ -188,7 +200,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Assignment>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Assignment>
void add_ntc(Assignment assignment)
{
add<Assignment, std::false_type>(assignment);
@@ -234,6 +249,9 @@ namespace sqlpp
{
using _data_t = insert_list_data_t<Database, Assignments...>;
template<typename ...Args>
_base_t(Args&& ...args) : insert_list{std::forward<Args>(args)...} {}
_impl_t<Policies> insert_list;
_impl_t<Policies>& operator()()
{
@@ -259,7 +277,7 @@ namespace sqlpp
template <typename... Columns>
struct column_list_data_t
{
column_list_data_t(Columns... cols) : _columns(simple_column_t<Columns>{cols}...)
column_list_data_t(Columns... cols) : _columns(simple_column_t<Columns>(cols)...)
{
}
@@ -301,7 +319,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename... Assignments>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename... Assignments>
void add(Assignments... assignments)
{
static_assert(logic::all_t<is_assignment_t<Assignments>::value...>::value,
@@ -335,6 +356,9 @@ namespace sqlpp
{
using _data_t = column_list_data_t<Columns...>;
template<typename ...Args>
_base_t(Args&& ...args) : values{std::forward<Args>(args)...} {}
_impl_t<Policies> values;
_impl_t<Policies>& operator()()
{
@@ -381,7 +405,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -390,6 +417,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_insert_values{std::forward<Args>(args)...} {}
_impl_t<Policies> no_insert_values;
_impl_t<Policies>& operator()()
{
@@ -409,7 +439,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _column_check = logic::all_t<is_column_t<T>::value...>;
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>;
@@ -430,7 +460,7 @@ namespace sqlpp
return _columns_impl(_column_check<Columns...>{}, cols...);
}
template <typename... Assignments>
auto set(Assignments... assignments) const
-> _new_statement_t<check_insert_static_set_t<Assignments...>, insert_list_t<void, Assignments...>>

8
include/sqlpp11/into.h
View File

@@ -71,7 +71,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -80,6 +83,9 @@ namespace sqlpp
{
using _data_t = into_data_t<Database, Table>;
template<typename ...Args>
_base_t(Args&& ...args) : into{std::forward<Args>(args)...} {}
_impl_t<Policies> into;
_impl_t<Policies>& operator()()
{

26
include/sqlpp11/limit.h
View File

@@ -64,7 +64,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -73,6 +76,9 @@ namespace sqlpp
{
using _data_t = limit_data_t<Limit>;
template<typename ...Args>
_base_t(Args&& ...args) : limit{std::forward<Args>(args)...} {}
_impl_t<Policies> limit;
_impl_t<Policies>& operator()()
{
@@ -131,7 +137,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Limit>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Limit>
void set(Limit value)
{
// FIXME: Make sure that Limit does not require external tables? Need to read up on SQL
@@ -151,7 +160,10 @@ namespace sqlpp
{
using _data_t = dynamic_limit_data_t<Database>;
_impl_t<Policies> limit;
template<typename ...Args>
_base_t(Args&& ...args) : limit{std::forward<Args>(args)...} {}
_impl_t<Policies> limit;
_impl_t<Policies>& operator()()
{
return limit;
@@ -183,7 +195,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -192,6 +207,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_limit{std::forward<Args>(args)...} {}
_impl_t<Policies> no_limit;
_impl_t<Policies>& operator()()
{

13
include/sqlpp11/logic.h
View File

@@ -38,9 +38,22 @@ namespace sqlpp
struct logic_helper;
// see http://lists.boost.org/Archives/boost/2014/05/212946.php :-)
template <bool... B>
struct all
{
using type = std::is_same<logic_helper<B...>, logic_helper<(B or true)...>>;
};
template <bool... B>
using all_t = std::is_same<logic_helper<B...>, logic_helper<(B or true)...>>;
template <bool... B>
struct any
{
using type =
std::integral_constant<bool, not std::is_same<logic_helper<B...>, logic_helper<(B and false)...>>::value>;
};
template <bool... B>
using any_t =
std::integral_constant<bool, not std::is_same<logic_helper<B...>, logic_helper<(B and false)...>>::value>;

26
include/sqlpp11/offset.h
View File

@@ -66,7 +66,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -75,6 +78,9 @@ namespace sqlpp
{
using _data_t = offset_data_t<Offset>;
template<typename ...Args>
_base_t(Args&& ...args) : offset{std::forward<Args>(args)...} {}
_impl_t<Policies> offset;
_impl_t<Policies>& operator()()
{
@@ -133,7 +139,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Offset>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Offset>
void set(Offset value)
{
// FIXME: Make sure that Offset does not require external tables? Need to read up on SQL
@@ -153,7 +162,10 @@ namespace sqlpp
{
using _data_t = dynamic_offset_data_t<Database>;
_impl_t<Policies> offset;
template<typename ...Args>
_base_t(Args&& ...args) : offset{std::forward<Args>(args)...} {}
_impl_t<Policies> offset;
_impl_t<Policies>& operator()()
{
return offset;
@@ -197,7 +209,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -206,6 +221,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_offset{std::forward<Args>(args)...} {}
_impl_t<Policies> no_offset;
_impl_t<Policies>& operator()()
{

18
include/sqlpp11/order_by.h
View File

@@ -83,7 +83,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Expression>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Expression>
void add_ntc(Expression expression)
{
add<Expression, std::false_type>(expression);
@@ -124,6 +127,9 @@ namespace sqlpp
{
using _data_t = order_by_data_t<Database, Expressions...>;
template<typename ...Args>
_base_t(Args&& ...args) : order_by{std::forward<Args>(args)...} {}
_impl_t<Policies> order_by;
_impl_t<Policies>& operator()()
{
@@ -159,7 +165,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -168,6 +177,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_order_by{std::forward<Args>(args)...} {}
_impl_t<Policies> no_order_by;
_impl_t<Policies>& operator()()
{
@@ -187,7 +199,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_sort_order_t<T>::value...>;
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>;

20
include/sqlpp11/select_column_list.h
View File

@@ -201,7 +201,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename NamedExpression>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename NamedExpression>
void add_ntc(NamedExpression namedExpression)
{
add<NamedExpression, std::false_type>(namedExpression);
@@ -248,6 +251,9 @@ namespace sqlpp
{
using _data_t = select_column_list_data_t<Database, Columns...>;
template<typename ...Args>
_base_t(Args&& ...args) : selected_columns{std::forward<Args>(args)...} {}
_impl_t<Policies> selected_columns;
_impl_t<Policies>& operator()()
{
@@ -397,7 +403,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -406,7 +415,10 @@ namespace sqlpp
{
using _data_t = no_data_t;
_impl_t<Policies> no_selected_columns;
template<typename ...Args>
_base_t(Args&& ...args) : no_selected_columns{std::forward<Args>(args)...} {}
_impl_t<Policies> no_selected_columns;
_impl_t<Policies>& operator()()
{
return no_selected_columns;
@@ -425,7 +437,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>;
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...>

20
include/sqlpp11/select_flag_list.h
View File

@@ -71,7 +71,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Flag>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Flag>
void add_ntc(Flag flag)
{
add<Flag, std::false_type>(flag);
@@ -112,6 +115,9 @@ namespace sqlpp
{
using _data_t = select_flag_list_data_t<Database, Flags...>;
template<typename ...Args>
_base_t(Args&& ...args) : select_flags{std::forward<Args>(args)...} {}
_impl_t<Policies> select_flags;
_impl_t<Policies>& operator()()
{
@@ -144,7 +150,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -153,6 +162,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_select_flags{std::forward<Args>(args)...} {}
_impl_t<Policies> no_select_flags;
_impl_t<Policies>& operator()()
{
@@ -170,9 +182,9 @@ namespace sqlpp
}
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_select_flag_t<T>::value...>;
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>;

3
include/sqlpp11/simple_column.h
View File

@@ -38,6 +38,9 @@ namespace sqlpp
using _column_t = Column;
_column_t _column;
simple_column_t() = default;
simple_column_t(const _column_t &column) : _column{column} {}
using _traits = make_traits<no_value_t, tag::is_noop>;
using _nodes = detail::type_vector<>;
};

8
include/sqlpp11/single_table.h
View File

@@ -73,7 +73,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -82,6 +85,9 @@ namespace sqlpp
{
using _data_t = single_table_data_t<Database, Table>;
template<typename ...Args>
_base_t(Args&& ...args) : from{std::forward<Args>(args)...} {}
_impl_t<Policies> from;
_impl_t<Policies>& operator()()
{

14
include/sqlpp11/statement.h
View File

@@ -113,7 +113,7 @@ namespace sqlpp
template <typename... Expressions>
using _no_unknown_aggregates =
logic::any_t<_all_provided_aggregates::size::value == 0,
logic::all_t<is_aggregate_expression_t<_all_provided_aggregates, Expressions>::value...>::value>;
logic::all_t<detail::is_aggregate_expression_impl<_all_provided_aggregates, Expressions>::type::value...>::value>;
template <template <typename> class Predicate>
using any_t = logic::any_t<Predicate<Policies>::value...>;
@@ -221,8 +221,8 @@ namespace sqlpp
template <typename Statement, typename Term>
statement_t(Statement statement, Term term)
: Policies::template _base_t<_policies_t>{typename Policies::template _impl_t<_policies_t>{
detail::pick_arg<typename Policies::template _base_t<_policies_t>>(statement, term)}}...
: Policies::template _base_t<_policies_t>(typename Policies::template _impl_t<_policies_t>(
detail::pick_arg<typename Policies::template _base_t<_policies_t>>(statement, term)))...
{
}
@@ -291,7 +291,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{ data } {}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -300,6 +303,9 @@ namespace sqlpp
{
using _data_t = NameData;
template<typename ...Args>
_base_t(Args&& ...args) : statement_name{std::forward<Args>(args)...} {}
_impl_t<Policies> statement_name;
_impl_t<Policies>& operator()()
{

2
include/sqlpp11/table.h
View File

@@ -42,7 +42,7 @@ namespace sqlpp
};
template <typename Table, typename... ColumnSpec>
struct table_t : public table_base_t, public member_t<ColumnSpec, column_t<Table, ColumnSpec>>...
struct table_t : public table_base_t, public ColumnSpec::_alias_t::template _member_t<column_t<Table, ColumnSpec>>...
{
using _traits = make_traits<no_value_t, tag::is_raw_table, tag::is_table>;

2
include/sqlpp11/table_alias.h
View File

@@ -36,7 +36,7 @@
namespace sqlpp
{
template <typename AliasProvider, typename Table, typename... ColumnSpec>
struct table_alias_t : public member_t<ColumnSpec, column_t<AliasProvider, ColumnSpec>>...
struct table_alias_t : public ColumnSpec::_alias_t::template _member_t<column_t<AliasProvider, ColumnSpec>>...
{
// FIXME: Need to add join functionality
using _traits = make_traits<value_type_of<Table>,

19
include/sqlpp11/union.h
View File

@@ -78,8 +78,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
public:
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -88,6 +90,9 @@ namespace sqlpp
{
using _data_t = union_data_t<Database, Flag, Lhs, Rhs>;
template<typename ...Args>
_base_t(Args&& ...args) : union_{std::forward<Args>(args)...} {}
_impl_t<Policies> union_;
_impl_t<Policies>& operator()()
{
@@ -137,7 +142,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{ data } {}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -146,6 +154,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_union{std::forward<Args>(args)...} {}
_impl_t<Policies> no_union;
_impl_t<Policies>& operator()()
{
@@ -165,7 +176,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_statement_t<T>::value...>;
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>;

18
include/sqlpp11/update_list.h
View File

@@ -79,7 +79,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Assignment>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Assignment>
void add_ntc(Assignment assignment)
{
add<Assignment, std::false_type>(assignment);
@@ -124,6 +127,9 @@ namespace sqlpp
{
using _data_t = update_list_data_t<Database, Assignments...>;
template<typename ...Args>
_base_t(Args&& ...args) : assignments{std::forward<Args>(args)...} {}
_impl_t<Policies> assignments;
_impl_t<Policies>& operator()()
{
@@ -169,7 +175,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -178,6 +187,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_assignments{std::forward<Args>(args)...} {}
_impl_t<Policies> no_assignments;
_impl_t<Policies>& operator()()
{
@@ -197,7 +209,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_assignment_t<T>::value...>;
struct _check : public logic::all_t<is_assignment_t<T>::value...> {};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_update_list_t, T>;

18
include/sqlpp11/using.h
View File

@@ -69,7 +69,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Table>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
template <typename Table>
void add(Table table)
{
static_assert(_is_dynamic::value, "add must not be called for static using()");
@@ -102,6 +105,9 @@ namespace sqlpp
{
using _data_t = using_data_t<Database, Tables...>;
template<typename ...Args>
_base_t(Args&& ...args) : using_{std::forward<Args>(args)...} {}
_impl_t<Policies> using_;
_impl_t<Policies>& operator()()
{
@@ -136,7 +142,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -145,6 +154,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_using{std::forward<Args>(args)...} {}
_impl_t<Policies> no_using;
_impl_t<Policies>& operator()()
{
@@ -164,7 +176,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_table_t<T>::value...>;
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>;

26
include/sqlpp11/where.h
View File

@@ -84,7 +84,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
template <typename Expression>
_impl_t() = default;
_impl_t(const _data_t &data) : _data{ data } {}
template <typename Expression>
void add_ntc(Expression expression)
{
add<Expression, std::false_type>(expression);
@@ -125,6 +128,9 @@ namespace sqlpp
{
using _data_t = where_data_t<Database, Expressions...>;
template<typename ...Args>
_base_t(Args&& ...args) : where{std::forward<Args>(args)...} {}
_impl_t<Policies> where;
_impl_t<Policies>& operator()()
{
@@ -167,7 +173,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -176,6 +185,9 @@ namespace sqlpp
{
using _data_t = where_data_t<void, bool>;
template<typename ...Args>
_base_t(Args&& ...args) : where{std::forward<Args>(args)...} {}
_impl_t<Policies> where;
_impl_t<Policies>& operator()()
{
@@ -221,7 +233,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -230,6 +245,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_where{std::forward<Args>(args)...} {}
_impl_t<Policies> no_where;
_impl_t<Policies>& operator()()
{
@@ -249,7 +267,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename... T>
using _check = logic::all_t<is_expression_t<T>::value...>;
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_where_t, T>;

17
include/sqlpp11/with.h
View File

@@ -79,8 +79,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
public:
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -89,6 +91,9 @@ namespace sqlpp
{
using _data_t = with_data_t<Database, Expressions...>;
template<typename ...Args>
_base_t(Args&& ...args) : with{std::forward<Args>(args)...} {}
_impl_t<Policies> with;
_impl_t<Policies>& operator()()
{
@@ -122,7 +127,10 @@ namespace sqlpp
template <typename Policies>
struct _impl_t
{
_data_t _data;
_impl_t() = default;
_impl_t(const _data_t &data) : _data{data}{}
_data_t _data;
};
// Base template to be inherited by the statement
@@ -131,6 +139,9 @@ namespace sqlpp
{
using _data_t = no_data_t;
template<typename ...Args>
_base_t(Args&& ...args) : no_with{std::forward<Args>(args)...} {}
_impl_t<Policies> no_with;
_impl_t<Policies>& operator()()
{