Merge remote-tracking branch 'origin/main' into feat/catalog-extended

# Conflicts:
#	src/ast/ddl.rs
#	src/ast/mod.rs
#	src/ast/spans.rs
#	src/parser/mod.rs
#	tests/sqlparser_postgres.rs

Author: fmguerreiro

src/ast/ddl.rs

@@ -6535,6 +6535,51 @@ impl fmt::Display for StatisticsKind {
             StatisticsKind::NDistinct => write!(f, "ndistinct"),
             StatisticsKind::Dependencies => write!(f, "dependencies"),
             StatisticsKind::Mcv => write!(f, "mcv"),
+/// The object kind targeted by a `SECURITY LABEL` statement.
+///
+/// See <https://www.postgresql.org/docs/current/sql-securitylabel.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum SecurityLabelObjectKind {
+    /// `TABLE name`
+    Table,
+    /// `COLUMN name.colname`
+    Column,
+    /// `DATABASE name`
+    Database,
+    /// `DOMAIN name`
+    Domain,
+    /// `FUNCTION name`
+    Function,
+    /// `ROLE name`
+    Role,
+    /// `SCHEMA name`
+    Schema,
+    /// `SEQUENCE name`
+    Sequence,
+    /// `TYPE name`
+    Type,
+    /// `VIEW name`
+    View,
+    /// `MATERIALIZED VIEW name`
+    MaterializedView,
+}
+
+impl fmt::Display for SecurityLabelObjectKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SecurityLabelObjectKind::Table => write!(f, "TABLE"),
+            SecurityLabelObjectKind::Column => write!(f, "COLUMN"),
+            SecurityLabelObjectKind::Database => write!(f, "DATABASE"),
+            SecurityLabelObjectKind::Domain => write!(f, "DOMAIN"),
+            SecurityLabelObjectKind::Function => write!(f, "FUNCTION"),
+            SecurityLabelObjectKind::Role => write!(f, "ROLE"),
+            SecurityLabelObjectKind::Schema => write!(f, "SCHEMA"),
+            SecurityLabelObjectKind::Sequence => write!(f, "SEQUENCE"),
+            SecurityLabelObjectKind::Type => write!(f, "TYPE"),
+            SecurityLabelObjectKind::View => write!(f, "VIEW"),
+            SecurityLabelObjectKind::MaterializedView => write!(f, "MATERIALIZED VIEW"),
         }
     }
 }
@@ -6571,6 +6616,108 @@ impl fmt::Display for CreateStatistics {
         }
         write!(f, " ON {}", display_comma_separated(&self.on))?;
         write!(f, " FROM {}", self.from)?;
+/// A `SECURITY LABEL` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-securitylabel.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct SecurityLabel {
+    /// Optional `FOR provider_name` clause.
+    pub provider: Option<Ident>,
+    /// The kind of object the label is applied to.
+    pub object_kind: SecurityLabelObjectKind,
+    /// The name of the object the label is applied to.
+    pub object_name: ObjectName,
+    /// The label string, or `None` for `IS NULL`.
+    pub label: Option<Value>,
+}
+
+impl fmt::Display for SecurityLabel {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "SECURITY LABEL")?;
+        if let Some(provider) = &self.provider {
+            write!(f, " FOR {provider}")?;
+        }
+        write!(f, " ON {} {}", self.object_kind, self.object_name)?;
+        write!(f, " IS ")?;
+        match &self.label {
+            Some(label) => write!(f, "{label}"),
+            None => write!(f, "NULL"),
+        }
+    }
+}
+
+impl From<SecurityLabel> for crate::ast::Statement {
+    fn from(v: SecurityLabel) -> Self {
+        crate::ast::Statement::SecurityLabel(v)
+    }
+}
+
+/// The role specification in a `CREATE USER MAPPING` statement.
+///
+/// See <https://www.postgresql.org/docs/current/sql-createusermapping.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum UserMappingUser {
+    /// A specific role name.
+    Ident(Ident),
+    /// `USER` (current user)
+    User,
+    /// `CURRENT_ROLE`
+    CurrentRole,
+    /// `CURRENT_USER`
+    CurrentUser,
+    /// `PUBLIC`
+    Public,
+}
+
+impl fmt::Display for UserMappingUser {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            UserMappingUser::Ident(ident) => write!(f, "{ident}"),
+            UserMappingUser::User => write!(f, "USER"),
+            UserMappingUser::CurrentRole => write!(f, "CURRENT_ROLE"),
+            UserMappingUser::CurrentUser => write!(f, "CURRENT_USER"),
+            UserMappingUser::Public => write!(f, "PUBLIC"),
+        }
+    }
+}
+
+/// A `CREATE USER MAPPING` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createusermapping.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateUserMapping {
+    /// `IF NOT EXISTS`
+    pub if_not_exists: bool,
+    /// The user/role for the mapping.
+    pub user: UserMappingUser,
+    /// The foreign server name.
+    pub server_name: Ident,
+    /// Optional `OPTIONS (key 'value', ...)` clause.
+    pub options: Option<Vec<CreateServerOption>>,
+}
+
+impl fmt::Display for CreateUserMapping {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE USER MAPPING")?;
+        if self.if_not_exists {
+            write!(f, " IF NOT EXISTS")?;
+        }
+        write!(f, " FOR {} SERVER {}", self.user, self.server_name)?;
+        if let Some(options) = &self.options {
+            write!(
+                f,
+                " OPTIONS ({})",
+                display_comma_separated(options)
+            )?;
+        }
         Ok(())
     }
 }
