Merge branch 'main' into extended-create-func

LucaCappelletti94 · web-flow · commit 86693d365168 · 2025-11-26T11:13:59.000+01:00
diff --git a/src/ast/ddl.rs b/src/ast/ddl.rs
@@ -4192,3 +4192,62 @@ impl fmt::Display for OperatorPurpose {
         }
     }
 }
+
+/// `DROP OPERATOR` statement
+/// See <https://www.postgresql.org/docs/current/sql-dropoperator.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 DropOperator {
+    /// `IF EXISTS` clause
+    pub if_exists: bool,
+    /// One or more operators to drop with their signatures
+    pub operators: Vec<DropOperatorSignature>,
+    /// `CASCADE or RESTRICT`
+    pub drop_behavior: Option<DropBehavior>,
+}
+
+/// Operator signature for a `DROP OPERATOR` statement
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct DropOperatorSignature {
+    /// Operator name
+    pub name: ObjectName,
+    /// Left operand type
+    pub left_type: Option<DataType>,
+    /// Right operand type
+    pub right_type: DataType,
+}
+
+impl fmt::Display for DropOperatorSignature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} (", self.name)?;
+        if let Some(left_type) = &self.left_type {
+            write!(f, "{}", left_type)?;
+        } else {
+            write!(f, "NONE")?;
+        }
+        write!(f, ", {})", self.right_type)
+    }
+}
+
+impl fmt::Display for DropOperator {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "DROP OPERATOR")?;
+        if self.if_exists {
+            write!(f, " IF EXISTS")?;
+        }
+        write!(f, " {}", display_comma_separated(&self.operators))?;
+        if let Some(drop_behavior) = &self.drop_behavior {
+            write!(f, " {}", drop_behavior)?;
+        }
+        Ok(())
+    }
+}
+
+impl Spanned for DropOperator {
+    fn span(&self) -> Span {
+        Span::empty()
+    }
+}
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -67,14 +67,15 @@ pub use self::ddl::{
     ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateDomain,
     CreateExtension, CreateFunction, CreateIndex, CreateOperator, CreateOperatorClass,
     CreateOperatorFamily, CreateTable, CreateTrigger, CreateView, Deduplicate, DeferrableInitial,
-    DropBehavior, DropExtension, DropFunction, DropTrigger, GeneratedAs, GeneratedExpressionMode,
-    IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
-    IdentityPropertyOrder, IndexColumn, IndexOption, IndexType, KeyOrIndexDisplay, Msck,
-    NullsDistinctOption, OperatorArgTypes, OperatorClassItem, OperatorPurpose, Owner, Partition,
-    ProcedureParam, ReferentialAction, RenameTableNameKind, ReplicaIdentity, TagsColumnOption,
-    TriggerObjectKind, Truncate, UserDefinedTypeCompositeAttributeDef,
-    UserDefinedTypeInternalLength, UserDefinedTypeRangeOption, UserDefinedTypeRepresentation,
-    UserDefinedTypeSqlDefinitionOption, UserDefinedTypeStorage, ViewColumnDef,
+    DropBehavior, DropExtension, DropFunction, DropOperator, DropOperatorSignature, DropTrigger,
+    GeneratedAs, GeneratedExpressionMode, IdentityParameters, IdentityProperty,
+    IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, IndexColumn,
+    IndexOption, IndexType, KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes,
+    OperatorClassItem, OperatorPurpose, Owner, Partition, ProcedureParam, ReferentialAction,
+    RenameTableNameKind, ReplicaIdentity, TagsColumnOption, TriggerObjectKind, Truncate,
+    UserDefinedTypeCompositeAttributeDef, UserDefinedTypeInternalLength,
+    UserDefinedTypeRangeOption, UserDefinedTypeRepresentation, UserDefinedTypeSqlDefinitionOption,
+    UserDefinedTypeStorage, ViewColumnDef,
 };
 pub use self::dml::{Delete, Insert, Update};
 pub use self::operator::{BinaryOperator, UnaryOperator};
