SQL-2288: Create mongosqltranslate integration tests

core/src/col_metadata.rs

@@ -171,9 +171,12 @@ pub struct VersionedJsonSchema {
 }
 
 // Struct representing the ResultSetSchema.
+// The `schema` field needs the alias `result_set_schema` because this struct is used to get the schema
+// from the __sql_schemas collection, which stores the schema in it's `schema` field, and the libmongosqltranslate
+// `translate` command, which stores the schema in it's `result_set_schema` field.
 #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Default)]
 pub struct ResultSetSchema {
-    #[serde(rename = "result_set_schema")]
+    #[serde(alias = "result_set_schema")]
     pub schema: crate::json_schema::Schema,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub select_order: Option<Vec<Vec<String>>>,

core/src/collections.rs

@@ -1,5 +1,5 @@
 use crate::stmt::EmptyStatement;
-use crate::util::{is_match, table_type_filter_to_vec, to_name_regex};
+use crate::util::{databases_filter, is_match, table_type_filter_to_vec, to_name_regex};
 use crate::{
     col_metadata::MongoColMetadata,
     conn::MongoConnection,
@@ -123,13 +123,7 @@ impl MongoCollections {
                     .unwrap()
                     .iter()
                     // MHOUSE-7119 - admin database and empty strings are showing in list_database_names
-                    .filter(|&db_name| {
-                        !db_name.is_empty()
-                            && !db_name.eq("admin")
-                            && !db_name.eq("config")
-                            && !db_name.eq("local")
-                            && !db_name.eq("system")
-                    })
+                    .filter(|&db_name| databases_filter(db_name))
                     .filter(|&db_name| is_match(db_name, db_name_filter, accept_search_patterns))
                     .map(|val| async move {
                         CollectionsForDb {

core/src/conn.rs

@@ -214,6 +214,8 @@ impl MongoConnection {
 
                 let compatibility = Self::is_libmongosqltranslate_compatible_with_driver_version()?;
 
+                log::info!("libmongosqltranslate version: `{0}`. ODBC driver version: `{1}`. The ODBC driver and libmongosqltranslate library is compatible: `{2}`.", libmongosqltranslate_version, *DRIVER_METRICS_VERSION, compatibility);
+
                 (Some(compatibility), Some(libmongosqltranslate_version))
             } else {
                 (None, None)

core/src/databases.rs

@@ -1,6 +1,6 @@
 use crate::{
     col_metadata::MongoColMetadata, conn::MongoConnection, err::Result, stmt::MongoStatement,
-    BsonTypeInfo, Error,
+    util::databases_filter, BsonTypeInfo, Error,
 };
 use definitions::Nullability;
 use mongodb::bson::Bson;
@@ -221,13 +221,7 @@ impl MongoDatabases {
             })
             .unwrap()
             .iter()
-            .filter(|&db_name| {
-                !db_name.is_empty()
-                    && !db_name.eq("admin")
-                    && !db_name.eq("config")
-                    && !db_name.eq("local")
-                    && !db_name.eq("system")
-            })
+            .filter(|&db_name| databases_filter(db_name))
             .map(|s| s.to_string())
             .collect();
 

core/src/fields.rs

@@ -5,7 +5,7 @@ use crate::{
     conn::MongoConnection,
     err::{Error, Result},
     stmt::MongoStatement,
-    util::to_name_regex,
+    util::{databases_filter, to_name_regex},
     BsonTypeInfo, TypeMode,
 };
 use constants::SQL_SCHEMAS_COLLECTION;
@@ -486,13 +486,7 @@ impl MongoFields {
                     .unwrap()
                     // MHOUSE-7119 - admin database and empty strings are showing in list_database_names
                     .iter()
-                    .filter(|&db_name| {
-                        !db_name.is_empty()
-                            && !db_name.eq("admin")
-                            && !db_name.eq("config")
-                            && !db_name.eq("local")
-                            && !db_name.eq("system")
-                    })
+                    .filter(|&db_name| databases_filter(db_name))
                     .map(|s| s.to_string())
                     .collect()
             },
@@ -567,13 +561,17 @@ impl MongoFields {
                                     Error::CollectionDeserialization(collection_name.clone(), e)
                                 });
 
-                            if let Err(error) = sql_get_schema_response {
-                                // If there is an Error while deserializing the schema, we won't show any columns for it
-                                warnings.push(error);
-                                continue;
-                            }
+                            let error_checked_sql_get_schema_response =
+                                match sql_get_schema_response {
+                                    Ok(sql_get_schema_response) => sql_get_schema_response,
+                                    Err(error) => {
+                                        // If there is an Error while deserializing the schema, we won't show any columns for it
+                                        warnings.push(error);
+                                        continue;
+                                    }
+                                };
 
-                            sql_get_schema_response.unwrap().into()
+                            error_checked_sql_get_schema_response.into()
                         } else if mongo_connection.cluster_type == MongoClusterType::Enterprise {
                             let schema_collection =
                                 db.collection::<Document>(SQL_SCHEMAS_COLLECTION);
@@ -599,13 +597,14 @@ impl MongoFields {
                                     },
                                 );
 
-                            if let Err(error) = result_set_schema {
-                                // If there is an Error while deserializing the schema, we won't show any columns for it
-                                warnings.push(error);
-                                continue;
+                            match result_set_schema {
+                                Ok(result_set_schema) => result_set_schema,
+                                Err(error) => {
+                                    // If there is an Error while deserializing the schema, we won't show any columns for it
+                                    warnings.push(error);
+                                    continue;
+                                }
                             }
-
-                            result_set_schema.unwrap()
                         } else {
                             unreachable!()
                         };

core/src/mongosqltranslate.rs

@@ -307,6 +307,11 @@ pub(crate) fn libmongosqltranslate_run_command<T: CommandName + Serialize>(
         capacity: command_bytes_capacity,
     };
 
+    log::info!(
+        "Calling `{}` libmongosqltranslate runCommand.",
+        T::command_name()
+    );
+
     let decomposed_returned_doc = unsafe { run_command_function(libmongosqltranslate_command) };
 
     let mut command_response_doc: Document = unsafe {

core/src/util/mod.rs

@@ -78,6 +78,14 @@ pub(crate) fn table_type_filter_to_vec(table_type: &str) -> Option<Vec<Collectio
     };
 }
 
+pub(crate) fn databases_filter(db_name: &str) -> bool {
+    !db_name.is_empty()
+        && !db_name.eq("admin")
+        && !db_name.eq("config")
+        && !db_name.eq("local")
+        && !db_name.eq("system")
+}
+
 #[macro_export]
 macro_rules! map {
         ($($key:expr => $val:expr),* $(,)?) => {

integration_test/tests/mongosqltranslate_tests.rs

@@ -125,6 +125,13 @@ mod mongosqltranslate {
                 get_sql_diagnostics(HandleType::SQL_HANDLE_STMT, stmt as Handle)
             );
 
+            let error_message = get_sql_diagnostics(HandleType::SQL_HANDLE_STMT, stmt as Handle);
+            assert!(
+                error_message.contains("No schema information returned for the requested collections."),
+                "Expected error message: `No schema information returned for the requested collections.`; actual error message: {}",
+                error_message
+            );
+
             disconnect_and_close_handles(dbc, stmt);
         }
         let _ = unsafe { Box::from_raw(env_handle) };
@@ -150,6 +157,13 @@ mod mongosqltranslate {
                 get_sql_diagnostics(HandleType::SQL_HANDLE_STMT, stmt as Handle)
             );
 
+            let error_message = get_sql_diagnostics(HandleType::SQL_HANDLE_STMT, stmt as Handle);
+            assert!(
+                error_message.contains("The libmongosqltranslate command `translate` failed. Error message: `algebrize error: Error 1016: unknown collection 'foo' in database 'test'`. Error is internal: false"),
+                "Expected error message: `The libmongosqltranslate command `translate` failed. Error message: `algebrize error: Error 1016: unknown collection 'foo' in database 'test'`. Error is internal: false`; actual error message: {}",
+                error_message
+            );
+
             disconnect_and_close_handles(dbc, stmt);
         }
         let _ = unsafe { Box::from_raw(env_handle) };