Merge branch 'main' into alter-operator-class

Author: LucaCappelletti94

src/ast/mod.rs

@@ -11171,12 +11171,15 @@ impl fmt::Display for CreateUser {
 
 /// Modifies the properties of a user
 ///
-/// Syntax:
+/// [Snowflake Syntax:](https://docs.snowflake.com/en/sql-reference/sql/alter-user)
 /// ```sql
 /// ALTER USER [ IF EXISTS ] [ <name> ] [ OPTIONS ]
 /// ```
 ///
-/// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/alter-user)
+/// [PostgreSQL Syntax:](https://www.postgresql.org/docs/current/sql-alteruser.html)
+/// ```sql
+/// ALTER USER <role_specification> [ WITH ] option [ ... ]
+/// ```
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -11218,6 +11221,8 @@ pub struct AlterUser {
     pub set_props: KeyValueOptions,
     /// Properties to unset on the user.
     pub unset_props: Vec<String>,
+    /// The following options are PostgreSQL-specific: <https://www.postgresql.org/docs/current/sql-alteruser.html>
+    pub password: Option<AlterUserPassword>,
 }
 
 /// ```sql
@@ -11409,6 +11414,34 @@ impl fmt::Display for AlterUser {
         if !self.unset_props.is_empty() {
             write!(f, " UNSET {}", display_comma_separated(&self.unset_props))?;
         }
+        if let Some(password) = &self.password {
+            write!(f, " {}", password)?;
+        }
+        Ok(())
+    }
+}
+
+/// ```sql
+/// ALTER USER <role_specification> [ WITH ] PASSWORD { 'password' | NULL }``
+/// ```
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterUserPassword {
+    pub encrypted: bool,
+    pub password: Option<String>,
+}
+
+impl Display for AlterUserPassword {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.encrypted {
+            write!(f, "ENCRYPTED ")?;
+        }
+        write!(f, "PASSWORD")?;
+        match &self.password {
+            None => write!(f, " NULL")?,
+            Some(password) => write!(f, " '{}'", value::escape_single_quote_string(password))?,
+        }
         Ok(())
     }
 }

src/dialect/mod.rs

@@ -1232,6 +1232,11 @@ pub trait Dialect: Debug + Any {
     fn supports_quote_delimited_string(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect considers the `&&` operator as a boolean AND operator.
+    fn supports_double_ampersand_operator(&self) -> bool {
+        false
+    }
 }
 
 /// Operators for which precedence must be defined.

src/dialect/mysql.rs

@@ -171,6 +171,11 @@ impl Dialect for MySqlDialect {
     fn supports_cross_join_constraint(&self) -> bool {
         true
     }
+
+    /// See: <https://dev.mysql.com/doc/refman/8.4/en/expressions.html>
+    fn supports_double_ampersand_operator(&self) -> bool {
+        true
+    }
 }
 
 /// `LOCK TABLES`

src/parser/alter.rs

@@ -21,8 +21,8 @@ use crate::{
         helpers::key_value_options::{KeyValueOptions, KeyValueOptionsDelimiter},
         AlterConnectorOwner, AlterPolicyOperation, AlterRoleOperation, AlterUser,
         AlterUserAddMfaMethodOtp, AlterUserAddRoleDelegation, AlterUserModifyMfaMethod,
-        AlterUserRemoveRoleDelegation, AlterUserSetPolicy, Expr, MfaMethodKind, Password,
-        ResetConfig, RoleOption, SetConfigValue, Statement, UserPolicyKind,
+        AlterUserPassword, AlterUserRemoveRoleDelegation, AlterUserSetPolicy, Expr, MfaMethodKind,
+        Password, ResetConfig, RoleOption, SetConfigValue, Statement, UserPolicyKind,
     },
     dialect::{MsSqlDialect, PostgreSqlDialect},
     keywords::Keyword,
@@ -151,6 +151,7 @@ impl Parser<'_> {
     pub fn parse_alter_user(&mut self) -> Result<Statement, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
         let name = self.parse_identifier()?;
+        let _ = self.parse_keyword(Keyword::WITH);
         let rename_to = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
             Some(self.parse_identifier()?)
         } else {
@@ -293,6 +294,21 @@ impl Parser<'_> {
             vec![]
         };
 
+        let encrypted = self.parse_keyword(Keyword::ENCRYPTED);
+        let password = if self.parse_keyword(Keyword::PASSWORD) {
+            let password = if self.parse_keyword(Keyword::NULL) {
+                None
+            } else {
+                Some(self.parse_literal_string()?)
+            };
+            Some(AlterUserPassword {
+                encrypted,
+                password,
+            })
+        } else {
+            None
+        };
+
         Ok(Statement::AlterUser(AlterUser {
             if_exists,
             name,
@@ -312,6 +328,7 @@ impl Parser<'_> {
             unset_tag,
             set_props,
             unset_props,
+            password,
         }))
     }
 

src/parser/mod.rs

@@ -3557,6 +3557,9 @@ impl<'a> Parser<'a> {
             Token::Overlap if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => {
                 Some(BinaryOperator::PGOverlap)
             }
+            Token::Overlap if dialect.supports_double_ampersand_operator() => {
+                Some(BinaryOperator::And)
+            }
             Token::CaretAt if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => {
                 Some(BinaryOperator::PGStartsWith)
             }
@@ -18995,7 +18998,7 @@ impl<'a> Parser<'a> {
                         return self.expected(" another option or EOF", self.peek_token());
                     }
                 }
-                Token::EOF => break,
+                Token::EOF | Token::SemiColon => break,
                 Token::Comma => {
                     delimiter = KeyValueOptionsDelimiter::Comma;
                     continue;
@@ -19007,7 +19010,12 @@ impl<'a> Parser<'a> {
                     self.prev_token();
                     break;
                 }
-                _ => return self.expected("another option, EOF, Comma or ')'", self.peek_token()),
+                _ => {
+                    return self.expected(
+                        "another option, EOF, SemiColon, Comma or ')'",
+                        self.peek_token(),
+                    )
+                }
             };
         }
 

tests/sqlparser_common.rs

@@ -17950,6 +17950,15 @@ fn test_parse_alter_user() {
         _ => unreachable!(),
     }
     verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('ALL'), PASSWORD='secret', WORKLOAD_IDENTITY=(TYPE=AWS, ARN='arn:aws:iam::123456789:r1/')");
+
+    verified_stmt("ALTER USER u1 PASSWORD 'AAA'");
+    verified_stmt("ALTER USER u1 ENCRYPTED PASSWORD 'AAA'");
+    verified_stmt("ALTER USER u1 PASSWORD NULL");
+
+    one_statement_parses_to(
+        "ALTER USER u1 WITH PASSWORD 'AAA'",
+        "ALTER USER u1 PASSWORD 'AAA'",
+    );
 }
 
 #[test]
@@ -18037,3 +18046,17 @@ fn parse_select_parenthesized_wildcard() {
     assert_eq!(select2.projection.len(), 1);
     assert!(matches!(select2.projection[0], SelectItem::Wildcard(_)));
 }
+
+#[test]
+fn parse_overlap_as_bool_and() {
+    let dialects = all_dialects_where(|d| d.supports_double_ampersand_operator());
+    dialects.one_statement_parses_to("SELECT x && y", "SELECT x AND y");
+}
+
+#[test]
+fn test_parse_key_value_options_trailing_semicolon() {
+    one_statement_parses_to(
+        "CREATE USER u1 option1='value1' option2='value2';",
+        "CREATE USER u1 option1='value1' option2='value2'",
+    );
+}