如何高效判断Kusto表中两列是否存在一一映射关系？

给定Kusto表T，需验证列A与列B是否存在**一一映射（双射）**关系——即每个A值唯一对应一个B值，且每个B值也唯一对应一个A值。该表为快照表，A、B列包含大量重复行，必须通过summarize去重处理。用户尝试了两种查询方法，但均出现超时或内存超限问题，即使使用materialize、shuffle、num_partitions等优化手段也无法解决。

用户尝试的方法 #

方法1 #

let t = materialize(
    cluster('<cluster>').database('<dB>').T
    | summarize hint.strategy=shuffle hint.num_partitions=10 by A, B
)
;
t
| summarize BPerA = dcount(B) by A
| where BPerA > 1
| take 2
;
snap
| summarize APerB = dcount(A) by B
| where APerB > 1
| take 2
;

执行时出现超时问题

方法2 #

let t =
// materialize( // 启用后触发错误：内存预算超限(5368709120)，结果可能不准确或不完整
    cluster('<cluster>').database('<dB>').T
    | project A, B
// )
;
t
| summarize hint.strategy=shuffle BPerA = dcount(B) by A
| where BPerA > 1
| take 2
;
t
| summarize hint.strategy=shuffle APerB = dcount(A) by B
| where APerB > 1
| take 2
;

禁用materialize后仍超时

优化后的查询方案 #

核心思路：提前终止不必要的计算，只要找到任意一个不满足一一映射的实例，就立即返回结果，无需处理全量数据；同时减少重复的数据扫描。

方案1：缓存去重结果，复用检查逻辑 #

先缓存去重后的(A,B)对，避免重复扫描原表，再分别检查A到B、B到A的映射唯一性：

// 缓存去重后的(A,B)唯一对，减少后续计算量
let unique_pairs = materialize(
    cluster('<cluster>').database('<dB>').T
    | project A, B
    | summarize by A, B
);

// 检查是否存在一个A对应多个B
unique_pairs
| summarize b_count = count() by A
| where b_count > 1
| take 2;

// 检查是否存在一个B对应多个A
unique_pairs
| summarize a_count = count() by B
| where a_count > 1
| take 2;

方案2：快速验证是否满足双射 #

如果只需要知道是否符合双射条件，而非具体的违规实例，可以用更简洁的方式快速判断：

let unique_pairs = materialize(
    cluster('<cluster>').database('<dB>').T
    | project A, B
    | summarize by A, B
);

let distinct_a = toscalar(unique_pairs | summarize dcount(A));
let distinct_b = toscalar(unique_pairs | summarize dcount(B));
let pair_count = toscalar(unique_pairs | summarize count());

// 双射的充要条件：去重后的(A,B)对数 = 不同A的数量 = 不同B的数量
print is_bijection = (distinct_a == distinct_b) and (distinct_a == pair_count)

方案3：分步异步检查，优先快速失败 #

如果表数据量极大，可拆分两个独立查询，只要其中一个找到违规实例就立即终止，避免全量计算：

let unique_pairs = materialize(
    cluster('<cluster>').database('<dB>').T
    | project A, B
    | summarize by A, B
);

// 检查A到B的映射是否唯一
let a_has_multiple_b = 
    unique_pairs
    | summarize count() by A
    | where count_ > 1
    | take 1
    | isnotempty(*);

// 检查B到A的映射是否唯一
let b_has_multiple_a = 
    unique_pairs
    | summarize count() by B
    | where count_ > 1
    | take 1
    | isnotempty(*);

// 输出结果
print 
    is_bijection = not(a_has_multiple_b or b_has_multiple_a),
    a_has_multiple_b = a_has_multiple_b,
    b_has_multiple_a = b_has_multiple_a

关键优化说明 #

1. 提前去重：通过summarize by A, B去除重复的(A,B)对，大幅减少后续计算的数据规模
2. 缓存复用：用materialize缓存去重后的结果，避免多次扫描原表
3. 快速终止：使用take 1找到第一个违规实例就停止计算，无需处理全量数据
4. 数学简化：利用双射的充要条件（去重后对数=不同A数=不同B数），将复杂的两次统计简化为三次计数对比

内容的提问来源于stack exchange，提问作者joseville