Files
ssw-mpc/crates/mpc-sql/src/engine.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

1117 lines
38 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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<f64>),
Str(Vec<String>),
}
/// 一张注册进引擎的表(列主序)。
#[derive(Clone, Debug)]
pub struct Table {
pub name: String,
pub site: String,
pub columns: Vec<String>,
pub data: Vec<Vec<Value>>,
pub key: Option<String>,
pub categorical: HashMap<String, Vec<Value>>,
pub public: Vec<String>,
}
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<Value> = 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<Value>> {
self.columns
.iter()
.position(|c| c == name)
.map(|j| &self.data[j])
}
}
/// 结果表:单元格可为空(被 k-匿名抑制)。
#[derive(Clone, Debug, Default)]
pub struct ResultTable {
pub columns: Vec<String>,
pub rows: Vec<Vec<Option<Value>>>,
}
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<T> = Result<T, SqlError>;
fn prive(msg: impl Into<String>) -> SqlError {
SqlError::new(msg)
}
/// 查询引擎(明文版)。
pub struct Engine {
pub reveal_to: Option<String>,
pub min_group_size: usize,
tables: HashMap<String, Table>,
}
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<ResultTable> {
let query = parse(text)?;
let ctx = RowContext::new(self, &query)?;
Executor::new(self, &query, ctx).run()
}
pub fn explain(&self, text: &str) -> EngineResult<String> {
let q = parse(text)?;
let mut lines = vec![format!("query : {}", text.split_whitespace().collect::<Vec<_>>().join(" "))];
let keys: Vec<String> = 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<String> = 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<String> = 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<String, &'a Table>,
/// 别名 → (列名 → 对齐后的列值),同一批行。
aligned: HashMap<String, HashMap<String, Vec<Value>>>,
nrows: usize,
}
impl<'a> RowContext<'a> {
fn new(engine: &'a Engine, query: &Query) -> EngineResult<Self> {
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<String> {
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<Vec<Value>> {
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<Option<Vec<Value>>> {
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<bool> {
Ok(self.domain_of(col)?.is_some())
}
}
fn sorted_keys(m: &HashMap<String, Table>) -> Vec<String> {
let mut v: Vec<String> = m.keys().cloned().collect();
v.sort();
v
}
fn table_columns(t: &Table) -> HashMap<String, Vec<Value>> {
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<String, Vec<Value>> {
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<usize>, Vec<usize>, 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<String, Vec<usize>> = 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<Value> {
let mut out: Vec<Value> = 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<f64>),
Coded(Vec<f64>, Vec<Value>),
Bits(Vec<f64>),
}
fn val_to_f64(v: &Value) -> Option<f64> {
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<ResultTable> {
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<HashMap<String, Option<Value>>> = Vec::new();
for (labels, mask) in &groups {
let count = sum_mask(mask);
let mut row: HashMap<String, Option<Value>> = 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<String> = 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<(Vec<(String, Value)>, Vec<f64>)>> {
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<Value>> = 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<f64> = 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<Operand> {
let v = self.eval(node)?;
match v {
Operand::Bits(_) => Ok(v),
_ => Err(prive("WHERE / HAVING 里必须是布尔表达式")),
}
}
fn eval(&self, node: &Expr) -> EngineResult<Operand> {
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<Vec<f64>> = 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<Operand> {
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<Operand> {
let a = self.eval(left)?;
let b = self.eval(right)?;
let (av, bv) = self.align_coded(a, b, left, right)?;
let out: Vec<f64> = 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<f64>, Vec<f64>)> {
let n = self.n;
let code_of = |dom: &[Value], lit: &Value| -> EngineResult<f64> {
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::<Vec<_>>()
))
})
};
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<Vec<f64>> {
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<Option<Value>> {
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<Option<Value>> {
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<Option<Value>> {
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<f64> = 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<HashMap<String, Option<Value>>>,
) -> EngineResult<ResultTable> {
let q = self.query;
// 列顺序:分组键 → SELECT 标签(去重) → suppressed
let mut columns: Vec<String> = 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<bool> = 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<Option<Value>>> = Vec::new();
for (row, k) in rows.iter().zip(keep) {
if !k {
continue;
}
let vals: Vec<Option<Value>> = 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<String, Option<Value>>,
node: &Expr,
) -> EngineResult<bool> {
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<String, Option<Value>>, node: &Expr) -> EngineResult<f64> {
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<Vec<f64>> {
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<Vec<f64>> {
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<Operand> {
// 若两侧都是标量,直接算
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<f64> = 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<Vec<f64>> {
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<Value>]) -> Vec<Vec<usize>> {
let mut out: Vec<Vec<usize>> = 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<Value>, b: &Option<Value>) -> 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,
}
}