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

Migrated remove to use inherited methods

Browse Source
This commit is contained in:
rbock
2014-04-10 18:59:05 +02:00
parent bc5ffc1492
commit 7f94002bec
3 changed files with 112 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/sqlpp11/detail/logic.h
View File

@@ -69,7 +69,7 @@ namespace sqlpp
template<bool... Rest>
struct any_impl<false, Rest...>
{
using type = typename all_impl<Rest...>::type;
using type = typename any_impl<Rest...>::type;
};
template<bool... Rest>

152
include/sqlpp11/remove.h
View File

@@ -39,37 +39,60 @@
namespace sqlpp
{
template<typename Db,
typename... Policies
>
struct remove_t;
namespace detail
{
template<typename Table, typename Using, typename Where>
struct check_remove_t
template<typename Db = void,
typename Table = vendor::no_single_table_t,
typename Using = vendor::no_using_t,
typename Where = vendor::no_where_t
>
struct remove_policies_t
{
static_assert(is_where_t<Where>::value, "cannot run remove without having a where condition, use .where(true) to remove all rows");
static constexpr bool value = true;
using _database_t = Db;
using _table_t = Table;
using _using_t = Using;
using _where_t = Where;
using _statement_t = remove_t<Db, Table, Using, Where>;
struct _methods_t:
public _using_t::template _methods_t<remove_policies_t>,
public _where_t::template _methods_t<remove_policies_t>
{};
template<typename Needle, typename Replacement, typename... Policies>
struct _policies_update_impl
{
using type = remove_t<Db, vendor::policy_update_t<Policies, Needle, Replacement>...>;
};
template<typename Needle, typename Replacement>
using _policies_update_t = typename _policies_update_impl<Needle, Replacement, Table, Using, Where>::type;
};
}
// REMOVE
template<typename Database,
typename Table = vendor::no_single_table_t,
typename Using = vendor::no_using_t,
typename Where = vendor::no_where_t
template<typename Db,
typename... Policies
>
struct remove_t
struct remove_t:
public detail::remove_policies_t<Db, Policies...>::_methods_t
{
using _database_t = Database;
using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
using _policies_t = typename detail::remove_policies_t<Db, Policies...>;
using _database_t = typename _policies_t::_database_t;
using _table_t = typename _policies_t::_table_t;
using _using_t = typename _policies_t::_using_t;
using _where_t = typename _policies_t::_where_t;
template<typename Needle, typename Replacement, typename... Policies>
struct _policies_update_impl
{
using type = remove_t<Database, vendor::policy_update_t<Policies, Needle, Replacement>...>;
};
using _is_dynamic = typename std::conditional<std::is_same<_database_t, void>::value, std::false_type, std::true_type>::type;
template<typename Needle, typename Replacement>
using _policies_update_t = typename _policies_update_impl<Needle, Replacement, Table, Using, Where>::type;
using _parameter_tuple_t = std::tuple<Table, Using, Where>;
using _parameter_tuple_t = std::tuple<Policies...>;
using _parameter_list_t = typename make_parameter_list_t<remove_t>::type;
// Constructors
@@ -78,9 +101,9 @@ namespace sqlpp
template<typename Statement, typename T>
remove_t(Statement s, T t):
_table(detail::arg_selector<Table>::_(s._table, t)),
_using(detail::arg_selector<Using>::_(s._using, t)),
_where(detail::arg_selector<Where>::_(s._where, t))
_table(detail::arg_selector<_table_t>::_(s._table, t)),
_using(detail::arg_selector<_using_t>::_(s._using, t)),
_where(detail::arg_selector<_where_t>::_(s._where, t))
{}
remove_t(const remove_t&) = default;
@@ -89,58 +112,6 @@ namespace sqlpp
remove_t& operator=(remove_t&&) = default;
~remove_t() = default;
// type update functions
template<typename... Args>
auto using_(Args... args)
-> _policies_update_t<vendor::no_using_t, vendor::using_t<void, Args...>>
{
static_assert(is_noop_t<Using>::value, "cannot call using_()/dynamic_using() twice");
return { *this, vendor::using_t<void, Args...>{args...} };
}
template<typename... Args>
auto dynamic_using(Args... args)
-> _policies_update_t<vendor::no_using_t, vendor::using_t<_database_t, Args...>>
{
static_assert(is_noop_t<Using>::value, "cannot call using_()/dynamic_using() twice");
static_assert(not std::is_same<_database_t, void>::value, "dynamic_using must not be called in a static statement");
return { *this, vendor::using_t<_database_t, Args...>{args...} };
}
template<typename... Args>
auto where(Args... args)
-> _policies_update_t<vendor::no_where_t, vendor::where_t<void, Args...>>
{
static_assert(is_noop_t<Where>::value, "cannot call where()/dynamic_where() twice");
return { *this, vendor::where_t<void, Args...>{args...} };
}
template<typename... Args>
auto dynamic_where(Args... args)
-> _policies_update_t<vendor::no_where_t, vendor::where_t<_database_t, Args...>>
{
static_assert(is_noop_t<Where>::value, "cannot call where()/dynamic_where() twice");
static_assert(not std::is_same<_database_t, void>::value, "dynamic_where must not be called in a static statement");
return { *this, vendor::where_t<_database_t, Args...>{args...} };
}
// value adding methods
template<typename... Args>
void add_using(Args... args)
{
static_assert(is_using_t<Using>::value, "cannot call add_using() before dynamic_using()");
static_assert(is_dynamic_t<Using>::value, "cannot call add_using() before dynamic_using()");
return _using.add_using(args...);
}
template<typename... Args>
void add_where(Args... args)
{
static_assert(is_where_t<Where>::value, "cannot call add_where() before dynamic_where()");
static_assert(is_dynamic_t<Where>::value, "cannot call add_where() before dynamic_where()");
return _where.add_where(*this, args...);
}
// run and prepare
static constexpr size_t _get_static_no_of_parameters()
{
@@ -152,25 +123,25 @@ namespace sqlpp
return _parameter_list_t::size::value;
}
template<typename Db>
std::size_t _run(Db& db) const
template<typename Database>
std::size_t _run(Database& db) const
{
static_assert(_get_static_no_of_parameters() == 0, "cannot run remove directly with parameters, use prepare instead");
//static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this remove expression");
static_assert(is_where_t<_where_t>::value, "cannot run remove without having a where condition, use .where(true) to remove all rows");
return db.remove(*this);
}
template<typename Db>
auto _prepare(Db& db) const
-> prepared_remove_t<Db, remove_t>
template<typename Database>
auto _prepare(Database& db) const
-> prepared_remove_t<Database, remove_t>
{
//static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this remove expression");
static_assert(is_where_t<_where_t>::value, "cannot run remove without having a where condition, use .where(true) to remove all rows");
return {{}, db.prepare_remove(*this)};
}
Table _table;
Using _using;
Where _where;
_table_t _table;
_using_t _using;
_where_t _where;
};
namespace vendor
@@ -191,18 +162,21 @@ namespace sqlpp
};
}
template<typename Database, typename... Policies>
using make_remove_t = typename detail::remove_policies_t<Database, Policies...>::_statement_t;
template<typename Table>
constexpr auto remove_from(Table table)
-> remove_t<void, vendor::single_table_t<void, Table>>
-> make_remove_t<void, vendor::single_table_t<void, Table>>
{
return { remove_t<void>(), vendor::single_table_t<void, Table>{table} };
return { make_remove_t<void>(), vendor::single_table_t<void, Table>{table} };
}
template<typename Database, typename Table>
constexpr auto dynamic_remove_from(const Database&, Table table)
-> remove_t<Database, vendor::single_table_t<void, Table>>
-> make_remove_t<Database, vendor::single_table_t<void, Table>>
{
return { remove_t<Database>(), vendor::single_table_t<void, Table>{table} };
return { make_remove_t<Database>(), vendor::single_table_t<void, Table>{table} };
}
}

