Merge pull request #187 from muzarski/enable-named-parameters-tests

binding: fix by-name parameter binding and enable corresponding IT

Author: muzarski

Makefile

@@ -11,6 +11,7 @@ SCYLLA_TEST_FILTER := $(subst ${SPACE},${EMPTY},ClusterTests.*\
 :SerialConsistencyTests.*\
 :HeartbeatTests.*\
 :PreparedTests.*\
+:NamedParametersTests.*\
 :CassandraTypes/CassandraTypesTests/*.Integration_Cassandra_*\
 :BatchSingleNodeClusterTests*:BatchCounterSingleNodeClusterTests*:BatchCounterThreeNodeClusterTests*\
 :ErrorTests.*\
@@ -40,6 +41,7 @@ CASSANDRA_TEST_FILTER := $(subst ${SPACE},${EMPTY},ClusterTests.*\
 :SerialConsistencyTests.*\
 :HeartbeatTests.*\
 :PreparedTests.*\
+:NamedParametersTests.*\
 :CassandraTypes/CassandraTypesTests/*.Integration_Cassandra_*\
 :ErrorTests.*\
 :SslClientAuthenticationTests*:SslNoClusterTests*:SslNoSslOnClusterTests*:SslTests*\

scylla-rust-wrapper/src/batch.rs

@@ -4,7 +4,7 @@ use crate::cass_types::CassConsistency;
 use crate::cass_types::{make_batch_type, CassBatchType};
 use crate::exec_profile::PerStatementExecProfile;
 use crate::retry_policy::CassRetryPolicy;
-use crate::statement::{CassStatement, Statement};
+use crate::statement::{BoundStatement, CassStatement};
 use crate::types::*;
 use crate::value::CassCqlValue;
 use scylla::batch::Batch;
@@ -166,11 +166,15 @@ pub unsafe extern "C" fn cass_batch_add_statement(
     let statement = BoxFFI::as_ref(statement);
 
     match &statement.statement {
-        Statement::Simple(q) => state.batch.append_statement(q.query.clone()),
-        Statement::Prepared(p) => state.batch.append_statement(p.statement.clone()),
+        BoundStatement::Simple(q) => {
+            state.batch.append_statement(q.query.clone());
+            state.bound_values.push(q.bound_values.clone());
+        }
+        BoundStatement::Prepared(p) => {
+            state.batch.append_statement(p.statement.statement.clone());
+            state.bound_values.push(p.bound_values.clone());
+        }
     };
 
-    state.bound_values.push(statement.bound_values.clone());
-
     CassError::CASS_OK
 }

scylla-rust-wrapper/src/cass_error.rs

@@ -3,6 +3,7 @@ use scylla::transport::errors::*;
 // Re-export error types.
 pub(crate) use crate::cass_error_types::{CassError, CassErrorSource};
 use crate::query_error::CassErrorResult;
+use crate::statement::UnknownNamedParameterError;
 
 pub trait ToCassError {
     fn to_cass_error(&self) -> CassError;
@@ -94,7 +95,14 @@ impl ToCassError for BadQuery {
             BadQuery::ValuesTooLongForKey(_usize, _usize2) => CassError::CASS_ERROR_LAST_ENTRY,
             BadQuery::BadKeyspaceName(_bad_keyspace_name) => CassError::CASS_ERROR_LAST_ENTRY,
             BadQuery::Other(_other_query) => CassError::CASS_ERROR_LAST_ENTRY,
-            BadQuery::SerializationError(_) => CassError::CASS_ERROR_LAST_ENTRY,
+            BadQuery::SerializationError(e) => {
+                if e.downcast_ref::<UnknownNamedParameterError>().is_some() {
+                    // It means that our custom `UnknownNamedParameterError` was returned.
+                    CassError::CASS_ERROR_LIB_NAME_DOES_NOT_EXIST
+                } else {
+                    CassError::CASS_ERROR_LAST_ENTRY
+                }
+            }
             BadQuery::TooManyQueriesInBatchStatement(_) => CassError::CASS_ERROR_LAST_ENTRY,
             // BadQuery is non_exhaustive
             // For now, since all other variants return LAST_ENTRY,

scylla-rust-wrapper/src/prepared.rs

@@ -6,7 +6,7 @@ use crate::{
     cass_error::CassError,
     cass_types::{get_column_type, CassDataType},
     query_result::CassResultMetadata,
-    statement::{CassStatement, Statement},
+    statement::{BoundPreparedStatement, BoundStatement, CassStatement},
     types::size_t,
 };
 use scylla::prepared_statement::PreparedStatement;
@@ -88,11 +88,14 @@ pub unsafe extern "C" fn cass_prepared_bind(
 
     // cloning prepared statement's arc, because creating CassStatement should not invalidate
     // the CassPrepared argument
-    let statement = Statement::Prepared(prepared);
+
+    let statement = BoundStatement::Prepared(BoundPreparedStatement {
+        statement: prepared,
+        bound_values: vec![Unset; bound_values_size],
+    });
 
     BoxFFI::into_ptr(Box::new(CassStatement {
         statement,
-        bound_values: vec![Unset; bound_values_size],
         paging_state: PagingState::start(),
         // Cpp driver disables paging by default.
         paging_enabled: false,

scylla-rust-wrapper/src/session.rs

@@ -10,8 +10,7 @@ use crate::metadata::create_table_metadata;
 use crate::metadata::{CassKeyspaceMeta, CassMaterializedViewMeta, CassSchemaMeta};
 use crate::prepared::CassPrepared;
 use crate::query_result::{CassResult, CassResultKind, CassResultMetadata};
-use crate::statement::CassStatement;
-use crate::statement::Statement;
+use crate::statement::{BoundStatement, CassStatement, SimpleQueryRowSerializer};
 use crate::types::{cass_uint64_t, size_t};
 use crate::uuid::CassUuid;
 use scylla::frame::types::Consistency;
@@ -258,7 +257,6 @@ pub unsafe extern "C" fn cass_session_execute(
     let statement_opt = BoxFFI::as_ref(statement_raw);
     let paging_state = statement_opt.paging_state.clone();
     let paging_enabled = statement_opt.paging_enabled;
-    let bound_values = statement_opt.bound_values.clone();
     let request_timeout_ms = statement_opt.request_timeout_ms;
 
     let mut statement = statement_opt.statement.clone();
@@ -282,8 +280,8 @@ pub unsafe extern "C" fn cass_session_execute(
             .await?;
 
         match &mut statement {
-            Statement::Simple(query) => query.query.set_execution_profile_handle(handle),
-            Statement::Prepared(prepared) => Arc::make_mut(prepared)
+            BoundStatement::Simple(query) => query.query.set_execution_profile_handle(handle),
+            BoundStatement::Prepared(prepared) => Arc::make_mut(&mut prepared.statement)
                 .statement
                 .set_execution_profile_handle(handle),
         }
@@ -304,10 +302,15 @@ pub unsafe extern "C" fn cass_session_execute(
             QueryError,
         >;
         let query_res: QueryRes = match statement {
-            Statement::Simple(query) => {
+            BoundStatement::Simple(query) => {
                 // We don't store result metadata for Queries - return None.
                 let maybe_result_metadata = None;
 
+                let bound_values = SimpleQueryRowSerializer {
+                    bound_values: query.bound_values,
+                    name_to_bound_index: query.name_to_bound_index,
+                };
+
                 if paging_enabled {
                     session
                         .query_single_page(query.query, bound_values, paging_state)
@@ -326,19 +329,23 @@ pub unsafe extern "C" fn cass_session_execute(
                         })
                 }
             }
-            Statement::Prepared(prepared) => {
+            BoundStatement::Prepared(prepared) => {
                 // Clone result metadata, so we don't need to construct it from scratch in
                 // `CassResultMetadata::from_column_specs` - it requires a lot of allocations for complex types.
-                let maybe_result_metadata = Some(Arc::clone(&prepared.result_metadata));
+                let maybe_result_metadata = Some(Arc::clone(&prepared.statement.result_metadata));
 
                 if paging_enabled {
                     session
-                        .execute_single_page(&prepared.statement, bound_values, paging_state)
+                        .execute_single_page(
+                            &prepared.statement.statement,
+                            prepared.bound_values,
+                            paging_state,
+                        )
                         .await
                         .map(|(qr, psr)| (qr, psr, maybe_result_metadata))
                 } else {
                     session
-                        .execute_unpaged(&prepared.statement, bound_values)
+                        .execute_unpaged(&prepared.statement.statement, prepared.bound_values)
                         .await
                         .map(|result| {
                             (
@@ -385,9 +392,9 @@ pub unsafe extern "C" fn cass_session_prepare_from_existing(
 
     CassFuture::make_raw(async move {
         let query = match &statement {
-            Statement::Simple(q) => q,
-            Statement::Prepared(ps) => {
-                return Ok(CassResultValue::Prepared(ps.clone()));
+            BoundStatement::Simple(q) => q,
+            BoundStatement::Prepared(ps) => {
+                return Ok(CassResultValue::Prepared(ps.statement.clone()));
             }
         };