mirror of
https://github.com/apache/datafusion-sqlparser-rs.git
synced 2025-07-18 22:04:59 +00:00
Split operators by arity
It is useful downstream to have two separate enums, one for unary operators and one for binary operators, so that the compiler can check exhaustiveness. Otherwise downstream consumers need to manually encode which operators are unary and which operators are binary when matching on an Operator enum.
This commit is contained in:
Nikhil Benesch
parent
9e33cea9b8
commit
ae25dce246
4 changed files with 85 additions and 71 deletions
|
|
@ -169,7 +169,7 @@ fn parse_delete_statement() {
|
|||
#[test]
|
||||
fn parse_where_delete_statement() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
|
||||
let sql = "DELETE FROM foo WHERE name = 5";
|
||||
match verified_stmt(sql) {
|
||||
|
|
@ -288,7 +288,7 @@ fn parse_column_aliases() {
|
|||
ref alias,
|
||||
} = only(&select.projection)
|
||||
{
|
||||
assert_eq!(&SQLOperator::Plus, op);
|
||||
assert_eq!(&SQLBinaryOperator::Plus, op);
|
||||
assert_eq!(&ASTNode::SQLValue(Value::Long(1)), right.as_ref());
|
||||
assert_eq!("newname", alias);
|
||||
} else {
|
||||
|
|
@ -337,7 +337,7 @@ fn parse_select_count_distinct() {
|
|||
&ASTNode::SQLFunction(SQLFunction {
|
||||
name: SQLObjectName(vec!["COUNT".to_string()]),
|
||||
args: vec![ASTNode::SQLUnaryOp {
|
||||
op: SQLOperator::Plus,
|
||||
op: SQLUnaryOperator::Plus,
|
||||
expr: Box::new(ASTNode::SQLIdentifier("x".to_string()))
|
||||
}],
|
||||
over: None,
|
||||
|
|
@ -404,7 +404,7 @@ fn parse_projection_nested_type() {
|
|||
#[test]
|
||||
fn parse_escaped_single_quote_string_predicate() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let sql = "SELECT id, fname, lname FROM customer \
|
||||
WHERE salary <> 'Jim''s salary'";
|
||||
let ast = verified_only_select(sql);
|
||||
|
|
@ -423,7 +423,7 @@ fn parse_escaped_single_quote_string_predicate() {
|
|||
#[test]
|
||||
fn parse_compound_expr_1() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let sql = "a + b * c";
|
||||
assert_eq!(
|
||||
SQLBinaryOp {
|
||||
|
|
@ -442,7 +442,7 @@ fn parse_compound_expr_1() {
|
|||
#[test]
|
||||
fn parse_compound_expr_2() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let sql = "a * b + c";
|
||||
assert_eq!(
|
||||
SQLBinaryOp {
|
||||
|
|
@ -461,17 +461,16 @@ fn parse_compound_expr_2() {
|
|||
#[test]
|
||||
fn parse_unary_math() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
let sql = "- a + - b";
|
||||
assert_eq!(
|
||||
SQLBinaryOp {
|
||||
left: Box::new(SQLUnaryOp {
|
||||
op: Minus,
|
||||
op: SQLUnaryOperator::Minus,
|
||||
expr: Box::new(SQLIdentifier("a".to_string())),
|
||||
}),
|
||||
op: Plus,
|
||||
op: SQLBinaryOperator::Plus,
|
||||
right: Box::new(SQLUnaryOp {
|
||||
op: Minus,
|
||||
op: SQLUnaryOperator::Minus,
|
||||
expr: Box::new(SQLIdentifier("b".to_string())),
|
||||
}),
|
||||
},
|
||||
|
|
@ -505,14 +504,14 @@ fn parse_not_precedence() {
|
|||
// NOT has higher precedence than OR/AND, so the following must parse as (NOT true) OR true
|
||||
let sql = "NOT true OR true";
|
||||
assert_matches!(verified_expr(sql), SQLBinaryOp {
|
||||
op: SQLOperator::Or,
|
||||
op: SQLBinaryOperator::Or,
|
||||
..
|
||||
});
|
||||
|
||||
// But NOT has lower precedence than comparison operators, so the following parses as NOT (a IS NULL)
|
||||
let sql = "NOT a IS NULL";
|
||||
assert_matches!(verified_expr(sql), SQLUnaryOp {
|
||||
op: SQLOperator::Not,
|
||||
op: SQLUnaryOperator::Not,
|
||||
..
|
||||
});
|
||||
|
||||
|
|
@ -521,7 +520,7 @@ fn parse_not_precedence() {
|
|||
assert_eq!(
|
||||
verified_expr(sql),
|
||||
SQLUnaryOp {
|
||||
op: SQLOperator::Not,
|
||||
op: SQLUnaryOperator::Not,
|
||||
expr: Box::new(SQLBetween {
|
||||
expr: Box::new(SQLValue(Value::Long(1))),
|
||||
low: Box::new(SQLValue(Value::Long(1))),
|
||||
|
|
@ -536,10 +535,10 @@ fn parse_not_precedence() {
|
|||
assert_eq!(
|
||||
verified_expr(sql),
|
||||
SQLUnaryOp {
|
||||
op: SQLOperator::Not,
|
||||
op: SQLUnaryOperator::Not,
|
||||
expr: Box::new(SQLBinaryOp {
|
||||
left: Box::new(SQLValue(Value::SingleQuotedString("a".into()))),
|
||||
op: SQLOperator::NotLike,
|
||||
op: SQLBinaryOperator::NotLike,
|
||||
right: Box::new(SQLValue(Value::SingleQuotedString("b".into()))),
|
||||
}),
|
||||
},
|
||||
|
|
@ -550,7 +549,7 @@ fn parse_not_precedence() {
|
|||
assert_eq!(
|
||||
verified_expr(sql),
|
||||
SQLUnaryOp {
|
||||
op: SQLOperator::Not,
|
||||
op: SQLUnaryOperator::Not,
|
||||
expr: Box::new(SQLInList {
|
||||
expr: Box::new(SQLIdentifier("a".into())),
|
||||
list: vec![SQLValue(Value::SingleQuotedString("a".into()))],
|
||||
|
|
@ -572,9 +571,9 @@ fn parse_like() {
|
|||
ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
|
||||
op: if negated {
|
||||
SQLOperator::NotLike
|
||||
SQLBinaryOperator::NotLike
|
||||
} else {
|
||||
SQLOperator::Like
|
||||
SQLBinaryOperator::Like
|
||||
},
|
||||
right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
|
||||
"%a".to_string()
|
||||
|
|
@ -594,9 +593,9 @@ fn parse_like() {
|
|||
ASTNode::SQLIsNull(Box::new(ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
|
||||
op: if negated {
|
||||
SQLOperator::NotLike
|
||||
SQLBinaryOperator::NotLike
|
||||
} else {
|
||||
SQLOperator::Like
|
||||
SQLBinaryOperator::Like
|
||||
},
|
||||
right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
|
||||
"%a".to_string()
|
||||
|
|
@ -672,7 +671,7 @@ fn parse_between() {
|
|||
#[test]
|
||||
fn parse_between_with_expr() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let sql = "SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL";
|
||||
let select = verified_only_select(sql);
|
||||
assert_eq!(
|
||||
|
|
@ -699,14 +698,14 @@ fn parse_between_with_expr() {
|
|||
ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLValue(Value::Long(1))),
|
||||
op: SQLOperator::Eq,
|
||||
op: SQLBinaryOperator::Eq,
|
||||
right: Box::new(ASTNode::SQLValue(Value::Long(1))),
|
||||
}),
|
||||
op: SQLOperator::And,
|
||||
op: SQLBinaryOperator::And,
|
||||
right: Box::new(ASTNode::SQLBetween {
|
||||
expr: Box::new(ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLValue(Value::Long(1))),
|
||||
op: SQLOperator::Plus,
|
||||
op: SQLBinaryOperator::Plus,
|
||||
right: Box::new(ASTNode::SQLIdentifier("x".to_string())),
|
||||
}),
|
||||
low: Box::new(ASTNode::SQLValue(Value::Long(1))),
|
||||
|
|
@ -1365,7 +1364,7 @@ fn parse_delimited_identifiers() {
|
|||
#[test]
|
||||
fn parse_parens() {
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let sql = "(a + b) - (c + d)";
|
||||
assert_eq!(
|
||||
SQLBinaryOp {
|
||||
|
|
@ -1389,7 +1388,7 @@ fn parse_parens() {
|
|||
fn parse_searched_case_expression() {
|
||||
let sql = "SELECT CASE WHEN bar IS NULL THEN 'null' WHEN bar = 0 THEN '=0' WHEN bar >= 0 THEN '>=0' ELSE '<0' END FROM foo";
|
||||
use self::ASTNode::{SQLBinaryOp, SQLCase, SQLIdentifier, SQLIsNull, SQLValue};
|
||||
use self::SQLOperator::*;
|
||||
use self::SQLBinaryOperator::*;
|
||||
let select = verified_only_select(sql);
|
||||
assert_eq!(
|
||||
&SQLCase {
|
||||
|
|
@ -1557,7 +1556,7 @@ fn parse_joins_on() {
|
|||
},
|
||||
join_operator: f(JoinConstraint::On(ASTNode::SQLBinaryOp {
|
||||
left: Box::new(ASTNode::SQLIdentifier("c1".into())),
|
||||
op: SQLOperator::Eq,
|
||||
op: SQLBinaryOperator::Eq,
|
||||
right: Box::new(ASTNode::SQLIdentifier("c2".into())),
|
||||
})),
|
||||
}
|
||||
|
|
@ -1921,7 +1920,7 @@ fn parse_scalar_subqueries() {
|
|||
use self::ASTNode::*;
|
||||
let sql = "(SELECT 1) + (SELECT 2)";
|
||||
assert_matches!(verified_expr(sql), SQLBinaryOp {
|
||||
op: SQLOperator::Plus, ..
|
||||
op: SQLBinaryOperator::Plus, ..
|
||||
//left: box SQLSubquery { .. },
|
||||
//right: box SQLSubquery { .. },
|
||||
});
|
||||
|
|
@ -1941,7 +1940,7 @@ fn parse_exists_subquery() {
|
|||
let select = verified_only_select(sql);
|
||||
assert_eq!(
|
||||
ASTNode::SQLUnaryOp {
|
||||
op: SQLOperator::Not,
|
||||
op: SQLUnaryOperator::Not,
|
||||
expr: Box::new(ASTNode::SQLExists(Box::new(expected_inner))),
|
||||
},
|
||||
select.selection.unwrap(),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue