Added support for ALTER OPERATOR FAMILY syntax (apache#2125)

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -4301,25 +4301,25 @@ impl fmt::Display for OperatorArgTypes {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum OperatorClassItem {
-    /// OPERATOR clause
+    /// `OPERATOR` clause
     Operator {
-        strategy_number: u32,
+        strategy_number: u64,
         operator_name: ObjectName,
         /// Optional operator argument types
         op_types: Option<OperatorArgTypes>,
-        /// FOR SEARCH or FOR ORDER BY
+        /// `FOR SEARCH` or `FOR ORDER BY`
         purpose: Option<OperatorPurpose>,
     },
-    /// FUNCTION clause
+    /// `FUNCTION` clause
     Function {
-        support_number: u32,
+        support_number: u64,
         /// Optional function argument types for the operator class
         op_types: Option<Vec<DataType>>,
         function_name: ObjectName,
         /// Function argument types
         argument_types: Vec<DataType>,
     },
-    /// STORAGE clause
+    /// `STORAGE` clause
     Storage { storage_type: DataType },
 }
 
@@ -4516,3 +4516,189 @@ impl Spanned for DropOperatorClass {
         Span::empty()
     }
 }
+
+/// An item in an ALTER OPERATOR FAMILY ADD statement
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum OperatorFamilyItem {
+    /// `OPERATOR` clause
+    Operator {
+        strategy_number: u64,
+        operator_name: ObjectName,
+        /// Operator argument types
+        op_types: Vec<DataType>,
+        /// `FOR SEARCH` or `FOR ORDER BY`
+        purpose: Option<OperatorPurpose>,
+    },
+    /// `FUNCTION` clause
+    Function {
+        support_number: u64,
+        /// Optional operator argument types for the function
+        op_types: Option<Vec<DataType>>,
+        function_name: ObjectName,
+        /// Function argument types
+        argument_types: Vec<DataType>,
+    },
+}
+
+/// An item in an ALTER OPERATOR FAMILY DROP statement
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum OperatorFamilyDropItem {
+    /// `OPERATOR` clause
+    Operator {
+        strategy_number: u64,
+        /// Operator argument types
+        op_types: Vec<DataType>,
+    },
+    /// `FUNCTION` clause
+    Function {
+        support_number: u64,
+        /// Operator argument types for the function
+        op_types: Vec<DataType>,
+    },
+}
+
+impl fmt::Display for OperatorFamilyItem {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            OperatorFamilyItem::Operator {
+                strategy_number,
+                operator_name,
+                op_types,
+                purpose,
+            } => {
+                write!(
+                    f,
+                    "OPERATOR {strategy_number} {operator_name} ({})",
+                    display_comma_separated(op_types)
+                )?;
+                if let Some(purpose) = purpose {
+                    write!(f, " {purpose}")?;
+                }
+                Ok(())
+            }
+            OperatorFamilyItem::Function {
+                support_number,
+                op_types,
+                function_name,
+                argument_types,
+            } => {
+                write!(f, "FUNCTION {support_number}")?;
+                if let Some(types) = op_types {
+                    write!(f, " ({})", display_comma_separated(types))?;
+                }
+                write!(f, " {function_name}")?;
+                if !argument_types.is_empty() {
+                    write!(f, "({})", display_comma_separated(argument_types))?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+impl fmt::Display for OperatorFamilyDropItem {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            OperatorFamilyDropItem::Operator {
+                strategy_number,
+                op_types,
+            } => {
+                write!(
+                    f,
+                    "OPERATOR {strategy_number} ({})",
+                    display_comma_separated(op_types)
+                )
+            }
+            OperatorFamilyDropItem::Function {
+                support_number,
+                op_types,
+            } => {
+                write!(
+                    f,
+                    "FUNCTION {support_number} ({})",
+                    display_comma_separated(op_types)
+                )
+            }
+        }
+    }
+}
+
+/// `ALTER OPERATOR FAMILY` statement
+/// See <https://www.postgresql.org/docs/current/sql-alteropfamily.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 AlterOperatorFamily {
+    /// Operator family name (can be schema-qualified)
+    pub name: ObjectName,
+    /// Index method (btree, hash, gist, gin, etc.)
+    pub using: Ident,
+    /// The operation to perform
+    pub operation: AlterOperatorFamilyOperation,
+}
+
+/// An [AlterOperatorFamily] operation
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterOperatorFamilyOperation {
+    /// `ADD { OPERATOR ... | FUNCTION ... } [, ...]`
+    Add {
+        /// List of operator family items to add
+        items: Vec<OperatorFamilyItem>,
+    },
+    /// `DROP { OPERATOR ... | FUNCTION ... } [, ...]`
+    Drop {
+        /// List of operator family items to drop
+        items: Vec<OperatorFamilyDropItem>,
+    },
+    /// `RENAME TO new_name`
+    RenameTo { new_name: ObjectName },
+    /// `OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }`
+    OwnerTo(Owner),
+    /// `SET SCHEMA new_schema`
+    SetSchema { schema_name: ObjectName },
+}
+
+impl fmt::Display for AlterOperatorFamily {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "ALTER OPERATOR FAMILY {} USING {}",
+            self.name, self.using
+        )?;
+        write!(f, " {}", self.operation)
+    }
+}
+
+impl fmt::Display for AlterOperatorFamilyOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AlterOperatorFamilyOperation::Add { items } => {
+                write!(f, "ADD {}", display_comma_separated(items))
+            }
+            AlterOperatorFamilyOperation::Drop { items } => {
+                write!(f, "DROP {}", display_comma_separated(items))
+            }
+            AlterOperatorFamilyOperation::RenameTo { new_name } => {
+                write!(f, "RENAME TO {new_name}")
+            }
+            AlterOperatorFamilyOperation::OwnerTo(owner) => {
+                write!(f, "OWNER TO {owner}")
+            }
+            AlterOperatorFamilyOperation::SetSchema { schema_name } => {
+                write!(f, "SET SCHEMA {schema_name}")
+            }
+        }
+    }
+}
+
+impl Spanned for AlterOperatorFamily {
+    fn span(&self) -> Span {
+        Span::empty()
+    }
+}

