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 'develop' of https://github.com/rbock/sqlpp11 into develop

Browse Source
This commit is contained in:
rbock 2017-11-06 21:37:36 +01:00
commit 3a6e4d93ec
5 changed files with 482 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
include/sqlpp11/connection_pool.h
View File

@ -41,18 +41,20 @@ namespace sqlpp
{
namespace reconnect_policy
{
struct auto_reconnect {
struct auto_reconnect
{
template <typename Connection>
void operator()(Connection* connection)
{
if (!connection->is_valid())
connection->reconnect()
connection->reconnect();
}
template <typename Connection>
void clean(Connection* connection) {}
void clean(Connection* connection)
{
}
};
using namespace std::chrono_literals;
class periodic_reconnect
{
private:
@ -60,8 +62,10 @@ namespace sqlpp
std::unordered_map<void*, std::chrono::time_point<std::chrono::system_clock>> last_checked;
public:
periodic_reconnect(const std::chrono::seconds r = 28800s) //default wait_timeout in MySQL
: revalidate_after(r), last_checked() {}
periodic_reconnect(const std::chrono::seconds r = std::chrono::seconds(28800)) // default wait_timeout in MySQL
: revalidate_after(r), last_checked()
{
}
template <typename Connection>
void operator()(Connection* con)
@ -86,7 +90,8 @@ namespace sqlpp
}
}
template <typename Connection>
void clean(Connection* con) {
void clean(Connection* con)
{
auto itr = last_checked.find(con);
if (itr != last_checked.end())
{
@ -95,17 +100,23 @@ namespace sqlpp
}
};
struct never_reconnect {
struct never_reconnect
{
template <typename Connection>
void operator()(Connection*) {}
void operator()(Connection*)
{
}
template <typename Connection>
void clean(Connection*) {}
void clean(Connection*)
{
}
};
}
template <typename Connection_config,
typename Reconnect_policy = reconnect_policy::auto_reconnect,
typename Connection = typename std::enable_if<std::is_class<Connection_config::connection>::value, Connection_config::connection>::type>
typename Connection = typename std::enable_if<std::is_class<typename Connection_config::connection>::value,
typename Connection_config::connection>::type>
class connection_pool
{
friend pool_connection<Connection_config, Reconnect_policy, Connection>;
@ -146,12 +157,17 @@ namespace sqlpp
public:
connection_pool(const std::shared_ptr<Connection_config>& config, size_t pool_size)
: config(config), maximum_pool_size(pool_size), reconnect_policy(Reconnect_policy()) {}
: config(config), maximum_pool_size(pool_size), reconnect_policy(Reconnect_policy())
{
}
~connection_pool() = default;
connection_pool(const connection_pool&) = delete;
connection_pool(connection_pool&& other)
: config(std::move(other.config)), maximum_pool_size(std::move(other.maximum_pool_size)),
reconnect_policy(std::move(other.reconnect_policy)) {}
: config(std::move(other.config)),
maximum_pool_size(std::move(other.maximum_pool_size)),
reconnect_policy(std::move(other.reconnect_policy))
{
}
connection_pool& operator=(const connection_pool&) = delete;
connection_pool& operator=(connection_pool&&) = delete;
@ -167,7 +183,8 @@ namespace sqlpp
try
{
return pool_connection<Connection_config, Reconnect_policy, Connection>(std::move(std::make_unique<Connection>(config)), this);
auto c = std::unique_ptr<Connection>(new Connection(*(config.get())));
return pool_connection<Connection_config, Reconnect_policy, Connection>(c, this);
}
catch (const sqlpp::exception& e)
{
@ -180,10 +197,10 @@ namespace sqlpp
template <typename Connection_config,
typename Reconnect_policy = reconnect_policy::auto_reconnect,
typename Connection = typename std::enable_if<std::is_class<Connection_config::connection>::value,Connection_config::connection>::type>
typename Connection = typename std::enable_if<std::is_class<typename Connection_config::connection>::value,
typename Connection_config::connection>::type>
connection_pool<Connection_config, Reconnect_policy, Connection> make_connection_pool(
const std::shared_ptr<Connection_config>& config,
size_t max_pool_size)
const std::shared_ptr<Connection_config>& config, size_t max_pool_size)
{
return connection_pool<Connection_config, Reconnect_policy, Connection>(config, max_pool_size);
}

26
include/sqlpp11/pool_connection.h
View File

@ -31,7 +31,12 @@
namespace sqlpp
{
template <typename Connection_config, typename Reconnect_policy, typename Connection,
template <typename Connection_config, typename Reconnect_policy, typename Connection>
class connection_pool;
template <typename Connection_config,
typename Reconnect_policy,
typename Connection,
typename Connection_pool = connection_pool<Connection_config, Reconnect_policy, Connection>>
struct pool_connection
{
@ -41,7 +46,9 @@ namespace sqlpp
public:
pool_connection(std::unique_ptr<Connection>& connection, Connection_pool* origin)
: _impl(std::move(connection)), origin(origin) {}
: _impl(std::move(connection)), origin(origin)
{
}
~pool_connection()
{
@ -49,25 +56,26 @@ namespace sqlpp
}
template <typename... Args>
auto operator()(Args&&... args) -> decltype(_impl->args(std::forward<Args>(args)...))
auto operator()(Args&&... args) -> decltype((*_impl)(std::forward<Args>(args)...))
{
return _impl->args(std::forward<Args>(args)...);
return (*_impl)(std::forward<Args>(args)...);
}
template <typename T>
auto operator()(const T& t) -> decltype(_impl->run(t))
auto operator()(const T& t) -> decltype((*_impl)(t))
{
return _impl->run(t);
return (*_impl)(t);
}
Connection* operator->()
{
return &_impl;
return _impl.get();
}
pool_connection(const pool_connection&) = delete;
pool_connection(pool_connection&& other)
: _impl(std::move(other._impl)), origin(other.origin) {}
pool_connection(pool_connection&& other) : _impl(std::move(other._impl)), origin(other.origin)
{
}
pool_connection& operator=(const pool_connection&) = delete;
pool_connection& operator=(pool_connection&&) = delete;
};

28
include/sqlpp11/result.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* Copyright (c) 2013-2017, Roland Bock, Aaron Bishop
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@ -38,6 +38,25 @@ namespace sqlpp
using type = std::input_iterator_tag;
};
namespace detail
{
template<class DbResult, class = void>
struct result_has_size : std::false_type {};
template<class DbResult>
struct result_has_size<DbResult, void_t<decltype(std::declval<DbResult>().size())>>
: std::true_type {};
template<class DbResult, class = void>
struct result_size_type { using type = void; };
template<class DbResult>
struct result_size_type<DbResult, void_t<decltype(std::declval<DbResult>().size())>>
{
using type = decltype(std::declval<DbResult>().size());
};
}
template <typename DbResult, typename ResultRow>
class result_t
{
@ -139,6 +158,13 @@ namespace sqlpp
{
_result.next(_result_row);
}
template<class Size = typename detail::result_size_type<DbResult>::type>
Size size() const
{
static_assert(detail::result_has_size<DbResult>::value, "Underlying connector does not support size()");
return _result.size();
}
};
} // namespace sqlpp

8
test_types/result_row.cpp
View File

@ -73,6 +73,14 @@ namespace
static_assert(not sqlpp::can_be_null_t<decltype(x.delta)>::value, "right side of (inner) join cannot be null");
static_assert(not sqlpp::can_be_null_t<decltype(x.s)>::value, "constant non-null value can not be null");
}
{
MockSizeDb db2;
auto&& result = db2(select(bar.alpha, foo.delta, bar.gamma, seven)
.from(bar.join(foo).on(foo.omega > bar.alpha))
.unconditionally());
result.size();
static_assert(std::is_same<size_t, decltype(result.size())>::value, "MockSizeDb size() isn't size_t");
}
// Inner join
{

202
tests/MockDb.h
View File

@ -288,4 +288,206 @@ struct MockDbT : public sqlpp::connection
using MockDb = MockDbT<false>;
using EnforceDb = MockDbT<true>;
struct MockSizeDb : public sqlpp::connection
{
using _traits = MockDb::_traits;
using _serializer_context_t = MockDb::_serializer_context_t;
using _interpreter_context_t = _serializer_context_t;
_serializer_context_t get_serializer_context()
{
return {};
}
template <typename T>
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)
{
sqlpp::serialize(t, context);
return context;
}
class result_t : public MockDb::result_t
{
public:
size_t size() const { return 0; }
};
// Directly executed statements start here
template <typename T>
auto _run(const T& t, ::sqlpp::consistent_t) -> decltype(t._run(*this))
{
return t._run(*this);
}
template <typename Check, typename T>
auto _run(const T& t, Check) -> Check;
template <typename T>
auto operator()(const T& t) -> decltype(this->_run(t, sqlpp::run_check_t<_serializer_context_t, T>{}))
{
return _run(t, sqlpp::run_check_t<_serializer_context_t, T>{});
}
size_t execute(const std::string&)
{
return 0;
}
template <
typename Statement,
typename Enable = typename std::enable_if<not std::is_convertible<Statement, std::string>::value, void>::type>
size_t execute(const Statement& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running execute call with\n" << context.str() << std::endl;
return execute(context.str());
}
template <typename Insert>
size_t insert(const Insert& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running insert call with\n" << context.str() << std::endl;
return 0;
}
template <typename Update>
size_t update(const Update& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running update call with\n" << context.str() << std::endl;
return 0;
}
template <typename Remove>
size_t remove(const Remove& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running remove call with\n" << context.str() << std::endl;
return 0;
}
template <typename Select>
result_t select(const Select& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running select call with\n" << context.str() << std::endl;
return {};
}
// Prepared statements start here
using _prepared_statement_t = std::nullptr_t;
template <typename T>
auto _prepare(const T& t, ::sqlpp::consistent_t) -> decltype(t._prepare(*this))
{
return t._prepare(*this);
}
template <typename Check, typename T>
auto _prepare(const T& t, Check) -> Check;
template <typename T>
auto prepare(const T& t) -> decltype(this->_prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{}))
{
return _prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{});
}
template <typename Statement>
_prepared_statement_t prepare_execute(Statement& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running prepare execute call with\n" << context.str() << std::endl;
return nullptr;
}
template <typename Insert>
_prepared_statement_t prepare_insert(Insert& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running prepare insert call with\n" << context.str() << std::endl;
return nullptr;
}
template <typename PreparedExecute>
size_t run_prepared_execute(const PreparedExecute&)
{
return 0;
}
template <typename PreparedInsert>
size_t run_prepared_insert(const PreparedInsert&)
{
return 0;
}
template <typename Select>
_prepared_statement_t prepare_select(Select& x)
{
_serializer_context_t context;
::sqlpp::serialize(x, context);
std::cout << "Running prepare select call with\n" << context.str() << std::endl;
return nullptr;
}
template <typename PreparedSelect>
result_t run_prepared_select(PreparedSelect&)
{
return {};
}
auto attach(std::string name) -> ::sqlpp::schema_t
{
return {name};
}
void start_transaction()
{
_mock_data._last_isolation_level = _mock_data._default_isolation_level;
}
void start_transaction(sqlpp::isolation_level level)
{
_mock_data._last_isolation_level = level;
}
void set_default_isolation_level(sqlpp::isolation_level level)
{
_mock_data._default_isolation_level = level;
}
sqlpp::isolation_level get_default_isolation_level()
{
return _mock_data._default_isolation_level;
}
void rollback_transaction(bool)
{}
void commit_transaction()
{}
void report_rollback_failure(std::string)
{}
// temporary data store to verify the expected results were produced
InternalMockData _mock_data;
};
#endif