Merge branch 'main' into feat/export_data_for_bigquery

Author: chenkovsky

src/ast/ddl.rs

@@ -351,6 +351,16 @@ pub enum AlterTableOperation {
     ValidateConstraint {
         name: Ident,
     },
+    /// Arbitrary parenthesized `SET` options.
+    ///
+    /// Example:
+    /// ```sql
+    /// SET (scale_factor = 0.01, threshold = 500)`
+    /// ```
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-altertable.html)
+    SetOptionsParens {
+        options: Vec<SqlOption>,
+    },
 }
 
 /// An `ALTER Policy` (`Statement::AlterPolicy`) operation
@@ -791,6 +801,9 @@ impl fmt::Display for AlterTableOperation {
             AlterTableOperation::ValidateConstraint { name } => {
                 write!(f, "VALIDATE CONSTRAINT {name}")
             }
+            AlterTableOperation::SetOptionsParens { options } => {
+                write!(f, "SET ({})", display_comma_separated(options))
+            }
         }
     }
 }

src/ast/helpers/key_value_options.rs

@@ -31,11 +31,22 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
+use crate::ast::display_separated;
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct KeyValueOptions {
     pub options: Vec<KeyValueOption>,
+    pub delimiter: KeyValueOptionsDelimiter,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum KeyValueOptionsDelimiter {
+    Space,
+    Comma,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -59,18 +70,11 @@ pub struct KeyValueOption {
 
 impl fmt::Display for KeyValueOptions {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        if !self.options.is_empty() {
-            let mut first = false;
-            for option in &self.options {
-                if !first {
-                    first = true;
-                } else {
-                    f.write_str(" ")?;
-                }
-                write!(f, "{option}")?;
-            }
-        }
-        Ok(())
+        let sep = match self.delimiter {
+            KeyValueOptionsDelimiter::Space => " ",
+            KeyValueOptionsDelimiter::Comma => ", ",
+        };
+        write!(f, "{}", display_separated(&self.options, sep))
     }
 }
 

src/ast/mod.rs

@@ -4355,7 +4355,6 @@ pub enum Statement {
     ///
     /// See [ReturnStatement]
     Return(ReturnStatement),
-
     /// Export data statement
     ///
     /// Example:
@@ -4364,6 +4363,11 @@ pub enum Statement {
     /// SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10
     /// ```
     ExportData(ExportData),
+    /// ```sql
+    /// CREATE [OR REPLACE] USER <user> [IF NOT EXISTS]
+    /// ```
+    /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-user)
+    CreateUser(CreateUser),
 }
 
 /// ```sql
@@ -6203,6 +6207,7 @@ impl fmt::Display for Statement {
             Statement::List(command) => write!(f, "LIST {command}"),
             Statement::Remove(command) => write!(f, "REMOVE {command}"),
             Statement::ExportData(e) => write!(f, "{e}"),
+            Statement::CreateUser(s) => write!(f, "{s}"),
         }
     }
 }
@@ -6658,7 +6663,7 @@ pub enum Action {
     Replicate,
     ResolveAll,
     Role {
-        role: Ident,
+        role: ObjectName,
     },
     Select {
         columns: Option<Vec<Ident>>,
@@ -10148,6 +10153,49 @@ impl fmt::Display for ExportData {
         write!(f, "EXPORT DATA OPTIONS({}) AS {}", display_comma_separated(&self.options), self.query)
     }
 }
+/// Creates a user
+///
+/// Syntax:
+/// ```sql
+/// CREATE [OR REPLACE] USER [IF NOT EXISTS] <name> [OPTIONS]
+/// ```
+///
+/// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-user)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateUser {
+    pub or_replace: bool,
+    pub if_not_exists: bool,
+    pub name: Ident,
+    pub options: KeyValueOptions,
+    pub with_tags: bool,
+    pub tags: KeyValueOptions,
+}
+
+impl fmt::Display for CreateUser {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE")?;
+        if self.or_replace {
+            write!(f, " OR REPLACE")?;
+        }
+        write!(f, " USER")?;
+        if self.if_not_exists {
+            write!(f, " IF NOT EXISTS")?;
+        }
+        write!(f, " {}", self.name)?;
+        if !self.options.options.is_empty() {
+            write!(f, " {}", self.options)?;
+        }
+        if !self.tags.options.is_empty() {
+            if self.with_tags {
+                write!(f, " WITH")?;
+            }
+            write!(f, " TAG ({})", self.tags)?;
+        }
+        Ok(())
+    }
+}
 
 #[cfg(test)]
 mod tests {

src/ast/spans.rs

@@ -534,6 +534,7 @@ impl Spanned for Statement {
             Statement::ExportData(ExportData { options, query }) => union_spans(
                 options.iter().map(|i| i.span()).chain(core::iter::once(query.span()))
             ),
+            Statement::CreateUser(..) => Span::empty(),
         }
     }
 }
@@ -1204,6 +1205,9 @@ impl Spanned for AlterTableOperation {
             AlterTableOperation::Lock { .. } => Span::empty(),
             AlterTableOperation::ReplicaIdentity { .. } => Span::empty(),
             AlterTableOperation::ValidateConstraint { name } => name.span,
+            AlterTableOperation::SetOptionsParens { options } => {
+                union_spans(options.iter().map(|i| i.span()))
+            }
         }
     }
 }