Use AdapterType instead of strings (#5415)

* dbt-fusion-adapter: Use AdapterType instead of strings

* dbt-schemas: Use AdapterType instead of strings

* dbt-jinj-utils: Use AdapterType instead of strings

* dbt-init: Use AdapterType instead of strings

* dbt-freshness: Use AdapterType instead of strings

* dbt-parser: Use AdapterType instead of strings

* sdf-linter: Use AdapterType instead of strings

* dbt-loader: Use AdapterType instead of strings

* dbt-metadata: Use AdapterType instead of strings

* dbt-lineage: Use AdapterType instead of strings

* dbt-adapter: Use AdapterType instead of strings

* dbt-tasks: Use AdapterType instead of strings

* dbt-common: Implement Ser/Deserialize for AdapterType

* sdf-lp-processor: Use AdapterType instead of strings

* sdf-formatter: Use AdapterType instead of strings

* dbt-lsp: Use AdapterType instead of strings

* dbt-cli: Use AdapterType instead of strings

* dbt-adapter-tests: Use AdapterType instead of strings

* Add TODOs for Salesforce

GitOrigin-RevId: 513366b0376bef50601a4e1f9191f77c219c00d9

Author: felipecrv

crates/dbt-common/src/adapter.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use arrow_schema::Schema;
 use dbt_frontend_common::dialect::Dialect;
+use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, Display, EnumString};
 
 /// Schema registry access interface.
@@ -16,8 +17,11 @@ pub trait SchemaRegistry: Send + Sync {
 /// The type of the adapter.
 ///
 /// Used to identify the specific database adapter being used.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, AsRefStr, EnumString)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Display, AsRefStr, EnumString, Deserialize, Serialize,
+)]
 #[strum(serialize_all = "lowercase", ascii_case_insensitive)]
