From 89ec500149c681e8c017759dc0dd3a8f4e53b684 Mon Sep 17 00:00:00 2001
From: Ruben Perez <rubenperez038@gmail.com>
Date: Fri, 14 Oct 2022 17:19:06 +0200
Subject: [PATCH] Recovered sync_exc

---
 include/boost/mysql/statement.hpp       |   2 +-
 test/integration/utils/src/sync_exc.cpp | 113 +++++++++++++-----------
 2 files changed, 61 insertions(+), 54 deletions(-)

diff --git a/include/boost/mysql/statement.hpp b/include/boost/mysql/statement.hpp
index 6ac0fce0..39d3ab17 100644
--- a/include/boost/mysql/statement.hpp
+++ b/include/boost/mysql/statement.hpp
@@ -74,7 +74,7 @@ public:
         class EnableIf = detail::enable_if_field_view_collection<FieldViewCollection>>
     void execute(const FieldViewCollection& params, resultset<Stream>& result)
     {
-        return execute_statement(make_execute_params(params), result);
+        return execute(make_execute_params(params), result);
     }
 
     /**
diff --git a/test/integration/utils/src/sync_exc.cpp b/test/integration/utils/src/sync_exc.cpp
index 85bd43d9..7cd44a41 100644
--- a/test/integration/utils/src/sync_exc.cpp
+++ b/test/integration/utils/src/sync_exc.cpp
@@ -5,30 +5,36 @@
 // 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 <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 "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 {
 
@@ -55,24 +61,17 @@ template <class Stream>
 class sync_exc_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([&] {
-            return this->r_.read_one(output);
-        });
+        return impl([&] { return this->obj().read_one(); });
     }
-    network_result<std::vector<row>> read_many(std::size_t count) override
+    network_result<rows_view> read_some() override
     {
-        return impl([&] {
-            return this->r_.read_many(count);
-        });
+        return impl([&] { return this->obj().read_some(); });
     }
-    network_result<std::vector<row>> read_all() override
+    network_result<rows_view> read_all() override
     {
-        return impl([&] {
-            return this->r_.read_all();
-        });
+        return impl([&] { return this->obj().read_all(); });
     }
 };
 
@@ -80,27 +79,30 @@ template <class Stream>
 class sync_exc_statement : public er_statement_base<Stream>
 {
 public:
-    using er_statement_base<Stream>::er_statement_base;
-    network_result<er_resultset_ptr> execute_params(
-        const boost::mysql::execute_params<value_list_it>& params
-    ) override
-    {
-        return impl([&]{
-            return erase_resultset<sync_exc_resultset>(this->stmt_.execute(params));
-        });
-    }
-    network_result<er_resultset_ptr> execute_container(
-        const std::vector<field_view>& values
+    network_result<no_result> execute_params(
+        const boost::mysql::execute_params<value_list_it>& params,
+        er_resultset& result
     ) override
     {
         return impl([&] {
-            return erase_resultset<sync_exc_resultset>(this->stmt_.execute(values));
+            this->obj().execute(params, this->cast(result));
+            return no_result();
+        });
+    }
+    network_result<no_result> execute_collection(
+        const std::vector<field_view>& values,
+        er_resultset& result
+    ) override
+    {
+        return impl([&] {
+            this->obj().execute(values, this->cast(result));
+            return no_result();
         });
     }
     network_result<no_result> close() override
     {
         return impl([&] {
-            this->stmt_.close();
+            this->obj().close();
             return no_result();
         });
     }
@@ -114,13 +116,13 @@ public:
     network_result<no_result> physical_connect(er_endpoint kind) override
     {
         return impl([&] {
-            this->conn_.next_layer().lowest_layer().connect(get_endpoint<Stream>(kind));
+            this->conn_.stream().lowest_layer().connect(get_endpoint<Stream>(kind));
             return no_result();
         });
     }
     network_result<no_result> connect(
         er_endpoint kind,
-        const boost::mysql::connection_params& params
+        const boost::mysql::handshake_params& params
     ) override
     {
         return impl([&] {
@@ -128,23 +130,26 @@ public:
             return no_result();
         });
     }
-    network_result<no_result> handshake(const connection_params& params) override
+    network_result<no_result> handshake(const handshake_params& params) override
     {
         return impl([&] {
             this->conn_.handshake(params);
             return no_result();
         });
     }
-    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 impl([&] {
-            return erase_resultset<sync_exc_resultset>(this->conn_.query(query));
+            this->conn_.query(query, this->cast(result));
+            return no_result();
         });
     }
-    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 impl([&] {
-            return erase_statement<sync_exc_statement>(this->conn_.prepare_statement(statement));
+            this->conn_.prepare_statement(statement, this->cast(stmt));
+            return no_result();
         });
     }
     network_result<no_result> quit() override
@@ -164,7 +169,11 @@ public:
 };
 
 template <class Stream>
-class sync_exc_variant : public er_network_variant_base<Stream, sync_exc_connection>
+class sync_exc_variant : public er_network_variant_base<
+                             Stream,
+                             sync_exc_connection,
+                             sync_exc_statement,
+                             sync_exc_resultset>
 {
 public:
     const char* variant_name() const override { return "sync_exc"; }
@@ -174,12 +183,10 @@ sync_exc_variant<tcp_socket> tcp;
 sync_exc_variant<tcp_ssl_socket> tcp_ssl;
 // UNIX sockets don't add much value here
 
-} // anon namespace
+}  // namespace
 
-void boost::mysql::test::add_sync_exc(
-    std::vector<er_network_variant*>& output
-)
+void boost::mysql::test::add_sync_exc(std::vector<er_network_variant*>& output)
 {
     output.push_back(&tcp);
     output.push_back(&tcp_ssl);
-}
\ No newline at end of file
+}