PostgreSQL: add GrantObjects::Types and Domains for GRANT ON TYPE/DOMAIN (#24)

`GRANT USAGE ON TYPE foo TO role` and `GRANT ON DOMAIN d TO role` are
valid PostgreSQL grammar but failed to parse — `parse_grant_target`
had no `TYPE` or `DOMAIN` keyword, and `GrantObjects` lacked variants
to carry them.

Add `GrantObjects::Types(Vec<ObjectName>)` and
`GrantObjects::Domains(Vec<ObjectName>)`, along with their `Display`
arms, the `Keyword::TYPE` / `Keyword::DOMAIN` arms in
`parse_grant_deny_revoke_privileges_objects`, and round-trip tests
in `parse_grant`.

Verified:
  cargo fmt --all -- --check
  cargo clippy --all-targets --all-features -- -D warnings
  cargo test --all-features parse_grant

Author: fmguerreiro

src/ast/mod.rs

@@ -7749,6 +7749,18 @@ pub enum GrantObjects {
         /// Optional argument types for overloaded functions.
         arg_types: Vec<DataType>,
     },
+
+    /// Grant privileges on specific user-defined types (PostgreSQL).
+    ///
+    /// For example:
+    /// `GRANT USAGE ON TYPE user_role TO app_user`
+    Types(Vec<ObjectName>),
+
+    /// Grant privileges on specific domains (PostgreSQL).
+    ///
+    /// For example:
+    /// `GRANT USAGE ON DOMAIN email_addr TO app_user`
+    Domains(Vec<ObjectName>),
 }
 
 impl fmt::Display for GrantObjects {
@@ -7894,6 +7906,12 @@ impl fmt::Display for GrantObjects {
                 }
                 Ok(())
             }
+            GrantObjects::Types(types) => {
+                write!(f, "TYPE {}", display_comma_separated(types))
+            }
+            GrantObjects::Domains(domains) => {
+                write!(f, "DOMAIN {}", display_comma_separated(domains))
+            }
         }
     }
 }

src/parser/mod.rs

@@ -17908,6 +17908,8 @@ impl<'a> Parser<'a> {
                     Keyword::CONNECTION,
                     Keyword::PROCEDURE,
                     Keyword::FUNCTION,
+                    Keyword::TYPE,
+                    Keyword::DOMAIN,
                 ]);
                 let objects =
                     self.parse_comma_separated(|p| p.parse_object_name_inner(false, true));
@@ -17920,6 +17922,8 @@ impl<'a> Parser<'a> {
                     Some(Keyword::VIEW) => Some(GrantObjects::Views(objects?)),
                     Some(Keyword::USER) => Some(GrantObjects::Users(objects?)),
                     Some(Keyword::CONNECTION) => Some(GrantObjects::Connections(objects?)),
+                    Some(Keyword::TYPE) => Some(GrantObjects::Types(objects?)),
+                    Some(Keyword::DOMAIN) => Some(GrantObjects::Domains(objects?)),
                     kw @ (Some(Keyword::PROCEDURE) | Some(Keyword::FUNCTION)) => {
                         if let Some(name) = objects?.first() {
                             self.parse_grant_procedure_or_function(name, &kw)?

tests/sqlparser_common.rs

@@ -9878,6 +9878,47 @@ fn parse_grant() {
     verified_stmt("GRANT ROLE role1 TO ROLE role2");
     verified_stmt("GRANT ROLE role1 TO USER user");
     verified_stmt("GRANT CREATE SCHEMA ON DATABASE db1 TO ROLE role1");
+
+    let sql_type = "GRANT USAGE ON TYPE user_role TO app_user";
+    match verified_stmt(sql_type) {
+        Statement::Grant(Grant {
+            privileges,
+            objects,
+            grantees,
+            ..
+        }) => match (privileges, objects) {
+            (Privileges::Actions(actions), Some(GrantObjects::Types(types))) => {
+                assert_eq!(vec![Action::Usage], actions);
+                assert_eq_vec(&["user_role"], &types);
+                assert_eq_vec(&["app_user"], &grantees);
+            }
+            _ => unreachable!(),
+        },
+        _ => unreachable!(),
+    }
+
+    let sql_domain = "GRANT USAGE ON DOMAIN email_addr TO app_user";
+    match verified_stmt(sql_domain) {
+        Statement::Grant(Grant {
+            privileges,
+            objects,
+            grantees,
+            ..
+        }) => match (privileges, objects) {
+            (Privileges::Actions(actions), Some(GrantObjects::Domains(domains))) => {
+                assert_eq!(vec![Action::Usage], actions);
+                assert_eq_vec(&["email_addr"], &domains);
+                assert_eq_vec(&["app_user"], &grantees);
+            }
+            _ => unreachable!(),
+        },
+        _ => unreachable!(),
+    }
+
+    verified_stmt("GRANT USAGE ON TYPE sc1.user_role TO ROLE role1");
+    verified_stmt("GRANT ALL ON TYPE t1, t2 TO role1");
+    verified_stmt("GRANT USAGE ON DOMAIN sc1.email_addr TO ROLE role1");
+    verified_stmt("GRANT ALL ON DOMAIN d1, d2 TO role1");
 }
 
 #[test]