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

Added dynamic versions of from and where to select

Browse Source
This commit is contained in:
Roland Bock 2013-09-22 20:42:19 +02:00
parent 5576df1775
commit 472833016f
6 changed files with 113 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/sqlpp11/column.h
View File

@ -51,6 +51,13 @@ namespace sqlpp
using _name_t = typename ColumnSpec::_name_t;
column_t() = default;
column_t(const column_t&) = default;
column_t(column_t&&) = default;
column_t& operator=(const column_t&) = default;
column_t& operator=(column_t&&) = default;
~column_t() = default;
template<typename Db>
void serialize(std::ostream& os, Db& db) const
{

12
include/sqlpp11/from.h
View File

@ -57,11 +57,11 @@ namespace sqlpp
std::tuple<TableOrJoin...> _tables;
};
template<typename Db, typename... TableOrJoin>
template<typename Db>
struct dynamic_from_t
{
using _is_from = tag_yes;
using _is_dynamic_from = tag_yes;
using _is_dynamic = tag_yes;
template<typename Table>
void add(Table&& table)
@ -69,13 +69,12 @@ namespace sqlpp
_dynamic_tables.push_back(std::forward<Table>(table));
}
void serialize(std::ostream& os, Db& db, bool has_static_from) const
void serialize(std::ostream& os, Db& db) const
{
if (sizeof...(TableOrJoin) == 0 and _dynamic_tables.empty())
if (_dynamic_tables.empty())
return;
os << " FROM ";
detail::serialize_tuple(os, db, _tables, ',');
bool first = sizeof...(TableOrJoin) == 0;
bool first = true;
for (const auto& table : _dynamic_tables)
{
if (not first)
@ -85,7 +84,6 @@ namespace sqlpp
}
}
std::tuple<TableOrJoin...> _tables;
std::vector<detail::serializable_t<Db>> _dynamic_tables;
};
}

80
include/sqlpp11/select.h
View File

@ -93,10 +93,10 @@ namespace sqlpp
using _is_select = tag_yes;
using _requires_braces = tag_yes;
template<typename... Table>
using set_from_t = select_t<Database, Flags, ExpressionList, from_t<typename std::decay<Table>::type...>, Where, GroupBy, Having, OrderBy, Limit, Offset>;
template<typename Expr>
using set_where_t = select_t<Database, Flags, ExpressionList, From, where_t<typename std::decay<Expr>::type>, GroupBy, Having, OrderBy, Limit, Offset>;
template<typename FromT>
using set_from_t = select_t<Database, Flags, ExpressionList, FromT, Where, GroupBy, Having, OrderBy, Limit, Offset>;
template<typename WhereT>
using set_where_t = select_t<Database, Flags, ExpressionList, From, WhereT, GroupBy, Having, OrderBy, Limit, Offset>;
template<typename... Col>
using set_group_by_t = select_t<Database, Flags, ExpressionList, From, Where, group_by_t<typename std::decay<Col>::type...>, Having, OrderBy, Limit, Offset>;
template<typename Expr>
@ -165,7 +165,8 @@ namespace sqlpp
// sqlpp functions
template<typename... Table>
set_from_t<Table...> from(Table&&... table)
auto from(Table&&... table)
-> set_from_t<from_t<typename std::decay<Table>::type...>>
{
static_assert(not is_noop<ExpressionList>::value, "cannot call from() without having selected anything");
static_assert(is_noop<From>::value, "cannot call from() twice for a single select");
@ -182,24 +183,40 @@ namespace sqlpp
};
}
/*
auto dynamic_from()
-> set_from_t<dynamic_from_t<Database>>
{
static_assert(not std::is_same<Database, void>::value, "cannot call dynamic_from() in a non-dynamic select");
static_assert(not is_noop<ExpressionList>::value, "cannot call from() without having selected anything");
static_assert(is_noop<From>::value, "cannot call from() twice for a single select");
return {
_flags,
_expression_list,
{{}},
_where,
_group_by,
_having,
_order_by,
_limit,
_offset
};
}
template<typename Table>
select_t& add_from(Table&& table)
{
static_assert(not is_noop<ExpressionList>::value, "cannot call add_from() without having selected anything");
static_assert(not std::is_same<Database, void>::value, "cannot call add_from() in a non-dynamic select");
void add_from(Table&& table)
{
static_assert(not is_noop<ExpressionList>::value, "cannot call add_from() without having selected anything");
static_assert(is_dynamic_t<From>::value, "cannot call add_from() in a non-dynamic from");
_dynamic._from.add(std::forward<Table>(table));
return *this;
}
*/
_from.add(std::forward<Table>(table));
}
template<typename Expr>
set_where_t<Expr> where(Expr&& expr)
auto where(Expr&& expr)
-> set_where_t<where_t<typename std::decay<Expr>::type>>
{
static_assert(not is_noop<From>::value, "cannot call where() without a from()");
static_assert(is_noop<Where>::value, "cannot call where() twice for a single select");
static_assert(is_noop<Where>::value, "cannot call where() or dynamic_where() twice for a single select");
return {
_flags,
_expression_list,
@ -213,6 +230,33 @@ namespace sqlpp
};
}
auto dynamic_where()
-> set_where_t<dynamic_where_t<Database>>
{
static_assert(not is_noop<From>::value, "cannot call dynamic_where() without a from()");
static_assert(is_noop<Where>::value, "cannot call where() or dynamic_where() twice for a single select");
return {
_flags,
_expression_list,
_from,
{{}},
_group_by,
_having,
_order_by,
_limit,
_offset,
};
}
template<typename Expr>
void add_where(Expr&& expr)
{
static_assert(not is_noop<From>::value, "cannot call add_from() without having selected anything");
static_assert(is_dynamic_t<Where>::value, "cannot call add_where() in a non-dynamic where");
_where.add(std::forward<Expr>(expr));
}
template<typename... Col>
set_group_by_t<Col...> group_by(Col&&... column)
{
@ -391,7 +435,6 @@ namespace sqlpp
{ detail::make_expression_tuple(std::forward<NamedExpr>(namedExpr)...) }
};
}
/*
template<typename Db, typename... NamedExpr>
select_t<typename std::decay<Db>::type, detail::make_select_flag_list_t<NamedExpr...>, detail::make_select_expression_list_t<NamedExpr...>> dynamic_select(const Db& db, NamedExpr&&... namedExpr)
{
@ -400,6 +443,5 @@ namespace sqlpp
{ detail::make_expression_tuple(std::forward<NamedExpr>(namedExpr)...) }
};
}
*/
}
#endif

