use sqlparser::ast::{Expr, Query, SetExpr, Statement};
use sqlparser::dialect::GenericDialect;
use sqlparser::parser::Parser;
mod cte;
mod emit;
mod functions;
mod join;
mod select;
use cte::{bind_ctes, parse_ctes};
use emit::{attach_trigger, split_emit};
use select::plan_select;
#[derive(Debug, Clone, PartialEq)]
pub struct Proj {
pub out: String,
pub expr: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct AggSpec {
pub op: String,
pub column: String,
pub alias: String,
pub call: String,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Win {
Tumble { size_ms: i64, lateness_ms: Option<i64> },
Hop {
slide_ms: i64,
size_ms: i64,
lateness_ms: Option<i64>,
},
Session { gap_ms: i64, lateness_ms: Option<i64> },
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Trigger {
EveryRows(u64),
EveryMs(i64),
}
#[derive(Debug, Clone, PartialEq)]
pub enum JoinKind {
Interval { time_column: String, window_ms: i64 },
Lookup,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Plan {
Source(String),
Join {
left: Box<Plan>,
right: Box<Plan>,
join_key: String,
kind: JoinKind,
right_rename: std::collections::BTreeMap<String, String>,
},
Filter { input: Box<Plan>, predicate: String },
Project {
input: Box<Plan>,
star: bool,
items: Vec<Proj>,
},
Aggregate {
input: Box<Plan>,
time_column: String,
window: Win,
group_by: Vec<String>,
pre: Vec<Proj>,
aggs: Vec<AggSpec>,
post: Vec<Proj>,
having: Option<String>,
trigger: Option<Trigger>,
},
TopN {
input: Box<Plan>,
group_by: Vec<String>,
order_by: String,
tie_by: Option<String>,
descending: bool,
n: usize,
},
Named { name: String, input: Box<Plan> },
Sink { input: Box<Plan>, name: String },
}
pub fn parse(sql: &str) -> Result<Plan, String> {
let (sql, trigger) = split_emit(sql)?;
let plan = parse_statement(&sql)?;
match trigger {
Some(t) => attach_trigger(plan, t),
None => Ok(plan),
}
}
fn parse_statement(sql: &str) -> Result<Plan, String> {
let mut stmts = Parser::parse_sql(&GenericDialect {}, sql).map_err(|e| format!("SQL parse error: {e}"))?;
if stmts.len() != 1 {
return Err(format!("expected exactly one statement, got {}", stmts.len()));
}
match stmts.pop().expect("one") {
Statement::Insert(insert) => {
let sink = object_name(&insert.table.to_string());
let query = insert
.source
.ok_or("INSERT INTO <sink> needs a SELECT (`INSERT INTO out SELECT …`)")?;
let input = plan_query(&query)?;
Ok(Plan::Sink {
input: Box::new(input),
name: sink,
})
}
Statement::Query(_) => Err("a streaming statement must write to a sink: `INSERT INTO <sink> SELECT …`".into()),
other => Err(format!(
"unsupported statement `{}` — the supported shape is `INSERT INTO <sink> SELECT … FROM … [WHERE …]`",
statement_kind(&other)
)),
}
}
fn plan_query(query: &Query) -> Result<Plan, String> {
let ctes = parse_ctes(query.with.as_ref())?;
if query.order_by.is_some() {
return Err("ORDER BY over an unbounded stream has no streaming meaning — use `ROW_NUMBER() OVER (PARTITION BY …) <= n` for a top-N".into());
}
if query.limit_clause.is_some() {
return Err("LIMIT over an unbounded stream is not supported — use a top-N (`ROW_NUMBER() … <= n`)".into());
}
let select = match query.body.as_ref() {
SetExpr::Select(s) => s.as_ref(),
SetExpr::SetOperation { .. } => {
return Err("UNION / INTERSECT / EXCEPT are not supported — a stage reads one input; write one pipeline per branch into the same sink (`INSERT INTO out SELECT … FROM a` and `INSERT INTO out SELECT … FROM b`), which is UNION ALL by construction".into())
}
_ => return Err("only a SELECT body is supported".into()),
};
Ok(bind_ctes(plan_select(select)?, &ctes))
}
fn column_name_of(e: &Expr) -> Option<String> {
match e {
Expr::Identifier(id) => Some(id.value.clone()),
Expr::CompoundIdentifier(parts) => parts.last().map(|p| p.value.clone()),
_ => None,
}
}
fn object_name(raw: &str) -> String {
raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_string()
}
fn statement_kind(s: &Statement) -> &'static str {
match s {
Statement::Insert(_) => "INSERT",
Statement::Query(_) => "SELECT",
Statement::CreateTable(_) => "CREATE TABLE",
_ => "statement",
}
}