ci / gate (push) Waiting to run
- 项目与文档标题: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
1117 lines
38 KiB
Rust
1117 lines
38 KiB
Rust
//! 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,
|
||
}
|
||
}
|