cleanup

Author: DatGuyJonathan

apps/framework-cli/src/framework/core/infrastructure/table.rs

@@ -511,10 +511,6 @@ impl Table {
                     })
             });
 
-        // Normalize auto-injected replication params so they match user code
-        // This prevents spurious diffs when comparing tables from inframap with code
-        let engine = engine.map(|e| e.normalize_auto_injected_params(&proto.name));
-
         // Engine settings are now handled via table_settings field
 
         let fallback = || -> OrderBy {

apps/framework-cli/src/infrastructure/olap/clickhouse.rs

@@ -1701,11 +1701,6 @@ impl OlapOperations for ConfiguredDBClient {
                 engine.as_str().try_into().ok()
             };
 
-            // Normalize auto-injected replication params so they match user code
-            // This prevents spurious diffs when comparing tables from the DB with code
-            let engine_parsed = engine_parsed
-                .map(|e: ClickhouseEngine| e.normalize_auto_injected_params(&table_name));
-
             let engine_params_hash = engine_parsed
                 .as_ref()
                 .map(|e: &ClickhouseEngine| e.non_alterable_params_hash());

apps/framework-cli/src/infrastructure/olap/clickhouse/queries.rs

@@ -885,93 +885,6 @@ impl ClickhouseEngine {
         self.is_merge_tree_family() || matches!(self, ClickhouseEngine::S3 { .. })
     }
 
-    /// Normalize auto-injected replication parameters back to None
-    ///
-    /// When Moose auto-injects replication params in dev mode or with clusters,
-    /// it uses a standard pattern. When reading tables back from ClickHouse,
-    /// we normalize these back to None so they match the user's code (which
-    /// doesn't specify params) and don't show spurious diffs.
-    ///
-    /// Auto-injected pattern:
-    /// - keeper_path: `/clickhouse/tables/{database}/{shard}/{table_name}`
-    /// - replica_name: `{replica}`
-    pub fn normalize_auto_injected_params(&self, table_name: &str) -> Self {
-        let expected_keeper_path =
-            format!("/clickhouse/tables/{{database}}/{{shard}}/{}", table_name);
-        let expected_replica_name = "{replica}";
-
-        match self {
-            ClickhouseEngine::ReplicatedMergeTree {
-                keeper_path,
-                replica_name,
-            } => {
-                if keeper_path.as_deref() == Some(&expected_keeper_path)
-                    && replica_name.as_deref() == Some(expected_replica_name)
-                {
-                    ClickhouseEngine::ReplicatedMergeTree {
-                        keeper_path: None,
-                        replica_name: None,
-                    }
-                } else {
-                    self.clone()
-                }
-            }
-            ClickhouseEngine::ReplicatedReplacingMergeTree {
-                keeper_path,
-                replica_name,
-                ver,
-                is_deleted,
-            } => {
-                if keeper_path.as_deref() == Some(&expected_keeper_path)
-                    && replica_name.as_deref() == Some(expected_replica_name)
-                {
-                    ClickhouseEngine::ReplicatedReplacingMergeTree {
-                        keeper_path: None,
-                        replica_name: None,
-                        ver: ver.clone(),
-                        is_deleted: is_deleted.clone(),
-                    }
-                } else {
-                    self.clone()
-                }
-            }
-            ClickhouseEngine::ReplicatedAggregatingMergeTree {
-                keeper_path,
-                replica_name,
-            } => {
-                if keeper_path.as_deref() == Some(&expected_keeper_path)
-                    && replica_name.as_deref() == Some(expected_replica_name)
-                {
-                    ClickhouseEngine::ReplicatedAggregatingMergeTree {
-                        keeper_path: None,
-                        replica_name: None,
-                    }
-                } else {
-                    self.clone()
-                }
-            }
-            ClickhouseEngine::ReplicatedSummingMergeTree {
-                keeper_path,
-                replica_name,
-                columns,
-            } => {
-                if keeper_path.as_deref() == Some(&expected_keeper_path)
-                    && replica_name.as_deref() == Some(expected_replica_name)
-                {
-                    ClickhouseEngine::ReplicatedSummingMergeTree {
-                        keeper_path: None,
-                        replica_name: None,
-                        columns: columns.clone(),
-                    }
-                } else {
-                    self.clone()
-                }
-            }
-            // Non-replicated engines don't need normalization
-            _ => self.clone(),
-        }
-    }
-
     /// Convert engine to string for proto storage (no sensitive data)
     pub fn to_proto_string(&self) -> String {
         match self {
@@ -4799,82 +4712,4 @@ ENGINE = S3Queue('s3://my-bucket/data/*.csv', NOSIGN, 'CSV')"#;
             _ => panic!("Expected InvalidParameters error"),
         }
     }
-
-    #[test]
-    fn test_normalize_auto_injected_params_replicated_merge_tree() {
-        // Test auto-injected params are normalized to None
-        let engine = ClickhouseEngine::ReplicatedMergeTree {
-            keeper_path: Some("/clickhouse/tables/{database}/{shard}/MyTable".to_string()),
-            replica_name: Some("{replica}".to_string()),
-        };
-
-        let normalized = engine.normalize_auto_injected_params("MyTable");
-
-        assert!(matches!(
-            normalized,
-            ClickhouseEngine::ReplicatedMergeTree {
-                keeper_path: None,
-                replica_name: None,
-            }
-        ));
-    }
-
-    #[test]
-    fn test_normalize_auto_injected_params_custom_params_unchanged() {
-        // Test custom params are NOT normalized
-        let engine = ClickhouseEngine::ReplicatedMergeTree {
-            keeper_path: Some("/custom/path/MyTable".to_string()),
-            replica_name: Some("custom_replica".to_string()),
-        };
-
-        let normalized = engine.normalize_auto_injected_params("MyTable");
-
-        // Should remain unchanged
-        match normalized {
-            ClickhouseEngine::ReplicatedMergeTree {
-                keeper_path,
-                replica_name,
-            } => {
-                assert_eq!(keeper_path, Some("/custom/path/MyTable".to_string()));
-                assert_eq!(replica_name, Some("custom_replica".to_string()));
-            }
-            _ => panic!("Expected ReplicatedMergeTree"),
-        }
-    }
-
-    #[test]
-    fn test_normalize_auto_injected_params_replicated_replacing_merge_tree() {
-        // Test ReplicatedReplacingMergeTree with auto-injected params
-        let engine = ClickhouseEngine::ReplicatedReplacingMergeTree {
-            keeper_path: Some("/clickhouse/tables/{database}/{shard}/MyTable".to_string()),
-            replica_name: Some("{replica}".to_string()),
-            ver: Some("version_col".to_string()),
-            is_deleted: None,
-        };
-
-        let normalized = engine.normalize_auto_injected_params("MyTable");
-
-        match normalized {
-            ClickhouseEngine::ReplicatedReplacingMergeTree {
-                keeper_path,
-                replica_name,
-                ver,
-                is_deleted,
-            } => {
-                assert_eq!(keeper_path, None);
-                assert_eq!(replica_name, None);
-                assert_eq!(ver, Some("version_col".to_string()));
-                assert_eq!(is_deleted, None);
-            }
-            _ => panic!("Expected ReplicatedReplacingMergeTree"),
-        }
-    }
-
-    #[test]
-    fn test_normalize_auto_injected_params_non_replicated_unchanged() {
-        // Test non-replicated engines are unchanged
-        let engine = ClickhouseEngine::MergeTree;
-        let normalized = engine.normalize_auto_injected_params("MyTable");
-        assert!(matches!(normalized, ClickhouseEngine::MergeTree));
-    }
 }