Properly detect and print DB version according to it's type

Author: vponomaryov

src/config.rs

@@ -548,7 +548,7 @@ pub struct RunCommand {
     pub cluster_name: Option<String>,
 
     #[clap(skip)]
-    pub cass_version: Option<String>,
+    pub db_version: Option<String>,
 
     #[clap(skip)]
     pub id: Option<String>,

src/main.rs

@@ -120,14 +120,14 @@ async fn connect(conf: &ConnectionConf) -> Result<(Context, Option<ClusterInfo>)
     let session = scripting::connect::connect(conf).await?;
     let cluster_info = session.cluster_info().await?;
     eprintln!(
-        "info: Connected to {} running Cassandra version {}",
+        "info: Connected to '{}' cluster running {}",
         cluster_info
             .as_ref()
             .map(|c| c.name.as_str())
             .unwrap_or("unknown"),
         cluster_info
             .as_ref()
-            .map(|c| c.cassandra_version.as_str())
+            .map(|c| c.db_version.as_str())
             .unwrap_or("unknown")
     );
     Ok((session, cluster_info))
@@ -237,7 +237,7 @@ async fn run(conf: RunCommand) -> Result<()> {
     let (mut session, cluster_info) = connect(&conf.connection).await?;
     if let Some(cluster_info) = cluster_info {
         conf.cluster_name = Some(cluster_info.name);
-        conf.cass_version = Some(cluster_info.cassandra_version);
+        conf.db_version = Some(cluster_info.db_version);
     }
 
     if program.has_prepare() {

src/report/mod.rs

@@ -487,8 +487,8 @@ impl Display for RunConfigCmp<'_> {
             self.line("Datacenter", "", |conf| {
                 conf.connection.datacenter.clone().unwrap_or_default()
             }),
-            self.line("Cass. version", "", |conf| {
-                OptionDisplay(conf.cass_version.clone())
+            self.line("DB version", "", |conf| {
+                OptionDisplay(conf.db_version.clone())
             }),
             self.line("Workload", "", |conf| {
                 conf.workload

src/scripting/connect.rs

@@ -66,5 +66,5 @@ pub async fn connect(conf: &ConnectionConf) -> Result<Context, CassError> {
 
 pub struct ClusterInfo {
     pub name: String,
-    pub cassandra_version: String,
+    pub db_version: String,
 }

src/scripting/context.rs

@@ -262,24 +262,53 @@ impl Context {
         })
     }
 
-    /// Returns cluster metadata such as cluster name and cassandra version.
+    /// Returns cluster metadata such as cluster name and DB version.
     pub async fn cluster_info(&self) -> Result<Option<ClusterInfo>, CassError> {
-        let cql = "SELECT cluster_name, release_version FROM system.local";
-
-        match &self.session {
-            Some(session) => {
+        let session = match &self.session {
+            Some(session) => session,
+            None => {
+                return Err(CassError(CassErrorKind::Error(
+                    "'session' is not defined".to_string(),
+                )))
+            }
+        };
+        let scylla_cql = "SELECT version, build_id FROM system.versions";
+        let rs = session
+            .query_unpaged(scylla_cql, ())
+            .await
+            .map_err(|e| CassError::query_execution_error(scylla_cql, &[], e));
+        match rs {
+            Ok(rs) => {
+                let rows_result = rs.into_rows_result()?;
+                while let Ok(mut row) = rows_result.rows::<(&str, &str)>() {
+                    if let Some(Ok((scylla_version, build_id))) = row.next() {
+                        return Ok(Some(ClusterInfo {
+                            name: "".to_string(),
+                            db_version: format!(
+                                "ScyllaDB {} with build-id {}",
+                                scylla_version, build_id
+                            ),
+                        }));
+                    }
+                }
+                Ok(None)
+            }
+            Err(_e) => {
+                // NOTE: following exists in both cases
+                // and if we run against ScyllaDB then it has static '3.0.8' version.
+                let cass_cql = "SELECT cluster_name, release_version FROM system.local";
                 let rs = session
-                    .query_unpaged(cql, ())
+                    .query_unpaged(cass_cql, ())
                     .await
-                    .map_err(|e| CassError::query_execution_error(cql, &[], e));
+                    .map_err(|e| CassError::query_execution_error(cass_cql, &[], e));
                 match rs {
                     Ok(rs) => {
                         let rows_result = rs.into_rows_result()?;
-                        while let Ok(mut row) = rows_result.rows() {
-                            if let Some(Ok((name, cassandra_version))) = row.next() {
+                        while let Ok(mut row) = rows_result.rows::<(&str, &str)>() {
+                            if let Some(Ok((name, cass_version))) = row.next() {
                                 return Ok(Some(ClusterInfo {
-                                    name,
-                                    cassandra_version,
+                                    name: name.to_string(),
+                                    db_version: format!("Cassandra {}", cass_version),
                                 }));
                             }
                         }
@@ -291,9 +320,6 @@ impl Context {
                     }
                 }
             }
-            None => Err(CassError(CassErrorKind::Error(
-                "'session' is not defined".to_string(),
-            ))),
         }
     }