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
601 lines
22 KiB
Rust
601 lines
22 KiB
Rust
//! `mpc sql-join`:**真两进程 TCP** 的 JOIN × PSI × 密态 SQL 演示。
|
||
//!
|
||
//! 与 `mpc sql`(in-process `Pipe::pair`)的区别:这里走真实 TCP,两个终端各起一方,
|
||
//! 流程是 PSI 求交 → 按键字节序排序对齐 → 列分片交换 → 密态聚合 → reveal。
|
||
//!
|
||
//! 分层约定:PSI 与行对齐在**本模块**(调用方),`mpc-sql::secure` 只吃已对齐的分片。
|
||
//! 对齐助手是 [`mpc_psi::align_by_key`],不在 `mpc-sql` 里。
|
||
//!
|
||
//! # 全局列序:`--schema`
|
||
//!
|
||
//! 竖向切分里两方各持**不同列**(alice 持 `balance`、bob 持 `spend,region`),
|
||
//! 密态聚合前必须拼出一致的全局列序。本模块用**公开 schema**约定:
|
||
//!
|
||
//! ```text
|
||
//! --schema balance,spend,region ← 两方必须完全一致
|
||
//! alice: --data balance=... ← 只给自己拥有的列
|
||
//! bob: --data spend=... --data region=...
|
||
//! ```
|
||
//!
|
||
//! 列交换后按 schema 下标落位,而不是简单 `mine + theirs` —— 后者两方拼出来
|
||
//! 的顺序不同(alice 得 `[b,s,r]`、bob 得 `[s,r,b]`),谓词下标会静默错位。
|
||
|
||
use mpc_node::{run_psi_session, PsiConfig, TcpTransport};
|
||
use mpc_sql::secure::{
|
||
exchange_split_columns, secure_aggregate_all, secure_where_aggregate_pred, Agg, CmpOp, Pred,
|
||
};
|
||
use mpc_vault::Vault;
|
||
|
||
/// 解析 `--data name=v1,v2,...` 为 `(列名, 列值)`。
|
||
pub fn parse_col(spec: &str) -> Result<(String, Vec<f64>), String> {
|
||
let (name, rest) = spec
|
||
.split_once('=')
|
||
.ok_or_else(|| format!("--data 缺少 '=': {spec:?}"))?;
|
||
let name = name.trim().to_string();
|
||
if name.is_empty() {
|
||
return Err("--data 列名为空".into());
|
||
}
|
||
let vals: Vec<f64> = rest
|
||
.split(',')
|
||
.map(|t| t.trim().parse::<f64>().map_err(|_| format!("--data {name:?} 里 {t:?} 不是浮点")))
|
||
.collect::<Result<_, _>>()?;
|
||
if vals.is_empty() {
|
||
return Err(format!("--data {name:?} 没有值"));
|
||
}
|
||
Ok((name, vals))
|
||
}
|
||
|
||
/// 解析 `--schema col1,col2,...` 为全局列名数组。
|
||
pub fn parse_schema(spec: &str) -> Result<Vec<String>, String> {
|
||
let names: Vec<String> = spec
|
||
.split(',')
|
||
.map(|s| s.trim().to_string())
|
||
.filter(|s| !s.is_empty())
|
||
.collect();
|
||
if names.len() < 2 {
|
||
return Err(format!("--schema 至少要两列,得到 {names:?}"));
|
||
}
|
||
let mut sorted = names.clone();
|
||
sorted.sort();
|
||
sorted.dedup();
|
||
if sorted.len() != names.len() {
|
||
return Err("--schema 有重复列名".into());
|
||
}
|
||
Ok(names)
|
||
}
|
||
|
||
/// 解析 `--pred` 为 [`Pred`](下标相对 schema)。
|
||
///
|
||
/// - `col OP col` —— 列 vs 列(如 `balance > spend`)
|
||
/// - `col OP 数字` —— 列 vs 公开常量(如 `balance >= 250`)
|
||
fn parse_pred(text: &str, schema: &[String]) -> Result<Pred, String> {
|
||
let find = |s: &str| -> Result<usize, String> {
|
||
schema
|
||
.iter()
|
||
.position(|n| n == s)
|
||
.ok_or_else(|| format!("谓词里的列 {s:?} 不在 schema {schema:?} 里"))
|
||
};
|
||
for (tok, op) in [
|
||
(">=", CmpOp::Ge),
|
||
("<=", CmpOp::Le),
|
||
("!=", CmpOp::Ne),
|
||
(">", CmpOp::Gt),
|
||
("<", CmpOp::Lt),
|
||
("=", CmpOp::Eq),
|
||
] {
|
||
if let Some((lhs, rhs)) = text.split_once(tok) {
|
||
let l = lhs.trim();
|
||
let r = rhs.trim();
|
||
if l.is_empty() || r.is_empty() {
|
||
return Err(format!("谓词两侧不能为空: {text:?}"));
|
||
}
|
||
let li = find(l)?;
|
||
if let Some(ri) = schema.iter().position(|n| n == r) {
|
||
return Ok(Pred::CmpCol {
|
||
col: li,
|
||
op,
|
||
rhs_col: ri,
|
||
});
|
||
}
|
||
let th: f64 = r
|
||
.parse()
|
||
.map_err(|_| format!("谓词右值 {r:?} 既不是列名也不是数字"))?;
|
||
return Ok(Pred::Cmp {
|
||
col: li,
|
||
op,
|
||
threshold: th,
|
||
});
|
||
}
|
||
}
|
||
Err(format!("谓词 {text:?} 里没找到比较运算符(>= <= != > < =)"))
|
||
}
|
||
|
||
/// 跑一方:TCP 连接 → PSI → 对齐 → 列交换 → 密态聚合。
|
||
///
|
||
/// 返回 `(对齐后的键序列, [COUNT, SUM, AVG, MIN, MAX])`。
|
||
///
|
||
/// # 两个种子,别搞混
|
||
///
|
||
/// - `psi_seed` —— **每方不同**。同种子 = 双方 ECDH 私钥相同,协议退化。
|
||
/// - `vault_seed` —— **两方必须一致**。Beaver 物料由它派生,不一致则所有
|
||
/// 乘法(含比较)结果都是垃圾值。
|
||
#[allow(clippy::too_many_arguments)]
|
||
pub fn run(
|
||
site: &str,
|
||
sites: &[String],
|
||
transport: &mut TcpTransport,
|
||
ids: &[u64],
|
||
cols: &[(String, Vec<f64>)],
|
||
schema: &[String],
|
||
agg_col: &str,
|
||
pred_text: Option<&str>,
|
||
psi_seed: [u8; 32],
|
||
vault_seed: [u8; 32],
|
||
fxp: u32,
|
||
verbose: bool,
|
||
) -> Result<(Vec<u64>, Vec<f64>), String> {
|
||
// ---- 入口校验(碰网络前)----
|
||
if sites.len() != 2 {
|
||
return Err(format!("sql-join 目前只支持两方,得到 {} 方", sites.len()));
|
||
}
|
||
if ids.is_empty() {
|
||
return Err("--ids 为空".into());
|
||
}
|
||
if cols.is_empty() {
|
||
return Err("至少要有一个 --data 列".into());
|
||
}
|
||
let n = ids.len();
|
||
for (name, vals) in cols {
|
||
if vals.len() != n {
|
||
return Err(format!(
|
||
"列 {name:?} 有 {} 行,与 --ids 的 {n} 行不一致",
|
||
vals.len()
|
||
));
|
||
}
|
||
}
|
||
// 本方列必须都在 schema 里,且不重复
|
||
for (name, _) in cols {
|
||
if !schema.contains(name) {
|
||
return Err(format!("列 {name:?} 不在 schema {schema:?} 里"));
|
||
}
|
||
}
|
||
{
|
||
let mut mine = cols.iter().map(|(n, _)| n.clone()).collect::<Vec<_>>();
|
||
mine.sort();
|
||
mine.dedup();
|
||
if mine.len() != cols.len() {
|
||
return Err("--data 里有重复列名".into());
|
||
}
|
||
}
|
||
let agg_idx = schema
|
||
.iter()
|
||
.position(|x| x == agg_col)
|
||
.ok_or_else(|| format!("--agg-col {agg_col:?} 不在 schema {schema:?} 里"))?;
|
||
|
||
// 本方列在 schema 里的下标(升序 = 本方 --data 顺序之外的安全排序)
|
||
let mut my_slots: Vec<usize> = cols
|
||
.iter()
|
||
.map(|(name, _)| {
|
||
schema
|
||
.iter()
|
||
.position(|s| s == name)
|
||
.expect("上面已校验在 schema 里")
|
||
})
|
||
.collect();
|
||
my_slots.sort_unstable();
|
||
// 对端列占剩下的 schema 槽位
|
||
let peer_slots: Vec<usize> = (0..schema.len()).filter(|i| !my_slots.contains(i)).collect();
|
||
|
||
let keys: Vec<Vec<u8>> = ids.iter().map(|&v| mpc_psi::id_from_u64(v)).collect();
|
||
|
||
// ---- 1) PSI:本方交集下标(本地行序升序)----
|
||
// JOIN 本身是两方协议,my_idx 只有 0/1;单连接 transport 忽略 party。
|
||
let my_idx = sites
|
||
.iter()
|
||
.position(|s| *s == site)
|
||
.ok_or_else(|| format!("site {site} 不在 sites {sites:?} 里"))?;
|
||
let psi_cfg = PsiConfig {
|
||
site: site.to_string(),
|
||
sites: sites.to_vec(),
|
||
my_idx,
|
||
ids: keys.clone(),
|
||
seed: psi_seed,
|
||
// session 取共享的 Vault 种子(两方一致);psi_seed 是每方不同的
|
||
session: mpc_psi::strict::session_id(&vault_seed),
|
||
};
|
||
let hits = run_psi_session(&mut *transport, &psi_cfg, verbose).map_err(|e| e.to_string())?;
|
||
if verbose {
|
||
eprintln!(" PSI 交集 {} 条", hits.len());
|
||
}
|
||
|
||
// ---- 2) 按共享规范键排序 —— 两方得到同一个顺序 ----
|
||
let order = mpc_psi::align_by_key(&keys, &hits)?;
|
||
let m = order.len();
|
||
if verbose {
|
||
eprintln!(" 对齐后 {m} 行");
|
||
}
|
||
|
||
// ---- 3) 只留交集行,按对齐行序重排本方各列(按 my_slots 升序)----
|
||
// `exchange_split_columns` 收发按 `--data` 给的列序,所以先按 my_slots 排好
|
||
let mut ordered_cols: Vec<&(String, Vec<f64>)> = cols.iter().collect();
|
||
ordered_cols.sort_by_key(|(name, _)| schema.iter().position(|s| s == name).unwrap());
|
||
|
||
let mut my_cols: Vec<Vec<f64>> = Vec::with_capacity(ordered_cols.len());
|
||
for (_, vals) in &ordered_cols {
|
||
let mut out = Vec::with_capacity(m);
|
||
for &row in &order {
|
||
out.push(vals[row]);
|
||
}
|
||
my_cols.push(out);
|
||
}
|
||
|
||
// ---- 4) 谓词(可选)----
|
||
let pred = pred_text.map(|t| parse_pred(t, schema)).transpose()?;
|
||
|
||
// ---- 5) 同一条 TCP 上进 Vault:先对表查询计划,再交换列分片 ----
|
||
let site_refs: Vec<&str> = sites.iter().map(|s| s.as_str()).collect();
|
||
let mut vault =
|
||
Vault::new(&mut *transport, site, &site_refs, vault_seed, fxp).map_err(|e| e.to_string())?;
|
||
|
||
// 计划对表:schema + 聚合列 + 谓词 + 对齐行数,**逐字段**比对。
|
||
//
|
||
// 不对表的话,任一方参数不同(最常见的是一方漏了 `--pred`)会让后续 open 的
|
||
// 调用序列错位,报出来是「open 长度不一致: 本方 186,第 1 方 3」——完全看不出
|
||
// 是谁配错了。这些参数本来就是两方必须公开一致的,不新增泄露面。
|
||
//
|
||
// 之所以不用「各出一份差值分片求和为零」的老办法:那只回答「不一样」,
|
||
// 逐字段清单能回答「`pred` 不一致:本方有、对端没有」。
|
||
let extra = vec![
|
||
("schema".to_string(), schema.join(",")),
|
||
("agg_col".to_string(), agg_col.to_string()),
|
||
(
|
||
"pred".to_string(),
|
||
pred_text.unwrap_or("<none>").to_string(),
|
||
),
|
||
("aligned_rows".to_string(), m.to_string()),
|
||
];
|
||
vault.exchange_manifest(&extra).map_err(|e| e.to_string())?;
|
||
|
||
let (mine, theirs) = exchange_split_columns(&mut vault, &my_cols, peer_slots.len())
|
||
.map_err(|e| e.to_string())?;
|
||
if verbose {
|
||
eprintln!(
|
||
" 列分片交换完毕(本方 {} 列、对端 {} 列)",
|
||
mine.len(),
|
||
theirs.len()
|
||
);
|
||
eprintln!(
|
||
" 分片长度详情: mine={:?} theirs={:?}",
|
||
mine.iter().map(|c| c.len()).collect::<Vec<_>>(),
|
||
theirs.iter().map(|c| c.len()).collect::<Vec<_>>()
|
||
);
|
||
}
|
||
|
||
// 按 schema 槽位落位(不是 mine + theirs)
|
||
let mut all_cols: Vec<Vec<u64>> = vec![Vec::new(); schema.len()];
|
||
for (k, c) in mine.into_iter().enumerate() {
|
||
all_cols[my_slots[k]] = c;
|
||
}
|
||
for (k, c) in theirs.into_iter().enumerate() {
|
||
all_cols[peer_slots[k]] = c;
|
||
}
|
||
|
||
// ---- 6) 密态聚合 ----
|
||
let aggs = [Agg::Count, Agg::Sum, Agg::Avg, Agg::Min, Agg::Max];
|
||
let vals = match &pred {
|
||
Some(p) => secure_where_aggregate_pred(&mut vault, &all_cols, p, agg_idx, &aggs)
|
||
.map_err(|e| e.to_string())?,
|
||
None => secure_aggregate_all(&mut vault, &all_cols[agg_idx], &aggs)
|
||
.map_err(|e| e.to_string())?,
|
||
};
|
||
|
||
// 回传对齐后的键,供调用方交叉核验两方对齐一致
|
||
let aligned_ids: Vec<u64> = order.iter().map(|&i| ids[i]).collect();
|
||
Ok((aligned_ids, vals))
|
||
}
|
||
|
||
/// 聚合结果的展示口径:每项一个表格单元格。
|
||
///
|
||
/// 屏幕输出和 `--report json` 共用这一份 —— 免得两条路径各格式化一次,
|
||
/// 出现「屏幕上是 3、JSON 里是 3.0000000001」这种对不上的事。
|
||
///
|
||
/// COUNT 走整数格、其余走 4 位小数格;空集的 `SUM/AVG/MIN/MAX` 是 NaN,
|
||
/// 统一成 `(空集)` 文本 / JSON `null`。
|
||
pub fn result_cells(vals: &[f64]) -> Vec<(&'static str, crate::report::Cell)> {
|
||
use crate::report::Cell;
|
||
let names = ["COUNT", "SUM", "AVG", "MIN", "MAX"];
|
||
names
|
||
.iter()
|
||
.zip(vals)
|
||
.map(|(name, v)| {
|
||
let cell = if v.is_nan() {
|
||
Cell::empty("空集")
|
||
} else if *name == "COUNT" {
|
||
Cell::int(*v as i64)
|
||
} else {
|
||
Cell::nump(*v, 4)
|
||
};
|
||
(*name, cell)
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 真 TCP 两方端到端测试
|
||
// ---------------------------------------------------------------------------
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use mpc_node::TcpTransport;
|
||
use std::net::TcpListener;
|
||
use std::thread;
|
||
|
||
/// 两方数据:alice 持 `balance`、bob 持 `spend`,交集 = {2, 3, 4}。
|
||
///
|
||
/// 刻意让两方本地顺序**不同**(alice 乱序、bob 也乱序),
|
||
/// 排序对齐才能让它俩逐行对上。
|
||
fn sample() -> (
|
||
(Vec<u64>, Vec<(String, Vec<f64>)>),
|
||
(Vec<u64>, Vec<(String, Vec<f64>)>),
|
||
) {
|
||
// alice: id=7,2,4,1,8,3 balance=700,200,400,100,800,300
|
||
let alice_ids = vec![7, 2, 4, 1, 8, 3];
|
||
let alice_cols = vec![("balance".to_string(), vec![700.0, 200.0, 400.0, 100.0, 800.0, 300.0])];
|
||
// bob: id=4,9,2,3,5 spend=40,90,20,30,50
|
||
let bob_ids = vec![4, 9, 2, 3, 5];
|
||
let bob_cols = vec![("spend".to_string(), vec![40.0, 90.0, 20.0, 30.0, 50.0])];
|
||
((alice_ids, alice_cols), (bob_ids, bob_cols))
|
||
}
|
||
|
||
/// 起两个线程,各持一个 TcpTransport,跑完整 `sql_join::run`。
|
||
fn run_pair(
|
||
a_ids: &[u64],
|
||
a_cols: &[(String, Vec<f64>)],
|
||
b_ids: &[u64],
|
||
b_cols: &[(String, Vec<f64>)],
|
||
schema: &[String],
|
||
agg_col: &str,
|
||
pred: Option<&str>,
|
||
) -> ((Vec<u64>, Vec<f64>), (Vec<u64>, Vec<f64>)) {
|
||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||
let addr = listener.local_addr().unwrap().to_string();
|
||
|
||
let schema_a = schema.to_vec();
|
||
let schema_b = schema.to_vec();
|
||
let agg_a = agg_col.to_string();
|
||
let agg_b = agg_col.to_string();
|
||
let pred_a = pred.map(|s| s.to_string());
|
||
let pred_b = pred.map(|s| s.to_string());
|
||
let a_cols = a_cols.to_vec();
|
||
let b_cols = b_cols.to_vec();
|
||
let a_ids = a_ids.to_vec();
|
||
let b_ids = b_ids.to_vec();
|
||
|
||
// bob: accept(listener 已在主线程 bind,这里直接 accept)
|
||
let hb = thread::spawn(move || {
|
||
let (stream, _) = listener.accept().unwrap();
|
||
let mut t = TcpTransport::new(stream).unwrap();
|
||
run(
|
||
"bob",
|
||
&["alice".to_string(), "bob".to_string()],
|
||
&mut t,
|
||
&b_ids,
|
||
&b_cols,
|
||
&schema_b,
|
||
&agg_b,
|
||
pred_b.as_deref(),
|
||
[0x22u8; 32], // PSI 种子:每方不同
|
||
[0x5Bu8; 32], // Vault 种子:两方一致
|
||
18,
|
||
false,
|
||
)
|
||
.unwrap()
|
||
});
|
||
|
||
// alice: connect
|
||
let ha = thread::spawn(move || {
|
||
let mut t = TcpTransport::connect(&addr, 50).unwrap();
|
||
run(
|
||
"alice",
|
||
&["alice".to_string(), "bob".to_string()],
|
||
&mut t,
|
||
&a_ids,
|
||
&a_cols,
|
||
&schema_a,
|
||
&agg_a,
|
||
pred_a.as_deref(),
|
||
[0x11u8; 32], // PSI 种子:每方不同
|
||
[0x5Bu8; 32], // Vault 种子:两方一致
|
||
18,
|
||
false,
|
||
)
|
||
.unwrap()
|
||
});
|
||
|
||
let ra = ha.join().expect("alice 线程");
|
||
let rb = hb.join().expect("bob 线程");
|
||
(ra, rb)
|
||
}
|
||
|
||
/// 无 WHERE:COUNT / SUM / AVG / MIN / MAX 全部对拍。
|
||
#[test]
|
||
fn tcp_join_count_sum_matches() {
|
||
let ((ai, ac), (bi, bc)) = sample();
|
||
let schema = vec!["balance".to_string(), "spend".to_string()];
|
||
let ((keys_a, va), (keys_b, vb)) =
|
||
run_pair(&ai, &ac, &bi, &bc, &schema, "balance", None);
|
||
|
||
// 对齐后键序列 = 2, 3, 4(键字节序)
|
||
assert_eq!(keys_a, vec![2, 3, 4], "alice 对齐键序");
|
||
assert_eq!(keys_b, vec![2, 3, 4], "bob 对齐键序");
|
||
|
||
// 对齐后 balance = [200, 300, 400],spend = [20, 30, 40]
|
||
// COUNT=3, SUM=900, AVG=300, MIN=200, MAX=400
|
||
let want = [3.0, 900.0, 300.0, 200.0, 400.0];
|
||
for (i, (a, b)) in va.iter().zip(&vb).enumerate() {
|
||
assert!((a - b).abs() < 1e-6, "两方结果不一致 [{i}]: {a} vs {b}");
|
||
// AVG 走 fxp truncate,精度 ~1e-3(与 secure.rs 的 AVG 容差一致)
|
||
let tol = if i == 2 { 1e-2 } else { 1e-4 };
|
||
assert!((a - want[i]).abs() < tol, "[{i}] got {a} want {}", want[i]);
|
||
}
|
||
}
|
||
|
||
/// 列 vs 列 WHERE:`balance > spend`。
|
||
///
|
||
/// 对齐后:key2: 200>20 ✓、key3: 300>30 ✓、key4: 400>40 ✓ → 全命中
|
||
/// 换个不对齐就红的数据:如果排序坏了,行会错位。
|
||
#[test]
|
||
fn tcp_join_where_col_vs_col() {
|
||
let ((ai, ac), (bi, bc)) = sample();
|
||
let schema = vec!["balance".to_string(), "spend".to_string()];
|
||
let ((_, va), (_, vb)) =
|
||
run_pair(&ai, &ac, &bi, &bc, &schema, "balance", Some("balance > spend"));
|
||
|
||
// 全命中 → COUNT=3, SUM=900
|
||
assert_eq!(va[0], 3.0, "COUNT");
|
||
assert!((va[1] - 900.0).abs() < 1e-4, "SUM {}", va[1]);
|
||
// 两方结果一致
|
||
for (a, b) in va.iter().zip(&vb) {
|
||
assert!((a - b).abs() < 1e-6, "两方不一致: {a} vs {b}");
|
||
}
|
||
}
|
||
|
||
/// 列 vs 常量 WHERE:`balance >= 250`。
|
||
///
|
||
/// 对齐后 balance = [200, 300, 400] → 命中 key3, key4 → COUNT=2, SUM=700
|
||
#[test]
|
||
fn tcp_join_where_const() {
|
||
let ((ai, ac), (bi, bc)) = sample();
|
||
let schema = vec!["balance".to_string(), "spend".to_string()];
|
||
let ((_, va), (_, vb)) =
|
||
run_pair(&ai, &ac, &bi, &bc, &schema, "balance", Some("balance >= 250"));
|
||
|
||
assert_eq!(va[0], 2.0, "COUNT");
|
||
assert!((va[1] - 700.0).abs() < 1e-4, "SUM {}", va[1]);
|
||
for (a, b) in va.iter().zip(&vb) {
|
||
assert!((a - b).abs() < 1e-6, "两方不一致: {a} vs {b}");
|
||
}
|
||
}
|
||
|
||
/// 空交集必须显式失败,不能静默返回 0。
|
||
#[test]
|
||
fn tcp_join_disjoint_fails() {
|
||
let a_ids = vec![1u64, 2, 3];
|
||
let a_cols = vec![("balance".to_string(), vec![1.0, 2.0, 3.0])];
|
||
let b_ids = vec![7u64, 8, 9];
|
||
let b_cols = vec![("spend".to_string(), vec![7.0, 8.0, 9.0])];
|
||
let schema_a = vec!["balance".to_string(), "spend".to_string()];
|
||
let schema_b = schema_a.clone();
|
||
|
||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||
let addr = listener.local_addr().unwrap().to_string();
|
||
|
||
let hb = thread::spawn(move || {
|
||
let (stream, _) = listener.accept().unwrap();
|
||
let mut t = TcpTransport::new(stream).unwrap();
|
||
run(
|
||
"bob",
|
||
&["alice".to_string(), "bob".to_string()],
|
||
&mut t,
|
||
&b_ids,
|
||
&b_cols,
|
||
&schema_b,
|
||
"spend",
|
||
None,
|
||
[0x22u8; 32],
|
||
[0x5Bu8; 32],
|
||
18,
|
||
false,
|
||
)
|
||
});
|
||
|
||
let ha = thread::spawn(move || {
|
||
let mut t = TcpTransport::connect(&addr, 50).unwrap();
|
||
run(
|
||
"alice",
|
||
&["alice".to_string(), "bob".to_string()],
|
||
&mut t,
|
||
&a_ids,
|
||
&a_cols,
|
||
&schema_a,
|
||
"balance",
|
||
None,
|
||
[0x11u8; 32],
|
||
[0x5Bu8; 32],
|
||
18,
|
||
false,
|
||
)
|
||
});
|
||
|
||
let ra = ha.join().unwrap();
|
||
let rb = hb.join().unwrap();
|
||
assert!(ra.is_err(), "alice 应报错(空交集): {ra:?}");
|
||
assert!(rb.is_err(), "bob 应报错(空交集): {rb:?}");
|
||
assert!(
|
||
ra.unwrap_err().contains("交集为空"),
|
||
"错误应指出交集为空"
|
||
);
|
||
}
|
||
|
||
/// 两方参数不一致(这里是最常见的:一方漏了 `--pred`)必须在**动手算之前**被点出来,
|
||
/// 而不是等到 open 序列错位报「长度不一致」——后者看不出是谁配错了。
|
||
#[test]
|
||
fn tcp_join_plan_mismatch_is_diagnosed() {
|
||
let ((ai, ac), (bi, bc)) = sample();
|
||
let schema_a = vec!["balance".to_string(), "spend".to_string()];
|
||
let schema_b = schema_a.clone();
|
||
|
||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||
let addr = listener.local_addr().unwrap().to_string();
|
||
let sites = vec!["alice".to_string(), "bob".to_string()];
|
||
let (sites_a, sites_b) = (sites.clone(), sites.clone());
|
||
|
||
let hb = thread::spawn(move || {
|
||
let (stream, _) = listener.accept().unwrap();
|
||
let mut t = TcpTransport::new(stream).unwrap();
|
||
// bob 漏了谓词
|
||
run(
|
||
"bob",
|
||
&sites_b,
|
||
&mut t,
|
||
&bi,
|
||
&bc,
|
||
&schema_b,
|
||
"spend",
|
||
None,
|
||
[0x22u8; 32],
|
||
[0x5Bu8; 32],
|
||
18,
|
||
false,
|
||
)
|
||
});
|
||
|
||
let ha = thread::spawn(move || {
|
||
let mut t = TcpTransport::connect(&addr, 50).unwrap();
|
||
run(
|
||
"alice",
|
||
&sites_a,
|
||
&mut t,
|
||
&ai,
|
||
&ac,
|
||
&schema_a,
|
||
// agg_col 两边一致,让**唯一**的差异是 pred —— 否则对表会先揪出
|
||
// agg_col,这条断言就永远测不到「漏谓词」这个真实场景
|
||
"spend",
|
||
Some("balance >= 250"),
|
||
[0x11u8; 32],
|
||
[0x5Bu8; 32],
|
||
18,
|
||
false,
|
||
)
|
||
});
|
||
|
||
let ea = ha.join().unwrap().unwrap_err();
|
||
let eb = hb.join().unwrap().unwrap_err();
|
||
// 两侧都必须点名是哪个参数不一致,而不是笼统说「计划不一致」
|
||
assert!(ea.contains("pred"), "alice 的错误要点名 pred: {ea}");
|
||
assert!(eb.contains("pred"), "bob 的错误要点名 pred: {eb}");
|
||
}
|
||
}
|