chore(routine): Move building of routine signature out of SQL

oniony · oniony · commit 3bb367d944d5 · 2025-01-10T21:47:24.000Z
diff --git a/src/compare/mod.rs b/src/compare/mod.rs
@@ -34,6 +34,7 @@ use crate::db::column_privilege::ColumnPrivilege;
 use crate::db::index::Index;
 use crate::db::privilege::Privilege;
 use crate::db::routine::Routine;
+use crate::db::routine_parameters::RoutineParameter;
 use crate::db::routine_privilege::RoutinePrivilege;
 use crate::db::table_constraint::TableConstraint;
 use crate::db::table_privilege::TablePrivilege;
@@ -72,6 +73,8 @@ impl Comparer {
         let right_column_privileges = self.right_db.column_privileges(&schemas[..]).await?;
         let left_routines = self.left_db.routines(&schemas[..]).await?;
         let right_routines = self.right_db.routines(&schemas[..]).await?;
+        let left_routine_parameters = self.left_db.routine_parameters(&schemas[..]).await?;
+        let right_routine_parameters = self.right_db.routine_parameters(&schemas[..]).await?;
         let left_routine_privileges = self.left_db.routine_privileges(&schemas[..]).await?;
         let right_routine_privileges = self.right_db.routine_privileges(&schemas[..]).await?;
         let left_schemas = self.left_db.schemas(&schemas[..]).await?;
@@ -107,9 +110,17 @@ impl Comparer {
 
                     let left_schema_routines = left_routines.iter().filter(|r| r.routine_schema == schema).collect();
                     let right_schema_routines = right_routines.iter().filter(|r| r.routine_schema == schema).collect();
+                    let left_schema_routine_parameters = left_routine_parameters.iter().filter(|p| p.specific_schema == schema).collect();
+                    let right_schema_routine_parameters = right_routine_parameters.iter().filter(|p| p.specific_schema == schema).collect();
                     let left_schema_routine_privileges = left_routine_privileges.iter().filter(|p| p.routine_schema == schema).collect();
                     let right_schema_routine_privileges = right_routine_privileges.iter().filter(|p| p.routine_schema == schema).collect();
-                    let routines = self.compare_routines(left_schema_routines, right_schema_routines, left_schema_routine_privileges, right_schema_routine_privileges)?;
+                    let routines = self.compare_routines(
+                        left_schema_routines,
+                        right_schema_routines,
+                        left_schema_routine_parameters,
+                        right_schema_routine_parameters,
+                        left_schema_routine_privileges,
+                        right_schema_routine_privileges)?;
 
                     let left_schema_sequences = left_sequences.iter().filter(|s| s.sequence_schema == schema).collect();
                     let right_schema_sequences = right_sequences.iter().filter(|s| s.sequence_schema == schema).collect();
@@ -172,39 +183,42 @@ impl Comparer {
     fn compare_routines(&mut self,
                         left_routines: Vec<&Routine>,
                         right_routines: Vec<&Routine>,
+                        left_routine_parameters: Vec<&RoutineParameter>,
+                        right_routine_parameters: Vec<&RoutineParameter>,
                         left_routine_privileges: Vec<&RoutinePrivilege>,
                         right_routine_privileges: Vec<&RoutinePrivilege>,
     ) -> Result<Report<RoutineComparison>, Error> {
-        let mut right_routines_map: HashMap<String, &Routine> = right_routines.into_iter().map(|t| (t.signature.clone(), t)).collect();
+        let mut right_routines_map: HashMap<String, &Routine> = right_routines.into_iter().map(|r| (routine_signature(r, &right_routine_parameters), r)).collect();
         let mut entries = Vec::new();
     
         for left_routine in left_routines {
-            let right_routine = right_routines_map.get(&left_routine.signature);
+            let signature = routine_signature(left_routine, &left_routine_parameters);
+            let right_routine = right_routines_map.get(&signature);
     
             match right_routine {
                 None => {
-                    entries.push(RoutineRemoved { routine_signature: left_routine.signature.clone() });
+                    entries.push(RoutineRemoved { routine_signature: signature.clone() });
                 },
                 Some(rr) => {
                     let properties = self.compare_routine_properties(&left_routine, rr);
-                    
-                    let left_routine_routine_privileges: Vec<&RoutinePrivilege> = left_routine_privileges.iter().filter(|p| p.signature == left_routine.signature).cloned().collect();
-                    let right_routine_routine_privileges: Vec<&RoutinePrivilege> = right_routine_privileges.iter().filter(|p| p.signature == rr.signature).cloned().collect();
+
+                    let left_routine_routine_privileges: Vec<&RoutinePrivilege> = left_routine_privileges.iter().filter(|p| p.specific_catalog == left_routine.specific_catalog && p.specific_schema == left_routine.specific_schema && p.specific_name == left_routine.specific_name).cloned().collect();
+                    let right_routine_routine_privileges: Vec<&RoutinePrivilege> = right_routine_privileges.iter().filter(|p| p.specific_catalog == rr.specific_catalog && p.specific_schema == rr.specific_schema && p.specific_name == rr.specific_name).cloned().collect();
                     let privileges = self.compare_routine_privileges(left_routine_routine_privileges, right_routine_routine_privileges)?;
     
-                    entries.push(RoutineMaintained { routine_signature: left_routine.signature.clone(), properties, privileges });
+                    entries.push(RoutineMaintained { routine_signature: signature.clone(), properties, privileges });
     
-                    right_routines_map.remove(&rr.signature.clone());
+                    right_routines_map.remove(&signature);
                 }
             }
         }
     
         if right_routines_map.len() > 0 {
-            let mut added_routines: Vec<&&Routine> = right_routines_map.values().collect();
-            added_routines.sort_unstable_by_key(|r| &r.signature);
+            let mut added_signatures : Vec<&String> = right_routines_map.keys().collect();
+            added_signatures.sort_unstable();
     
-            for right_routine in added_routines {
-                entries.push(RoutineAdded { routine_signature: right_routine.signature.clone() });
+            for added_signature in added_signatures {
+                entries.push(RoutineAdded { routine_signature: added_signature.clone() });
             }
         }
     
@@ -786,4 +800,37 @@ impl Comparer {
             PropertyChanged { property_name: String::from(property_name), left_value: left.to_string(), right_value: right.to_string() }
         }
     }
+    
+}
+
+fn routine_signature(routine: &Routine, all_parameters: &Vec<&RoutineParameter>) -> String {
+    let parameters : Vec<&RoutineParameter> = all_parameters.iter().filter(|p| p.specific_catalog == routine.specific_catalog && p.specific_schema == routine.specific_schema && p.specific_name == routine.specific_name).cloned().collect();
+    
+    let mut signature = routine.routine_name.clone();
+    signature.push('(');
+    
+    for (index, parameter) in parameters.iter().enumerate() {
+        if index > 0 {
+            signature.push_str(", ")
+        }
+
+        let parameter_name = match &parameter.parameter_name {
+            Some(parameter_name) => parameter_name,
+            None => &format!("${}", parameter.ordinal_position),
+        };
+
+        signature.push_str(parameter_name);
+        signature.push(' ');
+        signature.push_str(&parameter.parameter_mode);
+        signature.push(' ');
+        signature.push_str(&parameter.udt_catalog);
+        signature.push('.');
+        signature.push_str(&parameter.udt_schema);
+        signature.push('.');
+        signature.push_str(&parameter.udt_name);
+    }
+    
+    signature.push(')');
+    
+    signature
 }
diff --git a/src/db/mod.rs b/src/db/mod.rs
@@ -3,6 +3,7 @@ pub mod column_privilege;
 pub mod index;
 pub mod privilege;
 pub mod routine;
+pub mod routine_parameters;
 pub mod routine_privilege;
 pub mod schema;
 pub mod sequence;
@@ -17,6 +18,7 @@ use crate::db::column::Column;
 use crate::db::column_privilege::ColumnPrivilege;
 use crate::db::index::Index;
 use crate::db::routine::Routine;
+use crate::db::routine_parameters::RoutineParameter;
 use crate::db::routine_privilege::RoutinePrivilege;
 use crate::db::table_privilege::TablePrivilege;
 use crate::db::table_trigger::TableTrigger;
@@ -51,6 +53,10 @@ impl Database {
         routine::routines(&mut self.connection, schema_names).await
     }
     
+    pub async fn routine_parameters(&mut self, schema_names: &[String]) -> Result<Vec<RoutineParameter>, Error> {
+        routine_parameters::routine_parameters(&mut self.connection, schema_names).await
+    }
+    
     pub async fn routine_privileges(&mut self, schema_names: &[String]) -> Result<Vec<RoutinePrivilege>, Error> {
         routine_privilege::routine_privileges(&mut self.connection, schema_names).await
     }
diff --git a/src/db/routine.rs b/src/db/routine.rs
@@ -2,14 +2,12 @@ use sqlx::{Error, FromRow, PgConnection};
 
 pub const QUERY: &str = r#"
 SELECT
+    r.specific_catalog,
+    r.specific_schema,
+    r.specific_name,
     r.routine_catalog,
     r.routine_schema,
-    r.routine_name || '(' || COALESCE((
-	    SELECT string_agg(COALESCE(p.parameter_name, '$' || p.ordinal_position) || ' ' || p.parameter_mode || ' ' || p.udt_schema || '.' || p.udt_name, ', ' order by p.ordinal_position)
-        FROM information_schema.parameters p
-        WHERE p.specific_name = r.specific_name
-        GROUP BY p.specific_name
-    ), '') || ')' signature,
+    r.routine_name,
     r.routine_type,
     r.module_catalog,
     r.module_schema,
@@ -57,7 +55,7 @@ FROM
 WHERE
     r.routine_schema = ANY($1)
 ORDER BY
-    signature;"#;
+    r.routine_name;"#;
 
 pub async fn routines(connection: &mut PgConnection, schema_names: &[String]) -> Result<Vec<Routine>, Error> {
     sqlx::query_as(QUERY)
@@ -67,9 +65,12 @@ pub async fn routines(connection: &mut PgConnection, schema_names: &[String]) ->
 
 #[derive(Debug, Clone, PartialEq, FromRow)]
 pub struct Routine {
+    pub specific_catalog: String,
+    pub specific_schema: String,
+    pub specific_name: String,
     pub routine_catalog: String,
     pub routine_schema: String,
-    pub signature: String,
+    pub routine_name: String,
     pub routine_type: Option<String>,
     pub module_catalog: Option<String>,
     pub module_schema: Option<String>,
diff --git a/src/db/routine_parameters.rs b/src/db/routine_parameters.rs
@@ -0,0 +1,82 @@
+use sqlx::{Error, FromRow, PgConnection};
+
+pub const QUERY: &str = r#"
+SELECT
+    p.specific_catalog,
+    p.specific_schema,
+	p.specific_name,
+	p.ordinal_position,
+	p.parameter_mode,
+	p.is_result,
+	p.as_locator,
+	p.parameter_name,
+	p.data_type,
+	p.character_maximum_length,
+	p.character_octet_length,
+	p.character_set_catalog,
+	p.character_set_schema,
+	p.character_set_name,
+	p.collation_catalog,
+	p.collation_schema,
+	p.collation_name,
+	p.numeric_precision,
+	p.numeric_precision_radix,
+	p.numeric_scale,
+	p.datetime_precision,
+	p.interval_type,
+	p.interval_precision,
+	p.udt_catalog,
+	p.udt_schema,
+	p.udt_name,
+	p.scope_catalog,
+	p.scope_schema,
+	p.scope_name,
+	p.maximum_cardinality,
+	p.dtd_identifier,
+	p.parameter_default
+FROM information_schema.parameters p
+WHERE
+    p.specific_schema = ANY($1);"#;
+
+pub async fn routine_parameters(connection: &mut PgConnection, schema_names: &[String]) -> Result<Vec<RoutineParameter>, Error> {
+    sqlx::query_as(QUERY)
+        .bind(&schema_names[..])
+        .fetch_all(connection).await
+}
+
+#[derive(Debug, Clone, PartialEq, FromRow)]
+pub struct RoutineParameter {
+    pub specific_catalog: String,
+    pub specific_schema: String,
+    pub specific_name: String,
+    pub ordinal_position: i32,
+    pub parameter_mode: String,
+    pub is_result: Option<String>,
+    pub as_locator: Option<String>,
+    pub parameter_name: Option<String>,
+    pub data_type: String,
+    pub character_maximum_length: Option<i32>,
+    pub character_octet_length: Option<i32>,
+    pub character_set_catalog: Option<String>,
+    pub character_set_schema: Option<String>,
+    pub character_set_name: Option<String>,
+    pub collation_catalog: Option<String>,
+    pub collation_schema: Option<String>,
+    pub collation_name: Option<String>,
+    pub numeric_precision: Option<i32>,
+    pub numeric_precision_radix: Option<i32>,
+    pub numeric_scale: Option<i32>,
+    pub datetime_precision: Option<i32>,
+    pub interval_type: Option<String>,
+    pub interval_precision: Option<i32>,
+    pub udt_catalog: String,
+    pub udt_schema: String,
+    pub udt_name: String,
+    pub scope_catalog: Option<String>,
+    pub scope_schema: Option<String>,
+    pub scope_name: Option<String>,
+    pub maximum_cardinality: Option<i32>,
+    pub dtd_identifier: String,
+    pub parameter_default: Option<String>,
+}
+
diff --git a/src/db/routine_privilege.rs b/src/db/routine_privilege.rs
@@ -5,14 +5,12 @@ const QUERY: &str = r#"
 SELECT
     rp.grantor,
     rp.grantee,
+    rp.specific_catalog,
+    rp.specific_schema,
+    rp.specific_name,
     rp.routine_catalog,
     rp.routine_schema,
-    rp.routine_name || '(' || COALESCE((
-        SELECT string_agg(COALESCE(p.parameter_name, '$' || p.ordinal_position) || ' ' || p.parameter_mode || ' ' || p.udt_schema || '.' || p.udt_name, ', ' order by p.ordinal_position)
-        FROM information_schema.parameters p
-        WHERE p.specific_name = rp.specific_name
-        GROUP BY p.specific_name
-    ), '') || ')' signature,
+    rp.routine_name,
     rp.privilege_type,
     rp.is_grantable
 FROM
@@ -21,7 +19,6 @@ WHERE
     rp.routine_schema = ANY($1) AND
     rp.grantor != rp.grantee
 ORDER BY
-    signature,
     privilege_type;"#;
 
 pub async fn routine_privileges(connection: &mut PgConnection, schema_names: &[String]) -> Result<Vec<RoutinePrivilege>, Error> {
@@ -34,9 +31,12 @@ pub async fn routine_privileges(connection: &mut PgConnection, schema_names: &[S
 pub struct RoutinePrivilege {
     pub grantor: String,
     pub grantee: String,
+    pub specific_catalog: String,
+    pub specific_schema: String,
+    pub specific_name: String,
     pub routine_catalog: String,
     pub routine_schema: String,
-    pub signature: String,
+    pub routine_name: String,
     pub privilege_type: String,
     pub is_grantable: String,
 }
diff --git a/tests/identical-schemas-verbose/expected.txt b/tests/identical-schemas-verbose/expected.txt
@@ -3,7 +3,7 @@ Schema 'test': unchanged
   Property 'default_character_set_catalog': unchanged at '<none>'
   Property 'default_character_set_schema': unchanged at '<none>'
   Property 'default_character_set_name': unchanged at '<none>'
-  Routine 'new_employee(name IN pg_catalog.text, role_id IN pg_catalog.int4)': unchanged
+  Routine 'new_employee(name IN postgres.pg_catalog.text, role_id IN postgres.pg_catalog.int4)': unchanged
     Property 'routine_type': unchanged at 'PROCEDURE'
     Property 'module_catalog': unchanged at '<none>'
     Property 'module_schema': unchanged at '<none>'
diff --git a/tests/main/expected.txt b/tests/main/expected.txt
@@ -1,18 +1,18 @@
 Schema 'test':
-  Routine 'routine_changed(a IN pg_catalog.int4, b IN pg_catalog.text)':
+  Routine 'routine_changed(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)':
     Property 'routine_definition': changed from '
 INSERT INTO routine (a, b)
 VALUES (a, b);
 ' to '
 INSERT INTO routine (a, b)
 VALUES (a + 100, b);
 '
-  Routine 'routine_privilege_added(a IN pg_catalog.int4, b IN pg_catalog.text)':
+  Routine 'routine_privilege_added(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)':
     Privilege 'EXECUTE' (postgres->routine_privilege_added_role): added
-  Routine 'routine_privilege_removed(a IN pg_catalog.int4, b IN pg_catalog.text)':
+  Routine 'routine_privilege_removed(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)':
     Privilege 'EXECUTE' (postgres->routine_privilege_removed_role): removed
-  Routine 'routine_removed(a IN pg_catalog.int4, b IN pg_catalog.text)': removed
-  Routine 'routine_whitespace_changed(a IN pg_catalog.int4, b IN pg_catalog.text)':
+  Routine 'routine_removed(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)': removed
+  Routine 'routine_whitespace_changed(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)':
     Property 'routine_definition': changed from '
 INSERT INTO routine (a, b)
 VALUES (a, b);
@@ -22,8 +22,8 @@ VALUES (a, b);
 	VALUES
 		(a, b);
 '
-  Routine 'routine_added(a IN pg_catalog.int4, b IN pg_catalog.text)': added
-  Routine 'routine_added_with_unnamed_parameters($1 IN pg_catalog.int4, $2 IN pg_catalog.text)': added
+  Routine 'routine_added(a IN postgres.pg_catalog.int4, b IN postgres.pg_catalog.text)': added
+  Routine 'routine_added_with_unnamed_parameters($1 IN postgres.pg_catalog.int4, $2 IN postgres.pg_catalog.text)': added
   Routine 'trigger_exception()': added
   Sequence 'sequence_changed':
     Property 'data_type': changed from 'integer' to 'bigint'