@@ -3573,6 +3574,12 @@ pub enum Statement {
     /// <https://www.postgresql.org/docs/current/sql-dropextension.html>
     DropExtension(DropExtension),
     /// ```sql
+    /// DROP OPERATOR [ IF EXISTS ] name ( { left_type | NONE } , right_type ) [, ...] [ CASCADE | RESTRICT ]
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-dropoperator.html>
+    DropOperator(DropOperator),
+    /// ```sql
     /// FETCH
     /// ```
     /// Retrieve rows from a query using a cursor
@@ -4836,6 +4843,7 @@ impl fmt::Display for Statement {
             Statement::CreateIndex(create_index) => create_index.fmt(f),
             Statement::CreateExtension(create_extension) => write!(f, "{create_extension}"),
             Statement::DropExtension(drop_extension) => write!(f, "{drop_extension}"),
+            Statement::DropOperator(drop_operator) => write!(f, "{drop_operator}"),
             Statement::CreateRole(create_role) => write!(f, "{create_role}"),
             Statement::CreateSecret {
                 or_replace,
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -375,6 +375,7 @@ impl Spanned for Statement {
             Statement::CreateRole(create_role) => create_role.span(),
             Statement::CreateExtension(create_extension) => create_extension.span(),
             Statement::DropExtension(drop_extension) => drop_extension.span(),
+            Statement::DropOperator(drop_operator) => drop_operator.span(),
             Statement::CreateSecret { .. } => Span::empty(),
             Statement::CreateServer { .. } => Span::empty(),
             Statement::CreateConnector { .. } => Span::empty(),
diff --git a/src/dialect/snowflake.rs b/src/dialect/snowflake.rs
@@ -393,7 +393,7 @@ impl Dialect for SnowflakeDialect {
 
     fn is_column_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool {
         match kw {
-            // The following keywords can be considered an alias as long as 
+            // The following keywords can be considered an alias as long as
             // they are not followed by other tokens that may change their meaning
             // e.g. `SELECT * EXCEPT (col1) FROM tbl`
             Keyword::EXCEPT
@@ -408,7 +408,7 @@ impl Dialect for SnowflakeDialect {
             Keyword::LIMIT | Keyword::OFFSET if peek_for_limit_options(parser) => false,
 
             // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT`
-            // which would give it a different meanings, for example: 
+            // which would give it a different meanings, for example:
             // `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
             // `SELECT 1 FETCH 10` - not an alias
             Keyword::FETCH if parser.peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]).is_some()
@@ -417,8 +417,8 @@ impl Dialect for SnowflakeDialect {
                 false
             }
 
-            // Reserved keywords by the Snowflake dialect, which seem to be less strictive 
-            // than what is listed in `keywords::RESERVED_FOR_COLUMN_ALIAS`. The following 
+            // Reserved keywords by the Snowflake dialect, which seem to be less strictive
+            // than what is listed in `keywords::RESERVED_FOR_COLUMN_ALIAS`. The following
             // keywords were tested with the this statement: `SELECT 1 <KW>`.
             Keyword::FROM
             | Keyword::GROUP
@@ -688,7 +688,7 @@ pub fn parse_create_table(
         .iceberg(iceberg)
         .global(global)
         .dynamic(dynamic)
-        .hive_formats(Some(Default::default()));
+        .hive_formats(None);
 
     // Snowflake does not enforce order of the parameters in the statement. The parser needs to
     // parse the statement in a loop.
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -5832,15 +5832,19 @@ impl<'a> Parser<'a> {
         let hive_distribution = self.parse_hive_distribution()?;
         let hive_formats = self.parse_hive_formats()?;
 
-        let file_format = if let Some(ff) = &hive_formats.storage {
-            match ff {
-                HiveIOFormat::FileFormat { format } => Some(*format),
-                _ => None,
+        let file_format = if let Some(ref hf) = hive_formats {
+            if let Some(ref ff) = hf.storage {
+                match ff {
+                    HiveIOFormat::FileFormat { format } => Some(*format),
+                    _ => None,
+                }
+            } else {
+                None
             }
         } else {
             None
         };
-        let location = hive_formats.location.clone();
+        let location = hive_formats.as_ref().and_then(|hf| hf.location.clone());
         let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
         let table_options = if !table_properties.is_empty() {
             CreateTableOptions::TableProperties(table_properties)
@@ -5851,7 +5855,7 @@ impl<'a> Parser<'a> {
             .columns(columns)
             .constraints(constraints)
             .hive_distribution(hive_distribution)
-            .hive_formats(Some(hive_formats))
+            .hive_formats(hive_formats)
             .table_options(table_options)
             .or_replace(or_replace)
             .if_not_exists(if_not_exists)
@@ -6768,9 +6772,11 @@ impl<'a> Parser<'a> {
             return self.parse_drop_trigger();
         } else if self.parse_keyword(Keyword::EXTENSION) {
             return self.parse_drop_extension();
+        } else if self.parse_keyword(Keyword::OPERATOR) {
+            return self.parse_drop_operator();
         } else {
             return self.expected(
-                "CONNECTOR, DATABASE, EXTENSION, FUNCTION, INDEX, POLICY, PROCEDURE, ROLE, SCHEMA, SECRET, SEQUENCE, STAGE, TABLE, TRIGGER, TYPE, VIEW, MATERIALIZED VIEW or USER after DROP",
+                "CONNECTOR, DATABASE, EXTENSION, FUNCTION, INDEX, OPERATOR, POLICY, PROCEDURE, ROLE, SCHEMA, SECRET, SEQUENCE, STAGE, TABLE, TRIGGER, TYPE, VIEW, MATERIALIZED VIEW or USER after DROP",
                 self.peek_token(),
             );
         };
@@ -7526,6 +7532,46 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// Parse a[Statement::DropOperator] statement.
+    ///
+    pub fn parse_drop_operator(&mut self) -> Result<Statement, ParserError> {
+        let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
+        let operators = self.parse_comma_separated(|p| p.parse_drop_operator_signature())?;
+        let drop_behavior = self.parse_optional_drop_behavior();
+        Ok(Statement::DropOperator(DropOperator {
+            if_exists,
+            operators,
+            drop_behavior,
+        }))
+    }
+
+    /// Parse an operator signature for a [Statement::DropOperator]
+    /// Format: `name ( { left_type | NONE } , right_type )`
+    fn parse_drop_operator_signature(&mut self) -> Result<DropOperatorSignature, ParserError> {
+        let name = self.parse_operator_name()?;
+        self.expect_token(&Token::LParen)?;
+
+        // Parse left operand type (or NONE for prefix operators)
+        let left_type = if self.parse_keyword(Keyword::NONE) {
+            None
+        } else {
+            Some(self.parse_data_type()?)
+        };
+
+        self.expect_token(&Token::Comma)?;
+
+        // Parse right operand type (always required)
+        let right_type = self.parse_data_type()?;
+
+        self.expect_token(&Token::RParen)?;
+
+        Ok(DropOperatorSignature {
+            name,
+            left_type,
+            right_type,
+        })
+    }
+
     //TODO: Implement parsing for Skewed
     pub fn parse_hive_distribution(&mut self) -> Result<HiveDistributionStyle, ParserError> {
         if self.parse_keywords(&[Keyword::PARTITIONED, Keyword::BY]) {
@@ -7538,8 +7584,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_hive_formats(&mut self) -> Result<HiveFormat, ParserError> {
-        let mut hive_format = HiveFormat::default();
+    pub fn parse_hive_formats(&mut self) -> Result<Option<HiveFormat>, ParserError> {
+        let mut hive_format: Option<HiveFormat> = None;
         loop {
             match self.parse_one_of_keywords(&[
                 Keyword::ROW,
@@ -7548,32 +7594,39 @@ impl<'a> Parser<'a> {
                 Keyword::WITH,
             ]) {
                 Some(Keyword::ROW) => {
-                    hive_format.row_format = Some(self.parse_row_format()?);
+                    hive_format
+                        .get_or_insert_with(HiveFormat::default)
+                        .row_format = Some(self.parse_row_format()?);
                 }
                 Some(Keyword::STORED) => {
                     self.expect_keyword_is(Keyword::AS)?;
                     if self.parse_keyword(Keyword::INPUTFORMAT) {
                         let input_format = self.parse_expr()?;
                         self.expect_keyword_is(Keyword::OUTPUTFORMAT)?;
                         let output_format = self.parse_expr()?;
-                        hive_format.storage = Some(HiveIOFormat::IOF {
-                            input_format,
-                            output_format,
-                        });
+                        hive_format.get_or_insert_with(HiveFormat::default).storage =
+                            Some(HiveIOFormat::IOF {
+                                input_format,
+                                output_format,
+                            });
                     } else {
                         let format = self.parse_file_format()?;
-                        hive_format.storage = Some(HiveIOFormat::FileFormat { format });
+                        hive_format.get_or_insert_with(HiveFormat::default).storage =
+                            Some(HiveIOFormat::FileFormat { format });
                     }
                 }
                 Some(Keyword::LOCATION) => {
-                    hive_format.location = Some(self.parse_literal_string()?);
+                    hive_format.get_or_insert_with(HiveFormat::default).location =
+                        Some(self.parse_literal_string()?);
                 }
                 Some(Keyword::WITH) => {
                     self.prev_token();
                     let properties = self
                         .parse_options_with_keywords(&[Keyword::WITH, Keyword::SERDEPROPERTIES])?;
                     if !properties.is_empty() {
-                        hive_format.serde_properties = Some(properties);
+                        hive_format
+                            .get_or_insert_with(HiveFormat::default)
+                            .serde_properties = Some(properties);
                     } else {
                         break;
                     }
@@ -7788,7 +7841,7 @@ impl<'a> Parser<'a> {
             .if_not_exists(if_not_exists)
             .transient(transient)
             .hive_distribution(hive_distribution)
-            .hive_formats(Some(hive_formats))
+            .hive_formats(hive_formats)
             .global(global)
             .query(query)
             .without_rowid(without_rowid)
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -4724,6 +4724,17 @@ fn parse_create_external_table_lowercase() {
     assert_matches!(ast, Statement::CreateTable(CreateTable { .. }));
 }
 
+#[test]
+fn parse_create_table_hive_formats_none_when_no_options() {
+    let sql = "CREATE TABLE simple_table (id INT, name VARCHAR(100))";
+    match verified_stmt(sql) {
+        Statement::CreateTable(CreateTable { hive_formats, .. }) => {
+            assert_eq!(hive_formats, None);
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_alter_table() {
     let add_column = "ALTER TABLE tab ADD COLUMN foo TEXT;";
diff --git a/tests/sqlparser_duckdb.rs b/tests/sqlparser_duckdb.rs
@@ -739,12 +739,7 @@ fn test_duckdb_union_datatype() {
             ],
             constraints: Default::default(),
             hive_distribution: HiveDistributionStyle::NONE,
-            hive_formats: Some(HiveFormat {
-                row_format: Default::default(),
-                serde_properties: Default::default(),
-                storage: Default::default(),
-                location: Default::default()
-            }),
+            hive_formats: None,
             file_format: Default::default(),
             location: Default::default(),
             query: Default::default(),
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
@@ -1881,12 +1881,7 @@ fn parse_create_table_with_valid_options() {
                 ],
                 constraints: vec![],
                 hive_distribution: HiveDistributionStyle::NONE,
-                hive_formats: Some(HiveFormat {
-                    row_format: None,
-                    serde_properties: None,
-                    storage: None,
-                    location: None,
-                },),
+                hive_formats: None,
                 file_format: None,
                 location: None,
                 query: None,
@@ -2053,12 +2048,7 @@ fn parse_create_table_with_identity_column() {
                 },],
                 constraints: vec![],
                 hive_distribution: HiveDistributionStyle::NONE,
-                hive_formats: Some(HiveFormat {
-                    row_format: None,
-                    serde_properties: None,
-                    storage: None,
-                    location: None,
-                },),
+                hive_formats: None,
                 file_format: None,
                 location: None,
                 query: None,
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
