use sqlparser::ast::{
BinaryOperator, DateTimeField, DuplicateTreatment, Expr, Function, FunctionArg, FunctionArgExpr,
FunctionArguments, GroupByExpr, JoinConstraint, JoinOperator, Query, Select, SelectItem, SetExpr,
Statement, TableFactor, TableWithJoins, Value,
};
use sqlparser::dialect::GenericDialect;
use sqlparser::parser::Parser;
use crate::expr;
#[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,
}
#[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,
},
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>,
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 — express as separate pipelines".into())
}
_ => return Err("only a SELECT body is supported".into()),
};
Ok(bind_ctes(plan_select(select)?, &ctes))
}
fn parse_ctes(with: Option<&sqlparser::ast::With>) -> Result<Vec<(String, Plan)>, String> {
let Some(with) = with else { return Ok(Vec::new()) };
if with.recursive {
return Err("WITH RECURSIVE is not supported — a streaming CTE has no fixpoint".into());
}
let mut bound: Vec<(String, Plan)> = Vec::new();
for cte in &with.cte_tables {
let name = object_name(&cte.alias.name.value);
let plan = bind_ctes(plan_query(&cte.query)?, &bound);
bound.push((name, plan));
}
Ok(bound)
}
fn bind_ctes(plan: Plan, ctes: &[(String, Plan)]) -> Plan {
if ctes.is_empty() {
return plan;
}
let boxed = |p: Box<Plan>| Box::new(bind_ctes(*p, ctes));
match plan {
Plan::Source(name) => match ctes.iter().find(|(n, _)| *n == name) {
Some((_, cte)) => Plan::Named { name, input: Box::new(cte.clone()) },
None => Plan::Source(name),
},
Plan::Named { name, input } => Plan::Named { name, input: boxed(input) },
Plan::Join { left, right, join_key, kind } => Plan::Join {
left: boxed(left),
right: boxed(right),
join_key,
kind,
},
Plan::Filter { input, predicate } => Plan::Filter { input: boxed(input), predicate },
Plan::Project { input, star, items } => Plan::Project { input: boxed(input), star, items },
Plan::Aggregate { input, time_column, window, group_by, pre, aggs, post, trigger } => Plan::Aggregate {
input: boxed(input),
time_column,
window,
group_by,
pre,
aggs,
post,
trigger,
},
Plan::TopN { input, group_by, order_by, tie_by, descending, n } => Plan::TopN {
input: boxed(input),
group_by,
order_by,
tie_by,
descending,
n,
},
Plan::Sink { input, name } => Plan::Sink { input: boxed(input), name },
}
}
fn plan_select(select: &Select) -> Result<Plan, String> {
if let Some(topn) = detect_topn(select)? {
return parse_projection(topn, &select.projection);
}
if select.from.len() != 1 {
return Err(format!(
"expected one FROM item (comma joins are not supported — use `JOIN … ON …`), got {}",
select.from.len()
));
}
let source = parse_from(&select.from[0])?;
if select.having.is_some() {
return Err("HAVING is not supported yet".into());
}
let filtered = match &select.selection {
Some(pred) => Plan::Filter {
input: Box::new(source),
predicate: expr::to_dialect(pred)?,
},
None => source,
};
let group_exprs = match &select.group_by {
GroupByExpr::Expressions(exprs, _) if !exprs.is_empty() => Some(exprs.as_slice()),
GroupByExpr::All(_) => return Err("GROUP BY ALL is not supported".into()),
_ => None,
};
if let Some(gexprs) = group_exprs {
return plan_aggregate(filtered, gexprs, &select.projection);
}
parse_projection(filtered, &select.projection)
}
fn parse_projection(input: Plan, projection: &[SelectItem]) -> Result<Plan, String> {
let mut star = false;
let mut items = Vec::new();
for item in projection {
match item {
SelectItem::Wildcard(_) => star = true,
SelectItem::UnnamedExpr(e) => {
let out = column_name_of(e)
.ok_or("a projected expression needs an alias (`<expr> AS name`)")?;
match e {
Expr::Identifier(_) | Expr::CompoundIdentifier(_) => {
items.push(Proj { out, expr: None })
}
_ => items.push(Proj { out, expr: Some(expr::to_dialect(e)?) }),
}
}
SelectItem::ExprWithAlias { expr: e, alias } => {
items.push(Proj { out: alias.value.clone(), expr: Some(expr::to_dialect(e)?) });
}
_ => return Err("`table.*` / multi-alias projections are not supported — list the columns".into()),
}
}
if star && items.iter().any(|p| p.expr.is_none()) {
return Err("`SELECT *, <bare column>` is redundant — `*` already keeps every column; with `*` add only computed columns (`*, <expr> AS name`)".into());
}
Ok(Plan::Project { input: Box::new(input), star, items })
}
fn detect_topn(select: &Select) -> Result<Option<Plan>, String> {
if select.from.len() != 1 || !select.from[0].joins.is_empty() {
return Ok(None);
}
let TableFactor::Derived { subquery, .. } = &select.from[0].relation else {
return Ok(None);
};
let SetExpr::Select(inner) = subquery.body.as_ref() else {
return Ok(None);
};
let mut rn_fn = None;
for item in &inner.projection {
if let SelectItem::ExprWithAlias { expr: Expr::Function(f), alias } = item {
if f.name.to_string().eq_ignore_ascii_case("row_number") {
rn_fn = Some((f, alias.value.clone()));
}
}
}
let Some((f, rn)) = rn_fn else { return Ok(None) }; let Some(sqlparser::ast::WindowType::WindowSpec(ws)) = &f.over else {
return Err("ROW_NUMBER() needs `OVER (PARTITION BY … ORDER BY …)`".into());
};
let group_by: Vec<String> = ws.partition_by.iter().filter_map(column_name_of).collect();
let ob = ws.order_by.first().ok_or("ROW_NUMBER() OVER needs an ORDER BY column")?;
let order_by = column_name_of(&ob.expr).ok_or("ROW_NUMBER() ORDER BY must be a column")?;
let descending = ob.options.asc == Some(false); let tie_by = match ws.order_by.get(1) {
Some(t) => Some(column_name_of(&t.expr).ok_or("ROW_NUMBER() tie-break must be a column")?),
None => None,
};
if inner.from.len() != 1 || !inner.from[0].joins.is_empty() {
return Err("the ROW_NUMBER subquery must read exactly one source".into());
}
let source = table_source(&inner.from[0].relation)?;
let input = match &inner.selection {
Some(pred) => Plan::Filter { input: Box::new(source), predicate: expr::to_dialect(pred)? },
None => source,
};
let n = rank_limit(select.selection.as_ref(), &rn)?;
Ok(Some(Plan::TopN {
input: Box::new(input),
group_by,
order_by,
tie_by,
descending,
n,
}))
}
fn rank_limit(where_: Option<&Expr>, rn: &str) -> Result<usize, String> {
let e = where_.ok_or_else(|| format!("a ROW_NUMBER top-N needs an outer `WHERE {rn} <= n`"))?;
let is_rn = |x: &Expr| column_name_of(x).as_deref() == Some(rn);
match e {
Expr::BinaryOp { left, op: BinaryOperator::LtEq, right } if is_rn(left) => literal_usize(right),
Expr::BinaryOp { left, op: BinaryOperator::Eq, right } if is_rn(left) => match literal_usize(right)? {
1 => Ok(1),
_ => Err("a `= n` top-N filter only supports n = 1 — use `<= n`".into()),
},
_ => Err(format!("the top-N filter must be `{rn} <= n`")),
}
}
fn literal_usize(e: &Expr) -> Result<usize, String> {
match e {
Expr::Value(v) => match &v.value {
Value::Number(s, _) => s.trim().parse().map_err(|_| format!("`{s}` is not a whole number")),
other => Err(format!("expected a number, got `{other}`")),
},
other => Err(format!("expected a number, got `{other}`")),
}
}
fn plan_aggregate(input: Plan, group_exprs: &[Expr], projection: &[SelectItem]) -> Result<Plan, String> {
let mut window: Option<(String, Win)> = None;
let mut group_by = Vec::new();
for g in group_exprs {
match g {
Expr::Function(f) if is_window_fn(f) => {
if window.is_some() {
return Err("only one window function may appear in GROUP BY".into());
}
window = Some(parse_window_fn(f)?);
}
Expr::Identifier(id) => group_by.push(id.value.clone()),
Expr::CompoundIdentifier(p) => group_by.push(p.last().expect("non-empty").value.clone()),
other => {
return Err(format!(
"unsupported GROUP BY item `{other}` — a window function (`TUMBLE/HOP/SESSION`) or a plain column"
))
}
}
}
let (time_column, window) = window.ok_or(
"a streaming GROUP BY needs a window: `GROUP BY TUMBLE/HOP/SESSION(ts, INTERVAL …)` (an unbounded aggregate needs `… EMIT CHANGES` — the 5a updating aggregate)",
)?;
let (pre, aggs, post) = parse_agg_select(projection)?;
if aggs.is_empty() {
return Err("a windowed GROUP BY needs at least one aggregate in SELECT (count/sum/avg/min/max)".into());
}
Ok(Plan::Aggregate {
input: Box::new(input),
time_column,
window,
group_by,
pre,
aggs,
post,
trigger: None,
})
}
fn split_emit(sql: &str) -> Result<(String, Option<Trigger>), String> {
let lower = sql.to_ascii_lowercase();
let bytes = lower.as_bytes();
let is_word = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
let mut in_str = false;
let mut at = None;
let mut i = 0usize;
while i < bytes.len() {
if bytes[i] == b'\'' {
in_str = !in_str;
i += 1;
continue;
}
if !in_str
&& lower[i..].starts_with("emit")
&& (i == 0 || !is_word(bytes[i - 1]))
&& (i + 4 >= bytes.len() || !is_word(bytes[i + 4]))
{
at = Some(i); }
i += 1;
}
let Some(at) = at else {
return Ok((sql.to_string(), None));
};
let head = sql[..at].trim_end().to_string();
let trigger = parse_emit(&sql[at..])?;
Ok((head, Some(trigger)))
}
fn parse_emit(clause: &str) -> Result<Trigger, String> {
let toks: Vec<String> = clause.split_whitespace().map(|s| s.to_ascii_lowercase()).collect();
let shape = "`EMIT CHANGES EVERY <n> ROWS` or `EMIT CHANGES EVERY <n> MS`";
if toks.len() < 2 || toks[0] != "emit" || toks[1] != "changes" {
return Err(format!("unrecognised EMIT clause — use {shape}"));
}
if toks.len() == 2 {
return Err(format!("`EMIT CHANGES` needs a cadence: {shape}"));
}
if toks.len() != 5 || toks[2] != "every" {
return Err(format!("EMIT clause: expected {shape}"));
}
let n: u64 = toks[3]
.parse()
.map_err(|_| format!("EMIT cadence `{}` is not a whole number", toks[3]))?;
match toks[4].as_str() {
"rows" | "row" => Ok(Trigger::EveryRows(n)),
"ms" | "milliseconds" | "millisecond" => Ok(Trigger::EveryMs(n as i64)),
other => Err(format!("EMIT cadence unit `{other}` — use ROWS or MS")),
}
}
fn attach_trigger(plan: Plan, trigger: Trigger) -> Result<Plan, String> {
match plan {
Plan::Sink { input, name } => Ok(Plan::Sink {
input: Box::new(attach_trigger(*input, trigger)?),
name,
}),
Plan::Aggregate {
input,
time_column,
window,
group_by,
pre,
aggs,
post,
trigger: _,
} => {
if matches!(window, Win::Session { .. }) {
return Err("EMIT CHANGES is supported on windowed aggregates (TUMBLE / HOP), not sessions".into());
}
Ok(Plan::Aggregate {
input,
time_column,
window,
group_by,
pre,
aggs,
post,
trigger: Some(trigger),
})
}
_ => Err("EMIT CHANGES needs a windowed GROUP BY aggregate (`GROUP BY <keys>, TUMBLE(ts, INTERVAL …)`)".into()),
}
}
fn is_window_fn(f: &Function) -> bool {
matches!(f.name.to_string().to_uppercase().as_str(), "TUMBLE" | "HOP" | "SESSION")
}
fn parse_window_fn(f: &Function) -> Result<(String, Win), String> {
let name = f.name.to_string().to_uppercase();
let args = fn_args(f)?;
let time_col = |e: &Expr| -> Result<String, String> {
match e {
Expr::Identifier(id) => Ok(id.value.clone()),
Expr::CompoundIdentifier(p) => Ok(p.last().expect("non-empty").value.clone()),
_ => Err(format!("{name}(…)'s first argument must be the event-time column")),
}
};
let lateness = |base: usize| -> Result<Option<i64>, String> {
match args.len() {
n if n == base => Ok(None),
n if n == base + 1 => Ok(Some(interval_ms(args[base])?)),
_ => Err(String::new()), }
};
match name.as_str() {
"TUMBLE" if args.len() == 2 || args.len() == 3 => Ok((
time_col(args[0])?,
Win::Tumble { size_ms: interval_ms(args[1])?, lateness_ms: lateness(2)? },
)),
"HOP" if args.len() == 3 || args.len() == 4 => Ok((
time_col(args[0])?,
Win::Hop { slide_ms: interval_ms(args[1])?, size_ms: interval_ms(args[2])?, lateness_ms: lateness(3)? },
)),
"SESSION" if args.len() == 2 || args.len() == 3 => Ok((
time_col(args[0])?,
Win::Session { gap_ms: interval_ms(args[1])?, lateness_ms: lateness(2)? },
)),
"TUMBLE" | "SESSION" => Err(format!("{name}(ts, INTERVAL <size> [, INTERVAL <lateness>]) takes 2 or 3 arguments")),
"HOP" => Err("HOP(ts, INTERVAL <slide>, INTERVAL <size> [, INTERVAL <lateness>]) takes 3 or 4 arguments".into()),
other => Err(format!("unsupported window function `{other}`")),
}
}
fn is_agg_name(name: &str) -> bool {
matches!(name, "count" | "sum" | "avg" | "min" | "max")
}
#[allow(clippy::type_complexity)]
fn parse_agg_select(projection: &[SelectItem]) -> Result<(Vec<Proj>, Vec<AggSpec>, Vec<Proj>), String> {
let mut pre: Vec<Proj> = Vec::new();
let mut aggs = Vec::new();
let mut post: Vec<Proj> = Vec::new();
for item in projection {
let (e, alias) = match item {
SelectItem::ExprWithAlias { expr, alias } => (expr, Some(alias.value.clone())),
SelectItem::UnnamedExpr(e) => (e, None),
SelectItem::Wildcard(_) => return Err("`SELECT *` is not allowed with GROUP BY".into()),
_ => return Err("unsupported projection in a GROUP BY query".into()),
};
match e {
Expr::Function(f) if is_agg_name(&f.name.to_string().to_lowercase()) => {
aggs.push(agg_of(f, alias, &mut pre)?);
}
Expr::Identifier(_) | Expr::CompoundIdentifier(_) => {}
_ => {
let out = alias
.ok_or("a computed SELECT column in a GROUP BY query needs an alias (`<expr> AS name`)")?;
post.push(Proj { out, expr: Some(expr::to_dialect(e)?) });
}
}
}
Ok((pre, aggs, post))
}
fn agg_of(f: &Function, alias: Option<String>, pre: &mut Vec<Proj>) -> Result<AggSpec, String> {
let name = f.name.to_string().to_lowercase();
let alias = alias.ok_or_else(|| format!("aggregate `{name}(…)` needs an alias (`{name}(…) AS name`)"))?;
let distinct = matches!(
&f.args,
FunctionArguments::List(l) if l.duplicate_treatment == Some(DuplicateTreatment::Distinct)
);
let op = match (name.as_str(), distinct) {
("count", false) => "count",
("count", true) => "countDistinct",
("sum", false) => "sum",
("avg", false) => "avg",
("min", false) => "min",
("max", false) => "max",
(other, true) => return Err(format!("DISTINCT is only supported on `count()`, not `{other}()`")),
(other, false) => return Err(format!("unsupported aggregate `{other}` — count/sum/avg/min/max/count(DISTINCT …)")),
};
let args = fn_args(f)?;
let column = match args.first() {
None => String::new(),
Some(Expr::Identifier(id)) => id.value.clone(),
Some(Expr::CompoundIdentifier(p)) => p.last().expect("non-empty").value.clone(),
Some(other) => {
let synth = format!("_fv_agg{}", pre.len());
pre.push(Proj { out: synth.clone(), expr: Some(expr::to_dialect(other)?) });
synth
}
};
Ok(AggSpec { op: op.to_string(), column, alias })
}
fn fn_args(f: &Function) -> Result<Vec<&Expr>, String> {
let list = match &f.args {
FunctionArguments::List(l) => &l.args,
FunctionArguments::None => return Ok(Vec::new()),
FunctionArguments::Subquery(_) => return Err("subquery arguments are not supported".into()),
};
let mut out = Vec::new();
for a in list {
match a {
FunctionArg::Unnamed(FunctionArgExpr::Expr(e)) => out.push(e),
FunctionArg::Unnamed(FunctionArgExpr::Wildcard) => {}
_ => return Err("unsupported function argument (named / qualified wildcard)".into()),
}
}
Ok(out)
}
fn interval_ms(e: &Expr) -> Result<i64, String> {
let Expr::Interval(iv) = e else {
return Err(format!("expected an INTERVAL (e.g. `INTERVAL '10' SECOND`), got `{e}`"));
};
let n: i64 = match iv.value.as_ref() {
Expr::Value(v) => match &v.value {
Value::SingleQuotedString(s) | Value::Number(s, _) => {
s.trim().parse().map_err(|_| format!("interval value `{s}` is not an integer"))?
}
other => return Err(format!("unsupported interval value `{other}`")),
},
other => return Err(format!("unsupported interval value `{other}`")),
};
let unit = match &iv.leading_field {
Some(DateTimeField::Millisecond) => 1,
Some(DateTimeField::Second) => 1_000,
Some(DateTimeField::Minute) => 60_000,
Some(DateTimeField::Hour) => 3_600_000,
Some(DateTimeField::Day) => 86_400_000,
other => {
return Err(format!(
"unsupported interval unit `{other:?}` — use MILLISECOND / SECOND / MINUTE / HOUR / DAY"
))
}
};
Ok(n * unit)
}
fn parse_from(twj: &TableWithJoins) -> Result<Plan, String> {
let left = table_source(&twj.relation)?;
match twj.joins.len() {
0 => Ok(left),
1 => {
let j = &twj.joins[0];
let right = table_source(&j.relation)?;
let (join_key, kind) = parse_join_operator(&j.join_operator)?;
Ok(Plan::Join { left: Box::new(left), right: Box::new(right), join_key, kind })
}
_ => Err("only a single JOIN is supported".into()),
}
}
fn table_source(tf: &TableFactor) -> Result<Plan, String> {
match tf {
TableFactor::Table { name, .. } => Ok(Plan::Source(object_name(&name.to_string()))),
other => Err(format!("unsupported FROM item `{other}` — a plain dataset name")),
}
}
fn parse_join_operator(op: &JoinOperator) -> Result<(String, JoinKind), String> {
let on = match op {
JoinOperator::Inner(JoinConstraint::On(e)) | JoinOperator::Join(JoinConstraint::On(e)) => e,
_ => {
return Err(
"only `INNER JOIN … ON <a.k = b.k> [AND <ts> BETWEEN …]` is supported".into(),
)
}
};
let mut join_key: Option<String> = None;
let mut interval: Option<(String, i64)> = None;
for c in split_and(on) {
match c {
Expr::BinaryOp { left, op: BinaryOperator::Eq, right } => {
join_key = Some(same_column(left, right)?);
}
Expr::Between { expr, negated: false, low, high } => {
interval = Some(between_interval(expr, low, high)?);
}
other => {
return Err(format!(
"unsupported JOIN ON predicate `{other}` — an equi-key `a.k = b.k` and optionally `ts BETWEEN …`"
))
}
}
}
let join_key = join_key.ok_or("JOIN ON needs an equi-key (`a.k = b.k`, same column name on both sides)")?;
let kind = match interval {
Some((time_column, window_ms)) => JoinKind::Interval { time_column, window_ms },
None => JoinKind::Lookup,
};
Ok((join_key, kind))
}
fn split_and(e: &Expr) -> Vec<&Expr> {
match e {
Expr::BinaryOp { left, op: BinaryOperator::And, right } => {
let mut v = split_and(left);
v.extend(split_and(right));
v
}
Expr::Nested(inner) => split_and(inner),
other => vec![other],
}
}
fn same_column(l: &Expr, r: &Expr) -> Result<String, String> {
let lc = column_name_of(l);
let rc = column_name_of(r);
match (lc, rc) {
(Some(a), Some(b)) if a == b => Ok(a),
(Some(a), Some(b)) => Err(format!(
"the JOIN key columns must share a name (`{a}` vs `{b}`) — rename one upstream"
)),
_ => Err("JOIN key must be `a.col = b.col` (plain columns)".into()),
}
}
fn between_interval(expr: &Expr, low: &Expr, high: &Expr) -> Result<(String, i64), String> {
let time_column = column_name_of(expr)
.ok_or("the interval join's BETWEEN must be over an event-time column (`a.ts BETWEEN …`)")?;
let ms = interval_in(high).or_else(|_| interval_in(low))?;
Ok((time_column, ms))
}
fn interval_in(e: &Expr) -> Result<i64, String> {
match e {
Expr::Interval(_) => interval_ms(e),
Expr::BinaryOp { left, right, .. } => interval_in(right).or_else(|_| interval_in(left)),
Expr::Nested(inner) => interval_in(inner),
_ => Err("the interval join's BETWEEN needs an `INTERVAL` bound (`b.ts + INTERVAL '5' SECOND`)".into()),
}
}
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",
}
}