Struct sqlparser::sqlparser::Parser

pub struct Parser { /* fields omitted */ }

SQL Parser

Methods

impl Parser

pub fn new(tokens: Vec<Token>) -> Self

Parse the specified tokens

pub fn parse_sql(sql: String) -> Result<ASTNode, ParserError>

Parse a SQL statement and produce an Abstract Syntax Tree (AST)

pub fn parse(&mut self) -> Result<ASTNode, ParserError>

Parse a new expression

pub fn parse_expr(&mut self, precedence: u8) -> Result<ASTNode, ParserError>

Parse tokens until the precedence changes

pub fn parse_prefix(&mut self) -> Result<ASTNode, ParserError>

Parse an expression prefix

pub fn parse_cast_expression(&mut self) -> Result<ASTNode, ParserError>

Parse a SQL CAST function e.g. CAST(expr AS FLOAT)

pub fn parse_infix(     &mut self,     expr: ASTNode,     precedence: u8 ) -> Result<Option<ASTNode>, ParserError>

Parse an expression infix (typically an operator)

pub fn to_sql_operator(&self, tok: &Token) -> Result<SQLOperator, ParserError>

Convert a token operator to an AST operator

pub fn get_next_precedence(&self) -> Result<u8, ParserError>

Get the precedence of the next token

pub fn get_precedence(&self, tok: &Token) -> Result<u8, ParserError>

Get the precedence of a token

pub fn peek_token(&mut self) -> Option<Token>

Peek at the next token

pub fn next_token(&mut self) -> Option<Token>

Get the next token and increment the token index

pub fn prev_token(&mut self) -> Option<Token>

Get the previous token and decrement the token index

pub fn parse_keyword(&mut self, expected: &'static str) -> bool

Look for an expected keyword and consume it if it exists

pub fn parse_keywords(&mut self, keywords: Vec<&'static str>) -> bool

Look for an expected sequence of keywords and consume them if they exist

pub fn consume_token(&mut self, expected: &Token) -> Result<bool, ParserError>

Consume the next token if it matches the expected token, otherwise return an error

pub fn parse_create(&mut self) -> Result<ASTNode, ParserError>

Parse a SQL CREATE statement

pub fn parse_literal_int(&mut self) -> Result<i64, ParserError>

Parse a literal integer/long

pub fn parse_literal_string(&mut self) -> Result<String, ParserError>

Parse a literal string

pub fn parse_data_type(&mut self) -> Result<SQLType, ParserError>

Parse a SQL datatype (in the context of a CREATE TABLE statement for example)

pub fn parse_precision(&mut self) -> Result<usize, ParserError>

pub fn parse_optional_precision(&mut self) -> Result<Option<usize>, ParserError>

pub fn parse_delete(&mut self) -> Result<ASTNode, ParserError>

pub fn parse_select(&mut self) -> Result<ASTNode, ParserError>

Parse a SELECT statement

pub fn parse_expr_list(&mut self) -> Result<Vec<ASTNode>, ParserError>

Parse a comma-delimited list of SQL expressions

pub fn parse_order_by_expr_list(&mut self) -> Result<Vec<ASTNode>, ParserError>

Parse a comma-delimited list of SQL ORDER BY expressions

pub fn parse_limit(&mut self) -> Result<Option<Box<ASTNode>>, ParserError>

Parse a LIMIT clause