//! SCQL 明文执行语义,逐位对齐 `refs/nax/nax/sql/engine.py`。 //! //! 参考实现的密态算子(`_bit_lt` / `_bit_mask` / `vault.sum` …)由 `mpc-vault` 承担; //! 这里把**查询语义**落成明文,得到与「密文引擎 reveal 出来」一致的最终结果表,便于 //! 用 golden 验证: //! //! * WHERE 不求值成物理过滤,而是一列 0/1 **掩码**;聚合时用 `mask · value`。 //! * AND/OR/NOT 在 0/1 位上运算,任意深度不累积误差。 //! * GROUP BY 只允许**取值域公开**的列(`categorical` 或 `public`)。 //! * SELECT 只允许聚合、分组键、字面量;裸机密列被拒绝(CCL 列约束)。 //! * k-匿名:命中行数低于阈值的分组被整体抑制;无 GROUP BY 时直接报错。 //! * HAVING / ORDER BY / LIMIT 在已解密结果上做明文后处理。 use crate::ast::{Column, Expr, OrderKey, Query, SelectItem, Value}; use crate::parser::{parse, SqlError}; use std::collections::HashMap; /// 构造表用的列数据。 #[derive(Clone, Debug)] pub enum ColData { Num(Vec), Str(Vec), } /// 一张注册进引擎的表(列主序)。 #[derive(Clone, Debug)] pub struct Table { pub name: String, pub site: String, pub columns: Vec, pub data: Vec>, pub key: Option, pub categorical: HashMap>, pub public: Vec, } impl Table { pub fn new(name: &str, site: &str) -> Self { Self { name: name.to_string(), site: site.to_string(), columns: Vec::new(), data: Vec::new(), key: None, categorical: HashMap::new(), public: Vec::new(), } } pub fn with_col(mut self, name: &str, data: ColData) -> Self { let col: Vec = match data { ColData::Num(v) => v.into_iter().map(Value::Num).collect(), ColData::Str(v) => v.into_iter().map(Value::Str).collect(), }; self.columns.push(name.to_string()); self.data.push(col); self } pub fn with_key(mut self, k: &str) -> Self { self.key = Some(k.to_string()); self } pub fn with_categorical(mut self, col: &str, dom: &[&str]) -> Self { self.categorical.insert( col.to_string(), dom.iter().map(|s| Value::Str(s.to_string())).collect(), ); self } pub fn with_public(mut self, col: &str) -> Self { self.public.push(col.to_string()); self } pub fn nrows(&self) -> usize { self.data.first().map(|c| c.len()).unwrap_or(0) } fn col(&self, name: &str) -> Option<&Vec> { self.columns .iter() .position(|c| c == name) .map(|j| &self.data[j]) } } /// 结果表:单元格可为空(被 k-匿名抑制)。 #[derive(Clone, Debug, Default)] pub struct ResultTable { pub columns: Vec, pub rows: Vec>>, } impl ResultTable { pub fn get(&self, row: usize, col: &str) -> Option<&Value> { let j = self.columns.iter().position(|c| c == col)?; self.rows.get(row)?.get(j)?.as_ref() } pub fn nrows(&self) -> usize { self.rows.len() } } /// 引擎错误:一律用带说明的 [`SqlError`] 表达(语法 / 隐私 / 协议)。 pub type EngineResult = Result; fn prive(msg: impl Into) -> SqlError { SqlError::new(msg) } /// 查询引擎(明文版)。 pub struct Engine { pub reveal_to: Option, pub min_group_size: usize, tables: HashMap, } impl Engine { pub fn new(min_group_size: usize) -> Self { Self { reveal_to: None, min_group_size, tables: HashMap::new(), } } pub fn register(&mut self, table: Table) -> &mut Self { self.tables.insert(table.name.clone(), table); self } /// 解析并执行一条 SCQL。 pub fn sql(&self, text: &str) -> EngineResult { let query = parse(text)?; let ctx = RowContext::new(self, &query)?; Executor::new(self, &query, ctx).run() } pub fn explain(&self, text: &str) -> EngineResult { let q = parse(text)?; let mut lines = vec![format!("query : {}", text.split_whitespace().collect::>().join(" "))]; let keys: Vec = q.tables().iter().map(|t| t.key()).collect(); lines.push(format!("tables: {keys:?}")); if let Some(j) = &q.join { lines.push(format!( "join : PSI on {} = {}", j.left_key, j.right_key )); } let w = q .where_ .as_ref() .map(|e| e.label()) .unwrap_or_else(|| "(none)".into()); lines.push(format!("where : {w} → 密态 0/1 掩码,不做物理过滤")); let g: Vec = q.group_by.iter().map(|c| c.to_string()).collect(); lines.push(format!("group : {:?}", if g.is_empty() { vec!["(none)".to_string()] } else { g })); let s: Vec = q.select.iter().map(|i| i.label()).collect(); lines.push(format!("select: {s:?}")); lines.push(format!( "reveal: → {}{}", self.reveal_to.clone().unwrap_or_else(|| "(first site)".into()), if self.min_group_size > 0 { format!("(k-匿名阈值 {})", self.min_group_size) } else { String::new() } )); Ok(lines.join("\n")) } } // --------------------------------------------------------------------------- // // 行上下文:表对齐 + 列解析 // --------------------------------------------------------------------------- // struct RowContext<'a> { specs: HashMap, /// 别名 → (列名 → 对齐后的列值),同一批行。 aligned: HashMap>>, nrows: usize, } impl<'a> RowContext<'a> { fn new(engine: &'a Engine, query: &Query) -> EngineResult { let mut specs = HashMap::new(); for tref in query.tables() { let t = engine .tables .get(&tref.name) .ok_or_else(|| prive(format!("未注册的表 {:?};已注册:{:?}", tref.name, sorted_keys(&engine.tables))))?; specs.insert(tref.key(), t); } let mut aligned = HashMap::new(); let nrows; match &query.join { None => { let key = query.from.key(); let t = specs[&key]; aligned.insert(key.clone(), table_columns(t)); nrows = t.nrows(); } Some(j) => { let lname = j.left_key.table.clone().unwrap_or_else(|| query.from.key()); let rname = j.right_key.table.clone().unwrap_or_else(|| j.right.key()); if !specs.contains_key(&lname) || !specs.contains_key(&rname) { return Err(prive(format!( "JOIN ON 的两侧必须分别来自 {} 和 {}", query.from.key(), j.right.key() ))); } let lt = specs[&lname]; let rt = specs[&rname]; let (lpairs, rpairs, n) = inner_join(lt, &j.left_key.name, rt, &j.right_key.name)?; aligned.insert(lname.clone(), project_pairs(lt, &lpairs)); aligned.insert(rname.clone(), project_pairs(rt, &rpairs)); nrows = n; } } Ok(Self { specs, aligned, nrows, }) } fn resolve(&self, col: &Column) -> EngineResult { if let Some(t) = &col.table { if !self.specs.contains_key(t) { return Err(prive(format!("未知的表别名 {t:?}"))); } return Ok(t.clone()); } if self.specs.len() == 1 { return Ok(self.specs.keys().next().unwrap().clone()); } Err(prive(format!( "列 {:?} 有歧义(涉及多张表),请写成 表名.列名", col.name ))) } fn spec(&self, alias: &str) -> EngineResult<&'a Table> { self.specs .get(alias) .copied() .ok_or_else(|| prive(format!("未知的表别名 {alias:?}"))) } fn column_values(&self, col: &Column) -> EngineResult> { let alias = self.resolve(col)?; self.aligned .get(&alias) .and_then(|m| m.get(&col.name)) .cloned() .ok_or_else(|| prive(format!("列 {col} 不存在"))) } fn domain_of(&self, col: &Column) -> EngineResult>> { let alias = self.resolve(col)?; let spec = self.spec(&alias)?; if let Some(d) = spec.categorical.get(&col.name) { return Ok(Some(d.clone())); } if !spec.public.contains(&col.name) { return Ok(None); } let vals = self.column_values(col)?; Ok(Some(distinct_sorted(&vals))) } fn is_categorical(&self, col: &Column) -> EngineResult { Ok(self.domain_of(col)?.is_some()) } } fn sorted_keys(m: &HashMap) -> Vec { let mut v: Vec = m.keys().cloned().collect(); v.sort(); v } fn table_columns(t: &Table) -> HashMap> { let mut m = HashMap::new(); for (j, name) in t.columns.iter().enumerate() { m.insert(name.clone(), t.data[j].clone()); } m } fn project_pairs(t: &Table, rows: &[usize]) -> HashMap> { let mut m = HashMap::new(); for (j, name) in t.columns.iter().enumerate() { m.insert(name.clone(), rows.iter().map(|&i| t.data[j][i].clone()).collect()); } m } fn value_key(v: &Value) -> String { match v { Value::Num(n) => format!("n:{n}"), Value::Str(s) => format!("s:{s}"), } } /// 本地内连接,返回 (左行号序列, 右行号序列, 行数)。 fn inner_join( lt: &Table, lkey: &str, rt: &Table, rkey: &str, ) -> EngineResult<(Vec, Vec, usize)> { let lcol = lt.col(lkey).ok_or_else(|| prive(format!("左表缺列 {lkey:?}")))?; let rcol = rt.col(rkey).ok_or_else(|| prive(format!("右表缺列 {rkey:?}")))?; let mut rmap: HashMap> = HashMap::new(); for (j, v) in rcol.iter().enumerate() { rmap.entry(value_key(v)).or_default().push(j); } let mut lp = Vec::new(); let mut rp = Vec::new(); for (i, v) in lcol.iter().enumerate() { if let Some(js) = rmap.get(&value_key(v)) { for &j in js { lp.push(i); rp.push(j); } } } let n = lp.len(); Ok((lp, rp, n)) } fn distinct_sorted(vals: &[Value]) -> Vec { let mut out: Vec = Vec::new(); for v in vals { if !out.iter().any(|x| x == v) { out.push(v.clone()); } } out.sort_by(value_cmp); out } fn value_cmp(a: &Value, b: &Value) -> std::cmp::Ordering { match (a, b) { (Value::Num(x), Value::Num(y)) => x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal), (Value::Str(x), Value::Str(y)) => x.cmp(y), (Value::Num(_), Value::Str(_)) => std::cmp::Ordering::Less, (Value::Str(_), Value::Num(_)) => std::cmp::Ordering::Greater, } } // --------------------------------------------------------------------------- // // 求值操作数 // --------------------------------------------------------------------------- // #[derive(Clone, Debug)] enum Operand { Scalar(f64), Str(String), NumCol(Vec), Coded(Vec, Vec), Bits(Vec), } fn val_to_f64(v: &Value) -> Option { match v { Value::Num(n) => Some(*n), Value::Str(_) => None, } } // --------------------------------------------------------------------------- // // 执行器 // --------------------------------------------------------------------------- // struct Executor<'a, 'b> { engine: &'a Engine, query: &'b Query, ctx: RowContext<'a>, n: usize, } impl<'a, 'b> Executor<'a, 'b> { fn new(engine: &'a Engine, query: &'b Query, ctx: RowContext<'a>) -> Self { let n = ctx.nrows; Self { engine, query, ctx, n, } } fn run(&self) -> EngineResult { let q = self.query; self.validate_projection()?; let base = match &q.where_ { Some(e) => self.eval_predicate(e)?, None => Operand::Bits(vec![1.0; self.n]), }; let groups = self.build_groups(&base)?; let mut rows: Vec>> = Vec::new(); for (labels, mask) in &groups { let count = sum_mask(mask); let mut row: HashMap> = HashMap::new(); for (k, v) in labels { row.insert(k.clone(), Some(v.clone())); } if self.engine.min_group_size > 0 && (count as usize) < self.engine.min_group_size { if q.group_by.is_empty() { return Err(prive(format!( "命中行数 {count} 低于 k-匿名阈值 {},查询结果被抑制", self.engine.min_group_size ))); } for item in &q.select { if let Expr::Column(c) = &item.expr { let lbl = c.to_string(); if row.contains_key(&lbl) { continue; } } row.insert(item.label(), None); } row.insert("suppressed".into(), Some(Value::Num(1.0))); rows.push(row); continue; } for item in &q.select { let v = self.eval_output(item, mask, count, labels)?; row.insert(item.label(), v); } row.insert("suppressed".into(), Some(Value::Num(0.0))); rows.push(row); } self.post_process(rows) } // -- 投影合法性 -- // fn validate_projection(&self) -> EngineResult<()> { let group_keys: Vec = self.query.group_by.iter().map(|c| c.to_string()).collect(); for item in &self.query.select { self.check_expr(&item.expr, &group_keys, false)?; } Ok(()) } fn check_expr(&self, node: &Expr, group_keys: &[String], inside_agg: bool) -> EngineResult<()> { match node { Expr::Agg { arg, .. } => { if inside_agg { return Err(prive("聚合函数不能嵌套")); } if let Some(a) = arg { self.check_expr(a, group_keys, true)?; } Ok(()) } Expr::Column(c) => { if inside_agg { return Ok(()); } let alias = self.ctx.resolve(c)?; let qualified = format!("{alias}.{}", c.name); if group_keys.iter().any(|k| k == &qualified || k == &c.to_string()) { return Ok(()); } Err(prive(format!( "列 {c} 不是分组键,不能逐行出现在 SELECT 里——那是数据导出,不是查询。请把它包进聚合函数(SUM/AVG/MIN/MAX/COUNT),或放进 GROUP BY。" ))) } Expr::BinOp { left, right, .. } => { self.check_expr(left, group_keys, inside_agg)?; self.check_expr(right, group_keys, inside_agg) } Expr::UnaryOp { operand, .. } => self.check_expr(operand, group_keys, inside_agg), Expr::InList { expr, .. } => self.check_expr(expr, group_keys, inside_agg), Expr::Literal(_) => Ok(()), } } // -- 分组 -- // fn build_groups(&self, base: &Operand) -> EngineResult, Vec)>> { let base_bits = match base { Operand::Bits(b) => b.clone(), _ => return Err(prive("WHERE 里必须是布尔表达式")), }; if self.query.group_by.is_empty() { return Ok(vec![(Vec::new(), base_bits)]); } // 各分组列的公开取值域 let mut cols = Vec::new(); let mut domains: Vec> = Vec::new(); for col in &self.query.group_by { let dom = self.ctx.domain_of(col)?.ok_or_else(|| { prive(format!( "GROUP BY {col} 要求该列的取值域是公开的。请在注册时用 categorical 声明——否则引擎必须先在密态下找出有哪些取值,那本身就是一次泄露。" )) })?; cols.push(col.clone()); domains.push(dom); } let mut out = Vec::new(); for combo in cartesian(&domains) { let mut mask = base_bits.clone(); let mut labels = Vec::new(); for (k, &ci) in combo.iter().enumerate() { let col = &cols[k]; let dom = &domains[k]; let val = &dom[ci]; // 直接用「原始值是否等于域值」生成 0/1,避免字符串列被迫转数值。 let vals = self.ctx.column_values(col)?; let eq: Vec = vals .iter() .map(|v| if v == val { 1.0 } else { 0.0 }) .collect(); mask = mask.iter().zip(&eq).map(|(a, b)| a * b).collect(); labels.push((col.to_string(), val.clone())); } out.push((labels, mask)); } Ok(out) } // -- 表达式求值 -- // fn eval_predicate(&self, node: &Expr) -> EngineResult { let v = self.eval(node)?; match v { Operand::Bits(_) => Ok(v), _ => Err(prive("WHERE / HAVING 里必须是布尔表达式")), } } fn eval(&self, node: &Expr) -> EngineResult { match node { Expr::Literal(Value::Num(n)) => Ok(Operand::Scalar(*n)), Expr::Literal(Value::Str(s)) => Ok(Operand::Str(s.clone())), Expr::Column(c) => { if self.ctx.is_categorical(c)? { let dom = self.ctx.domain_of(c)?.unwrap(); let vals = self.ctx.column_values(c)?; let coded = vals .iter() .map(|v| dom.iter().position(|d| d == v).map(|p| p as f64).unwrap_or(-1.0)) .collect(); Ok(Operand::Coded(coded, dom)) } else { Ok(Operand::NumCol(self.column_f64(c)?)) } } Expr::UnaryOp { op, operand } => match op.as_str() { "NOT" => { let b = self.eval_predicate(operand)?; Ok(negate_bits(&b)) } "-" => { let inner = self.eval(operand)?; Ok(negate_operand(inner)) } other => Err(prive(format!("不支持的一元运算符 {other}"))), }, Expr::InList { expr, values, negated, } => { let mut acc: Option> = None; for v in values { let cmp = self.compare("=", expr, &Expr::Literal(v.clone()))?; let bits = as_bits(&cmp)?; acc = Some(match acc { None => bits, Some(prev) => prev.iter().zip(&bits).map(|(a, b)| if *a > 0.0 || *b > 0.0 { 1.0 } else { 0.0 }).collect(), }); } let bits = acc.unwrap_or_else(|| vec![0.0; self.n]); if *negated { Ok(Operand::Bits(bits.iter().map(|b| 1.0 - b).collect())) } else { Ok(Operand::Bits(bits)) } } Expr::BinOp { op, left, right } => self.eval_binop(op, left, right), Expr::Agg { .. } => Err(prive("聚合函数只能出现在 SELECT / HAVING 里")), } } fn eval_binop(&self, op: &str, left: &Expr, right: &Expr) -> EngineResult { if op == "AND" || op == "OR" { let a = as_bits(&self.eval_predicate(left)?)?; let b = as_bits(&self.eval_predicate(right)?)?; let out = a .iter() .zip(&b) .map(|(x, y)| { if op == "AND" { if *x > 0.0 && *y > 0.0 { 1.0 } else { 0.0 } } else if *x > 0.0 || *y > 0.0 { 1.0 } else { 0.0 } }) .collect(); return Ok(Operand::Bits(out)); } if matches!(op, "=" | "!=" | "<" | "<=" | ">" | ">=") { return self.compare(op, left, right); } let a = self.eval(left)?; let b = self.eval(right)?; arithmetic(op, &a, &b, self.n) } fn compare(&self, op: &str, left: &Expr, right: &Expr) -> EngineResult { let a = self.eval(left)?; let b = self.eval(right)?; let (av, bv) = self.align_coded(a, b, left, right)?; let out: Vec = av .iter() .zip(&bv) .map(|(x, y)| { let ok = match op { "=" => x == y, "!=" => x != y, "<" => x < y, "<=" => x <= y, ">" => x > y, ">=" => x >= y, _ => false, }; if ok { 1.0 } else { 0.0 } }) .collect(); Ok(Operand::Bits(out)) } fn align_coded( &self, left: Operand, right: Operand, left_node: &Expr, right_node: &Expr, ) -> EngineResult<(Vec, Vec)> { let n = self.n; let code_of = |dom: &[Value], lit: &Value| -> EngineResult { dom.iter() .position(|d| d == lit) .map(|p| p as f64) .ok_or_else(|| { prive(format!( "取值域里没有 {lit};已声明的取值:{:?}", dom.iter().map(|v| v.to_string()).collect::>() )) }) }; match (left, right) { (Operand::Coded(v, dom), Operand::Str(s)) => { let code = code_of(&dom, &Value::Str(s))?; Ok((v, vec![code; n])) } (Operand::Coded(v, _dom), Operand::Scalar(s)) => Ok((v, vec![s; n])), (Operand::Str(s), Operand::Coded(v, dom)) => { let code = code_of(&dom, &Value::Str(s))?; Ok((vec![code; n], v)) } (Operand::Scalar(s), Operand::Coded(v, _dom)) => Ok((vec![s; n], v)), (a, b) => { let _ = (left_node, right_node); Ok((operand_to_vec(a, n)?, operand_to_vec(b, n)?)) } } } fn column_f64(&self, col: &Column) -> EngineResult> { let vals = self.ctx.column_values(col)?; vals.iter() .map(|v| { val_to_f64(v).ok_or_else(|| prive(format!("列 {col} 含非数值,无法参与数值运算"))) }) .collect() } // -- 聚合与输出 -- // fn eval_output( &self, item: &SelectItem, mask: &[f64], count: usize, labels: &[(String, Value)], ) -> EngineResult> { if let Expr::Column(c) = &item.expr { let lbl = c.to_string(); if let Some((_, v)) = labels.iter().find(|(k, _)| k == &lbl) { return Ok(Some(v.clone())); } } self.eval_agg_expr(&item.expr, mask, count) } fn eval_agg_expr( &self, node: &Expr, mask: &[f64], count: usize, ) -> EngineResult> { match node { Expr::Agg { func, arg } => self.aggregate(func, arg.as_deref(), mask, count), Expr::Literal(v) => Ok(Some(v.clone())), Expr::Column(c) => Err(prive(format!("列 {c} 不是分组键,不能直接投影"))), Expr::UnaryOp { op, operand } => { let inner = self.eval_agg_expr(operand, mask, count)?; match (op.as_str(), inner) { ("-", Some(Value::Num(n))) => Ok(Some(Value::Num(-n))), ("-", None) => Ok(None), (o, _) => Err(prive(format!("聚合表达式不支持一元运算 {o}"))), } } Expr::BinOp { op, left, right } => { let a = self.eval_agg_expr(left, mask, count)?; let b = self.eval_agg_expr(right, mask, count)?; match (a, b) { (Some(Value::Num(x)), Some(Value::Num(y))) => { let r = match op.as_str() { "+" => x + y, "-" => x - y, "*" => x * y, other => return Err(prive(format!("聚合表达式不支持运算符 {other}"))), }; Ok(Some(Value::Num(r))) } _ => Ok(None), } } Expr::InList { .. } => Err(prive("SELECT 里不支持 IN 表达式")), } } fn aggregate( &self, func: &str, arg: Option<&Expr>, mask: &[f64], count: usize, ) -> EngineResult> { if func == "COUNT" { return Ok(Some(Value::Num(count as f64))); } let arg = arg.ok_or_else(|| prive(format!("{func} 需要一个参数")))?; let col = match arg { Expr::Column(c) => self.column_f64(c)?, _ => { // 允许 SUM(常量) 之类的退化写法 match self.eval(arg)? { Operand::Scalar(s) => vec![s; self.n], Operand::NumCol(v) => v, Operand::Coded(v, _) => v, _ => return Err(prive("聚合参数必须是数值列")), } } }; match func { "SUM" => { let s: f64 = col.iter().zip(mask).map(|(v, m)| v * m).sum(); Ok(Some(Value::Num(s))) } "AVG" => { if count == 0 { return Ok(None); } let s: f64 = col.iter().zip(mask).map(|(v, m)| v * m).sum(); Ok(Some(Value::Num(s / count as f64))) } "MIN" | "MAX" => { if count == 0 { return Ok(None); } let mut best: Option = None; for (v, m) in col.iter().zip(mask) { if *m > 0.0 { best = Some(match best { None => *v, Some(cur) => { if func == "MAX" { cur.max(*v) } else { cur.min(*v) } } }); } } Ok(best.map(Value::Num)) } other => Err(prive(format!("不支持的聚合函数 {other}"))), } } // -- 结果表后处理 -- // fn post_process( &self, rows: Vec>>, ) -> EngineResult { let q = self.query; // 列顺序:分组键 → SELECT 标签(去重) → suppressed let mut columns: Vec = Vec::new(); for col in &q.group_by { let s = col.to_string(); if !columns.contains(&s) { columns.push(s); } } for item in &q.select { let l = item.label(); if !columns.contains(&l) { columns.push(l); } } columns.push("suppressed".into()); // HAVING(明文过滤;抑制行始终保留) let mut keep: Vec = Vec::with_capacity(rows.len()); for row in &rows { let suppressed = matches!(row.get("suppressed"), Some(Some(Value::Num(n))) if *n != 0.0); if suppressed { keep.push(true); continue; } let ok = match &q.having { None => true, Some(node) => self.having_bool(row, node)?, }; keep.push(ok); } let mut out_rows: Vec>> = Vec::new(); for (row, k) in rows.iter().zip(keep) { if !k { continue; } let vals: Vec> = columns .iter() .map(|c| row.get(c).cloned().flatten()) .collect(); out_rows.push(vals); } let suppressed_idx = columns.iter().position(|c| c == "suppressed"); let any_suppressed = out_rows.iter().any(|r| { suppressed_idx .and_then(|j| r.get(j)) .and_then(|v| v.as_ref()) .and_then(|v| v.as_num()) .map(|n| n != 0.0) .unwrap_or(false) }); if !any_suppressed { if let Some(j) = suppressed_idx { columns.remove(j); for r in &mut out_rows { r.remove(j); } } } let mut result = ResultTable { columns, rows: out_rows, }; // ORDER BY if !q.order_by.is_empty() { let mut keys: Vec<(usize, bool)> = Vec::new(); for key in &q.order_by { let name = order_label(key, &q.select); let j = result .columns .iter() .position(|c| c == &name) .ok_or_else(|| prive(format!("ORDER BY {name:?} 不在结果列里:{:?}", result.columns)))?; keys.push((j, key.descending)); } result.rows.sort_by(|a, b| { for &(j, desc) in &keys { let ord = cmp_opt(&a[j], &b[j]); let ord = if desc { ord.reverse() } else { ord }; if ord != std::cmp::Ordering::Equal { return ord; } } std::cmp::Ordering::Equal }); } // LIMIT if let Some(l) = q.limit { result.rows.truncate(l); } Ok(result) } fn having_bool( &self, row: &HashMap>, node: &Expr, ) -> EngineResult { match node { Expr::Literal(Value::Num(n)) => Ok(*n != 0.0), Expr::Literal(Value::Str(s)) => Ok(!s.is_empty()), Expr::Agg { .. } | Expr::Column(_) => { let label = node.label(); let v = row .get(&label) .or_else(|| row.get(&label.replace(' ', ""))) .ok_or_else(|| { prive(format!( "HAVING 引用的 {label:?} 不在 SELECT 结果里(请先 SELECT 出来或起别名)" )) })?; Ok(match v { Some(Value::Num(n)) => *n != 0.0, Some(Value::Str(s)) => !s.is_empty(), None => false, }) } Expr::UnaryOp { op, operand } => match op.as_str() { "NOT" => Ok(!self.having_bool(row, operand)?), "-" => { let v = self.having_num(row, operand)?; Ok(v != 0.0) } o => Err(prive(format!("HAVING 不支持一元运算 {o}"))), }, Expr::BinOp { op, left, right } => match op.as_str() { "AND" => Ok(self.having_bool(row, left)? && self.having_bool(row, right)?), "OR" => Ok(self.having_bool(row, left)? || self.having_bool(row, right)?), "=" | "!=" | "<" | "<=" | ">" | ">=" => { let a = self.having_num(row, left)?; let b = self.having_num(row, right)?; Ok(match op.as_str() { "=" => a == b, "!=" => a != b, "<" => a < b, "<=" => a <= b, ">" => a > b, _ => a >= b, }) } "+" | "-" | "*" => Ok(self.having_num(row, node)? != 0.0), o => Err(prive(format!("HAVING 不支持 {o}"))), }, Expr::InList { .. } => Err(prive("HAVING 不支持 IN")), } } fn having_num(&self, row: &HashMap>, node: &Expr) -> EngineResult { match node { Expr::Literal(Value::Num(n)) => Ok(*n), Expr::Agg { .. } | Expr::Column(_) => { let label = node.label(); let v = row .get(&label) .or_else(|| row.get(&label.replace(' ', ""))) .ok_or_else(|| prive(format!("HAVING 引用的 {label:?} 不在 SELECT 结果里")))?; match v { Some(Value::Num(n)) => Ok(*n), _ => Err(prive(format!("HAVING 引用的 {label:?} 不是数值"))), } } Expr::UnaryOp { op, operand } if op == "-" => Ok(-self.having_num(row, operand)?), Expr::BinOp { op, left, right } => { let a = self.having_num(row, left)?; let b = self.having_num(row, right)?; match op.as_str() { "+" => Ok(a + b), "-" => Ok(a - b), "*" => Ok(a * b), o => Err(prive(format!("HAVING 数值表达式不支持 {o}"))), } } _ => Err(prive("HAVING 无法求值")), } } } // --------------------------------------------------------------------------- // // 辅助 // --------------------------------------------------------------------------- // fn sum_mask(mask: &[f64]) -> usize { mask.iter().filter(|&&m| m > 0.0).count() } fn as_bits(op: &Operand) -> EngineResult> { match op { Operand::Bits(b) => Ok(b.clone()), _ => Err(prive("期望布尔谓词")), } } fn negate_bits(op: &Operand) -> Operand { match op { Operand::Bits(b) => Operand::Bits(b.iter().map(|v| 1.0 - v).collect()), _ => op.clone(), } } fn negate_operand(op: Operand) -> Operand { match op { Operand::Scalar(s) => Operand::Scalar(-s), Operand::NumCol(v) => Operand::NumCol(v.iter().map(|x| -x).collect()), Operand::Coded(v, d) => Operand::Coded(v.iter().map(|x| -x).collect(), d), other => other, } } fn operand_to_vec(op: Operand, n: usize) -> EngineResult> { match op { Operand::Scalar(s) => Ok(vec![s; n]), Operand::NumCol(v) => Ok(v), Operand::Coded(v, _) => Ok(v), Operand::Str(_) => Err(prive("字符串不能参与数值比较")), Operand::Bits(_) => Err(prive("布尔谓词不能直接参与数值比较")), } } fn arithmetic(op: &str, a: &Operand, b: &Operand, n: usize) -> EngineResult { // 若两侧都是标量,直接算 if let (Operand::Scalar(x), Operand::Scalar(y)) = (a, b) { return Ok(Operand::Scalar(match op { "+" => x + y, "-" => x - y, "*" => x * y, other => return Err(prive(format!("不支持的运算符 {other}(密态除法未实现)"))), })); } let av = operand_vec_for_arith(a, n)?; let bv = operand_vec_for_arith(b, n)?; let out: Vec = av .iter() .zip(&bv) .map(|(x, y)| match op { "+" => x + y, "-" => x - y, "*" => x * y, _ => 0.0, }) .collect(); Ok(Operand::NumCol(out)) } fn operand_vec_for_arith(op: &Operand, n: usize) -> EngineResult> { match op { Operand::Scalar(s) => Ok(vec![*s; n]), Operand::NumCol(v) => Ok(v.clone()), Operand::Coded(v, _) => Ok(v.clone()), Operand::Str(_) => Err(prive("字符串不能参与算术运算")), Operand::Bits(_) => Err(prive("布尔谓词不能直接参与算术运算")), } } fn cartesian(domains: &[Vec]) -> Vec> { let mut out: Vec> = vec![Vec::new()]; for dom in domains { let mut next = Vec::new(); for prefix in &out { for i in 0..dom.len() { let mut p = prefix.clone(); p.push(i); next.push(p); } } out = next; } out } fn order_label(key: &OrderKey, select: &[SelectItem]) -> String { if let Expr::Column(c) = &key.expr { if c.table.is_none() { for item in select { if item.alias.as_deref() == Some(c.name.as_str()) { return item.alias.clone().unwrap(); } } return c.name.clone(); } } let target = key.expr.label(); for item in select { if item.expr.label() == target { return item.label(); } } target } fn cmp_opt(a: &Option, b: &Option) -> std::cmp::Ordering { match (a, b) { (Some(x), Some(y)) => value_cmp(x, y), (Some(_), None) => std::cmp::Ordering::Less, (None, Some(_)) => std::cmp::Ordering::Greater, (None, None) => std::cmp::Ordering::Equal, } }