PostgreSQL: rename Statement::Comment.relation to table_name (#31)

Aligns the partner-table field name with sibling AST nodes
(AlterPolicy.table_name, CreatePolicy.table_name, DropPolicy.table_name,
AlterTrigger.table_name). Breaking change on the public AST.

Pure mechanical rename; no behavior change. Display impl, parser
constructor, and existing COMMENT ON TRIGGER / POLICY / AGGREGATE /
FUNCTION / COLLATION tests updated to match.

Author: fmguerreiro

src/ast/mod.rs

@@ -4461,10 +4461,10 @@ pub enum Statement {
         /// while `None` means no parameter list was provided. Used for
         /// `FUNCTION`, `PROCEDURE`, and `AGGREGATE` targets.
         arguments: Option<Vec<DataType>>,
-        /// Partner relation for objects scoped to a table, i.e. the
-        /// `ON <relation>` tail in `COMMENT ON TRIGGER t ON tbl IS '…'` or
+        /// Partner table for objects scoped to a table, i.e. the
+        /// `ON <table>` tail in `COMMENT ON TRIGGER t ON tbl IS '…'` or
         /// `COMMENT ON POLICY p ON tbl IS '…'`.
-        relation: Option<ObjectName>,
+        table_name: Option<ObjectName>,
         /// Optional comment text (None to remove comment).
         comment: Option<String>,
         /// An optional `IF EXISTS` clause. (Non-standard.)
@@ -6252,7 +6252,7 @@ impl fmt::Display for Statement {
                 object_type,
                 object_name,
                 arguments,
-                relation,
+                table_name,
                 comment,
                 if_exists,
             } => {
@@ -6264,8 +6264,8 @@ impl fmt::Display for Statement {
                 if let Some(args) = arguments {
                     write!(f, "({})", display_comma_separated(args))?;
                 }
-                if let Some(relation) = relation {
-                    write!(f, " ON {relation}")?;
+                if let Some(table_name) = table_name {
+                    write!(f, " ON {table_name}")?;
                 }
                 write!(f, " IS ")?;
                 if let Some(c) = comment {

src/parser/mod.rs

@@ -939,7 +939,7 @@ impl<'a> Parser<'a> {
             ));
         }
 
-        let relation = match object_type {
+        let table_name = match object_type {
             CommentObject::Trigger | CommentObject::Policy => {
                 self.expect_keyword_is(Keyword::ON)?;
                 Some(self.parse_object_name(false)?)
@@ -957,7 +957,7 @@ impl<'a> Parser<'a> {
             object_type,
             object_name,
             arguments,
-            relation,
+            table_name,
             comment,
             if_exists,
         })

tests/sqlparser_postgres.rs

@@ -1115,7 +1115,7 @@ fn parse_drop_and_comment_collation_ast() {
             object_type: CommentObject::Collation,
             object_name: ObjectName::from(vec![Ident::new("test0")]),
             arguments: None,
-            relation: None,
+            table_name: None,
             comment: Some("US English".to_string()),
             if_exists: false,
         }
@@ -10558,14 +10558,14 @@ fn parse_comment_on_trigger() {
         Statement::Comment {
             object_type,
             object_name,
-            relation,
+            table_name,
             arguments,
             comment,
             if_exists,
         } => {
             assert_eq!(CommentObject::Trigger, object_type);
             assert_eq!("my_trigger", object_name.to_string());
-            assert_eq!("public.my_table", relation.unwrap().to_string());
+            assert_eq!("public.my_table", table_name.unwrap().to_string());
             assert!(arguments.is_none());
             assert_eq!(Some("trigger note".to_string()), comment);
             assert!(!if_exists);
@@ -10585,14 +10585,14 @@ fn parse_comment_on_policy() {
         Statement::Comment {
             object_type,
             object_name,
-            relation,
+            table_name,
             arguments,
             comment,
             if_exists,
         } => {
             assert_eq!(CommentObject::Policy, object_type);
             assert_eq!("tenant_isolation", object_name.to_string());
-            assert_eq!("public.docs", relation.unwrap().to_string());
+            assert_eq!("public.docs", table_name.unwrap().to_string());
             assert!(arguments.is_none());
             assert_eq!(Some("rls".to_string()), comment);
             assert!(!if_exists);
@@ -10609,14 +10609,14 @@ fn parse_comment_on_aggregate() {
         Statement::Comment {
             object_type,
             object_name,
-            relation,
+            table_name,
             arguments,
             comment,
             if_exists,
         } => {
             assert_eq!(CommentObject::Aggregate, object_type);
             assert_eq!("my_sum", object_name.to_string());
-            assert!(relation.is_none());
+            assert!(table_name.is_none());
             let args = arguments.expect("aggregate should carry argument types");
             assert_eq!(1, args.len());
             assert!(matches!(args[0], DataType::Integer(_)));
@@ -10646,14 +10646,14 @@ fn parse_comment_on_function_with_arg_types() {
         Statement::Comment {
             object_type,
             object_name,
-            relation,
+            table_name,
             arguments,
             comment,
             if_exists,
         } => {
             assert_eq!(CommentObject::Function, object_type);
             assert_eq!("add", object_name.to_string());
-            assert!(relation.is_none());
+            assert!(table_name.is_none());
             let args = arguments.expect("function should carry argument types");
             assert_eq!(2, args.len());
             assert_eq!(Some("adds".to_string()), comment);