session: add interface methods for the new deser API

Implements methods related to sending queries for the new Session.

Co-authored-by: Wojciech Przytuła <[email protected]>

Author: piodul

scylla/src/transport/session.rs

@@ -462,7 +462,7 @@ pub(crate) enum RunQueryResult<ResT> {
     Completed(ResT),
 }
 
-impl GenericSession<LegacyDeserializationApi> {
+impl GenericSession<CurrentDeserializationApi> {
     /// Sends a request to the database and receives a response.\
     /// Performs an unpaged query, i.e. all results are received in a single response.
     ///
@@ -526,11 +526,8 @@ impl GenericSession<LegacyDeserializationApi> {
         &self,
         query: impl Into<Query>,
         values: impl SerializeRow,
-    ) -> Result<LegacyQueryResult, QueryError> {
-        Ok(self
-            .do_query_unpaged(&query.into(), values)
-            .await?
-            .into_legacy_result()?)
+    ) -> Result<QueryResult, QueryError> {
+        self.do_query_unpaged(&query.into(), values).await
     }
 
     /// Queries a single page from the database, optionally continuing from a saved point.
@@ -586,11 +583,9 @@ impl GenericSession<LegacyDeserializationApi> {
         query: impl Into<Query>,
         values: impl SerializeRow,
         paging_state: PagingState,
-    ) -> Result<(LegacyQueryResult, PagingStateResponse), QueryError> {
-        let (result, paging_state_response) = self
-            .do_query_single_page(&query.into(), values, paging_state)
-            .await?;
-        Ok((result.into_legacy_result()?, paging_state_response))
+    ) -> Result<(QueryResult, PagingStateResponse), QueryError> {
+        self.do_query_single_page(&query.into(), values, paging_state)
+            .await
     }
 
     /// Run an unprepared query with paging\
@@ -634,10 +629,8 @@ impl GenericSession<LegacyDeserializationApi> {
         &self,
         query: impl Into<Query>,
         values: impl SerializeRow,
-    ) -> Result<LegacyRowIterator, QueryError> {
-        self.do_query_iter(query.into(), values)
-            .await
-            .map(QueryPager::into_legacy)
+    ) -> Result<QueryPager, QueryError> {
+        self.do_query_iter(query.into(), values).await
     }
 
     /// Execute a prepared statement. Requires a [PreparedStatement]
@@ -687,11 +680,8 @@ impl GenericSession<LegacyDeserializationApi> {
         &self,
         prepared: &PreparedStatement,
         values: impl SerializeRow,
-    ) -> Result<LegacyQueryResult, QueryError> {
-        Ok(self
-            .do_execute_unpaged(prepared, values)
-            .await?
-            .into_legacy_result()?)
+    ) -> Result<QueryResult, QueryError> {
+        self.do_execute_unpaged(prepared, values).await
     }
 
     /// Executes a prepared statement, restricting results to single page.
@@ -752,11 +742,9 @@ impl GenericSession<LegacyDeserializationApi> {
         prepared: &PreparedStatement,
         values: impl SerializeRow,
         paging_state: PagingState,
-    ) -> Result<(LegacyQueryResult, PagingStateResponse), QueryError> {
-        let (result, paging_state_response) = self
-            .do_execute_single_page(prepared, values, paging_state)
-            .await?;
-        Ok((result.into_legacy_result()?, paging_state_response))
+    ) -> Result<(QueryResult, PagingStateResponse), QueryError> {
+        self.do_execute_single_page(prepared, values, paging_state)
+            .await
     }
 
     /// Run a prepared query with paging.\
@@ -803,10 +791,8 @@ impl GenericSession<LegacyDeserializationApi> {
         &self,
         prepared: impl Into<PreparedStatement>,
         values: impl SerializeRow,
-    ) -> Result<LegacyRowIterator, QueryError> {
-        self.do_execute_iter(prepared.into(), values)
-            .await
-            .map(QueryPager::into_legacy)
+    ) -> Result<QueryPager, QueryError> {
+        self.do_execute_iter(prepared.into(), values).await
     }
 
     /// Perform a batch query\
@@ -854,6 +840,82 @@ impl GenericSession<LegacyDeserializationApi> {
     /// # Ok(())
     /// # }
     /// ```
+    pub async fn batch(
+        &self,
+        batch: &Batch,
+        values: impl BatchValues,
+    ) -> Result<QueryResult, QueryError> {
+        self.do_batch(batch, values).await
+    }
+}
+
+impl GenericSession<LegacyDeserializationApi> {
+    pub async fn query_unpaged(
+        &self,
+        query: impl Into<Query>,
+        values: impl SerializeRow,
+    ) -> Result<LegacyQueryResult, QueryError> {
+        Ok(self
+            .do_query_unpaged(&query.into(), values)
+            .await?
+            .into_legacy_result()?)
+    }
+
+    pub async fn query_single_page(
+        &self,
+        query: impl Into<Query>,
+        values: impl SerializeRow,
+        paging_state: PagingState,
+    ) -> Result<(LegacyQueryResult, PagingStateResponse), QueryError> {
+        let (result, paging_state_response) = self
+            .do_query_single_page(&query.into(), values, paging_state)
+            .await?;
+        Ok((result.into_legacy_result()?, paging_state_response))
+    }
+
+    pub async fn query_iter(
+        &self,
+        query: impl Into<Query>,
+        values: impl SerializeRow,
+    ) -> Result<LegacyRowIterator, QueryError> {
+        self.do_query_iter(query.into(), values)
+            .await
+            .map(QueryPager::into_legacy)
+    }
+
+    pub async fn execute_unpaged(
+        &self,
+        prepared: &PreparedStatement,
+        values: impl SerializeRow,
+    ) -> Result<LegacyQueryResult, QueryError> {
+        Ok(self
+            .do_execute_unpaged(prepared, values)
+            .await?
+            .into_legacy_result()?)
+    }
+
+    pub async fn execute_single_page(
+        &self,
+        prepared: &PreparedStatement,
+        values: impl SerializeRow,
+        paging_state: PagingState,
+    ) -> Result<(LegacyQueryResult, PagingStateResponse), QueryError> {
+        let (result, paging_state_response) = self
+            .do_execute_single_page(prepared, values, paging_state)
+            .await?;
+        Ok((result.into_legacy_result()?, paging_state_response))
+    }
+
+    pub async fn execute_iter(
+        &self,
+        prepared: impl Into<PreparedStatement>,
+        values: impl SerializeRow,
+    ) -> Result<LegacyRowIterator, QueryError> {
+        self.do_execute_iter(prepared.into(), values)
+            .await
+            .map(QueryPager::into_legacy)
+    }
+
     pub async fn batch(
         &self,
         batch: &Batch,