Rename OperatorSignature to DropOperatorSignature and update references

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -4198,7 +4198,7 @@ pub struct DropOperator {
     /// `IF EXISTS` clause
     pub if_exists: bool,
     /// One or more operators to drop with their signatures
-    pub operators: Vec<OperatorSignature>,
+    pub operators: Vec<DropOperatorSignature>,
     /// `CASCADE or RESTRICT`
     pub drop_behavior: Option<DropBehavior>,
 }
@@ -4207,7 +4207,7 @@ pub struct DropOperator {
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct OperatorSignature {
+pub struct DropOperatorSignature {
     /// Operator name
     pub name: ObjectName,
     /// Left operand type
@@ -4216,7 +4216,7 @@ pub struct OperatorSignature {
     pub right_type: DataType,
 }
 
-impl fmt::Display for OperatorSignature {
+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 {

src/ast/mod.rs

@@ -71,7 +71,7 @@ pub use self::ddl::{
     GeneratedExpressionMode, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind,
     IdentityPropertyKind, IdentityPropertyOrder, IndexColumn, IndexOption, IndexType,
     KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes, OperatorClassItem,
-    OperatorPurpose, OperatorSignature, Owner, Partition, ProcedureParam, ReferentialAction,
+    OperatorPurpose, DropOperatorSignature, Owner, Partition, ProcedureParam, ReferentialAction,
     RenameTableNameKind, ReplicaIdentity, TagsColumnOption, TriggerObjectKind, Truncate,
     UserDefinedTypeCompositeAttributeDef, UserDefinedTypeInternalLength,
     UserDefinedTypeRangeOption, UserDefinedTypeRepresentation, UserDefinedTypeSqlDefinitionOption,

src/parser/mod.rs

@@ -7542,7 +7542,7 @@ impl<'a> Parser<'a> {
 
     /// Parse an operator signature for a [Statement::DropOperator]
     /// Format: `name ( { left_type | NONE } , right_type )`
-    fn parse_operator_signature(&mut self) -> Result<OperatorSignature, ParserError> {
+    fn parse_operator_signature(&mut self) -> Result<DropOperatorSignature, ParserError> {
         let name = self.parse_operator_name()?;
         self.expect_token(&Token::LParen)?;
 
@@ -7560,7 +7560,7 @@ impl<'a> Parser<'a> {
 
         self.expect_token(&Token::RParen)?;
 
-        Ok(OperatorSignature {
+        Ok(DropOperatorSignature {
             name,
             left_type,
             right_type,

tests/sqlparser_postgres.rs

@@ -6765,15 +6765,15 @@ fn parse_create_operator() {
 
 #[test]
 fn parse_drop_operator() {
-    use sqlparser::ast::{DataType, DropBehavior, DropOperator, OperatorSignature};
+    use sqlparser::ast::{DataType, DropBehavior, DropOperator, DropOperatorSignature};
 
     // Test DROP OPERATOR with NONE for prefix operator
     let sql = "DROP OPERATOR ~ (NONE, BIT)";
     assert_eq!(
         pg().verified_stmt(sql),
         Statement::DropOperator(DropOperator {
             if_exists: false,
-            operators: vec![OperatorSignature {
+            operators: vec![DropOperatorSignature {
                 name: ObjectName::from(vec![Ident::new("~")]),
                 left_type: None,
                 right_type: DataType::Bit(None),
@@ -6801,7 +6801,7 @@ fn parse_drop_operator() {
                     pg().verified_stmt(&sql),
                     Statement::DropOperator(DropOperator {
                         if_exists: if_exist,
-                        operators: vec![OperatorSignature {
+                        operators: vec![DropOperatorSignature {
                             name: ObjectName::from(vec![Ident::new(*op)]),
                             left_type: Some(DataType::Integer(None)),
                             right_type: DataType::Integer(None),
@@ -6819,7 +6819,7 @@ fn parse_drop_operator() {
         pg().verified_stmt(sql),
         Statement::DropOperator(DropOperator {
             if_exists: false,
-            operators: vec![OperatorSignature {
+            operators: vec![DropOperatorSignature {
                 name: ObjectName::from(vec![Ident::new("myschema"), Ident::new("@@")]),
                 left_type: Some(DataType::Text),
                 right_type: DataType::Text,
@@ -6835,12 +6835,12 @@ fn parse_drop_operator() {
         Statement::DropOperator(DropOperator {
             if_exists: true,
             operators: vec![
-                OperatorSignature {
+                DropOperatorSignature {
                     name: ObjectName::from(vec![Ident::new("+")]),
                     left_type: Some(DataType::Integer(None)),
                     right_type: DataType::Integer(None),
                 },
-                OperatorSignature {
+                DropOperatorSignature {
                     name: ObjectName::from(vec![Ident::new("-")]),
                     left_type: Some(DataType::Integer(None)),
                     right_type: DataType::Integer(None),