diff --git a/include/boost/mysql/statement.hpp b/include/boost/mysql/statement.hpp
index 335799aa..f0f1f232 100644
--- a/include/boost/mysql/statement.hpp
+++ b/include/boost/mysql/statement.hpp
@@ -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)
diff --git a/test/integration/utils/src/async_callback.cpp b/test/integration/utils/src/async_callback.cpp
index ba74a8c3..49b902d2 100644
--- a/test/integration/utils/src/async_callback.cpp
+++ b/test/integration/utils/src/async_callback.cpp
@@ -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_
diff --git a/test/integration/utils/src/async_callback_noerrinfo.cpp b/test/integration/utils/src/async_callback_noerrinfo.cpp
index 95754eb0..aefe7d2b 100644
--- a/test/integration/utils/src/async_callback_noerrinfo.cpp
+++ b/test/integration/utils/src/async_callback_noerrinfo.cpp
@@ -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);