55
include/sqlpp11/vendor/using.h vendored
View File

@@ -61,14 +61,31 @@ namespace sqlpp
using_t& operator=(using_t&&) = default;
~using_t() = default;
template<typename Table>
void add_using(Table table)
template<typename Policies>
struct _methods_t
{
static_assert(_is_dynamic::value, "add_using can only be called for dynamic_using");
static_assert(is_table_t<Table>::value, "using() arguments require to be tables");
_dynamic_tables.emplace_back(table);
}
template<typename Table>
void add_using(Table table)
{
static_assert(_is_dynamic::value, "add_using must not be called for static using()");
static_assert(is_table_t<Table>::value, "invalid table argument in add_using()");
using ok = ::sqlpp::detail::all_t<sqlpp::detail::identity_t, _is_dynamic, is_table_t<Table>>;
_add_using_impl(table, ok()); // dispatch to prevent compile messages after the static_assert
}
private:
template<typename Table>
void _add_using_impl(Table table, const std::true_type&)
{
return static_cast<typename Policies::_statement_t*>(this)->_using._dynamic_tables.emplace_back(table);
}
template<typename Table>
void _add_using_impl(Table table, const std::false_type&);
};
_parameter_tuple_t _tables;
vendor::interpretable_list_t<Database> _dynamic_tables;
@@ -77,6 +94,30 @@ namespace sqlpp
struct no_using_t
{
using _is_noop = std::true_type;
using _table_set = ::sqlpp::detail::type_set<>;
template<typename Policies>
struct _methods_t
{
using _database_t = typename Policies::_database_t;
template<typename T>
using _new_select_t = typename Policies::template _policies_update_t<no_using_t, T>;
template<typename... Args>
auto using_(Args... args)
-> _new_select_t<using_t<void, Args...>>
{
return { *static_cast<typename Policies::_statement_t*>(this), using_t<void, Args...>{args...} };
}
template<typename... Args>
auto dynamic_using(Args... args)
-> _new_select_t<using_t<_database_t, Args...>>
{
static_assert(not std::is_same<_database_t, void>::value, "dynamic_using must not be called in a static statement");
return { *static_cast<typename Policies::_statement_t*>(this), vendor::using_t<_database_t, Args...>{args...} };
}
};
};
// Interpreters