diff --git a/datafusion/src/execution/context.rs b/datafusion/src/execution/context.rs index f8b344fecd9..adc53a05e04 100644 --- a/datafusion/src/execution/context.rs +++ b/datafusion/src/execution/context.rs @@ -1696,15 +1696,15 @@ mod tests { .await?; let expected = vec![ - "+----+----+--------------+-----------------------------------+----------------------------------+------------------------------------------+--------------+----------------+--------------+--------------+--------------+", - "| c1 | c2 | ROW_NUMBER() | FIRST_VALUE(test.c2 Plus test.c1) | LAST_VALUE(test.c2 Plus test.c1) | NTH_VALUE(test.c2 Plus test.c1,Int64(1)) | SUM(test.c2) | COUNT(test.c2) | MAX(test.c2) | MIN(test.c2) | AVG(test.c2) |", - "+----+----+--------------+-----------------------------------+----------------------------------+------------------------------------------+--------------+----------------+--------------+--------------+--------------+", - "| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |", - "| 0 | 2 | 1 | 2 | 2 | 2 | 2 | 1 | 2 | 2 | 2 |", - "| 0 | 3 | 1 | 3 | 3 | 3 | 3 | 1 | 3 | 3 | 3 |", - "| 0 | 4 | 1 | 4 | 4 | 4 | 4 | 1 | 4 | 4 | 4 |", - "| 0 | 5 | 1 | 5 | 5 | 5 | 5 | 1 | 5 | 5 | 5 |", - "+----+----+--------------+-----------------------------------+----------------------------------+------------------------------------------+--------------+----------------+--------------+--------------+--------------+", + "+----+----+--------------+--------------------------------+-------------------------------+---------------------------------------+--------------+----------------+--------------+--------------+--------------+", + "| c1 | c2 | ROW_NUMBER() | FIRST_VALUE(test.c2 + test.c1) | LAST_VALUE(test.c2 + test.c1) | NTH_VALUE(test.c2 + test.c1,Int64(1)) | SUM(test.c2) | COUNT(test.c2) | MAX(test.c2) | MIN(test.c2) | AVG(test.c2) |", + "+----+----+--------------+--------------------------------+-------------------------------+---------------------------------------+--------------+----------------+--------------+--------------+--------------+", + "| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |", + "| 0 | 2 | 1 | 2 | 2 | 2 | 2 | 1 | 2 | 2 | 2 |", + "| 0 | 3 | 1 | 3 | 3 | 3 | 3 | 1 | 3 | 3 | 3 |", + "| 0 | 4 | 1 | 4 | 4 | 4 | 4 | 1 | 4 | 4 | 4 |", + "| 0 | 5 | 1 | 5 | 5 | 5 | 5 | 1 | 5 | 5 | 5 |", + "+----+----+--------------+--------------------------------+-------------------------------+---------------------------------------+--------------+----------------+--------------+--------------+--------------+", ]; // window function shall respect ordering diff --git a/datafusion/src/logical_plan/builder.rs b/datafusion/src/logical_plan/builder.rs index 5555939d74a..c0322739b0e 100644 --- a/datafusion/src/logical_plan/builder.rs +++ b/datafusion/src/logical_plan/builder.rs @@ -663,7 +663,7 @@ mod tests { .build()?; let expected = "Projection: #employee_csv.id\ - \n Filter: #employee_csv.state Eq Utf8(\"CO\")\ + \n Filter: #employee_csv.state = Utf8(\"CO\")\ \n TableScan: employee_csv projection=Some([0, 3])"; assert_eq!(expected, format!("{:?}", plan)); diff --git a/datafusion/src/logical_plan/expr.rs b/datafusion/src/logical_plan/expr.rs index 0ec445a222b..62dbf244d17 100644 --- a/datafusion/src/logical_plan/expr.rs +++ b/datafusion/src/logical_plan/expr.rs @@ -941,6 +941,33 @@ impl Not for Expr { } } +impl std::fmt::Display for Expr { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Expr::BinaryExpr { + ref left, + ref right, + ref op, + } => write!(f, "{} {} {}", left, op, right), + Expr::AggregateFunction { + /// Name of the function + ref fun, + /// List of expressions to feed to the functions as arguments + ref args, + /// Whether this is a DISTINCT aggregation or not + ref distinct, + } => fmt_function(f, &fun.to_string(), *distinct, args, true), + Expr::ScalarFunction { + /// Name of the function + ref fun, + /// List of expressions to feed to the functions as arguments + ref args, + } => fmt_function(f, &fun.to_string(), false, args, true), + _ => write!(f, "{:?}", self), + } + } +} + #[allow(clippy::boxed_local)] fn rewrite_boxed(boxed_expr: Box, rewriter: &mut R) -> Result> where @@ -1603,8 +1630,14 @@ fn fmt_function( fun: &str, distinct: bool, args: &[Expr], + display: bool, ) -> fmt::Result { - let args: Vec = args.iter().map(|arg| format!("{:?}", arg)).collect(); + let args: Vec = match display { + true => args.iter().map(|arg| format!("{}", arg)).collect(), + false => args.iter().map(|arg| format!("{:?}", arg)).collect(), + }; + + // let args: Vec = args.iter().map(|arg| format!("{:?}", arg)).collect(); let distinct_str = match distinct { true => "DISTINCT ", false => "", @@ -1648,7 +1681,7 @@ impl fmt::Debug for Expr { Expr::IsNull(expr) => write!(f, "{:?} IS NULL", expr), Expr::IsNotNull(expr) => write!(f, "{:?} IS NOT NULL", expr), Expr::BinaryExpr { left, op, right } => { - write!(f, "{:?} {:?} {:?}", left, op, right) + write!(f, "{:?} {} {:?}", left, op, right) } Expr::Sort { expr, @@ -1667,10 +1700,10 @@ impl fmt::Debug for Expr { } } Expr::ScalarFunction { fun, args, .. } => { - fmt_function(f, &fun.to_string(), false, args) + fmt_function(f, &fun.to_string(), false, args, false) } Expr::ScalarUDF { fun, ref args, .. } => { - fmt_function(f, &fun.name, false, args) + fmt_function(f, &fun.name, false, args, false) } Expr::WindowFunction { fun, @@ -1679,7 +1712,7 @@ impl fmt::Debug for Expr { order_by, window_frame, } => { - fmt_function(f, &fun.to_string(), false, args)?; + fmt_function(f, &fun.to_string(), false, args, false)?; if !partition_by.is_empty() { write!(f, " PARTITION BY {:?}", partition_by)?; } @@ -1702,9 +1735,9 @@ impl fmt::Debug for Expr { distinct, ref args, .. - } => fmt_function(f, &fun.to_string(), *distinct, args), + } => fmt_function(f, &fun.to_string(), *distinct, args, true), Expr::AggregateUDF { fun, ref args, .. } => { - fmt_function(f, &fun.name, false, args) + fmt_function(f, &fun.name, false, args, false) } Expr::Between { expr, @@ -1762,7 +1795,7 @@ fn create_name(e: &Expr, input_schema: &DFSchema) -> Result { Expr::BinaryExpr { left, op, right } => { let left = create_name(left, input_schema)?; let right = create_name(right, input_schema)?; - Ok(format!("{} {:?} {}", left, op, right)) + Ok(format!("{} {} {}", left, op, right)) } Expr::Case { expr, @@ -1925,12 +1958,12 @@ mod tests { assert_eq!( rewriter.v, vec![ - "Previsited #state Eq Utf8(\"CO\")", + "Previsited #state = Utf8(\"CO\")", "Previsited #state", "Mutated #state", "Previsited Utf8(\"CO\")", "Mutated Utf8(\"CO\")", - "Mutated #state Eq Utf8(\"CO\")" + "Mutated #state = Utf8(\"CO\")" ] ) } diff --git a/datafusion/src/logical_plan/operators.rs b/datafusion/src/logical_plan/operators.rs index 4e9ccb74846..0e00736faac 100644 --- a/datafusion/src/logical_plan/operators.rs +++ b/datafusion/src/logical_plan/operators.rs @@ -129,19 +129,19 @@ mod tests { fn test_operators() { assert_eq!( format!("{:?}", lit(1u32) + lit(2u32)), - "UInt32(1) Plus UInt32(2)" + "UInt32(1) + UInt32(2)" ); assert_eq!( format!("{:?}", lit(1u32) - lit(2u32)), - "UInt32(1) Minus UInt32(2)" + "UInt32(1) - UInt32(2)" ); assert_eq!( format!("{:?}", lit(1u32) * lit(2u32)), - "UInt32(1) Multiply UInt32(2)" + "UInt32(1) * UInt32(2)" ); assert_eq!( format!("{:?}", lit(1u32) / lit(2u32)), - "UInt32(1) Divide UInt32(2)" + "UInt32(1) / UInt32(2)" ); } } diff --git a/datafusion/src/logical_plan/plan.rs b/datafusion/src/logical_plan/plan.rs index cb81b8d852f..4b91ade52e6 100644 --- a/datafusion/src/logical_plan/plan.rs +++ b/datafusion/src/logical_plan/plan.rs @@ -551,7 +551,7 @@ impl LogicalPlan { /// // Format using display_indent /// let display_string = format!("{}", plan.display_indent()); /// - /// assert_eq!("Filter: #foo_csv.id Eq Int32(5)\ + /// assert_eq!("Filter: #foo_csv.id = Int32(5)\ /// \n TableScan: foo_csv projection=None", /// display_string); /// ``` @@ -575,7 +575,7 @@ impl LogicalPlan { /// /// ```text /// Projection: #employee.id [id:Int32]\ - /// Filter: #employee.state Eq Utf8(\"CO\") [id:Int32, state:Utf8]\ + /// Filter: #employee.state = Utf8(\"CO\") [id:Int32, state:Utf8]\ /// TableScan: employee projection=Some([0, 3]) [id:Int32, state:Utf8]"; /// ``` /// @@ -592,7 +592,7 @@ impl LogicalPlan { /// // Format using display_indent_schema /// let display_string = format!("{}", plan.display_indent_schema()); /// - /// assert_eq!("Filter: #foo_csv.id Eq Int32(5) [id:Int32]\ + /// assert_eq!("Filter: #foo_csv.id = Int32(5) [id:Int32]\ /// \n TableScan: foo_csv projection=None [id:Int32]", /// display_string); /// ``` @@ -939,7 +939,7 @@ mod tests { let plan = display_plan(); let expected = "Projection: #employee_csv.id\ - \n Filter: #employee_csv.state Eq Utf8(\"CO\")\ + \n Filter: #employee_csv.state = Utf8(\"CO\")\ \n TableScan: employee_csv projection=Some([0, 3])"; assert_eq!(expected, format!("{}", plan.display_indent())); @@ -950,7 +950,7 @@ mod tests { let plan = display_plan(); let expected = "Projection: #employee_csv.id [id:Int32]\ - \n Filter: #employee_csv.state Eq Utf8(\"CO\") [id:Int32, state:Utf8]\ + \n Filter: #employee_csv.state = Utf8(\"CO\") [id:Int32, state:Utf8]\ \n TableScan: employee_csv projection=Some([0, 3]) [id:Int32, state:Utf8]"; assert_eq!(expected, format!("{}", plan.display_indent_schema())); diff --git a/datafusion/src/optimizer/common_subexpr_eliminate.rs b/datafusion/src/optimizer/common_subexpr_eliminate.rs index 75109484ed3..4bda181e5e3 100644 --- a/datafusion/src/optimizer/common_subexpr_eliminate.rs +++ b/datafusion/src/optimizer/common_subexpr_eliminate.rs @@ -714,8 +714,8 @@ mod test { )? .build()?; - let expected = "Aggregate: groupBy=[[]], aggr=[[SUM(#BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a AS test.a Multiply Int32(1) Minus test.b), SUM(#BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a AS test.a Multiply Int32(1) Minus test.b Multiply Int32(1) Plus #test.c)]]\ - \n Projection: #test.a Multiply Int32(1) Minus #test.b AS BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a, #test.a, #test.b, #test.c\ + let expected = "Aggregate: groupBy=[[]], aggr=[[SUM(#BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a AS test.a * Int32(1) - test.b), SUM(#BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a AS test.a * Int32(1) - test.b * Int32(1) + #test.c)]]\ + \n Projection: #test.a * Int32(1) - #test.b AS BinaryExpr-*BinaryExpr--Column-test.bLiteral1Column-test.a, #test.a, #test.b, #test.c\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -737,7 +737,7 @@ mod test { )? .build()?; - let expected = "Aggregate: groupBy=[[]], aggr=[[Int32(1) Plus #AggregateFunction-AVGfalseColumn-test.a AS AVG(test.a), Int32(1) Minus #AggregateFunction-AVGfalseColumn-test.a AS AVG(test.a)]]\ + let expected = "Aggregate: groupBy=[[]], aggr=[[Int32(1) + #AggregateFunction-AVGfalseColumn-test.a AS AVG(test.a), Int32(1) - #AggregateFunction-AVGfalseColumn-test.a AS AVG(test.a)]]\ \n Projection: AVG(#test.a) AS AggregateFunction-AVGfalseColumn-test.a, #test.a, #test.b, #test.c\ \n TableScan: test projection=None"; @@ -757,8 +757,8 @@ mod test { ])? .build()?; - let expected = "Projection: #BinaryExpr-+Column-test.aLiteral1 AS Int32(1) Plus test.a AS first, #BinaryExpr-+Column-test.aLiteral1 AS Int32(1) Plus test.a AS second\ - \n Projection: Int32(1) Plus #test.a AS BinaryExpr-+Column-test.aLiteral1, #test.a, #test.b, #test.c\ + let expected = "Projection: #BinaryExpr-+Column-test.aLiteral1 AS Int32(1) + test.a AS first, #BinaryExpr-+Column-test.aLiteral1 AS Int32(1) + test.a AS second\ + \n Projection: Int32(1) + #test.a AS BinaryExpr-+Column-test.aLiteral1, #test.a, #test.b, #test.c\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -777,7 +777,7 @@ mod test { ])? .build()?; - let expected = "Projection: Int32(1) Plus #test.a, #test.a Plus Int32(1)\ + let expected = "Projection: Int32(1) + #test.a, #test.a + Int32(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -794,8 +794,8 @@ mod test { .project(vec![binary_expr(lit(1), Operator::Plus, col("a"))])? .build()?; - let expected = "Projection: #Int32(1) Plus test.a\ - \n Projection: Int32(1) Plus #test.a\ + let expected = "Projection: #Int32(1) + test.a\ + \n Projection: Int32(1) + #test.a\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); diff --git a/datafusion/src/optimizer/constant_folding.rs b/datafusion/src/optimizer/constant_folding.rs index 31b0b7f9e19..4d8f06fb284 100644 --- a/datafusion/src/optimizer/constant_folding.rs +++ b/datafusion/src/optimizer/constant_folding.rs @@ -592,7 +592,7 @@ mod tests { let expected = "\ Projection: #test.a\ - \n Filter: NOT #test.b And #test.c\ + \n Filter: NOT #test.b AND #test.c\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -609,7 +609,7 @@ mod tests { let expected = "\ Projection: #test.a\ - \n Filter: NOT #test.b Or NOT #test.c\ + \n Filter: NOT #test.b OR NOT #test.c\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); diff --git a/datafusion/src/optimizer/filter_push_down.rs b/datafusion/src/optimizer/filter_push_down.rs index 594e37194b2..7fc65409233 100644 --- a/datafusion/src/optimizer/filter_push_down.rs +++ b/datafusion/src/optimizer/filter_push_down.rs @@ -573,7 +573,7 @@ mod tests { // filter is before projection let expected = "\ Projection: #test.a, #test.b\ - \n Filter: #test.a Eq Int64(1)\ + \n Filter: #test.a = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -589,7 +589,7 @@ mod tests { .build()?; // filter is before single projection let expected = "\ - Filter: #test.a Eq Int64(1)\ + Filter: #test.a = Int64(1)\ \n Limit: 10\ \n Projection: #test.a, #test.b\ \n TableScan: test projection=None"; @@ -604,7 +604,7 @@ mod tests { .filter(lit(0i64).eq(lit(1i64)))? .build()?; let expected = "\ - Filter: Int64(0) Eq Int64(1)\ + Filter: Int64(0) = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -622,7 +622,7 @@ mod tests { let expected = "\ Projection: #test.c, #test.b\ \n Projection: #test.a, #test.b, #test.c\ - \n Filter: #test.a Eq Int64(1)\ + \n Filter: #test.a = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -638,7 +638,7 @@ mod tests { // filter of key aggregation is commutative let expected = "\ Aggregate: groupBy=[[#test.a]], aggr=[[SUM(#test.b) AS total_salary]]\ - \n Filter: #test.a Gt Int64(10)\ + \n Filter: #test.a > Int64(10)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -653,7 +653,7 @@ mod tests { .build()?; // filter of aggregate is after aggregation since they are non-commutative let expected = "\ - Filter: #b Gt Int64(10)\ + Filter: #b > Int64(10)\ \n Aggregate: groupBy=[[#test.a]], aggr=[[SUM(#test.b) AS b]]\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -671,7 +671,7 @@ mod tests { // filter is before projection let expected = "\ Projection: #test.a AS b, #test.c\ - \n Filter: #test.a Eq Int64(1)\ + \n Filter: #test.a = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -709,15 +709,15 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #b Eq Int64(1)\ - \n Projection: #test.a Multiply Int32(2) Plus #test.c AS b, #test.c\ + Filter: #b = Int64(1)\ + \n Projection: #test.a * Int32(2) + #test.c AS b, #test.c\ \n TableScan: test projection=None" ); // filter is before projection let expected = "\ - Projection: #test.a Multiply Int32(2) Plus #test.c AS b, #test.c\ - \n Filter: #test.a Multiply Int32(2) Plus #test.c Eq Int64(1)\ + Projection: #test.a * Int32(2) + #test.c AS b, #test.c\ + \n Filter: #test.a * Int32(2) + #test.c = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -741,17 +741,17 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #a Eq Int64(1)\ - \n Projection: #b Multiply Int32(3) AS a, #test.c\ - \n Projection: #test.a Multiply Int32(2) Plus #test.c AS b, #test.c\ + Filter: #a = Int64(1)\ + \n Projection: #b * Int32(3) AS a, #test.c\ + \n Projection: #test.a * Int32(2) + #test.c AS b, #test.c\ \n TableScan: test projection=None" ); // filter is before the projections let expected = "\ - Projection: #b Multiply Int32(3) AS a, #test.c\ - \n Projection: #test.a Multiply Int32(2) Plus #test.c AS b, #test.c\ - \n Filter: #test.a Multiply Int32(2) Plus #test.c Multiply Int32(3) Eq Int64(1)\ + Projection: #b * Int32(3) AS a, #test.c\ + \n Projection: #test.a * Int32(2) + #test.c AS b, #test.c\ + \n Filter: #test.a * Int32(2) + #test.c * Int32(3) = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -774,8 +774,8 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #SUM(test.c) Gt Int64(10)\ - \n Filter: #b Gt Int64(10)\ + Filter: #SUM(test.c) > Int64(10)\ + \n Filter: #b > Int64(10)\ \n Aggregate: groupBy=[[#b]], aggr=[[SUM(#test.c)]]\ \n Projection: #test.a AS b, #test.c\ \n TableScan: test projection=None" @@ -783,10 +783,10 @@ mod tests { // filter is before the projections let expected = "\ - Filter: #SUM(test.c) Gt Int64(10)\ + Filter: #SUM(test.c) > Int64(10)\ \n Aggregate: groupBy=[[#b]], aggr=[[SUM(#test.c)]]\ \n Projection: #test.a AS b, #test.c\ - \n Filter: #test.a Gt Int64(10)\ + \n Filter: #test.a > Int64(10)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -812,7 +812,7 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #SUM(test.c) Gt Int64(10) And #b Gt Int64(10) And #SUM(test.c) Lt Int64(20)\ + Filter: #SUM(test.c) > Int64(10) AND #b > Int64(10) AND #SUM(test.c) < Int64(20)\ \n Aggregate: groupBy=[[#b]], aggr=[[SUM(#test.c)]]\ \n Projection: #test.a AS b, #test.c\ \n TableScan: test projection=None" @@ -820,10 +820,10 @@ mod tests { // filter is before the projections let expected = "\ - Filter: #SUM(test.c) Gt Int64(10) And #SUM(test.c) Lt Int64(20)\ + Filter: #SUM(test.c) > Int64(10) AND #SUM(test.c) < Int64(20)\ \n Aggregate: groupBy=[[#b]], aggr=[[SUM(#test.c)]]\ \n Projection: #test.a AS b, #test.c\ - \n Filter: #test.a Gt Int64(10)\ + \n Filter: #test.a > Int64(10)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -844,7 +844,7 @@ mod tests { // filter does not just any of the limits let expected = "\ Projection: #test.a, #test.b\ - \n Filter: #test.a Eq Int64(1)\ + \n Filter: #test.a = Int64(1)\ \n Limit: 10\ \n Limit: 20\ \n Projection: #test.a, #test.b\ @@ -863,9 +863,9 @@ mod tests { // filter appears below Union let expected = "\ Union\ - \n Filter: #a Eq Int64(1)\ + \n Filter: #a = Int64(1)\ \n TableScan: test projection=None\ - \n Filter: #a Eq Int64(1)\ + \n Filter: #a = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -887,20 +887,20 @@ mod tests { // not part of the test assert_eq!( format!("{:?}", plan), - "Filter: #test.a GtEq Int64(1)\ + "Filter: #test.a >= Int64(1)\ \n Projection: #test.a\ \n Limit: 1\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n Projection: #test.a\ \n TableScan: test projection=None" ); let expected = "\ Projection: #test.a\ - \n Filter: #test.a GtEq Int64(1)\ + \n Filter: #test.a >= Int64(1)\ \n Limit: 1\ \n Projection: #test.a\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); @@ -922,15 +922,15 @@ mod tests { assert_eq!( format!("{:?}", plan), "Projection: #test.a\ - \n Filter: #test.a GtEq Int64(1)\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a >= Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n Limit: 1\ \n TableScan: test projection=None" ); let expected = "\ Projection: #test.a\ - \n Filter: #test.a GtEq Int64(1) And #test.a LtEq Int64(1)\ + \n Filter: #test.a >= Int64(1) AND #test.a <= Int64(1)\ \n Limit: 1\ \n TableScan: test projection=None"; @@ -951,7 +951,7 @@ mod tests { let expected = "\ TestUserDefined\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n TableScan: test projection=None"; // not part of the test @@ -983,7 +983,7 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #test.a LtEq Int64(1)\ + Filter: #test.a <= Int64(1)\ \n Join: #test.a = #test2.a\ \n TableScan: test projection=None\ \n Projection: #test2.a\ @@ -993,10 +993,10 @@ mod tests { // filter sent to side before the join let expected = "\ Join: #test.a = #test2.a\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n TableScan: test projection=None\ \n Projection: #test2.a\ - \n Filter: #test2.a LtEq Int64(1)\ + \n Filter: #test2.a <= Int64(1)\ \n TableScan: test2 projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -1024,7 +1024,7 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #test.a LtEq Int64(1)\ + Filter: #test.a <= Int64(1)\ \n Join: Using #test.a = #test2.a\ \n TableScan: test projection=None\ \n Projection: #test2.a\ @@ -1034,10 +1034,10 @@ mod tests { // filter sent to side before the join let expected = "\ Join: Using #test.a = #test2.a\ - \n Filter: #test.a LtEq Int64(1)\ + \n Filter: #test.a <= Int64(1)\ \n TableScan: test projection=None\ \n Projection: #test2.a\ - \n Filter: #test2.a LtEq Int64(1)\ + \n Filter: #test2.a <= Int64(1)\ \n TableScan: test2 projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) @@ -1068,7 +1068,7 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #test.c LtEq #test2.b\ + Filter: #test.c <= #test2.b\ \n Join: #test.a = #test2.a\ \n Projection: #test.a, #test.c\ \n TableScan: test projection=None\ @@ -1107,7 +1107,7 @@ mod tests { assert_eq!( format!("{:?}", plan), "\ - Filter: #test.b LtEq Int64(1)\ + Filter: #test.b <= Int64(1)\ \n Join: #test.a = #test2.a\ \n Projection: #test.a, #test.b\ \n TableScan: test projection=None\ @@ -1118,7 +1118,7 @@ mod tests { let expected = "\ Join: #test.a = #test2.a\ \n Projection: #test.a, #test.b\ - \n Filter: #test.b LtEq Int64(1)\ + \n Filter: #test.b <= Int64(1)\ \n TableScan: test projection=None\ \n Projection: #test2.a, #test2.c\ \n TableScan: test2 projection=None"; @@ -1192,7 +1192,7 @@ mod tests { let plan = table_scan_with_pushdown_provider(TableProviderFilterPushDown::Exact)?; let expected = "\ - TableScan: test projection=None, filters=[#a Eq Int64(1)]"; + TableScan: test projection=None, filters=[#a = Int64(1)]"; assert_optimized_plan_eq(&plan, expected); Ok(()) } @@ -1203,8 +1203,8 @@ mod tests { table_scan_with_pushdown_provider(TableProviderFilterPushDown::Inexact)?; let expected = "\ - Filter: #a Eq Int64(1)\ - \n TableScan: test projection=None, filters=[#a Eq Int64(1)]"; + Filter: #a = Int64(1)\ + \n TableScan: test projection=None, filters=[#a = Int64(1)]"; assert_optimized_plan_eq(&plan, expected); Ok(()) } @@ -1217,8 +1217,8 @@ mod tests { let optimised_plan = optimize_plan(&plan); let expected = "\ - Filter: #a Eq Int64(1)\ - \n TableScan: test projection=None, filters=[#a Eq Int64(1)]"; + Filter: #a = Int64(1)\ + \n TableScan: test projection=None, filters=[#a = Int64(1)]"; // Optimizing the same plan multiple times should produce the same plan // each time. @@ -1232,7 +1232,7 @@ mod tests { table_scan_with_pushdown_provider(TableProviderFilterPushDown::Unsupported)?; let expected = "\ - Filter: #a Eq Int64(1)\ + Filter: #a = Int64(1)\ \n TableScan: test projection=None"; assert_optimized_plan_eq(&plan, expected); Ok(()) diff --git a/datafusion/src/optimizer/projection_push_down.rs b/datafusion/src/optimizer/projection_push_down.rs index 7dddbffa264..927e3cb8430 100644 --- a/datafusion/src/optimizer/projection_push_down.rs +++ b/datafusion/src/optimizer/projection_push_down.rs @@ -561,9 +561,9 @@ mod tests { .project(vec![col("a"), col("c"), col("b")])? .build()?; let expected = "Projection: #test.a, #test.c, #test.b\ - \n Filter: #test.a Gt Int32(1)\ - \n Filter: #test.b Gt Int32(1)\ - \n Filter: #test.c Gt Int32(1)\ + \n Filter: #test.a > Int32(1)\ + \n Filter: #test.b > Int32(1)\ + \n Filter: #test.c > Int32(1)\ \n TableScan: test projection=Some([0, 1, 2])"; assert_optimized_plan_eq(&plan, expected); @@ -818,7 +818,7 @@ mod tests { let expected = "\ Aggregate: groupBy=[[#test.c]], aggr=[[MAX(#test.a)]]\ - \n Filter: #test.c Gt Int32(1)\ + \n Filter: #test.c > Int32(1)\ \n Projection: #test.c, #test.a\ \n TableScan: test projection=Some([0, 2])"; @@ -888,7 +888,7 @@ mod tests { assert_fields_eq(&plan, vec!["c", "a", "MAX(test.b)"]); let expected = "Projection: #test.c, #test.a, #MAX(test.b)\ - \n Filter: #test.c Gt Int32(1)\ + \n Filter: #test.c > Int32(1)\ \n Aggregate: groupBy=[[#test.a, #test.c]], aggr=[[MAX(#test.b)]]\ \n TableScan: test projection=Some([0, 1, 2])"; diff --git a/datafusion/src/optimizer/simplify_expressions.rs b/datafusion/src/optimizer/simplify_expressions.rs index f629eaf95b5..5a2e856c8af 100644 --- a/datafusion/src/optimizer/simplify_expressions.rs +++ b/datafusion/src/optimizer/simplify_expressions.rs @@ -491,7 +491,7 @@ mod tests { assert_optimized_plan_eq( &plan, "\ - Filter: #test.b Gt Int32(1)\ + Filter: #test.b > Int32(1)\ \n Projection: #test.a\ \n TableScan: test projection=None", ); @@ -513,7 +513,7 @@ mod tests { assert_optimized_plan_eq( &plan, "\ - Filter: #test.a Gt Int32(5) And #test.b Lt Int32(6)\ + Filter: #test.a > Int32(5) AND #test.b < Int32(6)\ \n Projection: #test.a\ \n TableScan: test projection=None", ); diff --git a/datafusion/src/physical_optimizer/pruning.rs b/datafusion/src/physical_optimizer/pruning.rs index 2a10cfa5c9b..29a196df1c1 100644 --- a/datafusion/src/physical_optimizer/pruning.rs +++ b/datafusion/src/physical_optimizer/pruning.rs @@ -1020,7 +1020,7 @@ mod tests { #[test] fn row_group_predicate_eq() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_min LtEq Int32(1) And Int32(1) LtEq #c1_max"; + let expected_expr = "#c1_min <= Int32(1) AND Int32(1) <= #c1_max"; // test column on the left let expr = col("c1").eq(lit(1)); @@ -1040,7 +1040,7 @@ mod tests { #[test] fn row_group_predicate_not_eq() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_min NotEq Int32(1) Or Int32(1) NotEq #c1_max"; + let expected_expr = "#c1_min != Int32(1) OR Int32(1) != #c1_max"; // test column on the left let expr = col("c1").not_eq(lit(1)); @@ -1060,7 +1060,7 @@ mod tests { #[test] fn row_group_predicate_gt() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_max Gt Int32(1)"; + let expected_expr = "#c1_max > Int32(1)"; // test column on the left let expr = col("c1").gt(lit(1)); @@ -1080,7 +1080,7 @@ mod tests { #[test] fn row_group_predicate_gt_eq() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_max GtEq Int32(1)"; + let expected_expr = "#c1_max >= Int32(1)"; // test column on the left let expr = col("c1").gt_eq(lit(1)); @@ -1099,7 +1099,7 @@ mod tests { #[test] fn row_group_predicate_lt() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_min Lt Int32(1)"; + let expected_expr = "#c1_min < Int32(1)"; // test column on the left let expr = col("c1").lt(lit(1)); @@ -1119,7 +1119,7 @@ mod tests { #[test] fn row_group_predicate_lt_eq() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]); - let expected_expr = "#c1_min LtEq Int32(1)"; + let expected_expr = "#c1_min <= Int32(1)"; // test column on the left let expr = col("c1").lt_eq(lit(1)); @@ -1144,7 +1144,7 @@ mod tests { ]); // test AND operator joining supported c1 < 1 expression and unsupported c2 > c3 expression let expr = col("c1").lt(lit(1)).and(col("c2").lt(col("c3"))); - let expected_expr = "#c1_min Lt Int32(1) And Boolean(true)"; + let expected_expr = "#c1_min < Int32(1) AND Boolean(true)"; let predicate_expr = build_predicate_expression(&expr, &schema, &mut RequiredStatColumns::new())?; assert_eq!(format!("{:?}", predicate_expr), expected_expr); @@ -1160,7 +1160,7 @@ mod tests { ]); // test OR operator joining supported c1 < 1 expression and unsupported c2 % 2 expression let expr = col("c1").lt(lit(1)).or(col("c2").modulus(lit(2))); - let expected_expr = "#c1_min Lt Int32(1) Or Boolean(true)"; + let expected_expr = "#c1_min < Int32(1) OR Boolean(true)"; let predicate_expr = build_predicate_expression(&expr, &schema, &mut RequiredStatColumns::new())?; assert_eq!(format!("{:?}", predicate_expr), expected_expr); @@ -1184,7 +1184,7 @@ mod tests { #[test] fn row_group_predicate_not_bool() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Boolean, false)]); - let expected_expr = "NOT #c1_min And #c1_max"; + let expected_expr = "NOT #c1_min AND #c1_max"; let expr = col("c1").not(); let predicate_expr = @@ -1197,7 +1197,7 @@ mod tests { #[test] fn row_group_predicate_bool() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Boolean, false)]); - let expected_expr = "#c1_min Or #c1_max"; + let expected_expr = "#c1_min OR #c1_max"; let expr = col("c1"); let predicate_expr = @@ -1210,7 +1210,7 @@ mod tests { #[test] fn row_group_predicate_lt_bool() -> Result<()> { let schema = Schema::new(vec![Field::new("c1", DataType::Boolean, false)]); - let expected_expr = "#c1_min Lt Boolean(true)"; + let expected_expr = "#c1_min < Boolean(true)"; // DF doesn't support arithmetic on boolean columns so // this predicate will error when evaluated @@ -1233,7 +1233,7 @@ mod tests { let expr = col("c1") .lt(lit(1)) .and(col("c2").eq(lit(2)).or(col("c2").eq(lit(3)))); - let expected_expr = "#c1_min Lt Int32(1) And #c2_min LtEq Int32(2) And Int32(2) LtEq #c2_max Or #c2_min LtEq Int32(3) And Int32(3) LtEq #c2_max"; + let expected_expr = "#c1_min < Int32(1) AND #c2_min <= Int32(2) AND Int32(2) <= #c2_max OR #c2_min <= Int32(3) AND Int32(3) <= #c2_max"; let predicate_expr = build_predicate_expression(&expr, &schema, &mut required_columns)?; assert_eq!(format!("{:?}", predicate_expr), expected_expr); diff --git a/datafusion/src/sql/planner.rs b/datafusion/src/sql/planner.rs index 50c36dde583..f3d1e9eb3aa 100644 --- a/datafusion/src/sql/planner.rs +++ b/datafusion/src/sql/planner.rs @@ -1913,7 +1913,7 @@ mod tests { let sql = "SELECT id, first_name, last_name \ FROM person WHERE state = 'CO'"; let expected = "Projection: #person.id, #person.first_name, #person.last_name\ - \n Filter: #person.state Eq Utf8(\"CO\")\ + \n Filter: #person.state = Utf8(\"CO\")\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -1953,7 +1953,7 @@ mod tests { let sql = "SELECT id, first_name, last_name \ FROM person WHERE state = 'CO' AND age >= 21 AND age <= 65"; let expected = "Projection: #person.id, #person.first_name, #person.last_name\ - \n Filter: #person.state Eq Utf8(\"CO\") And #person.age GtEq Int64(21) And #person.age LtEq Int64(65)\ + \n Filter: #person.state = Utf8(\"CO\") AND #person.age >= Int64(21) AND #person.age <= Int64(65)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -1964,7 +1964,7 @@ mod tests { "SELECT state FROM person WHERE birth_date < CAST (158412331400600000 as timestamp)"; let expected = "Projection: #person.state\ - \n Filter: #person.birth_date Lt CAST(Int64(158412331400600000) AS Timestamp(Nanosecond, None))\ + \n Filter: #person.birth_date < CAST(Int64(158412331400600000) AS Timestamp(Nanosecond, None))\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -1976,7 +1976,7 @@ mod tests { "SELECT state FROM person WHERE birth_date < CAST ('2020-01-01' as date)"; let expected = "Projection: #person.state\ - \n Filter: #person.birth_date Lt CAST(Utf8(\"2020-01-01\") AS Date32)\ + \n Filter: #person.birth_date < CAST(Utf8(\"2020-01-01\") AS Date32)\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -1993,12 +1993,12 @@ mod tests { AND age < 65 \ AND age <= 65"; let expected = "Projection: #person.age, #person.first_name, #person.last_name\ - \n Filter: #person.age Eq Int64(21) \ - And #person.age NotEq Int64(21) \ - And #person.age Gt Int64(21) \ - And #person.age GtEq Int64(21) \ - And #person.age Lt Int64(65) \ - And #person.age LtEq Int64(65)\ + \n Filter: #person.age = Int64(21) \ + AND #person.age != Int64(21) \ + AND #person.age > Int64(21) \ + AND #person.age >= Int64(21) \ + AND #person.age < Int64(65) \ + AND #person.age <= Int64(65)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2051,9 +2051,9 @@ mod tests { WHERE fn1 = 'X' AND age < 30"; let expected = "Projection: #fn1, #person.age\ - \n Filter: #fn1 Eq Utf8(\"X\") And #person.age Lt Int64(30)\ + \n Filter: #fn1 = Utf8(\"X\") AND #person.age < Int64(30)\ \n Projection: #person.first_name AS fn1, #person.age\ - \n Filter: #person.age Gt Int64(20)\ + \n Filter: #person.age > Int64(20)\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2086,7 +2086,7 @@ mod tests { FROM person HAVING age > 100 AND age < 200"; let expected = "Projection: #person.id, #person.age\ - \n Filter: #person.age Gt Int64(100) And #person.age Lt Int64(200)\ + \n Filter: #person.age > Int64(100) AND #person.age < Int64(200)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2133,7 +2133,7 @@ mod tests { FROM person HAVING MAX(age) < 30"; let expected = "Projection: #MAX(person.age)\ - \n Filter: #MAX(person.age) Lt Int64(30)\ + \n Filter: #MAX(person.age) < Int64(30)\ \n Aggregate: groupBy=[[]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2145,7 +2145,7 @@ mod tests { FROM person HAVING MAX(first_name) > 'M'"; let expected = "Projection: #MAX(person.age)\ - \n Filter: #MAX(person.first_name) Gt Utf8(\"M\")\ + \n Filter: #MAX(person.first_name) > Utf8(\"M\")\ \n Aggregate: groupBy=[[]], aggr=[[MAX(#person.age), MAX(#person.first_name)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2170,7 +2170,7 @@ mod tests { HAVING max_age < 30"; // FIXME: add test for having in execution let expected = "Projection: #MAX(person.age) AS max_age\ - \n Filter: #MAX(person.age) Lt Int64(30)\ + \n Filter: #MAX(person.age) < Int64(30)\ \n Aggregate: groupBy=[[]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2182,7 +2182,7 @@ mod tests { FROM person HAVING MAX(age) < 30"; let expected = "Projection: #MAX(person.age) AS max_age\ - \n Filter: #MAX(person.age) Lt Int64(30)\ + \n Filter: #MAX(person.age) < Int64(30)\ \n Aggregate: groupBy=[[]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2195,7 +2195,7 @@ mod tests { GROUP BY first_name HAVING first_name = 'M'"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #person.first_name Eq Utf8(\"M\")\ + \n Filter: #person.first_name = Utf8(\"M\")\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2209,9 +2209,9 @@ mod tests { GROUP BY first_name HAVING MAX(age) < 100"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Lt Int64(100)\ + \n Filter: #MAX(person.age) < Int64(100)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ - \n Filter: #person.id Gt Int64(5)\ + \n Filter: #person.id > Int64(5)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2225,9 +2225,9 @@ mod tests { GROUP BY first_name HAVING MAX(age) < 100"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Lt Int64(100)\ + \n Filter: #MAX(person.age) < Int64(100)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ - \n Filter: #person.id Gt Int64(5) And #person.age Gt Int64(18)\ + \n Filter: #person.id > Int64(5) AND #person.age > Int64(18)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2239,7 +2239,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 2 AND fn = 'M'"; let expected = "Projection: #person.first_name AS fn, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(2) And #person.first_name Eq Utf8(\"M\")\ + \n Filter: #MAX(person.age) > Int64(2) AND #person.first_name = Utf8(\"M\")\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2253,7 +2253,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 2 AND max_age < 5 AND first_name = 'M' AND fn = 'N'"; let expected = "Projection: #person.first_name AS fn, #MAX(person.age) AS max_age\ - \n Filter: #MAX(person.age) Gt Int64(2) And #MAX(person.age) Lt Int64(5) And #person.first_name Eq Utf8(\"M\") And #person.first_name Eq Utf8(\"N\")\ + \n Filter: #MAX(person.age) > Int64(2) AND #MAX(person.age) < Int64(5) AND #person.first_name = Utf8(\"M\") AND #person.first_name = Utf8(\"N\")\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2266,7 +2266,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 100"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(100)\ + \n Filter: #MAX(person.age) > Int64(100)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2292,7 +2292,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 100 AND MAX(age) < 200"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(100) And #MAX(person.age) Lt Int64(200)\ + \n Filter: #MAX(person.age) > Int64(100) AND #MAX(person.age) < Int64(200)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2305,7 +2305,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 100 AND MIN(id) < 50"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(100) And #MIN(person.id) Lt Int64(50)\ + \n Filter: #MAX(person.age) > Int64(100) AND #MIN(person.id) < Int64(50)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age), MIN(#person.id)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2319,7 +2319,7 @@ mod tests { GROUP BY first_name HAVING max_age > 100"; let expected = "Projection: #person.first_name, #MAX(person.age) AS max_age\ - \n Filter: #MAX(person.age) Gt Int64(100)\ + \n Filter: #MAX(person.age) > Int64(100)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2333,8 +2333,8 @@ mod tests { GROUP BY first_name HAVING max_age_plus_one > 100"; let expected = - "Projection: #person.first_name, #MAX(person.age) Plus Int64(1) AS max_age_plus_one\ - \n Filter: #MAX(person.age) Plus Int64(1) Gt Int64(100)\ + "Projection: #person.first_name, #MAX(person.age) + Int64(1) AS max_age_plus_one\ + \n Filter: #MAX(person.age) + Int64(1) > Int64(100)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age)]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2348,8 +2348,8 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 100 AND MIN(id - 2) < 50"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(100) And #MIN(person.id Minus Int64(2)) Lt Int64(50)\ - \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age), MIN(#person.id Minus Int64(2))]]\ + \n Filter: #MAX(person.age) > Int64(100) AND #MIN(person.id - Int64(2)) < Int64(50)\ + \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age), MIN(#person.id - Int64(2))]]\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2361,7 +2361,7 @@ mod tests { GROUP BY first_name HAVING MAX(age) > 100 AND COUNT(*) < 50"; let expected = "Projection: #person.first_name, #MAX(person.age)\ - \n Filter: #MAX(person.age) Gt Int64(100) And #COUNT(UInt8(1)) Lt Int64(50)\ + \n Filter: #MAX(person.age) > Int64(100) AND #COUNT(UInt8(1)) < Int64(50)\ \n Aggregate: groupBy=[[#person.first_name]], aggr=[[MAX(#person.age), COUNT(UInt8(1))]]\ \n TableScan: person projection=None"; quick_test(sql, expected); @@ -2370,7 +2370,7 @@ mod tests { #[test] fn select_binary_expr() { let sql = "SELECT age + salary from person"; - let expected = "Projection: #person.age Plus #person.salary\ + let expected = "Projection: #person.age + #person.salary\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2378,7 +2378,7 @@ mod tests { #[test] fn select_binary_expr_nested() { let sql = "SELECT (age + salary)/2 from person"; - let expected = "Projection: #person.age Plus #person.salary Divide Int64(2)\ + let expected = "Projection: #person.age + #person.salary / Int64(2)\ \n TableScan: person projection=None"; quick_test(sql, expected); } @@ -2627,7 +2627,7 @@ mod tests { quick_test( "SELECT MIN(first_name) FROM person GROUP BY age + 1", "Projection: #MIN(person.first_name)\ - \n Aggregate: groupBy=[[#person.age Plus Int64(1)]], aggr=[[MIN(#person.first_name)]]\ + \n Aggregate: groupBy=[[#person.age + Int64(1)]], aggr=[[MIN(#person.first_name)]]\ \n TableScan: person projection=None", ); } @@ -2637,14 +2637,14 @@ mod tests { ) { quick_test( "SELECT age + 1, MIN(first_name) FROM person GROUP BY age + 1", - "Projection: #person.age Plus Int64(1), #MIN(person.first_name)\ - \n Aggregate: groupBy=[[#person.age Plus Int64(1)]], aggr=[[MIN(#person.first_name)]]\ + "Projection: #person.age + Int64(1), #MIN(person.first_name)\ + \n Aggregate: groupBy=[[#person.age + Int64(1)]], aggr=[[MIN(#person.first_name)]]\ \n TableScan: person projection=None", ); quick_test( "SELECT MIN(first_name), age + 1 FROM person GROUP BY age + 1", - "Projection: #MIN(person.first_name), #person.age Plus Int64(1)\ - \n Aggregate: groupBy=[[#person.age Plus Int64(1)]], aggr=[[MIN(#person.first_name)]]\ + "Projection: #MIN(person.first_name), #person.age + Int64(1)\ + \n Aggregate: groupBy=[[#person.age + Int64(1)]], aggr=[[MIN(#person.first_name)]]\ \n TableScan: person projection=None", ); } @@ -2654,8 +2654,8 @@ mod tests { { quick_test( "SELECT ((age + 1) / 2) * (age + 1), MIN(first_name) FROM person GROUP BY age + 1", - "Projection: #person.age Plus Int64(1) Divide Int64(2) Multiply #person.age Plus Int64(1), #MIN(person.first_name)\ - \n Aggregate: groupBy=[[#person.age Plus Int64(1)]], aggr=[[MIN(#person.first_name)]]\ + "Projection: #person.age + Int64(1) / Int64(2) * #person.age + Int64(1), #MIN(person.first_name)\ + \n Aggregate: groupBy=[[#person.age + Int64(1)]], aggr=[[MIN(#person.first_name)]]\ \n TableScan: person projection=None", ); } @@ -2688,7 +2688,7 @@ mod tests { fn select_simple_aggregate_nested_in_binary_expr_with_groupby() { quick_test( "SELECT state, MIN(age) < 10 FROM person GROUP BY state", - "Projection: #person.state, #MIN(person.age) Lt Int64(10)\ + "Projection: #person.state, #MIN(person.age) < Int64(10)\ \n Aggregate: groupBy=[[#person.state]], aggr=[[MIN(#person.age)]]\ \n TableScan: person projection=None", ); @@ -2698,7 +2698,7 @@ mod tests { fn select_simple_aggregate_and_nested_groupby_column() { quick_test( "SELECT age + 1, MAX(first_name) FROM person GROUP BY age", - "Projection: #person.age Plus Int64(1), #MAX(person.first_name)\ + "Projection: #person.age + Int64(1), #MAX(person.first_name)\ \n Aggregate: groupBy=[[#person.age]], aggr=[[MAX(#person.first_name)]]\ \n TableScan: person projection=None", ); @@ -2708,7 +2708,7 @@ mod tests { fn select_aggregate_compounded_with_groupby_column() { quick_test( "SELECT age + MIN(salary) FROM person GROUP BY age", - "Projection: #person.age Plus #MIN(person.salary)\ + "Projection: #person.age + #MIN(person.salary)\ \n Aggregate: groupBy=[[#person.age]], aggr=[[MIN(#person.salary)]]\ \n TableScan: person projection=None", ); @@ -2718,8 +2718,8 @@ mod tests { fn select_aggregate_with_non_column_inner_expression_with_groupby() { quick_test( "SELECT state, MIN(age + 1) FROM person GROUP BY state", - "Projection: #person.state, #MIN(person.age Plus Int64(1))\ - \n Aggregate: groupBy=[[#person.state]], aggr=[[MIN(#person.age Plus Int64(1))]]\ + "Projection: #person.state, #MIN(person.age + Int64(1))\ + \n Aggregate: groupBy=[[#person.state]], aggr=[[MIN(#person.age + Int64(1))]]\ \n TableScan: person projection=None", ); } @@ -2771,8 +2771,8 @@ mod tests { fn select_where_nullif_division() { let sql = "SELECT c3/(c4+c5) \ FROM aggregate_test_100 WHERE c3/nullif(c4+c5, 0) > 0.1"; - let expected = "Projection: #aggregate_test_100.c3 Divide #aggregate_test_100.c4 Plus #aggregate_test_100.c5\ - \n Filter: #aggregate_test_100.c3 Divide nullif(#aggregate_test_100.c4 Plus #aggregate_test_100.c5, Int64(0)) Gt Float64(0.1)\ + let expected = "Projection: #aggregate_test_100.c3 / #aggregate_test_100.c4 + #aggregate_test_100.c5\ + \n Filter: #aggregate_test_100.c3 / nullif(#aggregate_test_100.c4 + #aggregate_test_100.c5, Int64(0)) > Float64(0.1)\ \n TableScan: aggregate_test_100 projection=None"; quick_test(sql, expected); } @@ -2781,7 +2781,7 @@ mod tests { fn select_where_with_negative_operator() { let sql = "SELECT c3 FROM aggregate_test_100 WHERE c3 > -0.1 AND -c4 > 0"; let expected = "Projection: #aggregate_test_100.c3\ - \n Filter: #aggregate_test_100.c3 Gt Float64(-0.1) And (- #aggregate_test_100.c4) Gt Int64(0)\ + \n Filter: #aggregate_test_100.c3 > Float64(-0.1) AND (- #aggregate_test_100.c4) > Int64(0)\ \n TableScan: aggregate_test_100 projection=None"; quick_test(sql, expected); } @@ -2790,7 +2790,7 @@ mod tests { fn select_where_with_positive_operator() { let sql = "SELECT c3 FROM aggregate_test_100 WHERE c3 > +0.1 AND +c4 > 0"; let expected = "Projection: #aggregate_test_100.c3\ - \n Filter: #aggregate_test_100.c3 Gt Float64(0.1) And #aggregate_test_100.c4 Gt Int64(0)\ + \n Filter: #aggregate_test_100.c3 > Float64(0.1) AND #aggregate_test_100.c4 > Int64(0)\ \n TableScan: aggregate_test_100 projection=None"; quick_test(sql, expected); } @@ -2945,7 +2945,7 @@ mod tests { JOIN orders \ ON id = customer_id AND order_id > 1 "; let expected = "Projection: #person.id, #orders.order_id\ - \n Filter: #orders.order_id Gt Int64(1)\ + \n Filter: #orders.order_id > Int64(1)\ \n Join: #person.id = #orders.customer_id\ \n TableScan: person projection=None\ \n TableScan: orders projection=None"; @@ -2961,7 +2961,7 @@ mod tests { let expected = "Projection: #person.id, #orders.order_id\ \n Join: #person.id = #orders.customer_id\ \n TableScan: person projection=None\ - \n Filter: #orders.order_id Gt Int64(1)\ + \n Filter: #orders.order_id > Int64(1)\ \n TableScan: orders projection=None"; quick_test(sql, expected); } @@ -2974,7 +2974,7 @@ mod tests { ON id = customer_id AND id > 1"; let expected = "Projection: #person.id, #orders.order_id\ \n Join: #person.id = #orders.customer_id\ - \n Filter: #person.id Gt Int64(1)\ + \n Filter: #person.id > Int64(1)\ \n TableScan: person projection=None\ \n TableScan: orders projection=None"; quick_test(sql, expected); @@ -3041,7 +3041,7 @@ mod tests { FROM orders \ WHERE delivered = false OR delivered = true"; let expected = "Projection: #orders.order_id\ - \n Filter: #orders.delivered Eq Boolean(false) Or #orders.delivered Eq Boolean(true)\ + \n Filter: #orders.delivered = Boolean(false) OR #orders.delivered = Boolean(true)\ \n TableScan: orders projection=None"; quick_test(sql, expected); } @@ -3130,8 +3130,8 @@ mod tests { fn empty_over_plus() { let sql = "SELECT order_id, MAX(qty * 1.1) OVER () from orders"; let expected = "\ - Projection: #orders.order_id, #MAX(orders.qty Multiply Float64(1.1))\ - \n WindowAggr: windowExpr=[[MAX(#orders.qty Multiply Float64(1.1))]]\ + Projection: #orders.order_id, #MAX(orders.qty * Float64(1.1))\ + \n WindowAggr: windowExpr=[[MAX(#orders.qty * Float64(1.1))]]\ \n TableScan: orders projection=None"; quick_test(sql, expected); } @@ -3270,9 +3270,9 @@ mod tests { fn over_order_by_two_sort_keys() { let sql = "SELECT order_id, MAX(qty) OVER (ORDER BY order_id), MIN(qty) OVER (ORDER BY (order_id + 1)) from orders"; let expected = "\ - Projection: #orders.order_id, #MAX(orders.qty) ORDER BY [#orders.order_id ASC NULLS FIRST], #MIN(orders.qty) ORDER BY [#orders.order_id Plus Int64(1) ASC NULLS FIRST]\ + Projection: #orders.order_id, #MAX(orders.qty) ORDER BY [#orders.order_id ASC NULLS FIRST], #MIN(orders.qty) ORDER BY [#orders.order_id + Int64(1) ASC NULLS FIRST]\ \n WindowAggr: windowExpr=[[MAX(#orders.qty) ORDER BY [#orders.order_id ASC NULLS FIRST]]]\ - \n WindowAggr: windowExpr=[[MIN(#orders.qty) ORDER BY [#orders.order_id Plus Int64(1) ASC NULLS FIRST]]]\ + \n WindowAggr: windowExpr=[[MIN(#orders.qty) ORDER BY [#orders.order_id + Int64(1) ASC NULLS FIRST]]]\ \n TableScan: orders projection=None"; quick_test(sql, expected); } diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index a67c82b5232..55f719bd365 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -1867,7 +1867,7 @@ async fn equijoin_and_unsupported_condition() -> Result<()> { let res = ctx.create_logical_plan(sql); assert!(res.is_err()); - assert_eq!(format!("{}", res.unwrap_err()), "This feature is not implemented: Unsupported expressions in Left JOIN: [#t1_id GtEq Utf8(\"44\")]"); + assert_eq!(format!("{}", res.unwrap_err()), "This feature is not implemented: Unsupported expressions in Left JOIN: [#t1_id >= Utf8(\"44\")]"); Ok(()) } @@ -2271,7 +2271,7 @@ async fn csv_explain() { vec![ "logical_plan", "Projection: #aggregate_test_100.c1\ - \n Filter: #aggregate_test_100.c2 Gt Int64(10)\ + \n Filter: #aggregate_test_100.c2 > Int64(10)\ \n TableScan: aggregate_test_100 projection=Some([0, 1])" ], vec!["physical_plan", @@ -2507,7 +2507,7 @@ async fn csv_explain_plans() { let expected = vec![ "Explain [plan_type:Utf8, plan:Utf8]", " Projection: #aggregate_test_100.c1 [c1:Utf8]", - " Filter: #aggregate_test_100.c2 Gt Int64(10) [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", + " Filter: #aggregate_test_100.c2 > Int64(10) [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", " TableScan: aggregate_test_100 projection=None [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", ]; let formatted = plan.display_indent_schema().to_string(); @@ -2522,7 +2522,7 @@ async fn csv_explain_plans() { let expected = vec![ "Explain", " Projection: #aggregate_test_100.c1", - " Filter: #aggregate_test_100.c2 Gt Int64(10)", + " Filter: #aggregate_test_100.c2 > Int64(10)", " TableScan: aggregate_test_100 projection=None", ]; let formatted = plan.display_indent().to_string(); @@ -2543,7 +2543,7 @@ async fn csv_explain_plans() { " 2[shape=box label=\"Explain\"]", " 3[shape=box label=\"Projection: #aggregate_test_100.c1\"]", " 2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]", - " 4[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\"]", + " 4[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\"]", " 3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]", " 5[shape=box label=\"TableScan: aggregate_test_100 projection=None\"]", " 4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2554,7 +2554,7 @@ async fn csv_explain_plans() { " 7[shape=box label=\"Explain\\nSchema: [plan_type:Utf8, plan:Utf8]\"]", " 8[shape=box label=\"Projection: #aggregate_test_100.c1\\nSchema: [c1:Utf8]\"]", " 7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]", - " 9[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", + " 9[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", " 8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]", " 10[shape=box label=\"TableScan: aggregate_test_100 projection=None\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", " 9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2582,7 +2582,7 @@ async fn csv_explain_plans() { let expected = vec![ "Explain [plan_type:Utf8, plan:Utf8]", " Projection: #aggregate_test_100.c1 [c1:Utf8]", - " Filter: #aggregate_test_100.c2 Gt Int64(10) [c1:Utf8, c2:Int32]", + " Filter: #aggregate_test_100.c2 > Int64(10) [c1:Utf8, c2:Int32]", " TableScan: aggregate_test_100 projection=Some([0, 1]) [c1:Utf8, c2:Int32]", ]; let formatted = plan.display_indent_schema().to_string(); @@ -2597,7 +2597,7 @@ async fn csv_explain_plans() { let expected = vec![ "Explain", " Projection: #aggregate_test_100.c1", - " Filter: #aggregate_test_100.c2 Gt Int64(10)", + " Filter: #aggregate_test_100.c2 > Int64(10)", " TableScan: aggregate_test_100 projection=Some([0, 1])", ]; let formatted = plan.display_indent().to_string(); @@ -2618,7 +2618,7 @@ async fn csv_explain_plans() { " 2[shape=box label=\"Explain\"]", " 3[shape=box label=\"Projection: #aggregate_test_100.c1\"]", " 2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]", - " 4[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\"]", + " 4[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\"]", " 3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]", " 5[shape=box label=\"TableScan: aggregate_test_100 projection=Some([0, 1])\"]", " 4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2629,7 +2629,7 @@ async fn csv_explain_plans() { " 7[shape=box label=\"Explain\\nSchema: [plan_type:Utf8, plan:Utf8]\"]", " 8[shape=box label=\"Projection: #aggregate_test_100.c1\\nSchema: [c1:Utf8]\"]", " 7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]", - " 9[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\\nSchema: [c1:Utf8, c2:Int32]\"]", + " 9[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\\nSchema: [c1:Utf8, c2:Int32]\"]", " 8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]", " 10[shape=box label=\"TableScan: aggregate_test_100 projection=Some([0, 1])\\nSchema: [c1:Utf8, c2:Int32]\"]", " 9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2659,7 +2659,7 @@ async fn csv_explain_plans() { // Since the plan contains path that are environmentally dependant (e.g. full path of the test file), only verify important content assert_contains!(&actual, "logical_plan"); assert_contains!(&actual, "Projection: #aggregate_test_100.c1"); - assert_contains!(actual, "Filter: #aggregate_test_100.c2 Gt Int64(10)"); + assert_contains!(actual, "Filter: #aggregate_test_100.c2 > Int64(10)"); } #[tokio::test] @@ -2677,7 +2677,7 @@ async fn csv_explain_verbose() { // pain). Instead just check for a few key pieces. assert_contains!(&actual, "logical_plan"); assert_contains!(&actual, "physical_plan"); - assert_contains!(&actual, "#aggregate_test_100.c2 Gt Int64(10)"); + assert_contains!(&actual, "#aggregate_test_100.c2 > Int64(10)"); // ensure the "same text as above" optimization is working assert_contains!(actual, "SAME TEXT AS ABOVE"); @@ -2704,7 +2704,7 @@ async fn csv_explain_verbose_plans() { let expected = vec![ "Explain [plan_type:Utf8, plan:Utf8]", " Projection: #aggregate_test_100.c1 [c1:Utf8]", - " Filter: #aggregate_test_100.c2 Gt Int64(10) [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", + " Filter: #aggregate_test_100.c2 > Int64(10) [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", " TableScan: aggregate_test_100 projection=None [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]", ]; let formatted = plan.display_indent_schema().to_string(); @@ -2719,7 +2719,7 @@ async fn csv_explain_verbose_plans() { let expected = vec![ "Explain", " Projection: #aggregate_test_100.c1", - " Filter: #aggregate_test_100.c2 Gt Int64(10)", + " Filter: #aggregate_test_100.c2 > Int64(10)", " TableScan: aggregate_test_100 projection=None", ]; let formatted = plan.display_indent().to_string(); @@ -2740,7 +2740,7 @@ async fn csv_explain_verbose_plans() { " 2[shape=box label=\"Explain\"]", " 3[shape=box label=\"Projection: #aggregate_test_100.c1\"]", " 2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]", - " 4[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\"]", + " 4[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\"]", " 3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]", " 5[shape=box label=\"TableScan: aggregate_test_100 projection=None\"]", " 4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2751,7 +2751,7 @@ async fn csv_explain_verbose_plans() { " 7[shape=box label=\"Explain\\nSchema: [plan_type:Utf8, plan:Utf8]\"]", " 8[shape=box label=\"Projection: #aggregate_test_100.c1\\nSchema: [c1:Utf8]\"]", " 7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]", - " 9[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", + " 9[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", " 8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]", " 10[shape=box label=\"TableScan: aggregate_test_100 projection=None\\nSchema: [c1:Utf8, c2:Int32, c3:Int16, c4:Int16, c5:Int32, c6:Int64, c7:Int16, c8:Int32, c9:Int64, c10:Utf8, c11:Float32, c12:Float64, c13:Utf8]\"]", " 9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2779,7 +2779,7 @@ async fn csv_explain_verbose_plans() { let expected = vec![ "Explain [plan_type:Utf8, plan:Utf8]", " Projection: #aggregate_test_100.c1 [c1:Utf8]", - " Filter: #aggregate_test_100.c2 Gt Int64(10) [c1:Utf8, c2:Int32]", + " Filter: #aggregate_test_100.c2 > Int64(10) [c1:Utf8, c2:Int32]", " TableScan: aggregate_test_100 projection=Some([0, 1]) [c1:Utf8, c2:Int32]", ]; let formatted = plan.display_indent_schema().to_string(); @@ -2794,7 +2794,7 @@ async fn csv_explain_verbose_plans() { let expected = vec![ "Explain", " Projection: #aggregate_test_100.c1", - " Filter: #aggregate_test_100.c2 Gt Int64(10)", + " Filter: #aggregate_test_100.c2 > Int64(10)", " TableScan: aggregate_test_100 projection=Some([0, 1])", ]; let formatted = plan.display_indent().to_string(); @@ -2815,7 +2815,7 @@ async fn csv_explain_verbose_plans() { " 2[shape=box label=\"Explain\"]", " 3[shape=box label=\"Projection: #aggregate_test_100.c1\"]", " 2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]", - " 4[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\"]", + " 4[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\"]", " 3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]", " 5[shape=box label=\"TableScan: aggregate_test_100 projection=Some([0, 1])\"]", " 4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]", @@ -2826,7 +2826,7 @@ async fn csv_explain_verbose_plans() { " 7[shape=box label=\"Explain\\nSchema: [plan_type:Utf8, plan:Utf8]\"]", " 8[shape=box label=\"Projection: #aggregate_test_100.c1\\nSchema: [c1:Utf8]\"]", " 7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]", - " 9[shape=box label=\"Filter: #aggregate_test_100.c2 Gt Int64(10)\\nSchema: [c1:Utf8, c2:Int32]\"]", + " 9[shape=box label=\"Filter: #aggregate_test_100.c2 > Int64(10)\\nSchema: [c1:Utf8, c2:Int32]\"]", " 8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]", " 10[shape=box label=\"TableScan: aggregate_test_100 projection=Some([0, 1])\\nSchema: [c1:Utf8, c2:Int32]\"]", " 9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]",