Refactor ORDER BY ... USING operator handling to use ObjectName instead of OrderByUsingOperator

Author: LucaCappelletti94

src/ast/mod.rs

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

src/ast/query.rs

@@ -2861,35 +2861,13 @@ pub struct OrderByExpr {
     /// The expression to order by.
     pub expr: Expr,
     /// Optional PostgreSQL `USING <operator>` clause.
-    pub using_operator: Option<OrderByUsingOperator>,
+    pub using_operator: Option<ObjectName>,
     /// 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 {
@@ -2905,7 +2883,11 @@ impl fmt::Display for OrderByExpr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.expr)?;
         if let Some(using_operator) = &self.using_operator {
-            write!(f, " USING {using_operator}")?;
+            if using_operator.0.len() > 1 {
+                write!(f, " USING OPERATOR({using_operator})")?;
+            } else {
+                write!(f, " USING {using_operator}")?;
+            }
         }
         write!(f, "{}", self.options)?;
         if let Some(ref with_fill) = self.with_fill {

src/parser/mod.rs

@@ -18118,33 +18118,25 @@ impl<'a> Parser<'a> {
         ))
     }
 
-    fn parse_order_by_using_operator(&mut self) -> Result<OrderByUsingOperator, ParserError> {
+    fn parse_order_by_using_operator(&mut self) -> Result<ObjectName, ParserError> {
         if self.parse_keyword(Keyword::OPERATOR) {
             self.expect_token(&Token::LParen)?;
-            let mut operator_path = vec![];
-            let last_token = loop {
-                let token = self.next_token();
-                if token.token == Token::RParen {
-                    return self.expected_ref("an operator name", &token);
-                }
-                operator_path.push(token.token.to_string());
-                if !self.consume_token(&Token::Period) {
-                    break token;
-                }
+            let operator_name = self.parse_operator_name()?;
+            let Some(last_part) = operator_name.0.last() else {
+                return self.expected_ref("an operator name", self.peek_token_ref());
             };
-            if let Some(operator) = operator_path.last() {
-                if !Self::is_valid_order_by_using_operator_symbol(operator) {
-                    return self.expected_ref("an operator name", &last_token);
-                }
+            let operator = last_part.to_string();
+            if !Self::is_valid_order_by_using_operator_symbol(&operator) {
+                return self.expected_ref("an operator name", self.peek_token_ref());
             }
             self.expect_token(&Token::RParen)?;
-            return Ok(OrderByUsingOperator::Qualified(operator_path));
+            return Ok(operator_name);
         }
 
         let token = self.next_token();
         let operator = token.token.to_string();
         if Self::is_valid_order_by_using_operator_symbol(&operator) {
-            Ok(OrderByUsingOperator::Symbol(operator))
+            Ok(ObjectName::from(vec![Ident::new(operator)]))
         } else {
             self.expected_ref("an ordering operator after USING", &token)
         }

tests/sqlparser_postgres.rs

@@ -5708,13 +5708,18 @@ fn parse_pg_aggregate_order_by_using_operator() {
 
     assert_eq!(
         order_by_exprs[0].using_operator,
-        Some(OrderByUsingOperator::Symbol("~<~".to_string()))
+        Some(ObjectName::from(vec!["~<~".into()]))
     );
     assert_eq!(order_by_exprs[1].using_operator, None);
 }
 
 #[test]
 fn parse_pg_order_by_using_operator_syntax() {
+    pg().one_statement_parses_to(
+        "SELECT a FROM t ORDER BY a USING OPERATOR(<)",
+        "SELECT a FROM t ORDER BY a USING <",
+    );
+
     let query =
         pg().verified_query("SELECT a FROM t ORDER BY a USING OPERATOR(pg_catalog.<) NULLS LAST");
     let order_by = query.order_by.expect("expected ORDER BY clause");
@@ -5724,9 +5729,9 @@ fn parse_pg_order_by_using_operator_syntax() {
 
     assert_eq!(
         exprs[0].using_operator,
-        Some(OrderByUsingOperator::Qualified(vec![
-            "pg_catalog".to_string(),
-            "<".to_string(),
+        Some(ObjectName::from(vec![
+            Ident::new("pg_catalog"),
+            Ident::new("<"),
         ]))
     );
     assert_eq!(exprs[0].options.asc, None);