metadata: introduce CassColumnSpec

This structure will hold information about the column name
and the column data type.

Refactored the `CassResultData`, so now it holds one vector
of `CassColumnSpec` instead of two separate vectors for names and
data types. Previous version was buggy for prepared statements:
- data types came from cached metadata from the statement
- column names came from metadata provided by query result

Because of this, the vector could be of a different length, when someone
ALTERed the corresponding table.

Notice that after this commit, we don't reuse cached metadata from prepared
statement and reuse the metadata provided from the server. Next commits
will fix that.

Author: muzarski

scylla-rust-wrapper/src/cass_types.rs

@@ -138,6 +138,11 @@ pub enum MapDataType {
     KeyAndValue(Arc<CassDataType>, Arc<CassDataType>),
 }
 
+pub struct CassColumnSpec {
+    pub name: String,
+    pub data_type: Arc<CassDataType>,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum CassDataType {
     Value(CassValueType),

scylla-rust-wrapper/src/query_result.rs

@@ -1,7 +1,7 @@
 use crate::argconv::*;
 use crate::cass_error::CassError;
 use crate::cass_types::{
-    cass_data_type_type, get_column_type, CassDataType, CassValueType, MapDataType,
+    cass_data_type_type, get_column_type, CassColumnSpec, CassDataType, CassValueType, MapDataType,
 };
 use crate::inet::CassInet;
 use crate::metadata::{
@@ -24,37 +24,22 @@ pub struct CassResult {
 }
 
 pub struct CassResultData {
-    pub col_names: Vec<String>,
-    pub col_data_types: Arc<Vec<Arc<CassDataType>>>,
+    pub col_specs: Vec<CassColumnSpec>,
 }
 
 impl CassResultData {
-    pub fn from_result_payload(
-        col_specs: &[ColumnSpec<'_>],
-        maybe_col_data_types: Option<Arc<Vec<Arc<CassDataType>>>>,
-    ) -> CassResultData {
-        // `maybe_col_data_types` is:
-        // - Some(_) for prepared statements executions
-        // - None for unprepared (simple) queries executions
-        let col_data_types = maybe_col_data_types.unwrap_or_else(|| {
-            // This allocation is unfortunately necessary, because of the type of CassResultData::col_data_types.
-            Arc::new(
-                col_specs
-                    .iter()
-                    .map(|col_spec| Arc::new(get_column_type(col_spec.typ())))
-                    .collect(),
-            )
-        });
-
-        let col_names = col_specs
+    pub fn from_column_specs(col_specs: &[ColumnSpec<'_>]) -> CassResultData {
+        let col_specs = col_specs
             .iter()
-            .map(|col_spec| col_spec.name().to_owned())
+            .map(|col_spec| {
+                let name = col_spec.name().to_owned();
+                let data_type = Arc::new(get_column_type(col_spec.typ()));
+
+                CassColumnSpec { name, data_type }
+            })
             .collect();
 
-        CassResultData {
-            col_names,
-            col_data_types,
-        }
+        CassResultData { col_specs }
     }
 }
 
@@ -900,12 +885,12 @@ pub unsafe extern "C" fn cass_row_get_column_by_name_n(
 
     return row_from_raw
         .result_metadata
-        .col_names
+        .col_specs
         .iter()
         .enumerate()
-        .find(|(_, col_name)| {
-            is_case_sensitive && *col_name == name_str
-                || !is_case_sensitive && col_name.eq_ignore_ascii_case(name_str)
+        .find(|(_, col_spec)| {
+            is_case_sensitive && col_spec.name == name_str
+                || !is_case_sensitive && col_spec.name.eq_ignore_ascii_case(name_str)
         })
         .map(|(index, _)| {
             return match row_from_raw.columns.get(index) {
@@ -926,11 +911,16 @@ pub unsafe extern "C" fn cass_result_column_name(
     let result_from_raw = ptr_to_ref(result);
     let index_usize: usize = index.try_into().unwrap();
 
-    if index_usize >= result_from_raw.metadata.col_data_types.len() {
+    if index_usize >= result_from_raw.metadata.col_specs.len() {
         return CassError::CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
     }
 
-    let column_name = result_from_raw.metadata.col_names.get(index_usize).unwrap();
+    let column_name = &result_from_raw
+        .metadata
+        .col_specs
+        .get(index_usize)
+        .unwrap()
+        .name;
 
     write_str_to_c(column_name, name, name_length);
 
@@ -961,9 +951,9 @@ pub unsafe extern "C" fn cass_result_column_data_type(
 
     result_from_raw
         .metadata
-        .col_data_types
+        .col_specs
         .get(index_usize)
-        .map(Arc::as_ptr)
+        .map(|col_spec| Arc::as_ptr(&col_spec.data_type))
         .unwrap_or(std::ptr::null())
 }
 
@@ -1338,7 +1328,7 @@ pub unsafe extern "C" fn cass_result_row_count(result_raw: *const CassResult) ->
 pub unsafe extern "C" fn cass_result_column_count(result_raw: *const CassResult) -> size_t {
     let result = ptr_to_ref(result_raw);
 
-    result.metadata.col_data_types.len() as size_t
+    result.metadata.col_specs.len() as size_t
 }
 
 #[no_mangle]
@@ -1414,17 +1404,14 @@ mod tests {
     const SECOND_COLUMN_NAME: &str = "varint_col";
     const THIRD_COLUMN_NAME: &str = "list_double_col";
     fn create_cass_rows_result() -> CassResult {
-        let metadata = Arc::new(CassResultData::from_result_payload(
-            &[
-                col_spec(FIRST_COLUMN_NAME, ColumnType::BigInt),
-                col_spec(SECOND_COLUMN_NAME, ColumnType::Varint),
-                col_spec(
-                    THIRD_COLUMN_NAME,
-                    ColumnType::List(Box::new(ColumnType::Double)),
-                ),
-            ],
-            None,
-        ));
+        let metadata = Arc::new(CassResultData::from_column_specs(&[
+            col_spec(FIRST_COLUMN_NAME, ColumnType::BigInt),
+            col_spec(SECOND_COLUMN_NAME, ColumnType::Varint),
+            col_spec(
+                THIRD_COLUMN_NAME,
+                ColumnType::List(Box::new(ColumnType::Double)),
+            ),
+        ]));
 
         let rows = create_cass_rows_from_rows(
             vec![Row {
@@ -1532,7 +1519,7 @@ mod tests {
     }
 
     fn create_non_rows_cass_result() -> CassResult {
-        let metadata = Arc::new(CassResultData::from_result_payload(&[], None));
+        let metadata = Arc::new(CassResultData::from_column_specs(&[]));
         CassResult {
             rows: None,
             metadata,

scylla-rust-wrapper/src/session.rs

@@ -220,7 +220,7 @@ pub unsafe extern "C" fn cass_session_execute_batch(
         match query_res {
             Ok(_result) => Ok(CassResultValue::QueryResult(Arc::new(CassResult {
                 rows: None,
-                metadata: Arc::new(CassResultData::from_result_payload(&[], None)),
+                metadata: Arc::new(CassResultData::from_column_specs(&[])),
                 tracing_id: None,
                 paging_state_response: PagingStateResponse::NoMorePages,
             }))),
@@ -353,11 +353,8 @@ pub unsafe extern "C" fn cass_session_execute(
         };
 
         match query_res {
-            Ok((result, paging_state_response, maybe_col_data_types)) => {
-                let metadata = Arc::new(CassResultData::from_result_payload(
-                    result.col_specs(),
-                    maybe_col_data_types,
-                ));
+            Ok((result, paging_state_response, _maybe_col_data_types)) => {
+                let metadata = Arc::new(CassResultData::from_column_specs(result.col_specs()));
                 let cass_rows = result
                     .rows
                     .map(|rows| create_cass_rows_from_rows(rows, &metadata));
@@ -397,9 +394,9 @@ pub(crate) fn create_cass_rows_from_rows(
 fn create_cass_row_columns(row: Row, metadata: &Arc<CassResultData>) -> Vec<CassValue> {
     row.columns
         .into_iter()
-        .zip(metadata.col_data_types.iter())
-        .map(|(val, col_data_type)| {
-            let column_type = Arc::clone(col_data_type);
+        .zip(metadata.col_specs.iter())
+        .map(|(val, col_spec)| {
+            let column_type = Arc::clone(&col_spec.data_type);
             CassValue {
                 value: val.map(|col_val| get_column_value(col_val, &column_type)),
                 value_type: column_type,