@@ -6699,6 +6846,40 @@ impl fmt::Display for CreateEventTrigger {
             "FUNCTION"
         };
         write!(f, " EXECUTE {func_kw} {}()", self.execute)?;
+impl From<CreateUserMapping> for crate::ast::Statement {
+    fn from(v: CreateUserMapping) -> Self {
+        crate::ast::Statement::CreateUserMapping(v)
+    }
+}
+
+/// A `CREATE TABLESPACE` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtablespace.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTablespace {
+    /// The tablespace name.
+    pub name: Ident,
+    /// Optional `OWNER role` clause.
+    pub owner: Option<Ident>,
+    /// The `LOCATION 'directory'` string.
+    pub location: Value,
+    /// Optional `WITH (option = value, ...)` clause.
+    pub with_options: Vec<SqlOption>,
+}
+
+impl fmt::Display for CreateTablespace {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE TABLESPACE {}", self.name)?;
+        if let Some(owner) = &self.owner {
+            write!(f, " OWNER {owner}")?;
+        }
+        write!(f, " LOCATION {}", self.location)?;
+        if !self.with_options.is_empty() {
+            write!(f, " WITH ({})", display_comma_separated(&self.with_options))?;
+        }
         Ok(())
     }
 }
@@ -6776,5 +6957,8 @@ impl fmt::Display for CreateTransform {
 impl From<CreateTransform> for crate::ast::Statement {
     fn from(v: CreateTransform) -> Self {
         crate::ast::Statement::CreateTransform(v)
+impl From<CreateTablespace> for crate::ast::Statement {
+    fn from(v: CreateTablespace) -> Self {
+        crate::ast::Statement::CreateTablespace(v)
     }
 }

src/ast/mod.rs

@@ -75,10 +75,11 @@ pub use self::ddl::{
     CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable, CreateFunction,
     CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy,
     CreatePolicyCommand, CreatePolicyType, CreatePublication, CreateSubscription, CreateTable,
+    AccessMethodType, CreateAccessMethod, CreateEventTrigger, CreateStatistics, CreateTablespace,
     CreateTextSearchConfiguration, CreateTextSearchDictionary, CreateTextSearchParser,
-    CreateTextSearchTemplate, CreateTrigger, PublicationTarget,
-    AccessMethodType, CreateAccessMethod, CreateEventTrigger, CreateStatistics, CreateTransform,
-    EventTriggerEvent, StatisticsKind, TransformElement,
+    CreateTextSearchTemplate, CreateTransform, CreateTrigger, CreateUserMapping,
+    EventTriggerEvent, PublicationTarget, SecurityLabel, SecurityLabelObjectKind, StatisticsKind,
+    TransformElement, UserMappingUser,
     CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension,
     DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature,
     DropPolicy, DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
@@ -4075,6 +4076,24 @@ pub enum Statement {
     /// <https://www.postgresql.org/docs/current/sql-createtransform.html>
     CreateTransform(CreateTransform),
     /// ```sql
+    /// SECURITY LABEL [ FOR provider_name ] ON object_type object_name IS { 'label' | NULL }
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-securitylabel.html>
+    SecurityLabel(SecurityLabel),
+    /// ```sql
+    /// CREATE USER MAPPING [ IF NOT EXISTS ] FOR { role | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC } SERVER server_name [ OPTIONS (...) ]
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createusermapping.html>
+    CreateUserMapping(CreateUserMapping),
+    /// ```sql
+    /// CREATE TABLESPACE name [ OWNER role ] LOCATION 'directory' [ WITH (options) ]
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtablespace.html>
+    CreateTablespace(CreateTablespace),
+    /// ```sql
     /// DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
     /// ```
     /// Note: this is a PostgreSQL-specific statement.
@@ -5567,6 +5586,9 @@ impl fmt::Display for Statement {
             Statement::CreateAccessMethod(v) => write!(f, "{v}"),
             Statement::CreateEventTrigger(v) => write!(f, "{v}"),
             Statement::CreateTransform(v) => write!(f, "{v}"),
+            Statement::SecurityLabel(v) => write!(f, "{v}"),
+            Statement::CreateUserMapping(v) => write!(f, "{v}"),
+            Statement::CreateTablespace(v) => write!(f, "{v}"),
             Statement::DropExtension(drop_extension) => write!(f, "{drop_extension}"),
             Statement::DropOperator(drop_operator) => write!(f, "{drop_operator}"),
             Statement::DropOperatorFamily(drop_operator_family) => {

src/ast/spans.rs

@@ -394,6 +394,9 @@ impl Spanned for Statement {
             Statement::CreateAccessMethod(_) => Span::empty(),
             Statement::CreateEventTrigger(_) => Span::empty(),
             Statement::CreateTransform(_) => Span::empty(),
+            Statement::SecurityLabel(_) => Span::empty(),
+            Statement::CreateUserMapping(_) => Span::empty(),
+            Statement::CreateTablespace(_) => Span::empty(),
             Statement::DropExtension(drop_extension) => drop_extension.span(),
             Statement::DropOperator(drop_operator) => drop_operator.span(),
             Statement::DropOperatorFamily(drop_operator_family) => drop_operator_family.span(),

src/keywords.rs

@@ -567,6 +567,7 @@ define_keywords!(
     KEYS,
     KEY_BLOCK_SIZE,
     KILL,
+    LABEL,
     LAG,
     LAMBDA,
     LANGUAGE,
@@ -616,6 +617,7 @@ define_keywords!(
     MANAGEDLOCATION,
     MANIFEST,
     MAP,
+    MAPPING,
     MASKING,
     MATCH,
     MATCHED,