boost/mysql
2
0
Fork 0
mirror of https://github.com/boostorg/mysql.git synced 2026-02-17 13:52:18 +00:00
Code Issues Projects Releases Wiki Activity

async_callback_noerrinfo

Browse Source
This commit is contained in:
Ruben Perez
2022-10-14 17:44:57 +02:00
parent 02e864ac9f
commit f8498a2138
3 changed files with 67 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/boost/mysql/statement.hpp
View File

@@ -104,7 +104,7 @@ public:
CompletionToken&& token BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)
)
{
return async_execute_statement(
return async_execute(
make_execute_params(params),
result,
std::forward<CompletionToken>(token)

5
test/integration/utils/src/async_callback.cpp
View File

@@ -142,10 +142,7 @@ public:
);
});
}
network_result<no_result> connect(
er_endpoint kind,
const boost::mysql::handshake_params& params
) override
network_result<no_result> connect(er_endpoint kind, const handshake_params& params) override
{
return impl<no_result>([&](handler<no_result> h, error_info& info) {
return this->conn_

143
test/integration/utils/src/async_callback_noerrinfo.cpp
View File

@@ -5,31 +5,37 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "er_network_variant.hpp"
#include "er_connection.hpp"
#include "er_resultset.hpp"
#include "er_statement.hpp"
#include "network_result.hpp"
#include "streams.hpp"
#include "er_impl_common.hpp"
#include "get_endpoint.hpp"
#include "handler_call_tracker.hpp"
#include <boost/mysql/handshake_params.hpp>
#include <boost/mysql/connection.hpp>
#include <boost/mysql/errc.hpp>
#include <boost/mysql/error.hpp>
#include <boost/mysql/execute_params.hpp>
#include <boost/mysql/statement_base.hpp>
#include <boost/mysql/row.hpp>
#include <boost/mysql/handshake_params.hpp>
#include <boost/mysql/resultset_base.hpp>
#include <boost/mysql/connection.hpp>
#include <boost/mysql/row.hpp>
#include <boost/mysql/row_view.hpp>
#include <boost/mysql/rows_view.hpp>
#include <boost/mysql/statement_base.hpp>
#include <memory>
#include "er_connection.hpp"
#include "er_impl_common.hpp"
#include "er_network_variant.hpp"
#include "er_resultset.hpp"
#include "er_statement.hpp"
#include "get_endpoint.hpp"
#include "handler_call_tracker.hpp"
#include "network_result.hpp"
#include "streams.hpp"
using namespace boost::mysql::test;
using boost::mysql::row;
using boost::mysql::error_code;
using boost::mysql::error_info;
using boost::mysql::field_view;
using boost::mysql::connection_params;
using boost::mysql::handshake_params;
using boost::mysql::row;
using boost::mysql::row_view;
using boost::mysql::rows_view;
namespace {
@@ -67,116 +73,95 @@ template <class Stream>
class async_callback_noerrinfo_resultset : public er_resultset_base<Stream>
{
public:
using er_resultset_base<Stream>::er_resultset_base;
network_result<bool> read_one(row& output) override
network_result<row_view> read_one() override
{
return impl<bool>([&](handler<bool> h) {
return this->r_.async_read_one(output, std::move(h));
return impl<row_view>([&](handler<row_view> h) {
return this->obj().async_read_one(std::move(h));
});
}
network_result<std::vector<row>> read_many(std::size_t count) override
network_result<rows_view> read_some() override
{
return impl<std::vector<row>>([&](handler<std::vector<row>> h) {
return this->r_.async_read_many(count, std::move(h));
return impl<rows_view>([&](handler<rows_view> h) {
return this->obj().async_read_some(std::move(h));
});
}
network_result<std::vector<row>> read_all() override
network_result<rows_view> read_all() override
{
return impl<std::vector<row>>([&](handler<std::vector<row>> h) {
return this->r_.async_read_all(std::move(h));
return impl<rows_view>([&](handler<rows_view> h) {
return this->obj().async_read_all(std::move(h));
});
}
};
template <class Stream>
network_result<er_resultset_ptr> erase_network_result(network_result<boost::mysql::resultset_base<Stream>>&& r)
{
return network_result<er_resultset_ptr> (
r.err,
erase_resultset<async_callback_noerrinfo_resultset>(std::move(r.value))
);
}
template <class Stream>
class async_callback_noerrinfo_statement : public er_statement_base<Stream>
{
public:
using er_statement_base<Stream>::er_statement_base;
using resultset_type = boost::mysql::resultset_base<Stream>;
network_result<er_resultset_ptr> execute_params(
const boost::mysql::execute_params<value_list_it>& params
network_result<no_result> execute_params(
const boost::mysql::execute_params<value_list_it>& params,
er_resultset& result
) override
{
return erase_network_result(impl<resultset_type>([&](handler<resultset_type> h) {
return this->stmt_.async_execute(params, std::move(h));
}));
return impl<no_result>([&](handler<no_result> h) {
return this->obj().async_execute(params, this->cast(result), std::move(h));
});
}
network_result<er_resultset_ptr> execute_container(
const std::vector<field_view>& values
network_result<no_result> execute_collection(
const std::vector<field_view>& values,
er_resultset& result
) override
{
return erase_network_result(impl<resultset_type>([&](handler<resultset_type> h) {
return this->stmt_.async_execute(values, std::move(h));
}));
return impl<no_result>([&](handler<no_result> h) {
return this->obj().async_execute(values, this->cast(result), std::move(h));
});
}
network_result<no_result> close() override
{
return impl<no_result>([&](handler<no_result> h) {
return this->stmt_.async_close(std::move(h));
return this->obj().async_close(std::move(h));
});
}
};
template <class Stream>
network_result<er_statement_ptr> erase_network_result(network_result<boost::mysql::statement_base<Stream>>&& r)
{
return network_result<er_statement_ptr> (
r.err,
erase_statement<async_callback_noerrinfo_statement>(std::move(r.value))
);
}
template <class Stream>
class async_callback_noerrinfo_connection : public er_connection_base<Stream>
{
public:
using er_connection_base<Stream>::er_connection_base;
using statement_type = boost::mysql::statement_base<Stream>;
using resultset_type = boost::mysql::resultset_base<Stream>;
network_result<no_result> physical_connect(er_endpoint kind) override
{
return impl<no_result>([&](handler<no_result> h) {
return this->conn_.next_layer().lowest_layer().async_connect(get_endpoint<Stream>(kind), std::move(h));
return this->conn_.stream().lowest_layer().async_connect(
get_endpoint<Stream>(kind),
std::move(h)
);
});
}
network_result<no_result> connect(
er_endpoint kind,
const boost::mysql::connection_params& params
) override
network_result<no_result> connect(er_endpoint kind, const handshake_params& params) override
{
return impl<no_result>([&](handler<no_result> h) {
return this->conn_.async_connect(get_endpoint<Stream>(kind), params, std::move(h));
});
}
network_result<no_result> handshake(const connection_params& params) override
network_result<no_result> handshake(const handshake_params& params) override
{
return impl<no_result>([&](handler<no_result> h) {
return this->conn_.async_handshake(params, std::move(h));
});
}
network_result<er_resultset_ptr> query(boost::string_view query) override
network_result<no_result> query(boost::string_view query, er_resultset& result) override
{
return erase_network_result(impl<resultset_type>([&](handler<resultset_type> h) {
return this->conn_.async_query(query, std::move(h));
}));
return impl<no_result>([&](handler<no_result> h) {
return this->conn_.async_query(query, this->cast(result), std::move(h));
});
}
network_result<er_statement_ptr> prepare_statement(boost::string_view statement) override
network_result<no_result> prepare_statement(boost::string_view statement, er_statement& stmt)
override
{
return erase_network_result(impl<statement_type>([&](handler<statement_type> h) {
return this->conn_.async_prepare_statement(statement, std::move(h));
}));
return impl<no_result>([&](handler<no_result> h) {
return this->conn_.async_prepare_statement(statement, this->cast(stmt), std::move(h));
});
}
network_result<no_result> quit() override
{
@@ -193,7 +178,11 @@ public:
};
template <class Stream>
class async_callback_noerrinfo_variant : public er_network_variant_base<Stream, async_callback_noerrinfo_connection>
class async_callback_noerrinfo_variant : public er_network_variant_base<
Stream,
async_callback_noerrinfo_connection,
async_callback_noerrinfo_statement,
async_callback_noerrinfo_resultset>
{
public:
const char* variant_name() const override { return "async_callback_noerrinfo"; }
@@ -202,11 +191,9 @@ public:
async_callback_noerrinfo_variant<tcp_socket> tcp;
async_callback_noerrinfo_variant<tcp_ssl_socket> tcp_ssl;
} // anon namespace
} // namespace
void boost::mysql::test::add_async_callback_noerrinfo(
std::vector<er_network_variant*>& output
)
void boost::mysql::test::add_async_callback_noerrinfo(std::vector<er_network_variant*>& output)
{
output.push_back(&tcp);
output.push_back(&tcp_ssl);