Replace PreparedStatementWrapper with strings

Replace PreparedStatementWrapper with strings, when executing
prepared statements, when calling endpoint to execute queries.
With this change we only return expected types for prepared statements,
instead of the whole PreparedStatementWrapper object from the Rust.

This change introduces a speed improvement when executing queries
through executeConcurrent, and does not slow down other endpoints.

Author: adespawn

lib/cache.js

@@ -2,7 +2,7 @@ const _rust = require("../index");
 
 class PreparedCache {
     /**
-     * @type {Map<string, _rust.PreparedStatementWrapper>}
+     * @type {Map<string, list<Object | string>>}
      */
     #cache;
 
@@ -13,7 +13,7 @@ class PreparedCache {
     /**
      *
      * @param {string} key
-     * @returns {_rust.PreparedStatementWrapper}
+     * @returns {list<Object | string>}
      */
     getElement(key) {
         return this.#cache[key];
@@ -22,7 +22,7 @@ class PreparedCache {
     /**
      *
      * @param {string} key
-     * @param {_rust.PreparedStatementWrapper} element
+     * @param {list<Object | string>} element
      */
     storeElement(key, element) {
         this.#cache[key] = element;

lib/client.js

@@ -148,16 +148,13 @@ class Client extends events.EventEmitter {
     /**
      * Manually prepare query into prepared statement
      * @param {string} query
-     * @returns {Promise<list<Object | rust.PreparedStatementWrapper >>}
+     * @returns {Promise<list<Object | string>>}
      * Returns a tuple of type object (the format expected by the encoder) and prepared statement wrapper
      * @package
      */
     async prepareQuery(query) {
         let helper = await this.rustClient.prepareStatement(query);
-        let res = [
-            helper.getExpectedTypes().map((t) => convertComplexType(t)),
-            helper,
-        ];
+        let res = [helper.map((t) => convertComplexType(t)), query];
         return res;
     }
 
@@ -305,7 +302,7 @@ class Client extends events.EventEmitter {
 
     /**
      * Wrapper for executing queries by rust driver
-     * @param {string | rust.PreparedStatementWrapper} query
+     * @param {string | list<Object | string>} query
      * @param {Array} params
      * @param {ExecOptions.ExecutionOptions} execOptions
      * @returns {Promise<ResultSet>}
@@ -342,7 +339,7 @@ class Client extends events.EventEmitter {
             }
 
             /**
-             * @type {rust.PreparedStatementWrapper}
+             * @type {string}
              */
             let statement = query[1];
             /**
@@ -360,10 +357,8 @@ class Client extends events.EventEmitter {
             );
         } else {
             // We do not accept already prepared statements for unprepared queries
-            if (query instanceof rust.PreparedStatementWrapper) {
-                throw new Error(
-                    "Unexpected prepared statement wrapper for unprepared queries",
-                );
+            if (typeof query !== "string") {
+                throw new Error("Expected to obtain a string query");
             }
 
             // Parse parameters according to provided hints, with type guessing
@@ -542,7 +537,7 @@ class Client extends events.EventEmitter {
             }
 
             /**
-             * @type {rust.PreparedStatementWrapper}
+             * @type {string}
              */
             let statement = query[1];
             /**
@@ -561,10 +556,8 @@ class Client extends events.EventEmitter {
             );
         } else {
             // We do not accept already prepared statements for unprepared queries
-            if (query instanceof rust.PreparedStatementWrapper) {
-                throw new Error(
-                    "Unexpected prepared statement wrapper for unprepared queries",
-                );
+            if (typeof query !== "string") {
+                throw new Error("Expected to obtain a string query");
             }
             // Parse parameters according to provided hints, with type guessing
             let encoded = encodeParams(

src/requests/request.rs

@@ -3,8 +3,7 @@ use scylla::statement::prepared::PreparedStatement;
 
 use crate::{result::map_column_type_to_complex_type, types::type_wrappers::ComplexType};
 
-#[napi]
-pub struct PreparedStatementWrapper {
+pub(crate) struct PreparedStatementWrapper {
     pub(crate) prepared: PreparedStatement,
 }
 
@@ -34,9 +33,7 @@ pub struct QueryOptionsWrapper {
     pub trace_query: Option<bool>,
 }
 
-#[napi]
 impl PreparedStatementWrapper {
-    #[napi]
     /// Get array of expected types for this prepared statement.
     pub fn get_expected_types(&self) -> Vec<ComplexType> {
         self.prepared

src/session.rs

@@ -3,14 +3,14 @@ use scylla::client::caching_session::CachingSession;
 use scylla::client::session_builder::SessionBuilder;
 use scylla::response::PagingState;
 use scylla::statement::batch::Batch;
-use scylla::statement::prepared::PreparedStatement;
 use scylla::statement::{Consistency, SerialConsistency, Statement};
 
 use crate::errors::{err_to_napi, js_error};
 use crate::options;
 use crate::paging::{PagingResult, PagingStateWrapper};
 use crate::requests::request::QueryOptionsWrapper;
 use crate::types::encoded_data::EncodedValuesWrapper;
+use crate::types::type_wrappers::ComplexType;
 use crate::utils::bigint_to_i64;
 use crate::{requests::request::PreparedStatementWrapper, result::QueryResultWrapper};
 
@@ -103,20 +103,18 @@ impl SessionWrapper {
     }
 
     /// Prepares a statement through rust driver for a given session
-    /// Return PreparedStatementWrapper that wraps object returned by the rust driver
+    /// Return expected types for the prepared statement
     #[napi]
-    pub async fn prepare_statement(
-        &self,
-        statement: String,
-    ) -> napi::Result<PreparedStatementWrapper> {
+    pub async fn prepare_statement(&self, statement: String) -> napi::Result<Vec<ComplexType>> {
         let statement: Statement = statement.into();
         Ok(PreparedStatementWrapper {
             prepared: self
                 .inner
                 .add_prepared_statement(&statement) // TODO: change for add_prepared_statement_to_owned after it is made public
                 .await
                 .map_err(err_to_napi)?,
-        })
+        }
+        .get_expected_types())
     }
 
     /// Execute a given prepared statement against the database with provided parameters.
@@ -132,15 +130,14 @@ impl SessionWrapper {
     #[napi]
     pub async fn execute_prepared_unpaged_encoded(
         &self,
-        query: &PreparedStatementWrapper,
+        query: String,
         params: Vec<EncodedValuesWrapper>,
         options: &QueryOptionsWrapper,
     ) -> napi::Result<QueryResultWrapper> {
-        let query = apply_prepared_options(query.prepared.clone(), options)?;
+        let query = apply_statement_options(query.into(), options)?;
         QueryResultWrapper::from_query(
             self.inner
-                .get_session()
-                .execute_unpaged(&query, params)
+                .execute_unpaged(query, params)
                 .await
                 .map_err(err_to_napi)?,
         )
@@ -206,20 +203,19 @@ impl SessionWrapper {
     #[napi]
     pub async fn execute_single_page_encoded(
         &self,
-        query: &PreparedStatementWrapper,
+        query: String,
         params: Vec<EncodedValuesWrapper>,
         options: &QueryOptionsWrapper,
         paging_state: Option<&PagingStateWrapper>,
     ) -> napi::Result<PagingResult> {
         let paging_state = paging_state
             .map(|e| e.inner.clone())
             .unwrap_or(PagingState::start());
-        let prepared = apply_prepared_options(query.prepared.clone(), options)?;
+        let prepared = apply_statement_options(query.into(), options)?;
 
         let (result, paging_state) = self
             .inner
-            .get_session()
-            .execute_single_page(&prepared, params, paging_state)
+            .execute_single_page(prepared, params, paging_state)
             .await
             .map_err(err_to_napi)?;
         Ok(PagingResult {
@@ -233,13 +229,13 @@ impl SessionWrapper {
 /// Requires each passed statement to be already prepared.
 #[napi]
 pub fn create_prepared_batch(
-    statements: Vec<&PreparedStatementWrapper>,
+    statements: Vec<String>,
     options: &QueryOptionsWrapper,
 ) -> napi::Result<BatchWrapper> {
     let mut batch: Batch = Default::default();
     statements
         .iter()
-        .for_each(|q| batch.append_statement(q.prepared.clone()));
+        .for_each(|q| batch.append_statement(q.as_str()));
     batch = apply_batch_options(batch, options)?;
     Ok(BatchWrapper { inner: batch })
 }
@@ -348,11 +344,6 @@ macro_rules! make_non_batch_apply_options {
 }
 
 make_non_batch_apply_options!(Statement, apply_statement_options, statement_opt_partial);
-make_non_batch_apply_options!(
-    PreparedStatement,
-    apply_prepared_options,
-    prepared_opt_partial
-);
 make_apply_options!(Batch, apply_batch_options);
 
 /// Provides driver self identity, filling information on application based on session options.