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 some (no-op) statement executions

Browse Source
This commit is contained in:
rbock 2014-02-21 06:02:49 +01:00
parent 3bbe343a77
commit b7935b61d5
18 changed files with 185 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sqlpp11/boolean.h
View File

@ -98,6 +98,7 @@ namespace sqlpp
bool _is_null;
};
template<bool TrivialIsNull = false>
struct _result_entry_t
{
_result_entry_t():
@ -189,7 +190,8 @@ namespace sqlpp
};
};
inline std::ostream& operator<<(std::ostream& os, const boolean::_result_entry_t& e)
template<bool TrivialIsNull>
inline std::ostream& operator<<(std::ostream& os, const boolean::_result_entry_t<TrivialIsNull>& e)
{
return os << e.value();
}

4
include/sqlpp11/floating_point.h
View File

@ -98,6 +98,7 @@ namespace sqlpp
bool _is_null;
};
template<bool TrivialIsNull = false>
struct _result_entry_t
{
using _value_type = integral;
@ -237,7 +238,8 @@ namespace sqlpp
};
};
inline std::ostream& operator<<(std::ostream& os, const floating_point::_result_entry_t& e)
template<bool TrivialIsNull>
inline std::ostream& operator<<(std::ostream& os, const floating_point::_result_entry_t<TrivialIsNull>& e)
{
return os << e.value();
}

4
include/sqlpp11/integral.h
View File

@ -98,6 +98,7 @@ namespace sqlpp
bool _is_null;
};
template<bool NullIsTrivial = false>
struct _result_entry_t
{
using _value_type = integral;
@ -244,7 +245,8 @@ namespace sqlpp
};
};
inline std::ostream& operator<<(std::ostream& os, const integral::_result_entry_t& e)
template<bool NullIsTrivial>
inline std::ostream& operator<<(std::ostream& os, const integral::_result_entry_t<NullIsTrivial>& e)
{
return os << e.value();
}

6
include/sqlpp11/result_row.h
View File

@ -43,10 +43,10 @@ namespace sqlpp
template<size_t level, size_t index, typename NamedExpr, typename... Rest>
struct result_row_impl<level, index, NamedExpr, Rest...>:
public NamedExpr::_name_t::template _member_t<typename NamedExpr::_value_type::_result_entry_t>,
public NamedExpr::_name_t::template _member_t<typename NamedExpr::_value_type::template _result_entry_t<NamedExpr::_trivial_value_is_null>>,
public result_row_impl<level, index + 1, Rest...>
{
using _field = typename NamedExpr::_name_t::template _member_t<typename NamedExpr::_value_type::_result_entry_t>;
using _field = typename NamedExpr::_name_t::template _member_t<typename NamedExpr::_value_type::template _result_entry_t<NamedExpr::_trivial_value_is_null>>;
using _rest = result_row_impl<level, index + 1, Rest...>;
static constexpr size_t _last_index = _rest::_last_index;
@ -225,7 +225,7 @@ namespace sqlpp
struct dynamic_result_row_t: public detail::result_row_impl<0, 0, NamedExpr...>
{
using _impl = detail::result_row_impl<0, 0, NamedExpr...>;
using _field_type = detail::text::_result_entry_t;
using _field_type = detail::text::_result_entry_t<>;
static constexpr size_t _last_static_index = _impl::_last_index;
bool _is_valid;

10
include/sqlpp11/serialize.h
View File

@ -38,6 +38,16 @@ namespace sqlpp
return vendor::serializer_t<Context, T>::_(t, context);
}
namespace vendor // Required if you want to call serialize(sqlpp::value(7), printer), for instance
{
template<typename T, typename Context>
auto serialize(const T& t, Context& context)
-> decltype(vendor::serializer_t<Context, T>::_(t, context))
{
return vendor::serializer_t<Context, T>::_(t, context);
}
}
}
#endif

18
include/sqlpp11/serializer_context.h
View File

