Add support for PostgreSQL's ORDER BY ... USING <operator> clause

Author: LucaCappelletti94

src/ast/mod.rs

@@ -97,9 +97,9 @@ pub use self::query::{
     JsonTableNestedColumn, LateralView, LimitClause, LockClause, LockType, MatchRecognizePattern,
     MatchRecognizeSymbol, Measure, NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset,
     OffsetRows, OpenJsonTableColumn, OrderBy, OrderByExpr, OrderByKind, OrderByOptions,
-    PipeOperator, PivotValueSource, ProjectionSelect, Query, RenameSelectItem,
-    RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select,
-    SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SelectModifiers,
+    OrderByUsingOperator, PipeOperator, PivotValueSource, ProjectionSelect, Query,
+    RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch,
+    Select, SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SelectModifiers,
     SetExpr, SetOperator, SetQuantifier, Setting, SymbolDefinition, Table, TableAlias,
     TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexHintForClause,
     TableIndexHintType, TableIndexHints, TableIndexType, TableSample, TableSampleBucket,

src/ast/query.rs

@@ -2860,16 +2860,41 @@ impl fmt::Display for OrderBy {
 pub struct OrderByExpr {
     /// The expression to order by.
     pub expr: Expr,
+    /// Optional PostgreSQL `USING <operator>` clause.
+    pub using_operator: Option<OrderByUsingOperator>,
     /// Ordering options such as `ASC`/`DESC` and `NULLS` behavior.
     pub options: OrderByOptions,
     /// Optional `WITH FILL` clause (ClickHouse extension) which specifies how to fill gaps.
     pub with_fill: Option<WithFill>,
 }
 
+/// An operator used in PostgreSQL's `ORDER BY ... USING <operator>` clause.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum OrderByUsingOperator {
+    /// A symbolic operator such as `<`, `>`, or `~<~`.
+    Symbol(String),
+    /// PostgreSQL `OPERATOR(...)` syntax, e.g. `OPERATOR(pg_catalog.<)`.
+    Qualified(Vec<String>),
+}
+
+impl fmt::Display for OrderByUsingOperator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            OrderByUsingOperator::Symbol(op) => write!(f, "{op}"),
+            OrderByUsingOperator::Qualified(path) => {
+                write!(f, "OPERATOR({})", display_separated(path, "."))
+            }
+        }
+    }
+}
+
 impl From<Ident> for OrderByExpr {
     fn from(ident: Ident) -> Self {
         OrderByExpr {
             expr: Expr::Identifier(ident),
+            using_operator: None,
             options: OrderByOptions::default(),
             with_fill: None,
         }
@@ -2878,7 +2903,11 @@ impl From<Ident> for OrderByExpr {
 
 impl fmt::Display for OrderByExpr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}{}", self.expr, self.options)?;
+        write!(f, "{}", self.expr)?;
+        if let Some(using_operator) = &self.using_operator {
+            write!(f, " USING {using_operator}")?;
+        }
+        write!(f, "{}", self.options)?;
         if let Some(ref with_fill) = self.with_fill {
             write!(f, " {with_fill}")?
         }

src/ast/spans.rs

@@ -2087,6 +2087,7 @@ impl Spanned for OrderByExpr {
     fn span(&self) -> Span {
         let OrderByExpr {
             expr,
+            using_operator: _,
             options: _,
             with_fill,
         } = self;