SAS与Impala数据集1:1比对中的数值精度问题及动态截断方案咨询

我完全理解你遇到的痛点：明明两个数据集的“真实”数值一致，但因为CATS或BEST.格式的默认四舍五入，导致比对失败。下面给你一套贴合需求的动态截断解决方案，以及问题根源的分析。

问题根源拆解 #

你提到的9128554507.85这个数值，在SAS中用BEST12.（CATS默认格式）转换时，因为有效位数超过12位，会被四舍五入为9128554507.9；而Impala导入的副本B可能因为存储/导出时的微小浮点差异，被BEST12.格式处理成9128554507.8——本质是固定格式的精度限制放大了存储层面的微小差异。

你的需求是动态截断到实际小数位数减1，而不是用固定小数位，这个思路非常合理，下面是具体实现：

解决方案1：单变量动态截断比对 #

先从单个value变量的处理入手，核心是先计算每个数值的实际小数位数（忽略末尾零），再截断到目标位数：

/* 预处理数据集A */
data A_prep;
    set A;
    by ID; /* 按ID排序确保和B匹配 */
    
    /* 将数值转成超长字符，避免科学计数法 */
    char_val = put(value, BEST32.);
    /* 定位小数点位置 */
    dot_pos = index(char_val, '.');
    
    if dot_pos > 0 then do;
        /* 去掉小数部分末尾的零，计算实际有效小数位数 */
        trimmed_decimal = trim(left(compress(substr(char_val, dot_pos+1), '0', 't')));
        decimals = length(trimmed_decimal);
        /* 处理类似123.000的情况，实际小数位为0 */
        if decimals = 0 then decimals = 0;
    end;
    else decimals = 0; /* 整数的小数位为0 */
    
    /* 确定要保留的小数位：实际小数位-1，最小为0 */
    target_decimals = max(decimals - 1, 0);
    
    /* 截断数值（注意是截断，不是四舍五入） */
    truncated_value = int(value * 10**target_decimals) / 10**target_decimals;
    
    /* 生成用于比对的拼接字段 */
    conc = cats(ID, put(truncated_value, 32. || put(target_decimals, 2.)));
run;

/* 对数据集B执行完全相同的预处理 */
data B_prep;
    set B;
    by ID;
    
    char_val = put(value, BEST32.);
    dot_pos = index(char_val, '.');
    
    if dot_pos > 0 then do;
        trimmed_decimal = trim(left(compress(substr(char_val, dot_pos+1), '0', 't')));
        decimals = length(trimmed_decimal);
        if decimals = 0 then decimals = 0;
    end;
    else decimals = 0;
    
    target_decimals = max(decimals - 1, 0);
    truncated_value = int(value * 10**target_decimals) / 10**target_decimals;
    conc = cats(ID, put(truncated_value, 32. || put(target_decimals, 2.)));
run;

/* 比对两个预处理后的数据集，找出差异 */
proc sql;
    select 
        coalesce(a.ID, b.ID) as ID,
        a.value as A_value,
        b.value as B_value
    from A_prep a
    full join B_prep b on a.ID = b.ID
    where a.conc ne b.conc or a.ID is missing or b.ID is missing;
quit;

解决方案2：封装宏处理所有数值变量 #

如果你的数据集有多个数值变量需要处理，可以把上述逻辑封装成宏，自动遍历所有变量：

%macro truncate_for_compare(input_dsn, output_dsn);
    /* 获取数据集的变量列表和类型 */
    %let dsid = %sysfunc(open(&input_dsn));
    %let nvars = %sysfunc(attrn(&dsid, nvars));
    %let var_list =;
    %let type_list =;
    
    %do i=1 %to &nvars;
        %let var = %sysfunc(varname(&dsid, &i));
        %let type = %sysfunc(vartype(&dsid, &i));
        %let var_list = &var_list &var;
        %let type_list = &type_list &type;
    %end;
    %let rc = %sysfunc(close(&dsid));
    
    data &output_dsn;
        set &input_dsn;
        
        /* 遍历每个变量，处理数值型变量 */
        %do j=1 %to &nvars;
            %let var = %scan(&var_list, &j);
            %let type = %scan(&type_list, &j);
            
            %if &type = N %then %do;
                /* 计算实际小数位数 */
                char_&var = put(&var, BEST32.);
                dot_pos_&var = index(char_&var, '.');
                
                if dot_pos_&var > 0 then do;
                    trimmed_dec_&var = trim(left(compress(substr(char_&var, dot_pos_&var+1), '0', 't')));
                    decimals_&var = length(trimmed_dec_&var);
                    if decimals_&var = 0 then decimals_&var = 0;
                end;
                else decimals_&var = 0;
                
                /* 确定目标截断位数 */
                target_dec_&var = max(decimals_&var - 1, 0);
                /* 执行截断 */
                truncated_&var = int(&var * 10**target_dec_&var) / 10**target_dec_&var;
                /* 生成用于拼接的字符变量 */
                concat_&var = put(truncated_&var, 32. || put(target_dec_&var, 2.));
                
                /* 清理临时变量 */
                drop char_&var dot_pos_&var trimmed_dec_&var decimals_&var target_dec_&var;
            %end;
            %else %do;
                /* 字符变量直接保留用于拼接 */
                concat_&var = &var;
            %end;
        %end;
        
        /* 生成最终的拼接比对字段 */
        conc = cats(of concat_:);
        drop of concat_:;
    run;
%mend truncate_for_compare;

/* 使用宏处理两个数据集 */
%truncate_for_compare(A, A_prepped);
%truncate_for_compare(B, B_prepped);

/* 使用PROC COMPARE快速比对，按ID匹配 */
proc compare base=A_prepped compare=B_prepped;
    ID ID;
run;

备选方案：固定误差容忍（仅作参考） #

如果你可以接受微小的数值误差，也可以直接用PROC COMPARE的CRITERION选项指定允许的误差范围，比如：

proc compare base=A compare=B criterion=0.1; /* 允许0.1的误差 */
    ID ID;
run;

但这个方案是固定误差，不符合你“动态截断”的需求，所以仅作为备选。

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