mirrors/datafusion-sqlparse
1
0
Fork 0
mirror of https://github.com/apache/datafusion-sqlparser-rs.git synced 2025-09-09 15:40:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Reduce indentation in parse_prefix()

Browse source
This commit is contained in:
Nickolay Ponomarev 2019-04-27 18:38:12 +03:00
parent f82dc74e38
commit e7949d493c
1 changed files with 73 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

150
src/sqlparser.rs
View file

@ -155,87 +155,83 @@ impl Parser {
/// Parse an expression prefix /// Parse an expression prefix
pub fn parse_prefix(&mut self) -> Result<ASTNode, ParserError> { pub fn parse_prefix(&mut self) -> Result<ASTNode, ParserError> {
match self.next_token() { let tok = self
Some(t) => match t { .next_token()
Token::SQLWord(w) => match w.keyword.as_ref() { .ok_or_else(|| ParserError::ParserError("Unexpected EOF".to_string()))?;
"TRUE" | "FALSE" | "NULL" => { match tok {
self.prev_token(); Token::SQLWord(w) => match w.keyword.as_ref() {
self.parse_sql_value() "TRUE" | "FALSE" | "NULL" => {
}
"CASE" => self.parse_case_expression(),
"CAST" => self.parse_cast_expression(),
"NOT" => {
let p = self.get_precedence(&Token::make_keyword("NOT"))?;
Ok(ASTNode::SQLUnary {
operator: SQLOperator::Not,
expr: Box::new(self.parse_subexpr(p)?),
})
}
// Here `w` is a word, check if it's a part of a multi-part
// identifier, a function call, or a simple identifier:
_ => match self.peek_token() {
Some(Token::LParen) | Some(Token::Period) => {
let mut id_parts: Vec<SQLIdent> = vec![w.as_sql_ident()];
let mut ends_with_wildcard = false;
while self.consume_token(&Token::Period) {
match self.next_token() {
Some(Token::SQLWord(w)) => id_parts.push(w.as_sql_ident()),
Some(Token::Mult) => {
ends_with_wildcard = true;
break;
}
unexpected => {
return self.expected(
"an identifier or a '*' after '.'",
unexpected,
);
}
}
}
if ends_with_wildcard {
Ok(ASTNode::SQLQualifiedWildcard(id_parts))
} else if self.consume_token(&Token::LParen) {
self.prev_token();
self.parse_function(SQLObjectName(id_parts))
} else {
Ok(ASTNode::SQLCompoundIdentifier(id_parts))
}
}
_ => Ok(ASTNode::SQLIdentifier(w.as_sql_ident())),
},
}, // End of Token::SQLWord
Token::Mult => Ok(ASTNode::SQLWildcard),
tok @ Token::Minus | tok @ Token::Plus => {
let p = self.get_precedence(&tok)?;
let operator = if tok == Token::Plus {
SQLOperator::Plus
} else {
SQLOperator::Minus
};
Ok(ASTNode::SQLUnary {
operator,
expr: Box::new(self.parse_subexpr(p)?),
})
}
Token::Number(_)
| Token::SingleQuotedString(_)
| Token::NationalStringLiteral(_) => {
self.prev_token(); self.prev_token();
self.parse_sql_value() self.parse_sql_value()
} }
Token::LParen => { "CASE" => self.parse_case_expression(),
let expr = if self.parse_keyword("SELECT") || self.parse_keyword("WITH") { "CAST" => self.parse_cast_expression(),
self.prev_token(); "NOT" => {
ASTNode::SQLSubquery(Box::new(self.parse_query()?)) let p = self.get_precedence(&Token::make_keyword("NOT"))?;
} else { Ok(ASTNode::SQLUnary {
ASTNode::SQLNested(Box::new(self.parse_expr()?)) operator: SQLOperator::Not,
}; expr: Box::new(self.parse_subexpr(p)?),
self.expect_token(&Token::RParen)?; })
Ok(expr)
} }
_ => self.expected("an expression", Some(t)), // Here `w` is a word, check if it's a part of a multi-part
}, // identifier, a function call, or a simple identifier:
None => parser_err!("Prefix parser expected a keyword but hit EOF"), _ => match self.peek_token() {
Some(Token::LParen) | Some(Token::Period) => {
let mut id_parts: Vec<SQLIdent> = vec![w.as_sql_ident()];
let mut ends_with_wildcard = false;
while self.consume_token(&Token::Period) {
match self.next_token() {
Some(Token::SQLWord(w)) => id_parts.push(w.as_sql_ident()),
Some(Token::Mult) => {
ends_with_wildcard = true;
break;
}
unexpected => {
return self
.expected("an identifier or a '*' after '.'", unexpected);
}
}
}
if ends_with_wildcard {
Ok(ASTNode::SQLQualifiedWildcard(id_parts))
} else if self.consume_token(&Token::LParen) {
self.prev_token();
self.parse_function(SQLObjectName(id_parts))
} else {
Ok(ASTNode::SQLCompoundIdentifier(id_parts))
}
}
_ => Ok(ASTNode::SQLIdentifier(w.as_sql_ident())),
},
}, // End of Token::SQLWord
Token::Mult => Ok(ASTNode::SQLWildcard),
tok @ Token::Minus | tok @ Token::Plus => {
let p = self.get_precedence(&tok)?;
let operator = if tok == Token::Plus {
SQLOperator::Plus
} else {
SQLOperator::Minus
};
Ok(ASTNode::SQLUnary {
operator,
expr: Box::new(self.parse_subexpr(p)?),
})
}
Token::Number(_) | Token::SingleQuotedString(_) | Token::NationalStringLiteral(_) => {
self.prev_token();
self.parse_sql_value()
}
Token::LParen => {
let expr = if self.parse_keyword("SELECT") || self.parse_keyword("WITH") {
self.prev_token();
ASTNode::SQLSubquery(Box::new(self.parse_query()?))
} else {
ASTNode::SQLNested(Box::new(self.parse_expr()?))
};
self.expect_token(&Token::RParen)?;
Ok(expr)
}
unexpected => self.expected("an expression", Some(unexpected)),
} }
} }