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 'feature/recursive_traits' into develop

Browse Source
This commit is contained in:
rbock 2015-02-24 09:04:10 +01:00
commit f1dc56a822
73 changed files with 328 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/sqlpp11/alias.h
View File

@ -36,7 +36,7 @@ namespace sqlpp
struct expression_alias_t
{
using _traits = make_traits<value_type_of<Expression>, tag::is_selectable, tag::is_alias>;
using _recursive_traits = make_recursive_traits<Expression>;
using _nodes = detail::type_vector<Expression>;
static_assert(is_expression_t<Expression>::value, "invalid argument for an expression alias");
static_assert(not is_alias_t<Expression>::value, "cannot create an alias of an alias");

2
include/sqlpp11/any.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct any_t
{
using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
using _recursive_traits = make_recursive_traits<Select>;
using _nodes = detail::type_vector<Select>;
struct _alias_t
{

2
include/sqlpp11/assignment.h
View File

@ -41,7 +41,7 @@ namespace sqlpp
struct assignment_t
{
using _traits = make_traits<no_value_t, tag::is_assignment>;
using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
using _nodes = detail::type_vector<Lhs, Rhs>;
using _lhs_t = Lhs;
using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;

2
include/sqlpp11/avg.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
public alias_operators<avg_t<Flag, Expr>>
{
using _traits = make_traits<floating_point, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "avg() used with flag other than 'distinct'");
static_assert(is_numeric_t<Expr>::value, "avg() requires a value expression as argument");

2
include/sqlpp11/boolean_expression.h
View File

@ -36,7 +36,7 @@ namespace sqlpp
struct boolean_expression_t: public expression_operators<boolean_expression_t<Database>, boolean>
{
using _traits = make_traits<boolean, tag::is_expression>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
template<typename Expr>
boolean_expression_t(Expr expr):

16
include/sqlpp11/column.h
View File

@ -52,19 +52,9 @@ namespace sqlpp
using _tags = detail::make_joined_set_t<detail::type_set<tag::is_column, tag::is_expression, tag::is_selectable>, typename ColumnSpec::_traits::_tags>;
};
struct _recursive_traits
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<Table>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = typename std::conditional<column_spec_can_be_null_t<ColumnSpec>::value,
detail::type_set<tag::can_be_null>,
detail::type_set<>>::type;
};
using _nodes = detail::type_vector<>;
using _required_tables = detail::type_set<Table>;
using _can_be_null = column_spec_can_be_null_t<ColumnSpec>;
using _spec_t = ColumnSpec;
using _table = Table;

2
include/sqlpp11/concat.h
View File

@ -42,7 +42,7 @@ namespace sqlpp
public alias_operators<concat_t<First, Args...>>
{
using _traits = make_traits<value_type_of<First>, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<First, Args...>;
using _nodes = detail::type_vector<First, Args...>;
static_assert(sizeof...(Args) > 0, "concat requires two arguments at least");
static_assert(logic::all_t<is_text_t<First>::value, is_text_t<Args>::value...>::value, "at least one non-text argument detected in concat()");

16
include/sqlpp11/count.h
View File

@ -39,19 +39,9 @@ namespace sqlpp
public alias_operators<count_t<Flag, Expr>>
{
using _traits = make_traits<integral, tag::is_expression, tag::is_selectable>;
struct _recursive_traits
{
using _required_ctes = required_ctes_of<Expr>;
using _provided_ctes = detail::type_set<>;
using _required_tables = required_tables_of<Expr>;
using _provided_tables = provided_tables_of<Expr>;
using _provided_outer_tables = provided_outer_tables_of<Expr>;
using _extra_tables = extra_tables_of<Expr>;
using _parameters = parameters_of<Expr>;
using _tags = detail::make_difference_set_t<detail::joined_set_t<recursive_tags_of<Expr>, recursive_tags_of<aggregate_function>>,
detail::type_set<tag::can_be_null>>;
};
using _nodes = detail::type_vector<Expr, aggregate_function>;
using _can_be_null = std::false_type;
static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "count() used with flag other than 'distinct'");
@ -108,6 +98,7 @@ namespace sqlpp
template<typename T>
auto count(T t) -> count_t<noop, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "count() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
return { t };
}
@ -115,6 +106,7 @@ namespace sqlpp
template<typename T>
auto count(const distinct_t&, T t) -> count_t<distinct_t, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "count() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
return { t };
}

43
include/sqlpp11/cte.h
View File

@ -43,17 +43,9 @@ namespace sqlpp
template<typename Flag, typename Lhs, typename Rhs>
struct cte_union_t
{
struct _recursive_traits
{
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = detail::make_parameter_tuple_t<parameters_of<Lhs>, parameters_of<Rhs>>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
using _parameters = detail::type_vector_cat_t<parameters_of<Lhs>, parameters_of<Rhs>>;
cte_union_t(Lhs lhs, Rhs rhs):
_lhs(lhs),
@ -140,17 +132,10 @@ namespace sqlpp
struct cte_t: public member_t<cte_column_spec_t<FieldSpecs>, column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>>...
{
using _traits = make_traits<no_value_t, tag::is_cte, tag::is_table>; // FIXME: is table? really?
struct _recursive_traits
{
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Statement>, detail::type_set<AliasProvider>>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = parameters_of<Statement>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Statement>, detail::type_set<AliasProvider>>;
using _parameters = parameters_of<Statement>;
using _alias_t = typename AliasProvider::_alias_t;
constexpr static bool _is_recursive = detail::is_element_of<AliasProvider, required_ctes_of<Statement>>::value;
@ -235,17 +220,9 @@ namespace sqlpp
struct cte_ref_t
{
using _traits = make_traits<no_value_t, tag::is_alias, tag::is_cte, tag::is_table>; // FIXME: is table? really?
struct _recursive_traits
{
using _required_ctes = detail::make_type_set_t<AliasProvider>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<AliasProvider>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _required_ctes = detail::make_type_set_t<AliasProvider>;
using _provided_tables = detail::type_set<AliasProvider>;
using _alias_t = typename AliasProvider::_alias_t;

4
include/sqlpp11/custom_query.h
View File

@ -54,9 +54,9 @@ namespace sqlpp
{
using _methods_t = typename detail::custom_parts_t<Database, Parts...>::_result_methods_t;
using _traits = make_traits<no_value_t, tag::is_statement>;
using _recursive_traits = make_recursive_traits<Parts...>;
using _nodes = detail::type_vector<Parts...>;
using _parameter_check = typename std::conditional<std::tuple_size<typename _recursive_traits::_parameters>::value == 0,
using _parameter_check = typename std::conditional<detail::type_vector_size<parameters_of<custom_query_t>>::value == 0,
consistent_t, assert_no_parameters_t>::type;
using _run_check = detail::get_first_if<is_inconsistent_t, consistent_t,
_parameter_check>;

2
include/sqlpp11/default_value.h
View File

@ -34,7 +34,7 @@ namespace sqlpp
struct default_value_t
{
using _traits = make_traits<no_value_t, tag::is_expression>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
static constexpr bool _is_trivial() { return false; }
};

88
include/sqlpp11/detail/type_vector.h Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SQLPP_DETAIL_TYPE_VECTOR_H
#define SQLPP_DETAIL_TYPE_VECTOR_H
#include <sqlpp11/wrong.h>
namespace sqlpp
{
namespace detail
{
template<typename... T>
struct type_vector
{};
template<typename...T>
struct type_vector_cat_impl
{
static_assert(wrong_t<type_vector_cat_impl>::value, "type_vector_cat must be called with type_vector arguments");
};
template<>
struct type_vector_cat_impl<>
{
using type = type_vector<>;
};
template<typename... T>
struct type_vector_cat_impl<type_vector<T...>>
{
using type = type_vector<T...>;
};
template<typename... L, typename... R>
struct type_vector_cat_impl<type_vector<L...>, type_vector<R...>>
{
using type = type_vector<L..., R...>;
};
template<typename... L, typename... Rest>
struct type_vector_cat_impl<type_vector<L...>, Rest...>
{
using type = typename type_vector_cat_impl<type_vector<L...>, typename type_vector_cat_impl<Rest...>::type>::type;
};
template<typename... T>
using type_vector_cat_t = typename type_vector_cat_impl<T...>::type;
template<typename T>
struct type_vector_size
{
static_assert(wrong_t<type_vector_size>::value, "type_vector_size needs to be called with a type_vector argument");
};
template<typename... T>
struct type_vector_size<type_vector<T...>>
{
static constexpr std::size_t value = sizeof...(T);
};
}
}
#endif

2
include/sqlpp11/exists.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
public alias_operators<exists_t<Select>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Select>;
using _nodes = detail::type_vector<Select>;
static_assert(is_select_t<Select>::value, "exists() requires a select expression as argument");

10
include/sqlpp11/expression.h
View File

@ -44,7 +44,7 @@ namespace sqlpp
public alias_operators<binary_expression_t<Lhs, op::equal_to, Rhs>>
{
using _traits = make_traits<boolean, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
using _nodes = detail::type_vector<Lhs, Rhs>;
using _lhs_t = Lhs;
using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;
@ -93,7 +93,7 @@ namespace sqlpp
public alias_operators<binary_expression_t<Lhs, op::not_equal_to, Rhs>>
{
using _traits = make_traits<boolean, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
using _nodes = detail::type_vector<Lhs, Rhs>;
using _lhs_t = Lhs;
using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;
@ -142,7 +142,7 @@ namespace sqlpp
public alias_operators<unary_expression_t<op::logical_not, Rhs>>
{
using _traits = make_traits<boolean, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Rhs>;
using _nodes = detail::type_vector<Rhs>;
unary_expression_t(Rhs rhs):
_rhs(rhs)
@ -188,7 +188,7 @@ namespace sqlpp
public alias_operators<binary_expression_t<Lhs, O, Rhs>>
{
using _traits = make_traits<value_type_of<O>, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
using _nodes = detail::type_vector<Lhs, Rhs>;
binary_expression_t(Lhs lhs, Rhs rhs):
_lhs(lhs),
@ -228,7 +228,7 @@ namespace sqlpp
public alias_operators<unary_expression_t<O, Rhs>>
{
using _traits = make_traits<value_type_of<O>, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Rhs>;
using _nodes = detail::type_vector<Rhs>;
unary_expression_t(Rhs rhs):
_rhs(rhs)

16
include/sqlpp11/extra_tables.h
View File

@ -52,17 +52,9 @@ namespace sqlpp
struct extra_tables_t
{
using _traits = make_traits<no_value_t, tag::is_extra_tables>;
struct _recursive_traits
{
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Tables>...>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _extra_tables = detail::type_set<Tables...>;
using _parameters = std::tuple<>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Tables>...>;
using _extra_tables = detail::type_set<Tables...>;
// Data
using _data_t = extra_tables_data_t<Tables...>;
@ -98,7 +90,7 @@ namespace sqlpp
struct no_extra_tables_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/field_spec.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
tag_if<tag::can_be_null, CanBeNull>,
tag_if<tag::null_is_trivial_value, NullIsTrivialValue>
>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _alias_t = NameType;
};

4
include/sqlpp11/from.h
View File

@ -61,7 +61,7 @@ namespace sqlpp
struct from_t
{
using _traits = make_traits<no_value_t, tag::is_from>;
using _recursive_traits = make_recursive_traits<Tables...>;
using _nodes = detail::type_vector<Tables...>;
using _is_dynamic = is_database<Database>;
// Data
@ -125,7 +125,7 @@ namespace sqlpp
struct no_from_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/functions.h
View File

@ -82,7 +82,7 @@ namespace sqlpp
struct value_list_t // to be used in .in() method
{
using _traits = make_traits<value_type_t<typename Container::value_type>, tag::is_expression>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _container_t = Container;

4
include/sqlpp11/group_by.h
View File

@ -71,7 +71,7 @@ namespace sqlpp
struct group_by_t
{
using _traits = make_traits<no_value_t, tag::is_group_by>;
using _recursive_traits = make_recursive_traits<Expressions...>;
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;
@ -141,7 +141,7 @@ namespace sqlpp
struct no_group_by_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

4
include/sqlpp11/having.h
View File

@ -70,7 +70,7 @@ namespace sqlpp
struct having_t
{
using _traits = make_traits<no_value_t, tag::is_having>;
using _recursive_traits = make_recursive_traits<Expressions...>;
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;
@ -141,7 +141,7 @@ namespace sqlpp
struct no_having_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/in.h
View File

@ -41,7 +41,7 @@ namespace sqlpp
public alias_operators<in_t<Operand, Args...>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Operand, Args...>;
using _nodes = detail::type_vector<Operand, Args...>;
static_assert(sizeof...(Args) > 0, "in() requires at least one argument");

2
include/sqlpp11/insert_value.h
View File

@ -50,7 +50,7 @@ namespace sqlpp
struct type
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
};
}

8
include/sqlpp11/insert_value_list.h
View File

@ -64,7 +64,7 @@ namespace sqlpp
struct insert_default_values_t
{
using _traits = make_traits<no_value_t>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = insert_default_values_data_t;
@ -133,7 +133,7 @@ namespace sqlpp
struct insert_list_t
{
using _traits = make_traits<no_value_t, tag::is_insert_list>;
using _recursive_traits = make_recursive_traits<lhs_t<Assignments>..., rhs_t<Assignments>...>;
using _nodes = detail::type_vector<lhs_t<Assignments>..., rhs_t<Assignments>...>;
using _is_dynamic = is_database<Database>;
@ -245,7 +245,7 @@ namespace sqlpp
struct column_list_t
{
using _traits = make_traits<no_value_t, tag::is_column_list>;
using _recursive_traits = make_recursive_traits<Columns...>;
using _nodes = detail::type_vector<Columns...>;
using _value_tuple_t = typename column_list_data_t<Columns...>::_value_tuple_t;
@ -322,7 +322,7 @@ namespace sqlpp
struct no_insert_value_list_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

4
include/sqlpp11/into.h
View File

@ -59,7 +59,7 @@ namespace sqlpp
struct into_t
{
using _traits = make_traits<no_value_t, tag::is_into>;
using _recursive_traits = make_recursive_traits<Table>;
using _nodes = detail::type_vector<Table>;
using _data_t = into_data_t<Database, Table>;
@ -108,7 +108,7 @@ namespace sqlpp
struct no_into_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/is_not_null.h
View File

@ -40,7 +40,7 @@ namespace sqlpp
public alias_operators<is_not_null_t<Operand>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Operand>;
using _nodes = detail::type_vector<Operand>;
struct _alias_t
{

2
include/sqlpp11/is_null.h
View File

@ -40,7 +40,7 @@ namespace sqlpp
public alias_operators<is_null_t<Operand>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Operand>;
using _nodes = detail::type_vector<Operand>;
struct _alias_t
{

16
include/sqlpp11/join.h
View File

@ -66,18 +66,8 @@ namespace sqlpp
struct join_t
{
using _traits = make_traits<no_value_t, tag::is_table, tag::is_join>;
struct _recursive_traits
{
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::make_joined_set_t<required_tables_of<Lhs>, required_tables_of<Rhs>>;
using _provided_tables = detail::make_joined_set_t<provided_tables_of<Lhs>, provided_tables_of<Rhs>>;
using _provided_outer_tables = typename JoinType::template _provided_outer_tables<Lhs, Rhs>;
using _extra_tables = detail::make_joined_set_t<extra_tables_of<Lhs>, extra_tables_of<Rhs>>;
using _parameters = detail::make_parameter_tuple_t<parameters_of<Lhs>, parameters_of<Rhs>>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<Lhs, Rhs>;
using _can_be_null = std::false_type;
static_assert(is_table_t<Lhs>::value, "lhs argument for join() has to be a table or join");
static_assert(is_table_t<Rhs>::value, "rhs argument for join() has to be a table");
@ -86,7 +76,7 @@ namespace sqlpp
static_assert(detail::is_disjunct_from<provided_tables_of<Lhs>, provided_tables_of<Rhs>>::value, "joined tables must not be identical");
static_assert(_recursive_traits::_required_tables::size::value == 0, "joined tables must not depend on other tables");
static_assert(required_tables_of<join_t>::size::value == 0, "joined tables must not depend on other tables");
template<typename OnT>
using set_on_t = join_t<JoinType, Lhs, Rhs, OnT>;

2
include/sqlpp11/like.h
View File

@ -40,7 +40,7 @@ namespace sqlpp
public alias_operators<like_t<Operand, Pattern>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Operand, Pattern>;
using _nodes = detail::type_vector<Operand, Pattern>;
struct _alias_t
{

6
include/sqlpp11/limit.h
View File

@ -55,7 +55,7 @@ namespace sqlpp
struct limit_t
{
using _traits = make_traits<no_value_t, tag::is_limit>;
using _recursive_traits = make_recursive_traits<Limit>;
using _nodes = detail::type_vector<Limit>;
// Data
using _data_t = limit_data_t<Limit>;
@ -118,7 +118,7 @@ namespace sqlpp
struct dynamic_limit_t
{
using _traits = make_traits<no_value_t, tag::is_limit>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = dynamic_limit_data_t<Database>;
@ -163,7 +163,7 @@ namespace sqlpp
struct no_limit_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

3
include/sqlpp11/max.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
public alias_operators<max_t<Expr>>
{
using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
struct _alias_t
{
@ -84,6 +84,7 @@ namespace sqlpp
template<typename T>
auto max(T t) -> max_t<wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "max() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument");
return { t };
}

3
include/sqlpp11/min.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
public alias_operators<min_t<Expr>>
{
using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
struct _alias_t
{
@ -84,6 +84,7 @@ namespace sqlpp
template<typename T>
auto min(T t) -> min_t<wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "min() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument");
return { t };
}

4
include/sqlpp11/multi_column.h
View File

@ -42,7 +42,7 @@ namespace sqlpp
struct multi_column_t
{
using _traits = make_traits<no_value_t>;
using _recursive_traits = make_recursive_traits<Columns...>;
using _nodes = detail::type_vector<Columns...>;
static_assert(logic::all_t<is_selectable_t<Columns>::value...>::value, "multi_column parameters need to be named expressions");
@ -73,7 +73,7 @@ namespace sqlpp
struct multi_column_alias_t
{
using _traits = make_traits<no_value_t, tag::is_alias, tag::is_multi_column, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Columns...>;
using _nodes = detail::type_vector<Columns...>;
static_assert(logic::all_t<is_selectable_t<Columns>::value...>::value, "multi_column parameters need to be named expressions");

2
include/sqlpp11/noop.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct noop
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
struct _alias_t {};

2
include/sqlpp11/not_in.h
View File

@ -41,7 +41,7 @@ namespace sqlpp
public alias_operators<not_in_t<Operand, Args...>>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Operand, Args...>;
using _nodes = detail::type_vector<Operand, Args...>;
static_assert(sizeof...(Args) > 0, "not_in() requires at least one argument");

2
include/sqlpp11/null.h
View File

@ -34,7 +34,7 @@ namespace sqlpp
struct null_t
{
using _traits = make_traits<no_value_t, tag::is_expression, tag::is_sql_null>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
template<typename Context>

6
include/sqlpp11/offset.h
View File

@ -55,7 +55,7 @@ namespace sqlpp
struct offset_t
{
using _traits = make_traits<no_value_t, tag::is_offset>;
using _recursive_traits = make_recursive_traits<Offset>;
using _nodes = detail::type_vector<Offset>;
static_assert(is_integral_t<Offset>::value, "offset requires an integral value or integral parameter");
@ -120,7 +120,7 @@ namespace sqlpp
struct dynamic_offset_t
{
using _traits = make_traits<no_value_t, tag::is_offset>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = dynamic_offset_data_t<Database>;
@ -177,7 +177,7 @@ namespace sqlpp
struct no_offset_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/on.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
struct on_t
{
using _traits = make_traits<no_value_t, tag::is_on>;
using _recursive_traits = make_recursive_traits<Expressions...>;
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;

4
include/sqlpp11/order_by.h
View File

@ -71,7 +71,7 @@ namespace sqlpp
struct order_by_t
{
using _traits = make_traits<no_value_t, tag::is_order_by>;
using _recursive_traits = make_recursive_traits<Expressions...>;
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;
@ -141,7 +141,7 @@ namespace sqlpp
struct no_order_by_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

15
include/sqlpp11/parameter.h
View File

@ -38,17 +38,10 @@ namespace sqlpp
public expression_operators<parameter_t<ValueType, NameType>, ValueType>
{
using _traits = make_traits<ValueType, tag::is_parameter, tag::is_expression>;
struct _recursive_traits
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<parameter_t>;
using _tags = detail::type_set<tag::can_be_null>;
};
using _nodes = detail::type_vector<>;
using _parameters = detail::type_vector<parameter_t>;
using _can_be_null = std::true_type;
using _instance_t = member_t<NameType, parameter_value_t<ValueType>>;

4
include/sqlpp11/parameter_list.h
View File

@ -37,11 +37,11 @@ namespace sqlpp
template<typename T>
struct parameter_list_t
{
static_assert(wrong_t<parameter_list_t>::value, "Template parameter for parameter_list_t has to be a tuple");
static_assert(wrong_t<parameter_list_t>::value, "Template parameter for parameter_list_t has to be a type_vector");
};
template<typename... Parameter>
struct parameter_list_t<std::tuple<Parameter...>>: public Parameter::_instance_t...
struct parameter_list_t<detail::type_vector<Parameter...>>: public Parameter::_instance_t...
{
using _member_tuple_t = std::tuple<typename Parameter::_instance_t...>;
using size = std::integral_constant<std::size_t, sizeof...(Parameter)>;

2
include/sqlpp11/prepared_execute.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct prepared_execute_t
{
using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _parameter_list_t = make_parameter_list_t<Statement>;
using _prepared_statement_t = typename Db::_prepared_statement_t;

2
include/sqlpp11/prepared_insert.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct prepared_insert_t
{
using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _parameter_list_t = make_parameter_list_t<Insert>;
using _prepared_statement_t = typename Db::_prepared_statement_t;

2
include/sqlpp11/prepared_remove.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct prepared_remove_t
{
using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _parameter_list_t = make_parameter_list_t<Remove>;
using _prepared_statement_t = typename Db::_prepared_statement_t;

2
include/sqlpp11/prepared_select.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct prepared_select_t
{
using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _result_row_t = typename Statement::template _result_row_t<Database>;
using _parameter_list_t = make_parameter_list_t<Composite>;

2
include/sqlpp11/prepared_update.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct prepared_update_t
{
using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _parameter_list_t = make_parameter_list_t<Update>;
using _prepared_statement_t = typename Db::_prepared_statement_t;

16
include/sqlpp11/result_field_methods.h
View File

@ -81,20 +81,8 @@ namespace sqlpp
tag::is_expression,
tag_if<tag::null_is_trivial_value, _base_t::_null_is_trivial>>;
struct _recursive_traits
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = typename std::conditional<column_spec_can_be_null_t<_field_spec_t>::value,
detail::type_set<tag::can_be_null>,
detail::type_set<>>::type;
};
using _nodes = detail::type_vector<>;
using _can_be_null = column_spec_can_be_null_t<_field_spec_t>;
};
}

2
include/sqlpp11/result_row.h
View File

@ -185,7 +185,7 @@ namespace sqlpp
struct _field_spec_t
{
using _traits = make_traits<text, tag::is_noop, tag::can_be_null, tag::null_is_trivial_value>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
struct _alias_t {};
};

2
include/sqlpp11/rhs_wrap.h
View File

@ -118,7 +118,7 @@ namespace sqlpp
struct rhs_wrap_t
{
using _traits = typename Expr::_traits;
using _recursive_traits = typename Expr::_recursive_traits;
using _nodes = detail::type_vector<Expr>;
rhs_wrap_t(Expr expr):
_expr(expr)

4
include/sqlpp11/select_column_list.h
View File

@ -164,7 +164,7 @@ namespace sqlpp
struct select_column_list_t
{
using _traits = typename detail::select_traits<Columns...>::_traits;
using _recursive_traits = make_recursive_traits<Columns...>;
using _nodes = detail::type_vector<Columns...>;
using _alias_t = typename detail::select_traits<Columns...>::_alias_t;
@ -353,7 +353,7 @@ namespace sqlpp
struct no_select_column_list_t
{
using _traits = make_traits<no_value_t, tag::is_noop, tag::is_missing>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
struct _alias_t {};

4
include/sqlpp11/select_flag_list.h
View File

@ -60,7 +60,7 @@ namespace sqlpp
struct select_flag_list_t
{
using _traits = make_traits<no_value_t, tag::is_select_flag_list>;
using _recursive_traits = make_recursive_traits<Flags...>;
using _nodes = detail::type_vector<Flags...>;
using _is_dynamic = is_database<Database>;
@ -128,7 +128,7 @@ namespace sqlpp
struct no_select_flag_list_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

6
include/sqlpp11/select_flags.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
struct all_t
{
using _traits = make_traits<no_value_t, tag::is_select_flag>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
static constexpr all_t all = {};
@ -57,7 +57,7 @@ namespace sqlpp
struct distinct_t
{
using _traits = make_traits<no_value_t, tag::is_select_flag>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
static constexpr distinct_t distinct = {};
@ -76,7 +76,7 @@ namespace sqlpp
struct straight_join_t
{
using _traits = make_traits<no_value_t, tag::is_select_flag>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
static constexpr straight_join_t straight_join = {};

2
include/sqlpp11/select_pseudo_table.h
View File

@ -58,7 +58,7 @@ namespace sqlpp
NamedExpr...>, select_column_spec_t<Select, NamedExpr>...>
{
using _traits = make_traits<no_value_t, tag::is_table, tag::is_pseudo_table>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
select_pseudo_table_t(Select select):
_select(select)

2
include/sqlpp11/simple_column.h
View File

@ -39,7 +39,7 @@ namespace sqlpp
_column_t _column;
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
};
template<typename Context, typename Column>

4
include/sqlpp11/single_table.h
View File

@ -58,7 +58,7 @@ namespace sqlpp
struct single_table_t
{
using _traits = make_traits<no_value_t, tag::is_single_table>;
using _recursive_traits = make_recursive_traits<Table>;
using _nodes = detail::type_vector<Table>;
static_assert(is_table_t<Table>::value, "argument has to be a table");
static_assert(required_tables_of<Table>::size::value == 0, "table depends on another table");
@ -99,7 +99,7 @@ namespace sqlpp
struct no_single_table_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/some.h
View File

@ -37,7 +37,7 @@ namespace sqlpp
struct some_t
{
using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
using _recursive_traits = make_recursive_traits<Select>;
using _nodes = detail::type_vector<Select>;
struct _alias_t
{

2
include/sqlpp11/sort_order.h
View File

@ -42,7 +42,7 @@ namespace sqlpp
struct sort_order_t
{
using _traits = make_traits<no_value_t, tag::is_sort_order>;
using _recursive_traits = make_recursive_traits<Expression>;
using _nodes = detail::type_vector<Expression>;
Expression _expression;
};

35
include/sqlpp11/statement.h
View File

@ -130,14 +130,12 @@ namespace sqlpp
// A select can be used as a pseudo table if
// - at least one column is selected
// - the select is complete (leaks no table requirements)
// - the select is complete (leaks no table requirements or cte requirements)
static constexpr bool _can_be_used_as_table()
{
return has_result_row_t<_statement_t>::value
and _required_tables::size::value == 0
and _all_provided_ctes::size::value == 0 // a sub-select must not contain a WITH
? true
: false;
and _required_ctes::size::value == 0;
}
using _value_type = typename std::conditional<
@ -146,34 +144,23 @@ namespace sqlpp
no_value_t // if a required statement part is missing (e.g. columns in a select), then the statement cannot be used as a value
>::type;
using _traits = make_traits<_value_type, tag_if<tag::is_expression, not std::is_same<_value_type, no_value_t>::value>>;
using _nodes = detail::type_vector<>;
using _can_be_null = logic::any_t<
can_be_null_t<_result_type_provider>::value,
detail::make_intersect_set_t<
required_tables_of<_result_type_provider>,
_all_provided_outer_tables
>::size::value != 0>;
using _traits = make_traits<_value_type, tag_if<tag::is_expression, not std::is_same<_value_type, no_value_t>::value>>;
struct _recursive_traits
{
using _required_ctes = statement_policies_t::_required_ctes;
using _provided_ctes = detail::type_set<>;
using _required_tables = statement_policies_t::_required_tables;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = detail::make_parameter_tuple_t<parameters_of<Policies>...>;
using _tags = typename std::conditional<_can_be_null::value,
detail::type_set<tag::can_be_null>,
detail::type_set<>>::type;
};
using _parameters = detail::type_vector_cat_t<parameters_of<Policies>...>;
// required_tables and _required_ctes are defined above
using _cte_check = 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<std::tuple_size<typename _recursive_traits::_parameters>::value == 0,
using _parameter_check = typename std::conditional<detail::type_vector_size<_parameters>::value == 0,
consistent_t, assert_no_parameters_t>::type;
};
}
@ -212,7 +199,7 @@ namespace sqlpp
tag_if<tag::is_selectable, is_expression_t<_policies_t>::value>,
tag_if<tag::is_return_value, logic::none_t<is_noop_t<_result_type_provider>::value>::value>,
tag::requires_braces>;
using _recursive_traits = typename _policies_t::_recursive_traits;
using _nodes = detail::type_vector<_policies_t>;
using _used_outer_tables = typename _policies_t::_all_provided_outer_tables;
using _alias_t = typename _result_type_provider::_alias_t;
@ -237,7 +224,7 @@ namespace sqlpp
static constexpr size_t _get_static_no_of_parameters()
{
return std::tuple_size<parameters_of<statement_t>>::value;
return detail::type_vector_size<parameters_of<statement_t>>::value;
}
size_t _get_no_of_parameters() const
@ -286,7 +273,7 @@ namespace sqlpp
struct statement_name_t
{
using _traits = make_traits<no_value_t, Tag>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = NameData;

2
include/sqlpp11/sum.h
View File

@ -38,7 +38,7 @@ namespace sqlpp
public alias_operators<sum_t<Flag, Expr>>
{
using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "sum() used with flag other than 'distinct'");
static_assert(is_numeric_t<Expr>::value, "sum() requires a numeric expression as argument");

13
include/sqlpp11/table.h
View File

@ -46,17 +46,8 @@ namespace sqlpp
{
using _traits = make_traits<no_value_t, tag::is_table>;
struct _recursive_traits
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<Table>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _provided_tables = detail::type_set<Table>;
static_assert(sizeof...(ColumnSpec), "at least one column required per table");
using _required_insert_columns = typename detail::make_type_set_if<require_insert_t, column_t<Table, ColumnSpec>...>::type;

14
include/sqlpp11/table_alias.h
View File

@ -42,17 +42,9 @@ namespace sqlpp
//FIXME: Need to add join functionality
using _traits = make_traits<value_type_of<Table>, tag::is_table, tag::is_alias, tag_if<tag::is_selectable, is_expression_t<Table>::value>>;
struct _recursive_traits
{
using _required_ctes = required_ctes_of<Table>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<AliasProvider>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _required_ctes = required_ctes_of<Table>;
using _provided_tables = detail::type_set<AliasProvider>;
static_assert(required_tables_of<Table>::size::value == 0, "table aliases must not depend on external tables");

4
include/sqlpp11/tvin.h
View File

@ -40,7 +40,7 @@ namespace sqlpp
struct tvin_arg_t
{
using _traits = make_traits<value_type_of<Operand>, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Operand>;
using _nodes = detail::type_vector<Operand>;
using _operand_t = Operand;
@ -102,7 +102,7 @@ namespace sqlpp
struct tvin_t
{
using _traits = make_traits<value_type_of<Operand>, tag::is_expression>;
using _recursive_traits = make_recursive_traits<Operand>;
using _nodes = detail::type_vector<Operand>;
using _operand_t = Operand;

164
include/sqlpp11/type_traits.h
View File

@ -30,6 +30,7 @@
#include <type_traits>
#include <tuple>
#include <sqlpp11/serializer.h>
#include <sqlpp11/detail/type_vector.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/detail/get_first.h>
@ -38,29 +39,8 @@ namespace sqlpp
namespace tag
{
struct can_be_null{};
struct contains_aggregate_function{};
}
namespace detail
{
template<typename T, typename Enable = void>
struct can_be_null_impl { using type = std::false_type; };
template<typename T>
struct can_be_null_impl<T, typename std::enable_if<is_element_of<tag::can_be_null, typename T::_recursive_traits::_tags>::value>::type> { using type = std::true_type; };
}
template<typename T>
using can_be_null_t = typename detail::can_be_null_impl<T>::type;
namespace detail
{
template<typename T, typename Enable = void>
struct contains_aggregate_function_impl { using type = std::false_type; };
template<typename T>
struct contains_aggregate_function_impl<T, typename std::enable_if<is_element_of<tag::contains_aggregate_function, typename T::_recursive_traits::_tags>::value>::type> { using type = std::true_type; };
}
template<typename T>
using contains_aggregate_function_t = typename detail::contains_aggregate_function_impl<T>::type;
namespace detail
{
template<typename T, typename Enable = void>
@ -71,23 +51,6 @@ namespace sqlpp
template<typename T>
using column_spec_can_be_null_t = typename detail::column_spec_can_be_null_impl<T>::type;
namespace tag
{
struct is_expression{};
}
namespace detail
{
template<typename T, typename Enable = void>
struct is_expression_impl { using type = std::false_type; };
template<typename T>
struct is_expression_impl<T, typename std::enable_if<
detail::is_element_of<tag::is_expression, typename T::_traits::_tags>::value
and not detail::is_element_of<tag::contains_aggregate_function, typename T::_recursive_traits::_tags>::value
>::type> { using type = std::true_type; };
}
template<typename T>
using is_expression_t = typename detail::is_expression_impl<T>::type;
#define SQLPP_VALUE_TRAIT_GENERATOR(name) \
namespace tag\
{\
@ -116,6 +79,7 @@ namespace sqlpp
SQLPP_VALUE_TRAIT_GENERATOR(is_text)
SQLPP_VALUE_TRAIT_GENERATOR(is_wrapped_value)
SQLPP_VALUE_TRAIT_GENERATOR(is_selectable)
SQLPP_VALUE_TRAIT_GENERATOR(is_expression)
SQLPP_VALUE_TRAIT_GENERATOR(is_multi_expression)
SQLPP_VALUE_TRAIT_GENERATOR(is_alias)
SQLPP_VALUE_TRAIT_GENERATOR(is_select_flag)
@ -175,40 +139,86 @@ namespace sqlpp
template<typename Database>
using is_database = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
namespace detail
{
template<typename... T>
using make_parameter_tuple_t = decltype(std::tuple_cat(std::declval<T>()...));
}
template<typename T>
using value_type_of = typename T::_traits::_value_type;
template<typename T>
using cpp_value_type_of = typename value_type_of<T>::_cpp_value_type;
template<typename T>
using required_ctes_of = typename T::_recursive_traits::_required_ctes;
#define SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(trait) \
namespace detail\
{\
template<typename T, typename Leaf = void>\
struct trait##_of_impl\
{\
using type = typename trait##_of_impl<typename T::_nodes>::type;\
};\
template<typename T>\
struct trait##_of_impl<T, typename std::enable_if<std::is_class<typename T::_##trait>::value>::type>\
{\
using type = typename T::_##trait;\
};\
template<typename... Nodes>\
struct trait##_of_impl<type_vector<Nodes...>, void>\
{\
using type = detail::make_joined_set_t<typename trait##_of_impl<Nodes>::type...>;\
};\
}\
template<typename T>\
using trait##_of = typename detail::trait##_of_impl<T>::type;
template<typename T>
using provided_ctes_of = typename T::_recursive_traits::_provided_ctes;
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(required_ctes)
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_ctes)
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(required_tables)
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_tables)
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_outer_tables)
SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(extra_tables)
template<typename T>
using required_tables_of = typename T::_recursive_traits::_required_tables;
#define SQLPP_RECURSIVE_TRAIT_GENERATOR(trait) \
namespace detail\
{\
template<typename T, typename Leaf = void>\
struct trait##_impl\
{\
using type = typename trait##_impl<typename T::_nodes>::type;\
};\
template<typename T>\
struct trait##_impl<T, typename std::enable_if<std::is_class<typename T::_##trait>::value>::type>\
{\
using type = typename T::_##trait;\
};\
template<typename... Nodes>\
struct trait##_impl<type_vector<Nodes...>, void>\
{\
using type = logic::any_t<trait##_impl<Nodes>::type::value...>;\
};\
}\
template<typename T>\
using trait##_t = typename detail::trait##_impl<T>::type;
template<typename T>
using provided_tables_of = typename T::_recursive_traits::_provided_tables;
SQLPP_RECURSIVE_TRAIT_GENERATOR(can_be_null)
SQLPP_RECURSIVE_TRAIT_GENERATOR(contains_aggregate_function)
template<typename T>
using provided_outer_tables_of = typename T::_recursive_traits::_provided_outer_tables;
template<typename T>
using extra_tables_of = typename T::_recursive_traits::_extra_tables;
template<typename T>
using parameters_of = typename T::_recursive_traits::_parameters;
template<typename T>
using recursive_tags_of = typename T::_recursive_traits::_tags;
namespace detail
{
template<typename T, typename Leaf = void>
struct parameters_of_impl
{
using type = typename parameters_of_impl<typename T::_nodes>::type;
};
template<typename T>
struct parameters_of_impl<T, typename std::enable_if<std::is_class<typename T::_parameters>::value>::type>
{
using type = typename T::_parameters;
};
template<typename... Nodes>
struct parameters_of_impl<type_vector<Nodes...>, void>
{
using type = detail::type_vector_cat_t<typename parameters_of_impl<Nodes>::type...>;
};
}
template<typename T>\
using parameters_of = typename detail::parameters_of_impl<T>::type;
template<typename T>
using alias_of = typename T::_alias_t;
@ -223,36 +233,10 @@ namespace sqlpp
using _tags = detail::make_type_set_t<typename ValueType::_tag, Tags...>;
};
template<typename... Arguments>
struct make_recursive_traits
{
using _required_ctes = detail::make_joined_set_t<required_ctes_of<Arguments>...>;
using _provided_ctes = detail::make_joined_set_t<provided_ctes_of<Arguments>...>;
using _required_tables = detail::make_joined_set_t<required_tables_of<Arguments>...>;
using _provided_tables = detail::make_joined_set_t<provided_tables_of<Arguments>...>;
using _provided_outer_tables = detail::make_joined_set_t<provided_outer_tables_of<Arguments>...>;
using _extra_tables = detail::make_joined_set_t<extra_tables_of<Arguments>...>;
using _parameters = detail::make_parameter_tuple_t<parameters_of<Arguments>...>;
using _tags = detail::make_joined_set_t<recursive_tags_of<Arguments>...>;
};
template<typename... Tags>
struct recursive_tags
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::type_set<>;
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = std::tuple<>;
using _tags = detail::type_set<Tags...>;
};
struct aggregate_function
{
struct _traits { using _value_type = void; using _tags = detail::type_set<>; };
using _recursive_traits = recursive_tags<tag::contains_aggregate_function>;
using _nodes = detail::type_vector<>;
using _contains_aggregate_function = std::true_type;
};
template<typename NameProvider, typename Member>

4
include/sqlpp11/union.h
View File

@ -66,7 +66,7 @@ namespace sqlpp
struct union_t
{
using _traits = make_traits<no_value_t, tag::is_union, tag::is_return_value>;
using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
using _nodes = detail::type_vector<Lhs, Rhs>;
using _alias_t = struct{};
@ -114,7 +114,7 @@ namespace sqlpp
struct no_union_t
{
using _traits = make_traits<no_value_t, tag::is_union>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

4
include/sqlpp11/update_list.h
View File

@ -68,7 +68,7 @@ namespace sqlpp
struct update_list_t
{
using _traits = make_traits<no_value_t, tag::is_update_list>;
using _recursive_traits = make_recursive_traits<Assignments...>;
using _nodes = detail::type_vector<Assignments...>;
using _is_dynamic = is_database<Database>;
// Data
@ -153,7 +153,7 @@ namespace sqlpp
struct no_update_list_t
{
using _traits = make_traits<no_value_t, tag::is_where>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

4
include/sqlpp11/using.h
View File

@ -58,7 +58,7 @@ namespace sqlpp
struct using_t
{
using _traits = make_traits<no_value_t, tag::is_using_>;
using _recursive_traits = make_recursive_traits<Tables...>;
using _nodes = detail::type_vector<Tables...>;
using _is_dynamic = is_database<Database>;
@ -121,7 +121,7 @@ namespace sqlpp
struct no_using_t
{
using _traits = make_traits<no_value_t, tag::is_where>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

2
include/sqlpp11/value_or_null.h
View File

@ -51,7 +51,7 @@ namespace sqlpp
using _cpp_value_type = typename ValueType::_cpp_value_type;
using _traits = make_traits<ValueType, tag::is_expression>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
value_or_null_t(_cpp_value_type value):
_value(value),

6
include/sqlpp11/verbatim.h
View File

@ -39,10 +39,8 @@ namespace sqlpp
public alias_operators<verbatim_t<ValueType>>
{
using _traits = make_traits<ValueType, tag::is_expression>;
struct _recursive_traits : public make_recursive_traits<>
{
using _tags = detail::type_set<tag::can_be_null>; // since we do not know what's going on inside the verbatim, we assume it can be null
};
using _nodes = detail::type_vector<>;
using _can_be_null = std::true_type; // since we do not know what's going on inside the verbatim, we assume it can be null
verbatim_t(std::string verbatim): _verbatim(verbatim) {}
verbatim_t(const verbatim_t&) = default;

5
include/sqlpp11/verbatim_table.h
View File

@ -50,10 +50,7 @@ namespace sqlpp
struct verbatim_table_t: public table_t<verbatim_table_t, detail::unusable_pseudo_column_t>
{
struct _recursive_traits: public table_t<verbatim_table_t, detail::unusable_pseudo_column_t>::_recursive_traits
{
using _provided_outer_tables = detail::type_set<verbatim_table_t>;
};
using _nodes = detail::type_vector<>;
struct _alias_t
{

6
include/sqlpp11/where.h
View File

@ -71,7 +71,7 @@ namespace sqlpp
struct where_t
{
using _traits = make_traits<no_value_t, tag::is_where>;
using _recursive_traits = make_recursive_traits<Expressions...>;
using _nodes = detail::type_vector<Expressions...>;
using _is_dynamic = is_database<Database>;
@ -149,7 +149,7 @@ namespace sqlpp
struct where_t<void, bool>
{
using _traits = make_traits<no_value_t, tag::is_where>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = where_data_t<void, bool>;
@ -198,7 +198,7 @@ namespace sqlpp
struct no_where_t
{
using _traits = make_traits<no_value_t, tag::is_where>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

16
include/sqlpp11/with.h
View File

@ -66,17 +66,9 @@ namespace sqlpp
struct with_t
{
using _traits = make_traits<no_value_t, tag::is_with>;
struct _recursive_traits
{
using _required_ctes = detail::type_set<>;
using _provided_ctes = detail::make_joined_set_t<required_ctes_of<Expressions>...>; // with provides common table expressions
using _required_tables = detail::type_set<>;
using _provided_tables = detail::type_set<>;
using _provided_outer_tables = detail::type_set<>;
using _extra_tables = detail::type_set<>;
using _parameters = detail::make_parameter_tuple_t<parameters_of<Expressions>...>;
using _tags = detail::type_set<>;
};
using _nodes = detail::type_vector<>;
using _provided_ctes = detail::make_joined_set_t<required_ctes_of<Expressions>...>; // WITH provides common table expressions
using _parameters = detail::type_vector_cat_t<parameters_of<Expressions>...>;
using _is_dynamic = is_database<Database>;
@ -116,7 +108,7 @@ namespace sqlpp
struct no_with_t
{
using _traits = make_traits<no_value_t, tag::is_with>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
// Data
using _data_t = no_data_t;

8
include/sqlpp11/wrap_operand.h
View File

@ -43,7 +43,7 @@ namespace sqlpp
struct boolean_operand: public alias_operators<boolean_operand>
{
using _traits = make_traits<boolean, tag::is_expression, tag::is_wrapped_value>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _value_t = bool;
@ -82,7 +82,7 @@ namespace sqlpp
struct integral_operand: public alias_operators<integral_operand>
{
using _traits = make_traits<integral, tag::is_expression, tag::is_wrapped_value>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _value_t = int64_t;
@ -122,7 +122,7 @@ namespace sqlpp
struct floating_point_operand: public alias_operators<floating_point_operand>
{
using _traits = make_traits<floating_point, tag::is_expression, tag::is_wrapped_value>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _value_t = double;
@ -161,7 +161,7 @@ namespace sqlpp
struct text_operand: public alias_operators<text_operand>
{
using _traits = make_traits<text, tag::is_expression, tag::is_wrapped_value>;
using _recursive_traits = make_recursive_traits<>;
using _nodes = detail::type_vector<>;
using _value_t = std::string;

4
test_constraints/CMakeLists.txt
View File

@ -24,8 +24,8 @@ function(test_constraint name pattern)
endfunction(test_constraint)
test_constraint(count_of_count "requires an expression as argument")
test_constraint(max_of_max "requires an expression as argument")
test_constraint(count_of_count "count() cannot be used on an aggregate function")
test_constraint(max_of_max "max() cannot be used on an aggregate function")
test_constraint(no_conversion_operator_if_null_not_trivial "int i = row.alpha")
test_constraint(require_insert "required column is missing")
test_constraint(must_not_insert "one assignment is prohibited")

32
tests/PreparedTest.cpp
View File

@ -40,40 +40,48 @@ int main()
// empty parameter lists
{
using T = sqlpp::parameters_of<decltype(t.alpha)>;
static_assert(std::is_same<T, std::tuple<>>::value, "type requirement");
using T = sqlpp::make_parameter_list_t<decltype(t.alpha)>;
static_assert(T::size::value == 0, "type requirement");
}
// single parameter
{
using T = sqlpp::parameters_of<decltype(parameter(t.alpha))>;
static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
using T = sqlpp::make_parameter_list_t<decltype(parameter(t.alpha))>;
static_assert(T::size::value == 1, "type requirement");
auto t = T{};
t.alpha = 7;
}
// single parameter
{
using T = sqlpp::parameters_of<decltype(parameter(t.alpha))>;
static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
using T = sqlpp::make_parameter_list_t<decltype(parameter(t.beta))>;
static_assert(T::size::value == 1, "type requirement");
auto t = T{};
t.beta = "cheesecake";
}
// single parameter in expression
{
using T = sqlpp::parameters_of<decltype(t.alpha == parameter(t.alpha))>;
static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
using T = sqlpp::make_parameter_list_t<decltype(t.alpha == parameter(t.alpha))>;
static_assert(T::size::value == 1, "type requirement");
auto t = T{};
t.alpha = 7;
}
// single parameter in larger expression
{
using T = sqlpp::parameters_of<decltype((t.beta.like("%") and t.alpha == parameter(t.alpha)) or t.gamma != false)>;
static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
using T = sqlpp::make_parameter_list_t<decltype((t.beta.like("%") and t.alpha == parameter(t.alpha)) or t.gamma != false)>;
static_assert(T::size::value == 1, "type requirement");
auto t = T{};
t.alpha = 7;
}
// three parameters in expression
{
using T = sqlpp::parameters_of<decltype((t.beta.like(parameter(t.beta)) and t.alpha == parameter(t.alpha)) or t.gamma != parameter(t.gamma))>;
static_assert(std::tuple_size<T>::value == 3, "type requirement");
static_assert(std::is_same<T, std::tuple<decltype(parameter(t.beta)), decltype(parameter(t.alpha)),decltype(parameter(t.gamma))>>::value, "type requirement");
// FIXME: make some test, that does not depend on detail namespace, but still checks the correct order of the parameters
static_assert(std::is_same<T, sqlpp::detail::type_vector<decltype(parameter(t.beta)), decltype(parameter(t.alpha)),decltype(parameter(t.gamma))>>::value, "type requirement");
}
// OK, fine, now create a named parameter list from an expression