@ -42,14 +42,20 @@ namespace sqlpp
return _os << t;
}
void flush()
static std::string escape(std::string arg)
{
_os << std::endl;
if (arg.find('\''))
{
std::string retVal;
for (const auto c : arg)
{
if (c == '\'')
retVal.push_back(c);
retVal.push_back(c);
}
std::string escape(std::string arg)
{
// FIXME: Need to do better escaping
return retVal;
}
else
return arg;
}

4
include/sqlpp11/text.h
View File

@ -97,6 +97,7 @@ namespace sqlpp
bool _is_null;
};
template<bool TrivialIsNull = false>
struct _result_entry_t
{
_result_entry_t():
@ -195,7 +196,8 @@ namespace sqlpp
};
};
inline std::ostream& operator<<(std::ostream& os, const text::_result_entry_t& e)
template<bool TrivialIsNull>
inline std::ostream& operator<<(std::ostream& os, const text::_result_entry_t<TrivialIsNull>& e)
{
return os << e.value();
}

1
include/sqlpp11/type_traits.h
View File

@ -92,6 +92,7 @@ namespace sqlpp
SQLPP_IS_COLUMN_TRAIT_GENERATOR(must_not_update);
SQLPP_IS_COLUMN_TRAIT_GENERATOR(require_insert);
SQLPP_IS_COLUMN_TRAIT_GENERATOR(can_be_null);
SQLPP_IS_COLUMN_TRAIT_GENERATOR(trivial_value_is_null);
SQLPP_TYPE_TRAIT_GENERATOR(is_noop);
SQLPP_TYPE_TRAIT_GENERATOR(is_table);

7
include/sqlpp11/vendor/field.h vendored
View File