src/ast/mod.rs

@@ -60,20 +60,22 @@ pub use self::dcl::{
 };
 pub use self::ddl::{
     Alignment, AlterColumnOperation, AlterConnectorOwner, AlterIndexOperation, AlterOperator,
-    AlterOperatorOperation, AlterPolicyOperation, AlterSchema, AlterSchemaOperation, AlterTable,
-    AlterTableAlgorithm, AlterTableLock, AlterTableOperation, AlterTableType, AlterType,
-    AlterTypeAddValue, AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename,
-    AlterTypeRenameValue, ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions,
-    ColumnPolicy, ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateDomain,
+    AlterOperatorFamily, AlterOperatorFamilyOperation, AlterOperatorOperation,
+    AlterPolicyOperation, AlterSchema, AlterSchemaOperation, AlterTable, AlterTableAlgorithm,
+    AlterTableLock, AlterTableOperation, AlterTableType, AlterType, AlterTypeAddValue,
+    AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue,
+    ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions, ColumnPolicy,
+    ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateDomain,
     CreateExtension, CreateFunction, CreateIndex, CreateOperator, CreateOperatorClass,
     CreateOperatorFamily, CreateTable, CreateTrigger, CreateView, Deduplicate, DeferrableInitial,
     DropBehavior, DropExtension, DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily,
     DropOperatorSignature, DropTrigger, ForValues, GeneratedAs, GeneratedExpressionMode,
     IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
     IdentityPropertyOrder, IndexColumn, IndexOption, IndexType, KeyOrIndexDisplay, Msck,
-    NullsDistinctOption, OperatorArgTypes, OperatorClassItem, OperatorOption, OperatorPurpose,
-    Owner, Partition, PartitionBoundValue, ProcedureParam, ReferentialAction, RenameTableNameKind,
-    ReplicaIdentity, TagsColumnOption, TriggerObjectKind, Truncate,
+    NullsDistinctOption, OperatorArgTypes, OperatorClassItem, OperatorFamilyDropItem,
+    OperatorFamilyItem, OperatorOption, OperatorPurpose, Owner, Partition, PartitionBoundValue,
+    ProcedureParam, ReferentialAction, RenameTableNameKind, ReplicaIdentity, TagsColumnOption,
+    TriggerObjectKind, Truncate,
     UserDefinedTypeCompositeAttributeDef, UserDefinedTypeInternalLength,
     UserDefinedTypeRangeOption, UserDefinedTypeRepresentation, UserDefinedTypeSqlDefinitionOption,
     UserDefinedTypeStorage, ViewColumnDef,
@@ -3412,6 +3414,11 @@ pub enum Statement {
     /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteroperator.html)
     AlterOperator(AlterOperator),
     /// ```sql
+    /// ALTER OPERATOR FAMILY
+    /// ```
+    /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteropfamily.html)
+    AlterOperatorFamily(AlterOperatorFamily),
+    /// ```sql
     /// ALTER ROLE
     /// ```
     AlterRole {
@@ -4973,6 +4980,9 @@ impl fmt::Display for Statement {
                 write!(f, "ALTER TYPE {name} {operation}")
             }
             Statement::AlterOperator(alter_operator) => write!(f, "{alter_operator}"),
+            Statement::AlterOperatorFamily(alter_operator_family) => {
+                write!(f, "{alter_operator_family}")
+            }
             Statement::AlterRole { name, operation } => {
                 write!(f, "ALTER ROLE {name} {operation}")
             }

src/ast/spans.rs

@@ -403,6 +403,7 @@ impl Spanned for Statement {
             // These statements need to be implemented
             Statement::AlterType { .. } => Span::empty(),
             Statement::AlterOperator { .. } => Span::empty(),
+            Statement::AlterOperatorFamily { .. } => Span::empty(),
             Statement::AlterRole { .. } => Span::empty(),
             Statement::AlterSession { .. } => Span::empty(),
             Statement::AttachDatabase { .. } => Span::empty(),