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
339 lines
13 KiB
Rust
339 lines
13 KiB
Rust
//! `mpc sql-join --pg-url` 的数据源:从 PostgreSQL 读本方的 join 键与数值列。
|
||
//!
|
||
//! 竖向切分场景里,每方本来就有一张自己的业务表(`bank.customer`、`shop.orders`),
|
||
//! 让用户先把表导成 CSV 再喂 `--data` 是多余的仪式。这里直接连库取一列 id + 若干数值列。
|
||
//!
|
||
//! 约束(都是 `Frame` 的硬限制,不是懒):
|
||
//! * **join 键必须是整数列**。PSI 的 id 是 `u64`,文本/浮点键会静默错位,所以宁可报错。
|
||
//! * 其他非数值列(varchar/date/json)会被 `ResultSet::to_frame` 丢掉,这里把它们的列名
|
||
//! 打出来,免得用户以为列喂进去了。
|
||
//! * 只跑 Simple Query,SQL 由用户写死;不做参数化。
|
||
|
||
use crate::report;
|
||
use mpc_data::pg::{PgConfig, PgConn, ResultSet};
|
||
|
||
/// 从库里读出来的本方数据,形状与 `--ids` + 多个 `--data` 完全一致。
|
||
#[derive(Debug, Clone)]
|
||
pub struct Loaded {
|
||
/// PSI 用的整数 join 键(保持库里的行序)。
|
||
pub ids: Vec<u64>,
|
||
/// 数值列(不含 id 列),列名即 schema 里的名字。
|
||
pub cols: Vec<(String, Vec<f64>)>,
|
||
/// 被丢弃的非数值列名(仅用于提示)。
|
||
pub dropped: Vec<String>,
|
||
/// 实际用作 join 键的列名。
|
||
pub id_col: String,
|
||
}
|
||
|
||
/// 打印用:去掉连接串里的密码。
|
||
pub fn redact(url: &str) -> String {
|
||
PgConfig::parse_url(url)
|
||
.map(|c| c.redacted())
|
||
.unwrap_or_else(|_| "postgres://<连接串无法解析>".to_string())
|
||
}
|
||
|
||
/// 连库执行 `sql`,把结果拆成 `(ids, cols)`。
|
||
///
|
||
/// `id_col` 为 `None` 时取结果集的第一列。
|
||
pub fn load(url: &str, sql: &str, id_col: Option<&str>) -> Result<Loaded, String> {
|
||
let cfg = PgConfig::parse_url(url).map_err(|e| e.to_string())?;
|
||
let mut conn = PgConn::connect(&cfg).map_err(|e| e.to_string())?;
|
||
let results = conn.query(sql).map_err(|e| e.to_string())?;
|
||
let set = results
|
||
.into_iter()
|
||
.find(|r| !r.columns.is_empty())
|
||
.ok_or_else(|| "查询没有返回结果集(是不是写了多条语句 / 只写了 DDL?)".to_string())?;
|
||
split(set, id_col)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// `mpc pg`:只连库跑一条 SQL,把结果原样打出来
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// `mpc pg --url … --sql "SELECT …" [--frames]`
|
||
///
|
||
/// 存在的理由:`sql-join --pg-url` 一旦出问题,报错来自分布式会话深处——
|
||
/// 连不上库、列被丢、join 键不是整数、值不是数值,四种错在终端上长得差不多。
|
||
/// 这条命令把「库这条路」单独跑通并**把列类型摊开**,排障时先跑它,
|
||
/// 就能一眼分出「库的问题」还是「MPC 的问题」。
|
||
///
|
||
/// `--frames` 额外跑一遍 [`ResultSet::to_frame`],打印真正会进密态计算的那几列
|
||
/// —— 用户最常见的困惑是「我查了 5 列,怎么聚合只认 2 列」。
|
||
pub fn cmd(args: &[String]) -> Result<(), String> {
|
||
let url = crate::parse_flag(args, "--url")
|
||
.map(|s| s.to_string())
|
||
.or_else(|| std::env::var("MPC_PG_URL").ok().filter(|s| !s.trim().is_empty()))
|
||
.ok_or("缺少 --url(或环境变量 MPC_PG_URL)")?;
|
||
let sql = crate::parse_flag(args, "--sql").ok_or("缺少 --sql")?;
|
||
|
||
let cfg = PgConfig::parse_url(&url).map_err(|e| e.to_string())?;
|
||
note!("连接 {} …", cfg.redacted());
|
||
let mut conn = PgConn::connect(&cfg).map_err(|e| e.to_string())?;
|
||
note!(
|
||
"已连接 · backend pid={} · server_version={}",
|
||
conn.backend_pid,
|
||
conn.params
|
||
.iter()
|
||
.find(|(k, _)| k == "server_version")
|
||
.map(|(_, v)| v.as_str())
|
||
.unwrap_or("<未上报>")
|
||
);
|
||
|
||
let sets = conn.query(sql).map_err(|e| e.to_string())?;
|
||
if sets.is_empty() {
|
||
note!("查询成功,但没有结果集(DDL / 空语句?)");
|
||
return Ok(());
|
||
}
|
||
let n_sets = sets.len();
|
||
|
||
for (i, set) in sets.iter().enumerate() {
|
||
let title = if n_sets == 1 {
|
||
format!("结果集({} 行 × {} 列)", set.nrows(), set.ncols())
|
||
} else {
|
||
format!(
|
||
"结果集 {}/{}({} 行 × {} 列)",
|
||
i + 1,
|
||
n_sets,
|
||
set.nrows(),
|
||
set.ncols()
|
||
)
|
||
};
|
||
let header: Vec<&str> = set.columns.iter().map(|c| c.name.as_str()).collect();
|
||
// 空结果集也要把表头打出来:列名本身就是用户想看的东西
|
||
let rows: Vec<Vec<report::Cell>> = set
|
||
.rows
|
||
.iter()
|
||
.map(|r| {
|
||
r.iter()
|
||
.map(|v| match v {
|
||
Some(t) => report::Cell::txt(t.clone()),
|
||
None => report::Cell::empty("NULL"),
|
||
})
|
||
.collect()
|
||
})
|
||
.collect();
|
||
report::table(&title, &header, &rows);
|
||
|
||
// 列类型表:回答「这列为什么没进 Frame」
|
||
let trows: Vec<Vec<report::Cell>> = set
|
||
.columns
|
||
.iter()
|
||
.map(|c| {
|
||
vec![
|
||
report::Cell::txt(c.name.clone()),
|
||
report::Cell::int(c.type_oid as i64),
|
||
report::Cell::txt(oid_name(c.type_oid)),
|
||
report::Cell::flag(mpc_data::pg::is_numeric_oid(c.type_oid)),
|
||
]
|
||
})
|
||
.collect();
|
||
report::table("列类型", &["列", "oid", "类型", "进 Frame"], &trows);
|
||
|
||
// 布尔开关:不能用 parse_flag —— 它要求后面跟一个值,把开关写在命令末尾就看不见了
|
||
if args.iter().any(|a| a == "--frames") {
|
||
match set.clone().to_frame() {
|
||
Ok((frame, dropped)) => {
|
||
let mut frows = Vec::new();
|
||
for j in 0..frame.ncols() {
|
||
let name = &frame.column_names()[j];
|
||
let vals = frame.column(name).expect("列名来自同一 frame");
|
||
let shown: Vec<String> = vals
|
||
.iter()
|
||
.map(|v| if v.is_nan() { "NULL".to_string() } else { format!("{v}") })
|
||
.collect();
|
||
frows.push(vec![
|
||
report::Cell::txt(name.clone()),
|
||
report::Cell::int(vals.len() as i64),
|
||
report::Cell::txt(shown.join(",")),
|
||
]);
|
||
}
|
||
report::table("进 Frame 的列", &["列", "行数", "值"], &frows);
|
||
if !dropped.is_empty() {
|
||
note!("被丢弃的非数值列: {dropped:?}");
|
||
}
|
||
}
|
||
Err(e) => note!("to_frame 失败: {e}"),
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 常见 OID → 类型名。只覆盖联邦场景会碰到的那些,其余显示 `oid:<n>`。
|
||
fn oid_name(oid: u32) -> String {
|
||
match oid {
|
||
16 => "bool".into(),
|
||
20 => "int8".into(),
|
||
21 => "int2".into(),
|
||
23 => "int4".into(),
|
||
25 => "text".into(),
|
||
26 => "oid".into(),
|
||
700 => "float4".into(),
|
||
701 => "float8".into(),
|
||
1043 => "varchar".into(),
|
||
1082 => "date".into(),
|
||
1114 => "timestamp".into(),
|
||
1184 => "timestamptz".into(),
|
||
1700 => "numeric".into(),
|
||
other => format!("oid:{other}"),
|
||
}
|
||
}
|
||
|
||
/// 把结果集切成 `(整数键, 其余数值列)`。与网络解耦,便于直接测边界。
|
||
fn split(set: ResultSet, id_col: Option<&str>) -> Result<Loaded, String> {
|
||
let all_names = set.column_names();
|
||
let key = match id_col {
|
||
Some(c) if !all_names.iter().any(|n| n == c) => {
|
||
return Err(format!(
|
||
"--pg-id-col {c:?} 不在查询结果里(有:{all_names:?})"
|
||
))
|
||
}
|
||
Some(c) => c.to_string(),
|
||
None => all_names
|
||
.first()
|
||
.cloned()
|
||
.ok_or_else(|| "查询结果没有列".to_string())?,
|
||
};
|
||
|
||
let (frame, dropped) = set.to_frame().map_err(|e| e.to_string())?;
|
||
if !frame.column_names().iter().any(|n| n == &key) {
|
||
return Err(format!(
|
||
"join 键 {key:?} 不是数值列(被丢弃的列:{dropped:?});PSI 的 id 是 u64,只接受整数列"
|
||
));
|
||
}
|
||
|
||
let ids: Vec<u64> = frame
|
||
.column(&key)
|
||
.expect("上面刚校验过")
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(i, &v)| f64_to_u64(v).ok_or_else(|| {
|
||
format!("第 {} 行的 join 键 {v} 不是非负整数(u64 范围内)", i + 1)
|
||
}))
|
||
.collect::<Result<_, _>>()?;
|
||
|
||
let mut cols = Vec::new();
|
||
for name in frame.column_names().iter() {
|
||
if name.as_str() == key {
|
||
continue;
|
||
}
|
||
let vals = frame
|
||
.column(name)
|
||
.expect("column_names 来自同一 frame")
|
||
.to_vec();
|
||
cols.push((name.clone(), vals));
|
||
}
|
||
if cols.is_empty() {
|
||
return Err(format!(
|
||
"查询结果除了 join 键 {key:?} 没有别的数值列;密态聚合需要至少一列"
|
||
));
|
||
}
|
||
|
||
Ok(Loaded {
|
||
ids,
|
||
cols,
|
||
dropped,
|
||
id_col: key,
|
||
})
|
||
}
|
||
|
||
/// f64 → u64,只接受精确的非负整数且 < 2^53(f64 能精确表示的上界)。
|
||
fn f64_to_u64(v: f64) -> Option<u64> {
|
||
if !v.is_finite() || v < 0.0 || v > 9_007_199_254_740_992.0 || v.fract() != 0.0 {
|
||
return None;
|
||
}
|
||
Some(v as u64)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use mpc_data::pg::{Column, ResultSet};
|
||
|
||
#[test]
|
||
fn f64_to_u64_boundaries() {
|
||
assert_eq!(f64_to_u64(0.0), Some(0));
|
||
assert_eq!(f64_to_u64(42.0), Some(42));
|
||
assert_eq!(f64_to_u64(9_007_199_254_740_992.0), Some(9_007_199_254_740_992));
|
||
assert_eq!(f64_to_u64(1.5), None);
|
||
assert_eq!(f64_to_u64(-1.0), None);
|
||
assert_eq!(f64_to_u64(f64::NAN), None);
|
||
assert_eq!(f64_to_u64(f64::INFINITY), None);
|
||
assert_eq!(f64_to_u64(9_007_199_254_740_994.0), None);
|
||
}
|
||
|
||
fn set(cols: &[(&str, u32)], rows: &[&[Option<&str>]]) -> ResultSet {
|
||
ResultSet {
|
||
columns: cols
|
||
.iter()
|
||
.map(|(n, o)| Column {
|
||
name: (*n).to_string(),
|
||
type_oid: *o,
|
||
})
|
||
.collect(),
|
||
rows: rows
|
||
.iter()
|
||
.map(|r| r.iter().map(|v| v.map(|s| s.to_string())).collect())
|
||
.collect(),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn split_keeps_numeric_cols_and_reports_dropped() {
|
||
let s = set(
|
||
&[("uid", 23), ("name", 25), ("balance", 1700)],
|
||
&[
|
||
&[Some("2"), Some("bob"), Some("200")],
|
||
&[Some("3"), Some("carol"), Some("300")],
|
||
],
|
||
);
|
||
let l = split(s, None).unwrap();
|
||
assert_eq!(l.id_col, "uid");
|
||
assert_eq!(l.ids, vec![2, 3]);
|
||
assert_eq!(l.cols.len(), 1);
|
||
assert_eq!(l.cols[0].0, "balance");
|
||
assert_eq!(l.cols[0].1, vec![200.0, 300.0]);
|
||
assert_eq!(l.dropped, vec!["name".to_string()]);
|
||
}
|
||
|
||
#[test]
|
||
fn split_honours_explicit_id_col() {
|
||
let s = set(
|
||
&[("balance", 1700), ("uid", 20)],
|
||
&[&[Some("9.5"), Some("7")]],
|
||
);
|
||
let l = split(s, Some("uid")).unwrap();
|
||
assert_eq!(l.id_col, "uid");
|
||
assert_eq!(l.ids, vec![7]);
|
||
assert_eq!(l.cols[0].0, "balance");
|
||
assert_eq!(l.cols[0].1, vec![9.5]);
|
||
}
|
||
|
||
#[test]
|
||
fn split_rejects_text_key() {
|
||
let s = set(&[("uid", 25), ("balance", 1700)], &[&[Some("abc"), Some("1")]]);
|
||
let e = split(s, None).unwrap_err();
|
||
assert!(e.contains("不是数值列"), "{e}");
|
||
}
|
||
|
||
#[test]
|
||
fn split_rejects_missing_or_fractional_key() {
|
||
let s = set(&[("uid", 23), ("balance", 1700)], &[&[Some("1"), Some("1")]]);
|
||
assert!(split(s, Some("nope")).unwrap_err().contains("不在查询结果里"));
|
||
|
||
let s = set(&[("uid", 23), ("balance", 1700)], &[&[Some("1.5"), Some("1")]]);
|
||
assert!(split(s, None).unwrap_err().contains("不是非负整数"));
|
||
|
||
// NULL 键(NaN)同样拒绝,不能当 0 混过去
|
||
let s = set(&[("uid", 23), ("balance", 1700)], &[&[None, Some("1")]]);
|
||
assert!(split(s, None).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn split_rejects_key_only_result() {
|
||
let s = set(&[("uid", 23)], &[&[Some("1")]]);
|
||
let e = split(s, None).unwrap_err();
|
||
assert!(e.contains("没有别的数值列"), "{e}");
|
||
}
|
||
}
|