Implement prettier SQL unparsing (more human readable)

datafusion-examples/examples/parse_sql_expr.rs

@@ -135,7 +135,9 @@ async fn query_parquet_demo() -> Result<()> {
 
 /// DataFusion can parse a SQL text and convert it back to SQL using [`Unparser`].
 async fn round_trip_parse_sql_expr_demo() -> Result<()> {
-    let sql = "((int_col < 5) OR (double_col = 8))";
+    // unparser can also remove extra parentheses,
+    // so `((int_col < 5) OR (double_col = 8))` will also produce the same SQL
+    let sql = "int_col < 5 OR double_col = 8";
 
     let ctx = SessionContext::new();
     let testdata = datafusion::test_util::parquet_test_data();

datafusion-examples/examples/plan_to_sql.rs

@@ -60,7 +60,7 @@ async fn main() -> Result<()> {
 fn simple_expr_to_sql_demo() -> Result<()> {
     let expr = col("a").lt(lit(5)).or(col("a").eq(lit(8)));
     let sql = expr_to_sql(&expr)?.to_string();
-    assert_eq!(sql, r#"((a < 5) OR (a = 8))"#);
+    assert_eq!(sql, r#"a < 5 OR a = 8"#);
     Ok(())
 }
 
@@ -71,7 +71,7 @@ fn simple_expr_to_sql_demo_escape_mysql_style() -> Result<()> {
     let dialect = CustomDialect::new(Some('`'));
     let unparser = Unparser::new(&dialect);
     let sql = unparser.expr_to_sql(&expr)?.to_string();
-    assert_eq!(sql, r#"((`a` < 5) OR (`a` = 8))"#);
+    assert_eq!(sql, r#"`a` < 5 OR `a` = 8"#);
     Ok(())
 }
 
@@ -133,7 +133,7 @@ async fn round_trip_plan_to_sql_demo() -> Result<()> {
     let sql = plan_to_sql(df.logical_plan())?.to_string();
     assert_eq!(
         sql,
-        r#"SELECT alltypes_plain.int_col, alltypes_plain.double_col, CAST(alltypes_plain.date_string_col AS VARCHAR) FROM alltypes_plain WHERE ((alltypes_plain.id > 1) AND (alltypes_plain.tinyint_col < alltypes_plain.double_col))"#
+        r#"SELECT alltypes_plain.int_col, alltypes_plain.double_col, CAST(alltypes_plain.date_string_col AS VARCHAR) FROM alltypes_plain WHERE alltypes_plain.id > 1 AND alltypes_plain.tinyint_col < alltypes_plain.double_col"#
     );
 
     Ok(())

datafusion/core/tests/expr_api/parse_sql_expr.rs

@@ -39,17 +39,17 @@ fn schema() -> DFSchemaRef {
 #[tokio::test]
 async fn round_trip_parse_sql_expr() -> Result<()> {
     let tests = vec![
-        "(a = 10)",
-        "((a = 10) AND (b <> 20))",
-        "((a = 10) OR (b <> 20))",
-        "(((a = 10) AND (b <> 20)) OR (c = a))",
-        "((a = 10) AND b IN (20, 30))",
-        "((a = 10) AND b NOT IN (20, 30))",
+        "a = 10",
+        "(a = 10) AND (b <> 20)",
+        "(a = 10) OR (b <> 20)",
+        "((a = 10) AND (b <> 20)) OR (c = a)",
+        "(a = 10) AND b IN (20, 30)",
+        "(a = 10) AND b NOT IN (20, 30)",
         "sum(a)",
-        "(sum(a) + 1)",
-        "(MIN(a) + MAX(b))",
-        "(MIN(a) + (MAX(b) * sum(c)))",
-        "(MIN(a) + ((MAX(b) * sum(c)) / 10))",
+        "sum(a) + 1",
+        "MIN(a) + MAX(b)",
+        "MIN(a) + (MAX(b) * sum(c))",
+        "MIN(a) + ((MAX(b) * sum(c)) / 10)",
     ];
 
     for test in tests {
@@ -65,7 +65,8 @@ fn round_trip_session_context(sql: &str) -> Result<()> {
     let df_schema = schema();
     let expr = ctx.parse_sql_expr(sql, &df_schema)?;
     let sql2 = unparse_sql_expr(&expr)?;
-    assert_eq!(sql, sql2);
+    let expr2 = ctx.parse_sql_expr(&sql2, &df_schema)?;
+    assert_eq!(expr.to_string(), expr2.to_string());
 
     Ok(())
 }
@@ -80,7 +81,8 @@ async fn round_trip_dataframe(sql: &str) -> Result<()> {
         .await?;
     let expr = df.parse_sql_expr(sql)?;
     let sql2 = unparse_sql_expr(&expr)?;
-    assert_eq!(sql, sql2);
+    let roundtrip = df.parse_sql_expr(&sql2)?;
+    assert_eq!(expr, roundtrip);
 
     Ok(())
 }

datafusion/expr/src/operator.rs

@@ -218,37 +218,33 @@ impl Operator {
     }
 
     /// Get the operator precedence
-    /// use <https://www.postgresql.org/docs/7.0/operators.htm#AEN2026> as a reference
+    /// use <https://www.postgresql.org/docs/7.2/sql-precedence.html> as a reference
     pub fn precedence(&self) -> u8 {
         match self {
             Operator::Or => 5,
             Operator::And => 10,
-            Operator::NotEq
-            | Operator::Eq
-            | Operator::Lt
-            | Operator::LtEq
-            | Operator::Gt
-            | Operator::GtEq => 20,
-            Operator::Plus | Operator::Minus => 30,
-            Operator::Multiply | Operator::Divide | Operator::Modulo => 40,
+            Operator::Eq | Operator::NotEq | Operator::LtEq | Operator::GtEq => 15,
+            Operator::Lt | Operator::Gt => 20,
+            Operator::LikeMatch
+            | Operator::NotLikeMatch
+            | Operator::ILikeMatch
+            | Operator::NotILikeMatch => 25,
             Operator::IsDistinctFrom
             | Operator::IsNotDistinctFrom
             | Operator::RegexMatch
             | Operator::RegexNotMatch
             | Operator::RegexIMatch
             | Operator::RegexNotIMatch
-            | Operator::LikeMatch
-            | Operator::ILikeMatch
-            | Operator::NotLikeMatch
-            | Operator::NotILikeMatch
             | Operator::BitwiseAnd
             | Operator::BitwiseOr
             | Operator::BitwiseShiftLeft
             | Operator::BitwiseShiftRight
             | Operator::BitwiseXor
             | Operator::StringConcat
             | Operator::AtArrow
-            | Operator::ArrowAt => 0,
+            | Operator::ArrowAt => 30,
+            Operator::Plus | Operator::Minus => 40,
+            Operator::Multiply | Operator::Divide | Operator::Modulo => 45,
         }
     }
 }