result_data: include info about column data types

CassDataType can be a heavy object if the type is nested.
In this commit we include info about column data types in
result metadata (Arc<Vec<Arc<CassDataType>>>).

This will be needed to implement cass_result_column_data_type function.

We also adjust the construction of `CassValue::value_type` field
and avoid allocations. We simply clone Arc from result metadata.

Author: muzarski

scylla-rust-wrapper/src/query_result.rs

@@ -1,6 +1,8 @@
 use crate::argconv::*;
 use crate::cass_error::CassError;
-use crate::cass_types::{cass_data_type_type, CassDataType, CassValueType, MapDataType};
+use crate::cass_types::{
+    cass_data_type_type, get_column_type, CassDataType, CassValueType, MapDataType,
+};
 use crate::inet::CassInet;
 use crate::metadata::{
     CassColumnMeta, CassKeyspaceMeta, CassMaterializedViewMeta, CassSchemaMeta, CassTableMeta,
@@ -22,9 +24,36 @@ pub struct CassResult {
 pub struct CassResultData {
     pub paging_state_response: PagingStateResponse,
     pub col_specs: Vec<ColumnSpec>,
+    pub col_data_types: Arc<Vec<Arc<CassDataType>>>,
     pub tracing_id: Option<Uuid>,
 }
 
+impl CassResultData {
+    pub fn from_result_payload(
+        paging_state_response: PagingStateResponse,
+        col_specs: Vec<ColumnSpec>,
+        maybe_col_data_types: Option<Arc<Vec<Arc<CassDataType>>>>,
+        tracing_id: Option<Uuid>,
+    ) -> CassResultData {
+        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(),
+            )
+        });
+
+        CassResultData {
+            paging_state_response,
+            col_specs,
+            col_data_types,
+            tracing_id,
+        }
+    }
+}
+
 /// The lifetime of CassRow is bound to CassResult.
 /// It will be freed, when CassResult is freed.(see #[cass_result_free])
 pub struct CassRow {

scylla-rust-wrapper/src/session.rs

@@ -1,7 +1,7 @@
 use crate::argconv::*;
 use crate::batch::CassBatch;
 use crate::cass_error::*;
-use crate::cass_types::{get_column_type, CassDataType, MapDataType, UDTDataType};
+use crate::cass_types::{CassDataType, MapDataType, UDTDataType};
 use crate::cluster::build_session_builder;
 use crate::cluster::CassCluster;
 use crate::exec_profile::{CassExecProfile, ExecProfileName, PerStatementExecProfile};
@@ -214,11 +214,12 @@ 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 {
-                    paging_state_response: PagingStateResponse::NoMorePages,
-                    col_specs: vec![],
-                    tracing_id: None,
-                }),
+                metadata: Arc::new(CassResultData::from_result_payload(
+                    PagingStateResponse::NoMorePages,
+                    vec![],
+                    None,
+                    None,
+                )),
             }))),
             Err(err) => Ok(CassResultValue::QueryError(Arc::new(err))),
         }
@@ -285,40 +286,77 @@ pub unsafe extern "C" fn cass_session_execute(
                 .set_execution_profile_handle(handle),
         }
 
-        let query_res: Result<(QueryResult, PagingStateResponse), QueryError> = match statement {
+        // Creating a type alias here to fix clippy lints.
+        // I want this type to be explicit, so future developers can understand
+        // what's going on here (and why we include some weird Option of data types).
+        type QueryRes = Result<
+            (
+                QueryResult,
+                PagingStateResponse,
+                // We unfortunately have to retrieve the metadata here.
+                // Since `query.qery` is consumed, we cannot match the statement
+                // after execution, to retrieve the cached metadata in case
+                // of prepared statements.
+                Option<Arc<Vec<Arc<CassDataType>>>>,
+            ),
+            QueryError,
+        >;
+        let query_res: QueryRes = match statement {
             Statement::Simple(query) => {
+                // We don't store result metadta for Queries - return None.
+                let maybe_result_col_data_types = None;
+
                 if paging_enabled {
                     session
                         .query_single_page(query.query, bound_values, paging_state)
                         .await
+                        .map(|(qr, psr)| (qr, psr, maybe_result_col_data_types))
                 } else {
                     session
                         .query_unpaged(query.query, bound_values)
                         .await
-                        .map(|result| (result, PagingStateResponse::NoMorePages))
+                        .map(|result| {
+                            (
+                                result,
+                                PagingStateResponse::NoMorePages,
+                                maybe_result_col_data_types,
+                            )
+                        })
                 }
             }
             Statement::Prepared(prepared) => {
+                // Clone vector of the Arc<CassDataType>, so we don't do additional allocations when constructing
+                // CassDataTypes in `CassResultData::from_result_payload`.
+                let maybe_result_col_data_types = Some(prepared.result_col_data_types.clone());
+
                 if paging_enabled {
                     session
                         .execute_single_page(&prepared.statement, bound_values, paging_state)
                         .await
+                        .map(|(qr, psr)| (qr, psr, maybe_result_col_data_types))
                 } else {
                     session
                         .execute_unpaged(&prepared.statement, bound_values)
                         .await
-                        .map(|result| (result, PagingStateResponse::NoMorePages))
+                        .map(|result| {
+                            (
+                                result,
+                                PagingStateResponse::NoMorePages,
+                                maybe_result_col_data_types,
+                            )
+                        })
                 }
             }
         };
 
         match query_res {
-            Ok((result, paging_state_response)) => {
-                let metadata = Arc::new(CassResultData {
+            Ok((result, paging_state_response, maybe_col_data_types)) => {
+                let metadata = Arc::new(CassResultData::from_result_payload(
                     paging_state_response,
-                    col_specs: result.col_specs().to_vec(),
-                    tracing_id: result.tracing_id,
-                });
+                    result.col_specs().to_vec(),
+                    maybe_col_data_types,
+                    result.tracing_id,
+                ));
                 let cass_rows = create_cass_rows_from_rows(result.rows, &metadata);
                 let cass_result = Arc::new(CassResult {
                     rows: cass_rows,
@@ -358,9 +396,9 @@ 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_specs.iter())
-        .map(|(val, col)| {
-            let column_type = Arc::new(get_column_type(&col.typ));
+        .zip(metadata.col_data_types.iter())
+        .map(|(val, col_data_type)| {
+            let column_type = Arc::clone(col_data_type);
             CassValue {
                 value: val.map(|col_val| get_column_value(col_val, &column_type)),
                 value_type: column_type,