now looking for optional database field.

api/src/utils/query_engine/credentials.rs

@@ -97,7 +97,7 @@ pub struct RedshiftCredentials {
 pub struct SnowflakeCredentials {
     pub account_id: String,
     pub warehouse_id: String,
-    pub database_id: String,
+    pub database_id: Option<String>,
     pub username: String,
     pub password: String,
     pub role: Option<String>,

api/src/utils/query_engine/data_source_connections/get_snowflake_client.rs

@@ -5,12 +5,11 @@ use crate::utils::query_engine::credentials::SnowflakeCredentials;
 
 pub async fn get_snowflake_client(
     credentials: &SnowflakeCredentials,
-    database: Option<String>,
 ) -> Result<SnowflakeApi, Error> {
     let snowflake_client = match SnowflakeApi::with_password_auth(
         &credentials.account_id,
-        Some(credentials.warehouse_id.as_str()),
-        database.as_deref(),
+        Some(&credentials.warehouse_id),
+        credentials.database_id.as_deref(),
         None,
         &credentials.username,
         credentials.role.as_deref(),

api/src/utils/query_engine/data_source_query_routes/query_router.rs

@@ -229,7 +229,7 @@ async fn route_to_query(
         DataSourceType::Snowflake => {
             let credentials: SnowflakeCredentials = serde_json::from_str(&credentials_string)?;
 
-            let mut snowflake_client = match get_snowflake_client(&credentials, None).await {
+            let mut snowflake_client = match get_snowflake_client(&credentials).await {
                 Ok(snowflake_client) => snowflake_client,
                 Err(e) => {
                     tracing::error!("There was an issue while establishing a connection to the parent data source: {}", e);

api/src/utils/query_engine/import_dataset_columns.rs

@@ -222,7 +222,7 @@ async fn get_snowflake_columns_batch(
     credentials: &SnowflakeCredentials,
     database: Option<String>,
 ) -> Result<Vec<DatasetColumnRecord>> {
-    let snowflake_client = get_snowflake_client(credentials, database).await?;
+    let snowflake_client = get_snowflake_client(credentials).await?;
 
     // Build the IN clause for (schema, table) pairs
     let table_pairs: Vec<String> = datasets
@@ -647,7 +647,7 @@ async fn get_snowflake_columns(
     schema_name: &String,
     credentials: &SnowflakeCredentials,
 ) -> Result<Vec<DatasetColumnRecord>> {
-    let snowflake_client = get_snowflake_client(credentials, None).await?;
+    let snowflake_client = get_snowflake_client(credentials).await?;
 
     let uppercase_dataset_name = dataset_name.to_uppercase();
     let uppercase_schema_name = schema_name.to_uppercase();

api/src/utils/query_engine/import_datasets.rs

@@ -345,7 +345,7 @@ async fn get_bigquery_tables_and_views(
 async fn get_snowflake_tables_and_views(
     credentials: &SnowflakeCredentials,
 ) -> Result<Vec<DatasetRecord>> {
-    let snowflake_client = get_snowflake_client(credentials, None).await?;
+    let snowflake_client = get_snowflake_client(credentials).await?;
 
     let schema_list = credentials.schemas.clone().unwrap_or_else(|| vec![]);
     let schema_string = if !schema_list.is_empty() {

api/src/utils/query_engine/test_data_source_connections.rs

@@ -95,7 +95,7 @@ pub async fn test_data_source_connection(
                 _ => return Err(anyhow!("Invalid credential type")),
             };
 
-            match get_snowflake_client(&credential, None).await {
+            match get_snowflake_client(&credential).await {
                 Ok(client) => client,
                 Err(e) => return Err(anyhow!("Error getting snowflake client: {:?}", e)),
             };