@ -33,11 +33,12 @@ namespace sqlpp
{
namespace vendor
{
template<typename NameType, typename ValueType>
template<typename NameType, typename ValueType, bool TrivialValueIsNull>
struct field_t
{
using _name_t = NameType;
using _value_type = ValueType;
static constexpr bool _trivial_value_is_null = TrivialValueIsNull;
};
template<typename AliasProvider, typename FieldTuple>
@ -50,7 +51,9 @@ namespace sqlpp
template<typename NamedExpr>
struct make_field_t_impl
{
using type = field_t<typename NamedExpr::_name_t, typename NamedExpr::_value_type::_base_value_type>;
using type = field_t<typename NamedExpr::_name_t,
typename NamedExpr::_value_type::_base_value_type,
trivial_value_is_null_t<NamedExpr>::value>;
};
template<typename AliasProvider, typename... NamedExpr>

2
include/sqlpp11/vendor/interpretable.h vendored
View File

@ -63,7 +63,7 @@ namespace sqlpp
template<typename Context>
auto serialize(Context& context) const
-> typename std::enable_if<std::is_same<Context, _serializer_context_t>::value
and not std::is_same<Context, sqlpp::serializer_context_t>::value, void>::type
and not std::is_same<Context, sqlpp::serializer_context_t>::value, Context&>::type
{
return _impl->db_serialize(context);
}

2
include/sqlpp11/vendor/named_interpretable.h vendored
View File

@ -61,7 +61,7 @@ namespace sqlpp
template<typename Context>
auto serialize(Context& context) const
-> typename std::enable_if<std::is_same<Context, _serializer_context_t>::value
and not std::is_same<Context, sqlpp::serializer_context_t>::value, void>::type
and not std::is_same<Context, sqlpp::serializer_context_t>::value, Context&>::type
{
return _impl->db_serialize(context);
}

12
tests/CMakeLists.txt
View File

@ -7,12 +7,12 @@ macro (build_and_run arg)
endmacro ()
build_and_run(InterpretTest)
build_and_run(InsertTest)
build_and_run(RemoveTest)
build_and_run(UpdateTest)
build_and_run(SelectTest)
build_and_run(FunctionTest)
build_and_run(PreparedTest)
#build_and_run(InsertTest)
#build_and_run(RemoveTest)
#build_and_run(UpdateTest)
#build_and_run(SelectTest)
#build_and_run(FunctionTest)
#build_and_run(PreparedTest)
find_package(PythonInterp REQUIRED)

18
tests/InsertTest.cpp
View File

@ -30,7 +30,7 @@
#include <iostream>
DbMock db;
DbMock::_serializer_context_t printer(std::cerr);
DbMock::_serializer_context_t printer;
int main()
{
@ -58,16 +58,22 @@ int main()
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
serialize(insert_into(t).default_values(), printer).flush();
serialize(insert_into(t), printer).flush();
serialize(insert_into(t).set(t.beta = "kirschauflauf"), printer).flush();
serialize(insert_into(t).columns(t.beta), printer).flush();
db(insert_into(t).default_values());
db(insert_into(t).set(t.beta = "kirschauflauf"));
serialize(insert_into(t).default_values(), printer).str();
serialize(insert_into(t), printer).str();
serialize(insert_into(t).set(t.beta = "kirschauflauf"), printer).str();
serialize(insert_into(t).columns(t.beta), printer).str();
auto multi_insert = insert_into(t).columns(t.beta, t.delta);
multi_insert.add_values(t.beta = "cheesecake", t.delta = 1);
multi_insert.add_values(t.beta = sqlpp::default_value, t.delta = sqlpp::default_value);
auto i = dynamic_insert_into(db, t).dynamic_set();
i.add_set(t.beta = "kirschauflauf");
serialize(i, printer).flush();
serialize(i, printer).str();
db(multi_insert);
return 0;
}

145
tests/InterpretTest.cpp
View File

@ -35,7 +35,7 @@
#include <iostream>
DbMock db = {};
DbMock::_serializer_context_t printer(std::cerr);
DbMock::_serializer_context_t printer;
SQLPP_ALIAS_PROVIDER(kaesekuchen);
int main()
@ -43,122 +43,123 @@ int main()
test::TabFoo f;
test::TabBar t;
serialize(insert_into(t).columns(t.beta, t.gamma), printer).flush();
serialize(insert_into(t).columns(t.beta, t.gamma), printer).str();
{
auto i = insert_into(t).columns(t.gamma, t.beta);
i.add_values(t.gamma = true, t.beta = "cheesecake");
serialize(i, printer).flush();
serialize(i, printer).str();
i.add_values(t.gamma = false, t.beta = sqlpp::tvin("coffee"));
i.add_values(t.gamma = false, t.beta = sqlpp::tvin(std::string()));
serialize(i, printer).flush();
serialize(i, printer).str();
i.add_values(t.gamma = sqlpp::default_value, t.beta = sqlpp::null);
serialize(i, printer).flush();
serialize(i, printer).str();
}
serialize(t.alpha = sqlpp::null, printer).flush();
serialize(t.alpha = sqlpp::default_value, printer).flush();
serialize(t.alpha, printer).flush();
serialize(-t.alpha, printer).flush();
serialize(+t.alpha, printer).flush();
serialize(-(t.alpha + 7), printer).flush();
serialize(t.alpha = 0, printer).flush();
serialize(t.alpha = sqlpp::tvin(0), printer).flush();
serialize(t.alpha == 0, printer).flush();
serialize(t.alpha == sqlpp::tvin(0), printer).flush();
serialize(t.alpha != 0, printer).flush();
serialize(t.gamma != sqlpp::tvin(false), printer).flush();
serialize(t.alpha == 7, printer).flush();
serialize(t.beta + "kaesekuchen", printer).flush();
serialize(t.alpha = sqlpp::null, printer).str();
serialize(t.alpha = sqlpp::default_value, printer).str();
serialize(t.alpha, printer).str();
serialize(-t.alpha, printer).str();
serialize(+t.alpha, printer).str();
serialize(-(t.alpha + 7), printer).str();
serialize(t.alpha = 0, printer).str();
serialize(t.alpha = sqlpp::tvin(0), printer).str();
serialize(t.alpha == 0, printer).str();
serialize(t.alpha == sqlpp::tvin(0), printer).str();
serialize(t.alpha != 0, printer).str();
serialize(t.gamma != sqlpp::tvin(false), printer).str();
serialize(t.alpha == 7, printer).str();
serialize(t.beta + "kaesekuchen", printer).str();
serialize(sqlpp::select(), printer).flush();
serialize(sqlpp::select().flags(sqlpp::distinct), printer).flush();
serialize(select(t.alpha, t.beta).flags(sqlpp::distinct), printer).flush();
serialize(select(t.alpha, t.beta), printer).flush();
serialize(select(t.alpha, t.beta).from(t), printer).flush();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3), printer).flush();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma), printer).flush();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")), printer).flush();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()), printer).flush();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()).limit(17).offset(3), printer).flush();
serialize(sqlpp::select(), printer).str();
serialize(sqlpp::select().flags(sqlpp::distinct), printer).str();
serialize(select(t.alpha, t.beta).flags(sqlpp::distinct), printer).str();
serialize(select(t.alpha, t.beta), printer).str();
serialize(select(t.alpha, t.beta).from(t), printer).str();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3), printer).str();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma), printer).str();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")), printer).str();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()), printer).str();
serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")).order_by(t.beta.asc()).limit(17).offset(3), printer).str();
serialize(parameter(sqlpp::bigint(), t.alpha), printer).flush();
serialize(parameter(t.alpha), printer).flush();
serialize(t.alpha == parameter(t.alpha), printer).flush();
serialize(t.alpha == parameter(t.alpha) and (t.beta + "gimmick").like(parameter(t.beta)), printer).flush();
serialize(parameter(sqlpp::bigint(), t.alpha), printer).str();
serialize(parameter(t.alpha), printer).str();
serialize(t.alpha == parameter(t.alpha), printer).str();
serialize(t.alpha == parameter(t.alpha) and (t.beta + "gimmick").like(parameter(t.beta)), printer).str();
serialize(insert_into(t), printer).flush();
serialize(insert_into(f).default_values(), printer).flush();
serialize(insert_into(t).set(t.gamma = true), printer).flush();
//serialize(insert_into(t).set(t.gamma = sqlpp::tvin(false)), printer).flush(); cannot test this since gamma cannot be null and a static assert is thrown
serialize(insert_into(t), printer).str();
serialize(insert_into(f).default_values(), printer).str();
serialize(insert_into(t).set(t.gamma = true), printer).str();
//serialize(insert_into(t).set(t.gamma = sqlpp::tvin(false)), printer).str(); cannot test this since gamma cannot be null and a static assert is thrown
serialize(update(t), printer).flush();
serialize(update(t).set(t.gamma = true), printer).flush();
serialize(update(t).set(t.gamma = true).where(t.beta.in("kaesekuchen", "cheesecake")), printer).flush();
serialize(update(t), printer).str();
serialize(update(t).set(t.gamma = true), printer).str();
serialize(update(t).set(t.gamma = true).where(t.beta.in("kaesekuchen", "cheesecake")), printer).str();
serialize(remove_from(t), printer).flush();
serialize(remove_from(t).using_(t), printer).flush();
serialize(remove_from(t).where(t.alpha == sqlpp::tvin(0)), printer).flush();
serialize(remove_from(t).using_(t).where(t.alpha == sqlpp::tvin(0)), printer).flush();
serialize(remove_from(t), printer).str();
serialize(remove_from(t).using_(t), printer).str();
serialize(remove_from(t).where(t.alpha == sqlpp::tvin(0)), printer).str();
serialize(remove_from(t).using_(t).where(t.alpha == sqlpp::tvin(0)), printer).str();
// functions
serialize(sqlpp::value(7), printer).flush();
serialize(sqlpp::verbatim<sqlpp::detail::integral>("irgendwas integrales"), printer).flush();
serialize(sqlpp::value_list(std::vector<int>({1,2,3,4,5,6,8})), printer).flush();
serialize(exists(select(t.alpha).from(t)), printer).flush();
serialize(any(select(t.alpha).from(t)), printer).flush();
serialize(some(select(t.alpha).from(t)), printer).flush();
serialize(count(t.alpha), printer).flush();
serialize(min(t.alpha), printer).flush();
serialize(max(t.alpha), printer).flush();
serialize(avg(t.alpha), printer).flush();
serialize(sum(t.alpha), printer).flush();
serialize(sqlpp::verbatim_table("whatever"), printer).flush();
serialize(sqlpp::value(7), printer).str();
serialize(sqlpp::verbatim<sqlpp::detail::integral>("irgendwas integrales"), printer).str();
serialize(sqlpp::value_list(std::vector<int>({1,2,3,4,5,6,8})), printer).str();
serialize(exists(select(t.alpha).from(t)), printer).str();
serialize(any(select(t.alpha).from(t)), printer).str();
serialize(some(select(t.alpha).from(t)), printer).str();
serialize(count(t.alpha), printer).str();
serialize(min(t.alpha), printer).str();
serialize(max(t.alpha), printer).str();
serialize(avg(t.alpha), printer).str();
serialize(sum(t.alpha), printer).str();
serialize(sqlpp::verbatim_table("whatever"), printer).str();
// alias
serialize(t.as(t.alpha), printer).flush();
serialize(t.as(t.alpha).beta, printer).flush();
serialize(t.as(t.alpha), printer).str();
serialize(t.as(t.alpha).beta, printer).str();
// select alias
serialize(select(t.alpha).from(t).where(t.beta > "kaesekuchen").as(t.gamma), printer).flush();
serialize(select(t.alpha).from(t).where(t.beta > "kaesekuchen").as(t.gamma), printer).str();
serialize(t.alpha.is_null(), printer).flush();
serialize(t.alpha.is_null(), printer).str();
// join
serialize(t.inner_join(t.as(t.alpha)).on(t.beta == t.as(t.alpha).beta), printer).flush();
serialize(t.inner_join(t.as(t.alpha)).on(t.beta == t.as(t.alpha).beta), printer).str();
// multi_column
serialize(multi_column(t.alpha, (t.beta + "cake").as(t.gamma)).as(t.alpha), printer).flush();
serialize(multi_column(all_of(t)).as(t), printer).flush();
serialize(all_of(t).as(t), printer).flush();
serialize(multi_column(t.alpha, (t.beta + "cake").as(t.gamma)).as(t.alpha), printer).str();
serialize(multi_column(all_of(t)).as(t), printer).str();
serialize(all_of(t).as(t), printer).str();
// dynamic select
{
auto s = dynamic_select(db).dynamic_flags().dynamic_columns();
s.add_column(t.beta);
s.add_column(t.gamma);
serialize(s, printer).flush();
serialize(s, printer).str();
}
{
auto s = dynamic_select(db).dynamic_flags().dynamic_columns();
s.add_flag(sqlpp::distinct);
s.add_column(t.beta);
s.add_column(t.gamma);
serialize(s, printer).flush();
serialize(s, printer).str();
}
{
auto s = dynamic_select(db).dynamic_flags(sqlpp::distinct).dynamic_columns(t.alpha);
s.add_flag(sqlpp::all);
s.add_column(t.beta);
s.add_column(t.gamma);
serialize(s, printer).flush();
serialize(s, printer).str();
}
// distinct aggregate
serialize(count(sqlpp::distinct, t.alpha % 7), printer).flush();
serialize(avg(sqlpp::distinct, t.alpha - 7), printer).flush();
serialize(sum(sqlpp::distinct, t.alpha + 7), printer).flush();
serialize(count(sqlpp::distinct, t.alpha % 7), printer).str();
serialize(avg(sqlpp::distinct, t.alpha - 7), printer).str();
serialize(sum(sqlpp::distinct, t.alpha + 7), printer).str();
serialize(select(all_of(t)).from(t).where(true), printer).str();
serialize(select(all_of(t)).from(t).where(false), printer).str();
serialize(select(all_of(t)).from(t).where(true), printer).flush();
serialize(select(all_of(t)).from(t).where(false), printer).flush();
return 0;
}