+#[serde(rename_all = "lowercase")]
 pub enum AdapterType {
     /// Adapter used in parse phase
     Parse,

crates/dbt-common/src/pretty_table.rs

@@ -427,7 +427,7 @@ pub fn pretty_schema_table(
     subtitle: &str,
     display_format: &DisplayFormat,
     table_schema: &Schema,
-    _dialect: &Dialect,
+    _dialect: Dialect,
     limit: Option<usize>,
     show_footer: bool,
 ) -> FsResult<String> {

crates/dbt-fusion-adapter/src/bridge_adapter.rs

@@ -695,7 +695,7 @@ impl BaseAdapter for BridgeAdapter {
         identifier: &str,
     ) -> Result<Value, MinijinjaError> {
         let temp_relation = relation_object::create_relation(
-            self.typed_adapter.adapter_type().to_string(),
+            self.typed_adapter.adapter_type(),
             database.to_string(),
             schema.to_string(),
             Some(identifier.to_string()),

crates/dbt-fusion-adapter/src/cache.rs

@@ -351,6 +351,8 @@ impl Drop for RelationCache {
 
 #[cfg(test)]
 mod tests {
+    use crate::AdapterType;
+
     use super::*;
     use dbt_schemas::schemas::{common::ResolvedQuoting, relations::DEFAULT_RESOLVED_QUOTING};
 
@@ -362,7 +364,7 @@ mod tests {
 
         // Create relations with different combinations of database, schema, identifier
         let relation1 = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "db1".to_string(),
             "schema1".to_string(),
             Some("table1".to_string()),
@@ -372,7 +374,7 @@ mod tests {
         .unwrap();
 
         let relation2 = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "db2".to_string(),
             "schema1".to_string(),
             Some("table1".to_string()),
@@ -382,7 +384,7 @@ mod tests {
         .unwrap();
 
         let relation3 = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "db1".to_string(),
             "schema2".to_string(),
             Some("table1".to_string()),
@@ -392,7 +394,7 @@ mod tests {
         .unwrap();
 
         let relation4 = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "db1".to_string(),
             "schema1".to_string(),
             Some("table2".to_string()),
@@ -402,7 +404,7 @@ mod tests {
         .unwrap();
 
         let relation1_dup = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "db1".to_string(),
             "schema1".to_string(),
             Some("table1".to_string()),
@@ -451,7 +453,7 @@ mod tests {
 
         // With DEFAULT_RESOLVED_QUOTING
         let relation_quoted = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "MyDB".to_string(),
             "MySchema".to_string(),
             Some("MyTable".to_string()),
@@ -462,7 +464,7 @@ mod tests {
 
         // With no quoting
         let relation_unquoted = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "MyDB".to_string(),
             "MySchema".to_string(),
             Some("MyTable".to_string()),
@@ -492,7 +494,7 @@ mod tests {
 
         // Test that we find the unquoted relation when searching with unquoted policy
         let search_relation_unquoted = create_relation(
-            "postgres".to_string(),
+            AdapterType::Postgres,
             "MyDB".to_string(),
             "MySchema".to_string(),
             Some("MyTable".to_string()),
@@ -525,7 +527,7 @@ mod tests {
                 // Create relations in 3 different schemas
                 (0..3).map(move |schema_id| {
                     create_relation(
-                        "postgres".to_string(),
+                        AdapterType::Postgres,
                         "test_db".to_string(),
                         format!("schema_{schema_id}"),
                         Some(format!("table_{schema_id}_{i}")),
@@ -585,7 +587,7 @@ mod tests {
                             6 => {
                                 // Rename operations (less common but important)
                                 let new_relation = create_relation(
-                                    "postgres".to_string(),
+                                    AdapterType::Postgres,
                                     "test_db".to_string(),
                                     format!("schema_{}", thread_id % 3),
                                     Some(format!("renamed_table_{thread_id}_{i}")),

crates/dbt-fusion-adapter/src/databricks/relation_configs/comment.rs

@@ -92,6 +92,7 @@ impl DatabricksComponentProcessor for CommentProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::AdapterType;
     use crate::databricks::relation_configs::base::DatabricksRelationResultsBuilder;
     use dbt_agate::AgateTable;
     use dbt_schemas::schemas::{common::*, nodes::*, project::*};
@@ -135,7 +136,8 @@ mod tests {
         let warehouse_config = WarehouseSpecificNodeConfig::default();
 
         // Use the factory method to create adapter attributes
-        let adapter_attr = AdapterAttr::from_config_and_dialect(&warehouse_config, "databricks");
+        let adapter_attr =
+            AdapterAttr::from_config_and_dialect(&warehouse_config, AdapterType::Databricks);
 
         DbtModel {
             __common_attr__: CommonAttributes {

crates/dbt-fusion-adapter/src/databricks/relation_configs/partitioning.rs

@@ -104,6 +104,7 @@ impl DatabricksComponentProcessor for PartitionedByProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::AdapterType;
     use crate::databricks::relation_configs::base::DatabricksRelationResultsBuilder;
     use dbt_agate::AgateTable;
     use dbt_schemas::schemas::{common::*, nodes::*, project::*};
@@ -181,7 +182,8 @@ mod tests {
         };
 
         // Use the factory method to create adapter attributes
-        let adapter_attr = AdapterAttr::from_config_and_dialect(&warehouse_config, "databricks");
+        let adapter_attr =
+            AdapterAttr::from_config_and_dialect(&warehouse_config, AdapterType::Databricks);
 
         DbtModel {
             __common_attr__: CommonAttributes {

crates/dbt-fusion-adapter/src/databricks/relation_configs/refresh.rs

@@ -117,6 +117,7 @@ impl DatabricksComponentProcessor for RefreshProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::AdapterType;
     use crate::databricks::relation_configs::base::DatabricksRelationResultsBuilder;
     use dbt_agate::AgateTable;
     use dbt_schemas::schemas::{common::*, nodes::*, project::*};
@@ -190,7 +191,8 @@ mod tests {
         };
 
         // Use the factory method to create adapter attributes
-        let adapter_attr = AdapterAttr::from_config_and_dialect(&warehouse_config, "databricks");
+        let adapter_attr =
+            AdapterAttr::from_config_and_dialect(&warehouse_config, AdapterType::Databricks);
 
         DbtModel {
             __common_attr__: CommonAttributes {

crates/dbt-fusion-adapter/src/databricks/relation_configs/tblproperties.rs

@@ -157,6 +157,7 @@ impl DatabricksComponentProcessor for TblPropertiesProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::AdapterType;
     use crate::databricks::relation_configs::base::DatabricksRelationResultsBuilder;
     use dbt_agate::AgateTable;
     use dbt_schemas::schemas::{common::*, nodes::*, project::*};
@@ -218,7 +219,8 @@ mod tests {
         };
 
         // Use the factory method to create adapter attributes
-        let adapter_attr = AdapterAttr::from_config_and_dialect(&warehouse_config, "databricks");
+        let adapter_attr =
+            AdapterAttr::from_config_and_dialect(&warehouse_config, AdapterType::Databricks);
 
         DbtModel {
             __common_attr__: CommonAttributes {

crates/dbt-fusion-adapter/src/metadata.rs

@@ -201,6 +201,7 @@ pub trait MetadataAdapter: TypedBaseAdapter + Send + Sync {
         resolved_state: &ResolverState,
         run_stats: &Stats,
     ) -> Vec<Arc<dyn BaseRelation>> {
+        let adapter_type = resolved_state.adapter_type;
         let mut relations: Vec<Arc<dyn BaseRelation>> = Vec::new();
         let executed_unique_ids = run_stats
             .stats
@@ -214,7 +215,7 @@ pub trait MetadataAdapter: TypedBaseAdapter + Send + Sync {
         for (unique_id, node) in nodes.models.iter() {
             if executed_unique_ids.contains(unique_id) {
                 let relation = create_relation_internal(
-                    resolved_state.adapter_type.to_string(),
+                    adapter_type,
                     node.database(),
                     node.schema(),
                     Some(node.alias()),
@@ -229,7 +230,7 @@ pub trait MetadataAdapter: TypedBaseAdapter + Send + Sync {
         for (unique_id, node) in nodes.snapshots.iter() {
             if executed_unique_ids.contains(unique_id) {
                 let relation = create_relation_internal(
-                    resolved_state.adapter_type.to_string(),
+                    adapter_type,
                     node.database(),
                     node.schema(),
                     Some(node.alias()),
@@ -244,7 +245,7 @@ pub trait MetadataAdapter: TypedBaseAdapter + Send + Sync {
         for (unique_id, node) in nodes.seeds.iter() {
             if executed_unique_ids.contains(unique_id) {
                 let relation = create_relation_internal(
-                    resolved_state.adapter_type.to_string(),
+                    adapter_type,
                     node.database(),
                     node.schema(),
                     Some(node.alias()),
@@ -259,7 +260,7 @@ pub trait MetadataAdapter: TypedBaseAdapter + Send + Sync {
         for (unique_id, node) in nodes.sources.iter() {
             if executed_unique_ids.contains(unique_id) {
                 let relation = create_relation_internal(
-                    resolved_state.adapter_type.to_string(),
+                    adapter_type,
                     node.database(),
                     node.schema(),
                     Some(node.alias()),

crates/dbt-fusion-adapter/src/parse/adapter.rs

@@ -31,16 +31,15 @@ use serde::Deserialize;
 use std::collections::BTreeMap;
 use std::fmt;
 use std::rc::Rc;
-use std::str::FromStr;
 use std::sync::Arc;
 
 /// Parse adapter for Jinja templates.
 ///
 /// Returns stub values to enable the parsing phase.
 #[derive(Debug, Clone)]
 pub struct ParseAdapter {
-    /// The type of database adapter (e.g. "snowflake", "postgres", etc.)
-    adapter_type: String,
+    /// Adapter type
+    adapter_type: AdapterType,
     /// The call_get_relation method calls found during parse
     call_get_relation: DashMap<String, Vec<Value>>,
     /// The call_get_columns_in_relation method calls found during parse
@@ -66,12 +65,10 @@ type RelationsToFetch = (
 impl ParseAdapter {
     /// Make a new adapter
     pub fn new(
-        adapter_type: impl Into<String>,
+        adapter_type: AdapterType,
         package_quoting: DbtQuoting,
         token: CancellationToken,
     ) -> Self {
-        let adapter_type = adapter_type.into();
-        AdapterType::from_str(&adapter_type).expect("adapter_type is valid");
         Self {
             adapter_type,
             call_get_relation: DashMap::new(),
@@ -95,7 +92,7 @@ impl ParseAdapter {
         identifier: &str,
     ) -> Result<(), MinijinjaError> {
         let relation = create_relation(
-            self.adapter_type.clone(),
+            self.adapter_type,
             database.to_string(),
             schema.to_string(),
             Some(identifier.to_string()),
@@ -202,16 +199,7 @@ impl ParseAdapter {
 
 impl AdapterTyping for ParseAdapter {
     fn adapter_type(&self) -> AdapterType {
-        // TODO: check if we need adapterType::Parse
-        // since even ParseAdapter should be a specific <dialect> type
-        debug_assert!(
-            self.adapter_type
-                .parse::<AdapterType>()
-                .expect("adapter_type is valid")
-                != AdapterType::Parse,
-            "ParseAdapter should be a specific <dialect> type"
-        );
-        self.adapter_type.parse().unwrap_or(AdapterType::Parse)
+        self.adapter_type
     }
 
     fn as_metadata_adapter(&self) -> Option<&dyn MetadataAdapter> {
@@ -762,11 +750,10 @@ impl Object for ParseAdapter {
 
 /// Make parse factory
 pub fn create_parse_adapter(
-    adapter_type: impl Into<String>,
+    adapter_type: AdapterType,
     package_quoting: DbtQuoting,
     token: CancellationToken,
 ) -> FsResult<Arc<dyn BaseAdapter>> {
-    let adapter_type: String = adapter_type.into();
     Ok(Arc::new(ParseAdapter::new(
         adapter_type,
         package_quoting,