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
494 lines
18 KiB
Rust
494 lines
18 KiB
Rust
//! JOIN + PSI 接进密态 SQL:2 方 in-process 端到端,逐值对拍明文引擎。
|
||
//!
|
||
//! ```text
|
||
//! PSI(mpc-node::run_psi_session)
|
||
//! → 按共享规范键排序、裁剪(发生在这里,调用方)
|
||
//! → 切分片 + 交换(mpc-sql::secure::exchange_split_columns)
|
||
//! → 密态掩码 WHERE / 聚合 / GROUP BY(mpc-sql::secure)
|
||
//! → reveal,与明文 Engine 的等价 JOIN 查询逐值比对
|
||
//! ```
|
||
//!
|
||
//! # 分层:为什么 PSI 和对齐不在 `mpc-sql` 里
|
||
//!
|
||
//! `mpc-sql::secure` 只吃「已对齐的分片」,库依赖图里没有 `mpc-node`/`mpc-psi`。
|
||
//! PSI 是**调用方**的编排责任(生产环境是 `mpc-cli`,这里是测试),
|
||
//! 否则 SQL 层会被钉死在「先做 PSI 才能查」这一种拓扑上。本文件的
|
||
//! `mpc-node`/`mpc-psi` 是 **dev-dependency**,不进库的依赖闭包。
|
||
//!
|
||
//! # 为什么必须排序才能对齐
|
||
//!
|
||
//! PSI 只回答「本方哪几条记录在交集里」,返回的是**本地行序**升序的下标;
|
||
//! 两方拿到的下标序列互不相同、也不含共享顺序。而纵向聚合要求
|
||
//! 「两方的第 i 行是同一个人」,所以两边必须按同一个全序重排 ——
|
||
//! 这里用 join 键的字节序(十进制编码后的字典序)。
|
||
//!
|
||
//! 副作用(已知且接受):排序暴露了本方键相对对端键的秩,与 PSI 本身
|
||
//! 泄露交集是同一量级的元信息;不排序则结果直接错。
|
||
//!
|
||
//! 测试数据故意让两方本地顺序**相反**:不排序就会算错(见
|
||
//! [`alignment_orders_both_sides_identically`] 与 WHERE 用例的期望值)。
|
||
|
||
#![cfg(feature = "secure")]
|
||
|
||
use std::thread;
|
||
|
||
use mpc_node::{run_psi_session, PsiConfig};
|
||
use mpc_psi::id_from_u64;
|
||
use mpc_sql::engine::{ColData, Engine, ResultTable, Table};
|
||
use mpc_sql::secure::{
|
||
exchange_split_columns, secure_aggregate_all, secure_group_by, secure_where_aggregate_pred,
|
||
Agg, CmpOp, Pred,
|
||
};
|
||
use mpc_vault::{Pipe, Transport, Vault};
|
||
|
||
const FXP: u32 = 18;
|
||
const SITES: [&str; 2] = ["alice", "bob"];
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 数据:alice 持 (id, balance),bob 持 (uid, spend, region)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// 一方的表。`ids` 是 join 键;`cols` 是数值列(f64,密态侧按 fxp 编码)。
|
||
#[derive(Clone)]
|
||
struct Party {
|
||
site: &'static str,
|
||
/// PSI 会话种子。两方**故意不同** —— 同种子等于双方私钥相同,
|
||
/// ECDH 就退化成一个共享标量,测不出真实协议的交换律。
|
||
psi_seed: [u8; 32],
|
||
ids: Vec<u64>,
|
||
cols: Vec<Vec<f64>>,
|
||
}
|
||
|
||
impl Party {
|
||
/// PSI 用的键字节(与 `mpc_psi::id_from_u64` 的十进制编码一致)。
|
||
fn keys(&self) -> Vec<Vec<u8>> {
|
||
self.ids.iter().map(|v| id_from_u64(*v)).collect()
|
||
}
|
||
|
||
/// 按给定行序重排列。
|
||
fn take_rows(&self, order: &[usize]) -> Vec<Vec<f64>> {
|
||
self.cols
|
||
.iter()
|
||
.map(|c| order.iter().map(|&i| c[i]).collect())
|
||
.collect()
|
||
}
|
||
}
|
||
|
||
/// 两方本地顺序**互不相同**,交集 = {2, 3, 4}(3 条)。
|
||
fn sample() -> (Party, Party) {
|
||
let alice = Party {
|
||
site: "alice",
|
||
psi_seed: [0x11; 32],
|
||
ids: vec![7, 2, 4, 1, 8, 3],
|
||
cols: vec![vec![700.0, 200.0, 400.0, 100.0, 800.0, 300.0]], // balance
|
||
};
|
||
let bob = Party {
|
||
site: "bob",
|
||
psi_seed: [0x22; 32],
|
||
ids: vec![4, 9, 2, 3, 5],
|
||
cols: vec![
|
||
vec![40.0, 90.0, 20.0, 30.0, 50.0], // spend
|
||
vec![1.0, 0.0, 0.0, 0.0, 1.0], // region(公开组码)
|
||
],
|
||
};
|
||
(alice, bob)
|
||
}
|
||
|
||
/// 对齐后(键 2,3,4)两方的行:
|
||
///
|
||
/// | key | alice.balance | bob.spend | bob.region |
|
||
/// |-----|---------------|-----------|------------|
|
||
/// | 2 | 200 | 20 | 0 |
|
||
/// | 3 | 300 | 30 | 0 |
|
||
/// | 4 | 400 | 40 | 1 |
|
||
///
|
||
/// 若 alice 少排了序,行序会变成 (2, 4, 3) → balance 列 [200, 400, 300]
|
||
/// 对上 spend [20, 30, 40],`balance >= 250 AND spend < 40` 会算出
|
||
/// 400 而不是 300 —— WHERE 用例的期望值就是用来抓这个的。
|
||
fn plaintext(a: &Party, b: &Party) -> Engine {
|
||
let bank = Table::new("bank", "alice")
|
||
.with_col(
|
||
"id",
|
||
ColData::Num(a.ids.iter().map(|&v| v as f64).collect()),
|
||
)
|
||
.with_col("balance", ColData::Num(a.cols[0].clone()))
|
||
.with_key("id");
|
||
let shop = Table::new("shop", "bob")
|
||
.with_col(
|
||
"uid",
|
||
ColData::Num(b.ids.iter().map(|&v| v as f64).collect()),
|
||
)
|
||
.with_col("spend", ColData::Num(b.cols[0].clone()))
|
||
.with_col("region", ColData::Num(b.cols[1].clone()))
|
||
// GROUP BY 要求取值域公开:region 是公开组码 0/1
|
||
.with_public("region")
|
||
.with_key("uid");
|
||
let mut e = Engine::new(0);
|
||
e.register(bank);
|
||
e.register(shop);
|
||
e
|
||
}
|
||
|
||
fn num(rt: &ResultTable, row: usize, col: &str) -> f64 {
|
||
rt.get(row, col).and_then(|v| v.as_num()).expect("数值")
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 行对齐:调用方的责任
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// 把「本方落在交集里的行」按**共享规范键**排序,返回按对齐行序排列的行下标。
|
||
///
|
||
/// 排序键是键的字节序 —— 任何两方一致的**全序**都行,重要的是不能依赖
|
||
/// 本地行序(PSI 给的正是本地行序)。
|
||
fn align_by_key(keys: &[Vec<u8>], hits: &[usize]) -> Result<Vec<usize>, String> {
|
||
if hits.is_empty() {
|
||
// 零命中不是「结果为空」而是「这次 join 没有公共样本」——
|
||
// 继续往下跑会让两方都拿着空列去 open,必须在这里明确失败。
|
||
return Err("交集为空:两方没有可对齐的行".into());
|
||
}
|
||
if let Some(&bad) = hits.iter().find(|&&i| i >= keys.len()) {
|
||
return Err(format!("PSI 交集中出现越界下标 {bad}"));
|
||
}
|
||
let mut order = hits.to_vec();
|
||
order.sort_by(|&x, &y| keys[x].cmp(&keys[y]));
|
||
// 本方键必须唯一:重复键对应一对多 join,纵向对齐(一人一行)表达不了
|
||
if let Some(w) = order.windows(2).find(|w| keys[w[0]] == keys[w[1]]) {
|
||
return Err(format!(
|
||
"join 键在本方重复(第 {} 与第 {} 行),一对多 join 不支持",
|
||
w[0], w[1]
|
||
));
|
||
}
|
||
Ok(order)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 密态侧:同一份「计划」在两边对称执行
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// 一条查询在密态侧的执行方式。列下标是**全局列序**(alice 的列在前)。
|
||
///
|
||
/// 两边必须执行完全相同的计划:MPC 的每一轮都是对称的,一侧多跑一次
|
||
/// `bit_lt` 就会和另一侧错开一帧,然后死锁。
|
||
#[derive(Clone)]
|
||
enum Plan {
|
||
/// 无 WHERE:`SELECT <aggs(col)> FROM <已对齐>`。
|
||
All { col: usize, aggs: Vec<Agg> },
|
||
/// `SELECT <aggs(col)> FROM <已对齐> WHERE <pred>`。
|
||
Where {
|
||
pred: Pred,
|
||
col: usize,
|
||
aggs: Vec<Agg>,
|
||
},
|
||
/// `SELECT g, <aggs(col)> ... GROUP BY g`,`g` 的取值域是公开码 `0..n`。
|
||
GroupBy {
|
||
col: usize,
|
||
gcol: usize,
|
||
n_groups: usize,
|
||
aggs: Vec<Agg>,
|
||
},
|
||
}
|
||
|
||
impl Plan {
|
||
fn run<T: Transport>(&self, vault: &mut Vault<T>, cols: &[Vec<u64>]) -> Result<Vec<f64>, String> {
|
||
let e = |err: mpc_vault::VaultError| err.to_string();
|
||
match self {
|
||
Self::All { col, aggs } => secure_aggregate_all(vault, &cols[*col], aggs).map_err(e),
|
||
Self::Where { pred, col, aggs } => {
|
||
secure_where_aggregate_pred(vault, cols, pred, *col, aggs).map_err(e)
|
||
}
|
||
Self::GroupBy {
|
||
col,
|
||
gcol,
|
||
n_groups,
|
||
aggs,
|
||
} => {
|
||
let rows = secure_group_by(vault, &cols[*col], &cols[*gcol], *n_groups, None, aggs, 0)
|
||
.map_err(e)?;
|
||
Ok(rows.into_iter().flatten().collect())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 一方的完整链路。返回 `(对齐后的键序列, 本方算出的聚合值)`。
|
||
///
|
||
/// 键序列回传给测试,用来交叉确认两方**确实对齐到了同一顺序**。
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn party_run(
|
||
psi: Pipe,
|
||
vault_pipe: Pipe,
|
||
me: &Party,
|
||
col_off: usize,
|
||
peer_cols: usize,
|
||
peer_off: usize,
|
||
total_cols: usize,
|
||
plan: &Plan,
|
||
seed: [u8; 32],
|
||
) -> Result<(Vec<Vec<u8>>, Vec<f64>), String> {
|
||
let keys = me.keys();
|
||
|
||
// 1) PSI:本方交集下标,按本地行序升序
|
||
// 两方单连接,my_idx 只决定环上的前后继(n=2 时两者都是唯一对端)
|
||
let my_idx = SITES
|
||
.iter()
|
||
.position(|s| *s == me.site)
|
||
.ok_or_else(|| format!("{} 不在 SITES 里", me.site))?;
|
||
let cfg = PsiConfig {
|
||
site: me.site.to_string(),
|
||
sites: SITES.iter().map(|s| s.to_string()).collect(),
|
||
my_idx,
|
||
ids: keys.clone(),
|
||
seed: me.psi_seed,
|
||
// session 取共享主种子(两方一致),psi_seed 是每方不同的
|
||
session: mpc_psi::strict::session_id(&seed),
|
||
};
|
||
let hits = run_psi_session(psi, &cfg, false).map_err(|e| format!("PSI 失败: {e}"))?;
|
||
|
||
// 2) 按共享规范键排序 —— 两边得到同一个顺序
|
||
let order = align_by_key(&keys, &hits)?;
|
||
|
||
// 3) 只留交集行,并按对齐行序重排
|
||
let aligned = me.take_rows(&order);
|
||
|
||
// 4) 切分片 + 交换(先全发、再全收)
|
||
let mut vault = Vault::new(vault_pipe, me.site, &SITES, seed, FXP)
|
||
.map_err(|e| format!("Vault 初始化失败: {e}"))?;
|
||
let (mine, theirs) =
|
||
exchange_split_columns(&mut vault, &aligned, peer_cols).map_err(|e| format!("列交换失败: {e}"))?;
|
||
|
||
// 5) 拼成全局列序(公开 schema:alice 的列在前、bob 的在后)
|
||
let mut cols = vec![Vec::new(); total_cols];
|
||
for (k, c) in mine.into_iter().enumerate() {
|
||
cols[col_off + k] = c;
|
||
}
|
||
for (k, c) in theirs.into_iter().enumerate() {
|
||
cols[peer_off + k] = c;
|
||
}
|
||
|
||
// 6) 密态聚合(内部 reveal)
|
||
let vals = plan.run(&mut vault, &cols)?;
|
||
|
||
let aligned_keys = order.iter().map(|&i| keys[i].clone()).collect();
|
||
Ok((aligned_keys, vals))
|
||
}
|
||
|
||
/// 起两条独立管道跑完整两方会话,返回两方各自的 `(键序列, 结果)`。
|
||
///
|
||
/// PSI 与密态会话各用一对管道:两者协议无关,混用同一条管道会让帧串到
|
||
/// 对方的 `recv` 上(`Shares` 与 `PsiPoints` 的 op 不同,会直接报协议错)。
|
||
fn run_two_party(a: &Party, b: &Party, plan: Plan) -> ((Vec<Vec<u8>>, Vec<f64>), (Vec<Vec<u8>>, Vec<f64>)) {
|
||
let n_a = a.cols.len();
|
||
let n_b = b.cols.len();
|
||
let seed = [0x5Bu8; 32]; // 共享会话主种子:Beaver 物料由它派生,两边必须一致
|
||
|
||
let (psi_a, psi_b) = Pipe::pair();
|
||
let (va, vb) = Pipe::pair();
|
||
|
||
let (a, b, plan_b) = (a.clone(), b.clone(), plan.clone());
|
||
let ha = thread::spawn(move || {
|
||
party_run(psi_a, va, &a, 0, n_b, n_a, n_a + n_b, &plan, seed)
|
||
.unwrap_or_else(|e| panic!("alice 侧失败: {e}"))
|
||
});
|
||
let hb = thread::spawn(move || {
|
||
party_run(psi_b, vb, &b, n_a, n_a, 0, n_a + n_b, &plan_b, seed)
|
||
.unwrap_or_else(|e| panic!("bob 侧失败: {e}"))
|
||
});
|
||
(ha.join().expect("alice 线程"), hb.join().expect("bob 线程"))
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 用例
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// 前提自检:PSI 输出(本地行序)两边不同,排序后才一致。
|
||
///
|
||
/// 这条测试同时防止「数据改得太巧,排序没生效也能过」。
|
||
#[test]
|
||
fn alignment_orders_both_sides_identically() {
|
||
let (a, b) = sample();
|
||
let (ka, kb) = (a.keys(), b.keys());
|
||
|
||
// 明文求交,模拟 PSI 的输出形状(本方交集下标、本地行序升序)
|
||
let mut sorted_b = kb.clone();
|
||
sorted_b.sort();
|
||
let hits_a: Vec<usize> = (0..ka.len())
|
||
.filter(|&i| sorted_b.binary_search(&ka[i]).is_ok())
|
||
.collect();
|
||
let mut sorted_a = ka.clone();
|
||
sorted_a.sort();
|
||
let hits_b: Vec<usize> = (0..kb.len())
|
||
.filter(|&i| sorted_a.binary_search(&kb[i]).is_ok())
|
||
.collect();
|
||
|
||
assert_eq!(hits_a, vec![1, 2, 5], "alice 侧交集下标");
|
||
assert_eq!(hits_b, vec![0, 2, 3], "bob 侧交集下标");
|
||
|
||
// 未排序:两边的键序列不同 —— 直接拿去切分片就是行错位
|
||
let raw_a: Vec<&Vec<u8>> = hits_a.iter().map(|&i| &ka[i]).collect();
|
||
let raw_b: Vec<&Vec<u8>> = hits_b.iter().map(|&i| &kb[i]).collect();
|
||
assert_ne!(raw_a, raw_b, "测试数据必须让两方本地顺序不同");
|
||
|
||
// 排序后:两边键序列逐条相同
|
||
let oa = align_by_key(&ka, &hits_a).unwrap();
|
||
let ob = align_by_key(&kb, &hits_b).unwrap();
|
||
let sa: Vec<&Vec<u8>> = oa.iter().map(|&i| &ka[i]).collect();
|
||
let sb: Vec<&Vec<u8>> = ob.iter().map(|&i| &kb[i]).collect();
|
||
assert_eq!(sa, sb, "排序后两方键序列必须一致");
|
||
assert_eq!(
|
||
sa,
|
||
vec![b"2".to_vec(), b"3".to_vec(), b"4".to_vec()]
|
||
.iter()
|
||
.collect::<Vec<_>>(),
|
||
"规范序 = 键字节序"
|
||
);
|
||
}
|
||
|
||
/// 重复键(一对多 join)必须在切分片之前拦下,而不是静默按行号错拼。
|
||
#[test]
|
||
fn alignment_rejects_duplicate_keys() {
|
||
let keys = vec![b"1".to_vec(), b"2".to_vec(), b"2".to_vec()];
|
||
let err = align_by_key(&keys, &[0, 1, 2]).unwrap_err();
|
||
assert!(err.contains("重复"), "错误信息应指出键重复: {err}");
|
||
// 越界下标来自协议错乱,同样要拦
|
||
assert!(align_by_key(&keys, &[0, 3]).is_err());
|
||
}
|
||
|
||
/// join 后 COUNT / SUM(无 WHERE),对拍 `SELECT COUNT(*), SUM(...) FROM bank JOIN shop`。
|
||
#[test]
|
||
fn join_count_sum_matches_engine() {
|
||
let (a, b) = sample();
|
||
let e = plaintext(&a, &b);
|
||
let rt = e
|
||
.sql(
|
||
"SELECT COUNT(*) AS n, SUM(bank.balance) AS b, SUM(shop.spend) AS s \
|
||
FROM bank JOIN shop ON bank.id = shop.uid",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(num(&rt, 0, "n"), 3.0);
|
||
assert_eq!(num(&rt, 0, "b"), 900.0);
|
||
assert_eq!(num(&rt, 0, "s"), 90.0);
|
||
|
||
// 一次会话只能对一列求聚合,所以按列各跑一遍(计划两边对称即可)
|
||
let (r, r2) = run_two_party(
|
||
&a,
|
||
&b,
|
||
Plan::All {
|
||
col: 0,
|
||
aggs: vec![Agg::Count, Agg::Sum],
|
||
},
|
||
);
|
||
assert_eq!(r.0, r2.0, "两方对齐后的键序列必须一致");
|
||
assert_eq!(r.0.len(), 3, "交集 3 条");
|
||
// 整数在 fxp=18 下可精确表示,求和也精确 —— 不设容差
|
||
assert_eq!(r.1[0], 3.0, "COUNT");
|
||
assert_eq!(r.1[1], 900.0, "SUM(balance)");
|
||
|
||
let (r, r2) = run_two_party(
|
||
&a,
|
||
&b,
|
||
Plan::All {
|
||
col: 1,
|
||
aggs: vec![Agg::Sum],
|
||
},
|
||
);
|
||
assert_eq!(r2.1, r.1, "本端与对端 reveal 出的结果必须相同");
|
||
assert_eq!(r.1[0], 90.0, "SUM(spend)");
|
||
}
|
||
|
||
/// join + WHERE(跨两方的复合谓词)—— 行没对齐就会算错的那条。
|
||
#[test]
|
||
fn join_where_matches_engine() {
|
||
let (a, b) = sample();
|
||
let e = plaintext(&a, &b);
|
||
let sql = "SELECT COUNT(*) AS n, SUM(bank.balance) AS b, SUM(shop.spend) AS s \
|
||
FROM bank JOIN shop ON bank.id = shop.uid \
|
||
WHERE bank.balance >= 250 AND shop.spend < 40";
|
||
let rt = e.sql(sql).unwrap();
|
||
// 命中只有键 3 那一行:(balance 300, spend 30)
|
||
assert_eq!(num(&rt, 0, "n"), 1.0);
|
||
assert_eq!(num(&rt, 0, "b"), 300.0);
|
||
assert_eq!(num(&rt, 0, "s"), 30.0);
|
||
|
||
// 谓词跨两方:col 0 = alice.balance,col 1 = bob.spend
|
||
let pred = Pred::And(
|
||
Box::new(Pred::Cmp {
|
||
col: 0,
|
||
op: CmpOp::Ge,
|
||
threshold: 250.0,
|
||
}),
|
||
Box::new(Pred::Cmp {
|
||
col: 1,
|
||
op: CmpOp::Lt,
|
||
threshold: 40.0,
|
||
}),
|
||
);
|
||
|
||
let (r, r2) = run_two_party(
|
||
&a,
|
||
&b,
|
||
Plan::Where {
|
||
pred: pred.clone(),
|
||
col: 0,
|
||
aggs: vec![Agg::Count, Agg::Sum],
|
||
},
|
||
);
|
||
assert_eq!(r.1[0], num(&rt, 0, "n"), "COUNT");
|
||
assert_eq!(r.1[1], num(&rt, 0, "b"), "SUM(balance)");
|
||
|
||
let (r, _) = run_two_party(
|
||
&a,
|
||
&b,
|
||
Plan::Where {
|
||
pred,
|
||
col: 1,
|
||
aggs: vec![Agg::Sum],
|
||
},
|
||
);
|
||
assert_eq!(r.1[0], num(&rt, 0, "s"), "SUM(spend)");
|
||
let _ = r2;
|
||
}
|
||
|
||
/// join + GROUP BY:按 bob 的公开地区码分组,对拍 `GROUP BY shop.region`。
|
||
#[test]
|
||
fn join_group_by_matches_engine() {
|
||
let (a, b) = sample();
|
||
let e = plaintext(&a, &b);
|
||
let rt = e
|
||
.sql(
|
||
"SELECT shop.region AS r, COUNT(*) AS n, SUM(shop.spend) AS s \
|
||
FROM bank JOIN shop ON bank.id = shop.uid GROUP BY shop.region",
|
||
)
|
||
.unwrap();
|
||
// 域顺序 [0, 1]:组0 = 键 2,3 → n=2, s=50;组1 = 键 4 → n=1, s=40
|
||
assert_eq!(rt.nrows(), 2);
|
||
assert_eq!(num(&rt, 0, "n"), 2.0);
|
||
assert_eq!(num(&rt, 0, "s"), 50.0);
|
||
assert_eq!(num(&rt, 1, "n"), 1.0);
|
||
assert_eq!(num(&rt, 1, "s"), 40.0);
|
||
|
||
let (r, r2) = run_two_party(
|
||
&a,
|
||
&b,
|
||
Plan::GroupBy {
|
||
col: 1,
|
||
gcol: 2,
|
||
n_groups: 2,
|
||
aggs: vec![Agg::Count, Agg::Sum],
|
||
},
|
||
);
|
||
assert_eq!(r.1, r2.1, "两方 GROUP BY 结果必须一致");
|
||
// 扁平成 [n0, s0, n1, s1]
|
||
assert_eq!(r.1[0], 2.0, "组0 COUNT");
|
||
assert_eq!(r.1[1], 50.0, "组0 SUM");
|
||
assert_eq!(r.1[2], 1.0, "组1 COUNT");
|
||
assert_eq!(r.1[3], 40.0, "组1 SUM");
|
||
}
|
||
|
||
/// 交集为空时:PSI 返回空下标 → 对齐阶段就该报错(而不是拿空列表去跑聚合)。
|
||
#[test]
|
||
fn disjoint_tables_fail_before_aggregation() {
|
||
let keys = vec![b"1".to_vec(), b"2".to_vec()];
|
||
assert!(align_by_key(&keys, &[]).is_err(), "空交集应显式失败");
|
||
}
|