32
tests/MockDb.h
View File

@ -26,23 +26,49 @@
#ifndef SQLPP_MOCK_DB_H
#define SQLPP_MOCK_DB_H
#include <sstream>
#include <sqlpp11/serializer_context.h>
#include <sqlpp11/connection.h>
struct DbMock: public sqlpp::connection
{
using _serializer_context_t = sqlpp::serializer_context_t;
struct _serializer_context_t
{
std::ostringstream _os;
std::string str() const
{
return _os.str();
}
void reset()
{
_os.clear();
}
template<typename T>
std::ostream& operator<<(T t)
{
return _os << t;
}
static std::string escape(std::string arg)
{
return sqlpp::serializer_context_t::escape(arg);
}
};
using _interpreter_context_t = _serializer_context_t;
template<typename T>
static _serializer_context_t _serialize_interpretable(const T& t, _serializer_context_t& context)
static _serializer_context_t& _serialize_interpretable(const T& t, _serializer_context_t& context)
{
sqlpp::serialize(t, context);
return context;
}
template<typename T>
static _serializer_context_t _interpret_interpretable(const T& t, _interpreter_context_t& context)
static _serializer_context_t& _interpret_interpretable(const T& t, _interpreter_context_t& context)
{
sqlpp::serialize(t, context);
return context;

10
tests/RemoveTest.cpp
View File

@ -31,7 +31,7 @@
DbMock db;
DbMock::_serializer_context_t printer(std::cerr);
DbMock::_serializer_context_t printer;
int main()
{
@ -56,13 +56,13 @@ int main()
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
serialize(remove_from(t), printer).flush();
serialize(remove_from(t).where(t.beta != "transparent"), printer).flush();
serialize(remove_from(t).using_(t), printer).flush();
serialize(remove_from(t), printer).str();
serialize(remove_from(t).where(t.beta != "transparent"), printer).str();
serialize(remove_from(t).using_(t), printer).str();
auto r = dynamic_remove_from(db, t).dynamic_using().dynamic_where();
r.add_using(t);
r.add_where(t.beta != "transparent");
serialize(r, printer).flush();
serialize(r, printer).str();
return 0;
}

14
tests/SelectTest.cpp
View File

@ -34,7 +34,7 @@
DbMock db = {};
DbMock::_serializer_context_t printer(std::cerr);
DbMock::_serializer_context_t printer;
namespace alias
{
@ -311,7 +311,7 @@ int main()
s.set_limit(30);
s.set_limit(3);
std::cerr << "------------------------\n";
serialize(s, printer).flush();
serialize(s, printer).str();
std::cerr << "------------------------\n";
using T = decltype(s);
static_assert(sqlpp::is_regular<T>::value, "type requirement");
@ -321,13 +321,13 @@ int main()
{
auto s = dynamic_select(db).dynamic_columns();
s.add_column(t.alpha);
serialize(s, printer).flush();
serialize(s, printer).str();
}
// Test that verbatim_table compiles
{
auto s = select(t.alpha).from(sqlpp::verbatim_table("my_unknown_table"));
serialize(s, printer).flush();
serialize(s, printer).str();
}
@ -344,9 +344,9 @@ int main()
auto y = t.gamma and true and t.gamma;
!t.gamma;
t.beta < "kaesekuchen";
serialize(t.beta + "hallenhalma", printer).flush();
serialize(t.beta + "hallenhalma", printer).str();
static_assert(sqlpp::must_not_insert_t<decltype(t.alpha)>::value, "alpha must not be inserted");
serialize(t.alpha, printer).flush();
serialize(t.alpha, printer).str();
std::cerr << "\n" << sizeof(test::TabBar) << std::endl;
static_assert(std::is_same<typename decltype(t.alpha)::_value_type::_is_named_expression, std::true_type>::value, "alpha should be a named expression");
static_assert(sqlpp::is_named_expression_t<decltype(t.alpha)>::value, "alpha should be a named expression");
@ -365,7 +365,7 @@ int main()
.limit(17)
.offset(3)
.as(alias::a)
, printer).flush();
, printer).str();
return 0;
}

12
tests/UpdateTest.cpp
View File

@ -30,7 +30,7 @@
#include "is_regular.h"
DbMock db;
DbMock::_serializer_context_t printer(std::cerr);
DbMock::_serializer_context_t printer;
int main()
{
@ -56,13 +56,13 @@ int main()
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
serialize(update(t), printer).flush();
serialize(update(t).set(t.gamma = false), printer).flush();
serialize(update(t).set(t.gamma = false).where(t.beta != "transparent"), printer).flush();
serialize(update(t).set(t.beta = "opaque").where(t.beta != t.beta), printer).flush();
serialize(update(t), printer).str();
serialize(update(t).set(t.gamma = false), printer).str();
serialize(update(t).set(t.gamma = false).where(t.beta != "transparent"), printer).str();
serialize(update(t).set(t.beta = "opaque").where(t.beta != t.beta), printer).str();
auto u = dynamic_update(db, t).dynamic_set(t.gamma = false).dynamic_where();
u.add_set(t.gamma = false);
serialize(u, printer).flush();
serialize(u, printer).str();
return 0;
}