1
include/sqlpp11/type_traits.h
View File

@ -95,6 +95,7 @@ namespace sqlpp
SQLPP_TYPE_TRAIT_GENERATOR(is_select_flag_list);
SQLPP_TYPE_TRAIT_GENERATOR(is_select_expression_list);
SQLPP_TYPE_TRAIT_GENERATOR(is_from);
SQLPP_TYPE_TRAIT_GENERATOR(is_dynamic);
SQLPP_TYPE_TRAIT_GENERATOR(is_where);
SQLPP_TYPE_TRAIT_GENERATOR(is_group_by);
SQLPP_TYPE_TRAIT_GENERATOR(is_having);

36
include/sqlpp11/where.h
View File

@ -27,10 +27,13 @@
#ifndef SQLPP_WHERE_H
#define SQLPP_WHERE_H
#include <ostream>
#include <vector>
#include <sqlpp11/select_fwd.h>
#include <sqlpp11/expression.h>
#include <sqlpp11/type_traits.h>
#include <sqlpp11/detail/set.h>
#include <sqlpp11/detail/serializable.h>
namespace sqlpp
{
@ -51,6 +54,39 @@ namespace sqlpp
Expr _expr;
};
template<typename Db>
struct dynamic_where_t
{
using _is_where = tag_yes;
using _is_dynamic = tag_yes;
template<typename Expr>
void add(Expr&& expr)
{
static_assert(is_expression_t<Expr>::value, "invalid expression argument in where()");
_conditions.push_back(std::forward<Expr>(expr));
}
void serialize(std::ostream& os, Db& db) const
{
if (_conditions.empty())
return;
os << " WHERE ";
bool first = true;
for (const auto& condition : _conditions)
{
if (not first)
os << " AND ";
condition.serialize(os, db);
first = false;
}
}
std::vector<detail::serializable_t<Db>> _conditions;
};
}
#endif

8
tests/SelectTest.cpp
View File

@ -262,16 +262,14 @@ int main()
static_assert(std::is_same<A, B>::value, "select with identical columns(name/value_type) need to have identical result_types");
}
#if 0
{
auto s = dynamic_select(db, t);
s = s.add_from(t);
s = s.add_from(t); // This will not be accepted by the SQL server, but it is dynamic and this kind of test is not possible at compile time, I guess
auto s = dynamic_select(db, t).dynamic_from().dynamic_where();
s.add_from(t);
s.add_where(t.alpha > 7);
std::cerr << "------------------------\n";
s.serialize(std::cerr, db);
std::cerr << "------------------------\n";
}
#endif
static_assert(sqlpp::is_select_flag_t<decltype(sqlpp::all)>::value, "sqlpp::all has to be a select_flag");