//! `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, /// 数值列(不含 id 列),列名即 schema 里的名字。 pub cols: Vec<(String, Vec)>, /// 被丢弃的非数值列名(仅用于提示)。 pub dropped: Vec, /// 实际用作 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 { 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> = 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> = 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 = 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:`。 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 { 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 = frame .column(&key) .expect("上面刚校验过") .iter() .enumerate() .map(|(i, &v)| f64_to_u64(v).ok_or_else(|| { format!("第 {} 行的 join 键 {v} 不是非负整数(u64 范围内)", i + 1) })) .collect::>()?; 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 { 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}"); } }