use super::ast::{
DeallocateTarget, DiscardTarget, ResetTarget, SetScope, SetValue, Statement,
TransactionOptions, UnlistenTarget,
};
use super::lexer::{Token, lex};
pub fn parse(sql: &str) -> Statement {
let tokens = lex(sql);
let mut cur = Cursor::new(&tokens);
parse_statement(&mut cur)
}
struct Cursor<'a> {
tokens: &'a [Token],
pos: usize,
}
impl<'a> Cursor<'a> {
fn new(tokens: &'a [Token]) -> Self {
Self { tokens, pos: 0 }
}
fn peek(&self) -> Option<&'a Token> {
self.tokens.get(self.pos)
}
fn peek_at(&self, offset: usize) -> Option<&'a Token> {
self.tokens.get(self.pos + offset)
}
fn advance(&mut self) -> Option<&'a Token> {
let t = self.tokens.get(self.pos)?;
self.pos += 1;
Some(t)
}
fn eat_word(&mut self, expected: &str) -> bool {
if matches!(self.peek(), Some(Token::Word(w)) if w == expected) {
self.pos += 1;
return true;
}
false
}
fn eat_identifier(&mut self) -> Option<String> {
match self.peek()? {
Token::Word(name) | Token::QuotedIdent(name) => {
let s = name.clone();
self.pos += 1;
Some(s)
}
_ => None,
}
}
}
fn parse_statement(cur: &mut Cursor<'_>) -> Statement {
let Some(Token::Word(first)) = cur.peek() else {
return Statement::Other;
};
match first.as_str() {
"listen" => parse_listen(cur),
"unlisten" => parse_unlisten(cur),
"set" => parse_set(cur),
"reset" => parse_reset(cur),
"discard" => parse_discard(cur),
"deallocate" => parse_deallocate(cur),
"begin" | "start" => parse_begin(cur),
"commit" | "end" => Statement::Commit,
"rollback" | "abort" => Statement::Rollback,
"select" | "table" | "values" => Statement::Select,
"insert" => Statement::Insert,
"update" => Statement::Update,
"delete" | "truncate" => Statement::Delete,
"copy" => Statement::Copy,
"with" => parse_cte_wrapped(cur),
_ => Statement::Other,
}
}
fn parse_listen(cur: &mut Cursor<'_>) -> Statement {
cur.advance(); match cur.eat_identifier() {
Some(channel) => Statement::Listen { channel },
None => Statement::Other,
}
}
fn parse_unlisten(cur: &mut Cursor<'_>) -> Statement {
cur.advance();
match cur.peek() {
Some(Token::Star) => {
cur.advance();
Statement::Unlisten {
target: UnlistenTarget::Star,
}
}
Some(Token::Word(name) | Token::QuotedIdent(name)) => {
let name = name.clone();
cur.advance();
Statement::Unlisten {
target: UnlistenTarget::Channel(name),
}
}
_ => Statement::Other,
}
}
fn parse_set(cur: &mut Cursor<'_>) -> Statement {
cur.advance();
if cur.eat_word("transaction") {
return Statement::SetTransaction {
options: parse_transaction_options(cur),
};
}
let scope = if cur.eat_word("local") {
SetScope::Local
} else if cur.eat_word("session") {
if cur.eat_word("characteristics") {
if cur.eat_word("as") && cur.eat_word("transaction") {
return Statement::SetTransaction {
options: parse_transaction_options(cur),
};
}
return Statement::Other;
}
SetScope::Session
} else {
SetScope::Session
};
let Some(parameter) = cur.eat_identifier() else {
return Statement::Other;
};
match cur.peek() {
Some(Token::Word(w)) if w == "to" => {
cur.advance();
}
Some(Token::Other) => {
cur.advance();
}
_ => return Statement::Other,
}
let value = match cur.peek() {
Some(Token::Word(w)) if w == "default" => {
cur.advance();
SetValue::Default
}
Some(Token::Word(v) | Token::Literal(v) | Token::Number(v)) => {
let v = v.clone();
cur.advance();
SetValue::Literal(v)
}
Some(Token::Other) if matches!(cur.peek_at(1), Some(Token::Number(_))) => {
cur.advance(); let Some(Token::Number(v)) = cur.peek() else {
unreachable!("peek_at(1) matched Token::Number above");
};
let v = v.clone();
cur.advance();
SetValue::Literal(v)
}
_ => return Statement::Other,
};
Statement::Set {
scope,
parameter,
value,
}
}
fn parse_reset(cur: &mut Cursor<'_>) -> Statement {
cur.advance(); match cur.peek() {
Some(Token::Word(w)) if w == "all" => {
cur.advance();
Statement::Reset {
target: ResetTarget::All,
}
}
Some(Token::Word(_) | Token::QuotedIdent(_)) => {
let name = cur.eat_identifier().expect("identifier after RESET");
Statement::Reset {
target: ResetTarget::Parameter(name),
}
}
_ => Statement::Other,
}
}
fn parse_discard(cur: &mut Cursor<'_>) -> Statement {
cur.advance(); let Some(Token::Word(w)) = cur.peek() else {
return Statement::Other;
};
let target = match w.as_str() {
"all" => DiscardTarget::All,
"plans" => DiscardTarget::Plans,
"sequences" => DiscardTarget::Sequences,
"temporary" | "temp" => DiscardTarget::Temp,
_ => return Statement::Other,
};
cur.advance();
Statement::Discard { target }
}
fn parse_deallocate(cur: &mut Cursor<'_>) -> Statement {
cur.advance();
cur.eat_word("prepare");
match cur.peek() {
Some(Token::Word(w)) if w == "all" => {
cur.advance();
Statement::Deallocate {
target: DeallocateTarget::All,
}
}
Some(Token::Word(_) | Token::QuotedIdent(_)) => {
let name = cur.eat_identifier().expect("identifier after DEALLOCATE");
Statement::Deallocate {
target: DeallocateTarget::Name(name),
}
}
_ => Statement::Other,
}
}
fn parse_begin(cur: &mut Cursor<'_>) -> Statement {
let is_start = matches!(cur.peek(), Some(Token::Word(w)) if w == "start");
cur.advance();
if is_start {
if !cur.eat_word("transaction") {
return Statement::Other;
}
} else {
let _ = cur.eat_word("work") || cur.eat_word("transaction");
}
Statement::Begin {
options: parse_transaction_options(cur),
}
}
fn parse_transaction_options(cur: &mut Cursor<'_>) -> TransactionOptions {
let mut opts = TransactionOptions::default();
while let Some(tok) = cur.peek() {
match tok {
Token::Word(w) if w == "read" => {
cur.advance();
match cur.peek() {
Some(Token::Word(w)) if w == "only" => {
cur.advance();
opts.read_only = Some(true);
}
Some(Token::Word(w)) if w == "write" => {
cur.advance();
opts.read_only = Some(false);
}
_ => {}
}
}
_ => {
cur.advance();
}
}
}
opts
}
fn parse_cte_wrapped(cur: &mut Cursor<'_>) -> Statement {
cur.advance(); let mut depth = 0u32;
while let Some(t) = cur.advance() {
match t {
Token::LParen => depth += 1,
Token::RParen => depth = depth.saturating_sub(1),
Token::Word(w) if depth == 0 => match w.as_str() {
"select" | "table" | "values" => return Statement::Select,
"insert" => return Statement::Insert,
"update" => return Statement::Update,
"delete" | "truncate" => return Statement::Delete,
_ => {}
},
_ => {}
}
}
Statement::Other
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn listen_unquoted() {
assert_eq!(
parse("LISTEN my_channel"),
Statement::Listen {
channel: "my_channel".into()
}
);
}
#[test]
fn listen_quoted_preserves_case() {
assert_eq!(
parse(r#"LISTEN "MyChannel""#),
Statement::Listen {
channel: "MyChannel".into()
}
);
}
#[test]
fn listen_without_channel_is_other() {
assert_eq!(parse("LISTEN"), Statement::Other);
}
#[test]
fn unlisten_star() {
assert_eq!(
parse("UNLISTEN *"),
Statement::Unlisten {
target: UnlistenTarget::Star
}
);
}
#[test]
fn unlisten_quoted_star_is_channel_not_wildcard() {
assert_eq!(
parse(r#"UNLISTEN "*""#),
Statement::Unlisten {
target: UnlistenTarget::Channel("*".into())
}
);
}
#[test]
fn unlisten_channel_name() {
assert_eq!(
parse("UNLISTEN my_channel"),
Statement::Unlisten {
target: UnlistenTarget::Channel("my_channel".into())
}
);
}
#[test]
fn set_session_default() {
assert_eq!(
parse("SET work_mem = '256MB'"),
Statement::Set {
scope: SetScope::Session,
parameter: "work_mem".into(),
value: SetValue::Literal("256mb".into()),
}
);
}
#[test]
fn set_to_syntax() {
assert_eq!(
parse("SET search_path TO public"),
Statement::Set {
scope: SetScope::Session,
parameter: "search_path".into(),
value: SetValue::Literal("public".into()),
}
);
}
#[test]
fn set_local_scope() {
assert_eq!(
parse("SET LOCAL work_mem = '1MB'"),
Statement::Set {
scope: SetScope::Local,
parameter: "work_mem".into(),
value: SetValue::Literal("1mb".into()),
}
);
}
#[test]
fn set_session_scope_explicit() {
assert_eq!(
parse("SET SESSION work_mem = '1GB'"),
Statement::Set {
scope: SetScope::Session,
parameter: "work_mem".into(),
value: SetValue::Literal("1gb".into()),
}
);
}
#[test]
fn set_default_value() {
assert_eq!(
parse("SET default_transaction_read_only TO DEFAULT"),
Statement::Set {
scope: SetScope::Session,
parameter: "default_transaction_read_only".into(),
value: SetValue::Default,
}
);
}
#[test]
fn set_quoted_parameter_preserves_case() {
assert_eq!(
parse(r#"SET "MyVar" = 'value'"#),
Statement::Set {
scope: SetScope::Session,
parameter: "MyVar".into(),
value: SetValue::Literal("value".into()),
}
);
}
#[test]
fn set_negative_number() {
assert_eq!(
parse("SET work_mem = -1"),
Statement::Set {
scope: SetScope::Session,
parameter: "work_mem".into(),
value: SetValue::Literal("1".into()),
}
);
}
#[test]
fn set_positive_sign_number() {
assert_eq!(
parse("SET work_mem = +5"),
Statement::Set {
scope: SetScope::Session,
parameter: "work_mem".into(),
value: SetValue::Literal("5".into()),
}
);
}
#[test]
fn set_negative_with_to_syntax() {
assert_eq!(
parse("SET seed TO -1"),
Statement::Set {
scope: SetScope::Session,
parameter: "seed".into(),
value: SetValue::Literal("1".into()),
}
);
}
#[test]
fn set_local_negative_number() {
assert_eq!(
parse("SET LOCAL work_mem = -1"),
Statement::Set {
scope: SetScope::Local,
parameter: "work_mem".into(),
value: SetValue::Literal("1".into()),
}
);
}
#[test]
fn set_transaction_read_write() {
assert_eq!(
parse("SET TRANSACTION READ WRITE"),
Statement::SetTransaction {
options: TransactionOptions {
read_only: Some(false)
}
}
);
}
#[test]
fn set_session_characteristics() {
assert_eq!(
parse("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE"),
Statement::SetTransaction {
options: TransactionOptions {
read_only: Some(false)
}
}
);
}
#[test]
fn set_session_characteristics_malformed_is_other() {
assert_eq!(
parse("SET SESSION CHARACTERISTICS work_mem = '1GB'"),
Statement::Other
);
}
#[test]
fn reset_all() {
assert_eq!(
parse("RESET ALL"),
Statement::Reset {
target: ResetTarget::All
}
);
}
#[test]
fn reset_parameter() {
assert_eq!(
parse("RESET work_mem"),
Statement::Reset {
target: ResetTarget::Parameter("work_mem".into())
}
);
}
#[test]
fn discard_variants() {
assert_eq!(
parse("DISCARD ALL"),
Statement::Discard {
target: DiscardTarget::All
}
);
assert_eq!(
parse("DISCARD PLANS"),
Statement::Discard {
target: DiscardTarget::Plans
}
);
assert_eq!(
parse("DISCARD SEQUENCES"),
Statement::Discard {
target: DiscardTarget::Sequences
}
);
assert_eq!(
parse("DISCARD TEMPORARY"),
Statement::Discard {
target: DiscardTarget::Temp
}
);
assert_eq!(
parse("DISCARD TEMP"),
Statement::Discard {
target: DiscardTarget::Temp
}
);
}
#[test]
fn discard_malformed_is_other() {
assert_eq!(parse("DISCARD"), Statement::Other);
assert_eq!(parse("DISCARD FOO"), Statement::Other);
}
#[test]
fn deallocate_named() {
assert_eq!(
parse("DEALLOCATE my_stmt"),
Statement::Deallocate {
target: DeallocateTarget::Name("my_stmt".into())
}
);
}
#[test]
fn deallocate_all() {
assert_eq!(
parse("DEALLOCATE ALL"),
Statement::Deallocate {
target: DeallocateTarget::All
}
);
}
#[test]
fn deallocate_prepare_noise_keyword() {
assert_eq!(
parse("DEALLOCATE PREPARE my_stmt"),
Statement::Deallocate {
target: DeallocateTarget::Name("my_stmt".into())
}
);
assert_eq!(
parse("DEALLOCATE PREPARE ALL"),
Statement::Deallocate {
target: DeallocateTarget::All
}
);
}
#[test]
fn deallocate_mixed_case() {
assert_eq!(
parse("Deallocate Prepare My_Stmt"),
Statement::Deallocate {
target: DeallocateTarget::Name("my_stmt".into())
}
);
assert_eq!(
parse("deallocate all"),
Statement::Deallocate {
target: DeallocateTarget::All
}
);
}
#[test]
fn deallocate_quoted_identifier_preserves_case() {
assert_eq!(
parse(r#"DEALLOCATE "MyStmt""#),
Statement::Deallocate {
target: DeallocateTarget::Name("MyStmt".into())
}
);
assert_eq!(
parse(r#"DEALLOCATE PREPARE "MyStmt""#),
Statement::Deallocate {
target: DeallocateTarget::Name("MyStmt".into())
}
);
}
#[test]
fn deallocate_quoted_all_is_name_not_wildcard() {
assert_eq!(
parse(r#"DEALLOCATE "ALL""#),
Statement::Deallocate {
target: DeallocateTarget::Name("ALL".into())
}
);
}
#[test]
fn deallocate_malformed_is_other() {
assert_eq!(parse("DEALLOCATE"), Statement::Other);
assert_eq!(parse("DEALLOCATE PREPARE"), Statement::Other);
}
#[test]
fn begin_plain() {
assert_eq!(
parse("BEGIN"),
Statement::Begin {
options: TransactionOptions::default()
}
);
}
#[test]
fn begin_read_only() {
assert_eq!(
parse("BEGIN READ ONLY"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(true)
}
}
);
}
#[test]
fn begin_read_write() {
assert_eq!(
parse("BEGIN READ WRITE"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(false)
}
}
);
}
#[test]
fn begin_with_isolation_before_read_only() {
assert_eq!(
parse("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(true)
}
}
);
}
#[test]
fn begin_isolation_read_committed_no_mode() {
assert_eq!(
parse("BEGIN ISOLATION LEVEL READ COMMITTED"),
Statement::Begin {
options: TransactionOptions { read_only: None }
}
);
}
#[test]
fn start_transaction_read_only() {
assert_eq!(
parse("START TRANSACTION READ ONLY"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(true)
}
}
);
}
#[test]
fn start_without_transaction_is_other() {
assert_eq!(parse("START"), Statement::Other);
assert_eq!(parse("START WORK"), Statement::Other);
assert_eq!(parse("START READ ONLY"), Statement::Other);
assert_eq!(parse("START WORK READ ONLY"), Statement::Other);
}
#[test]
fn commit_aliases() {
assert_eq!(parse("COMMIT"), Statement::Commit);
assert_eq!(parse("END"), Statement::Commit);
}
#[test]
fn rollback_aliases() {
assert_eq!(parse("ROLLBACK"), Statement::Rollback);
assert_eq!(parse("ABORT"), Statement::Rollback);
}
#[test]
fn select_variants() {
assert_eq!(parse("SELECT 1"), Statement::Select);
assert_eq!(parse("TABLE t"), Statement::Select);
assert_eq!(parse("VALUES (1)"), Statement::Select);
}
#[test]
fn dml_variants() {
assert_eq!(parse("INSERT INTO t VALUES (1)"), Statement::Insert);
assert_eq!(parse("UPDATE t SET x = 1"), Statement::Update);
assert_eq!(parse("DELETE FROM t"), Statement::Delete);
assert_eq!(parse("TRUNCATE t"), Statement::Delete);
assert_eq!(parse("COPY t FROM stdin"), Statement::Copy);
}
#[test]
fn with_cte_select() {
assert_eq!(
parse("WITH cte AS (SELECT 1) SELECT * FROM cte"),
Statement::Select
);
}
#[test]
fn with_cte_insert() {
assert_eq!(
parse("WITH cte AS (SELECT 1) INSERT INTO t SELECT * FROM cte"),
Statement::Insert
);
}
#[test]
fn with_recursive() {
assert_eq!(
parse("WITH RECURSIVE tree AS (SELECT 1) SELECT * FROM tree"),
Statement::Select
);
}
#[test]
fn empty_input() {
assert_eq!(parse(""), Statement::Other);
assert_eq!(parse(" "), Statement::Other);
}
#[test]
fn only_comment() {
assert_eq!(parse("-- just a comment"), Statement::Other);
}
#[test]
fn ddl_is_other() {
assert_eq!(parse("CREATE TABLE t (id int)"), Statement::Other);
}
#[test]
fn is_read_only_pattern() {
assert!(matches!(
parse("BEGIN READ ONLY"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(true)
}
}
));
assert!(!matches!(
parse("BEGIN"),
Statement::Begin {
options: TransactionOptions {
read_only: Some(true)
}
}
));
}
#[test]
fn is_read_write_override_covers_all_paths() {
assert!(parse("BEGIN READ WRITE").is_read_write_override());
assert!(parse("SET TRANSACTION READ WRITE").is_read_write_override());
assert!(
parse("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE").is_read_write_override()
);
assert!(parse("SET default_transaction_read_only = off").is_read_write_override());
assert!(parse("SET default_transaction_read_only = 'off'").is_read_write_override());
assert!(parse("SET default_transaction_read_only TO DEFAULT").is_read_write_override());
assert!(!parse("BEGIN READ ONLY").is_read_write_override());
assert!(!parse("BEGIN").is_read_write_override());
assert!(!parse("SET default_transaction_read_only = on").is_read_write_override());
assert!(!parse("SET work_mem = '1MB'").is_read_write_override());
assert!(!parse("SELECT 1").is_read_write_override());
}
#[test]
fn reset_default_transaction_read_only_is_override() {
assert!(parse("RESET default_transaction_read_only").is_read_write_override());
assert!(parse("reset DEFAULT_TRANSACTION_READ_ONLY").is_read_write_override());
}
#[test]
fn reset_all_is_override() {
assert!(parse("RESET ALL").is_read_write_override());
assert!(parse("reset all").is_read_write_override());
}
#[test]
fn reset_other_parameter_is_not_override() {
assert!(!parse("RESET work_mem").is_read_write_override());
assert!(!parse("RESET search_path").is_read_write_override());
}
}