Files
ssw-mpc/crates/mpc-cli/src/pg_source.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

339 lines
13 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.
//! `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}");
}
}