feat: 注塑OEE报表功能增强与旧设备估算逻辑优化（TASK-xxx）

变更内容：
1.  优化接口注释与入参说明，补充设备利用率相关字段
2.  新增sumRtAndDay通用统计方法，支持跨表合并计算开机/产量数据
3.  重构旧设备开机数估算逻辑，调整浮动区间为70%-90%并优化去重规则
4.  重写累加器增量计算SQL，修复基线数据与同时间去重问题
5.  补充VO类新增班次、运行时长、标准周期等扩展字段

aucma-report/src/main/java/com/aucma/report/domain/vo/InjectionOeeAnalysisVo.java

@@ -25,7 +25,11 @@ public class InjectionOeeAnalysisVo extends BaseEntity implements Serializable {
     @JsonProperty("DEVICE_NAME")
     private String DEVICE_NAME;
 
-    /** 可用率 (A) */
+    /** 统计班次类型：ALL / DAY / NIGHT */
+    @JsonProperty("SHIFT_TYPE")
+    private String SHIFT_TYPE;
+
+    /** 设备利用率 A */
     @JsonProperty("AVAILABILITY")
     private Double AVAILABILITY;
 
@@ -41,7 +45,7 @@ public class InjectionOeeAnalysisVo extends BaseEntity implements Serializable {
     @JsonProperty("QUALITY")
     private Double QUALITY;
 
-    /** OEE */
+    /** 完整 OEE = A * P * Q，当前利用率页不把 A 直接当成 OEE */
     @JsonProperty("OEE")
     private Double OEE;
 
@@ -57,6 +61,10 @@ public class InjectionOeeAnalysisVo extends BaseEntity implements Serializable {
     @JsonProperty("ACTUAL_RUN_SECONDS")
     private Long ACTUAL_RUN_SECONDS;
 
+    /** 实际运行时间（分钟） */
+    @JsonProperty("RUN_TIME_MINUTES")
+    private Double RUN_TIME_MINUTES;
+
     /** 实际开模次数 (实际产出数量增量) */
     @JsonProperty("SHOTS")
     private Long SHOTS;
@@ -81,10 +89,18 @@ public class InjectionOeeAnalysisVo extends BaseEntity implements Serializable {
     @JsonProperty("STANDARD_CYCLE")
     private Double STANDARD_CYCLE;
 
+    /** 标准周期 (秒)，按方案约定返回字段名 */
+    @JsonProperty("STANDARD_CYCLE_SECONDS")
+    private Double STANDARD_CYCLE_SECONDS;
+
     /** 标准周期来源 */
     @JsonProperty("CYCLE_SOURCE")
     private String CYCLE_SOURCE;
 
+    /** 标准周期来源，按方案约定返回字段名 */
+    @JsonProperty("STANDARD_CYCLE_SOURCE")
+    private String STANDARD_CYCLE_SOURCE;
+
     /** 质量分析范围 */
     @JsonProperty("QUALITY_SCOPE")
     private String QUALITY_SCOPE;
@@ -105,179 +121,16 @@ public class InjectionOeeAnalysisVo extends BaseEntity implements Serializable {
     @JsonProperty("SHIFT_NAME")
     private String SHIFT_NAME;
 
-    public String getDEVICE_CODE() {
+    /** 本日利用率 */
-        return DEVICE_CODE;
+    @JsonProperty("TODAY_AVAILABILITY")
-    }
+    private Double TODAY_AVAILABILITY;
 
-    public void setDEVICE_CODE(String DEVICE_CODE) {
+    /** 周利用率 */
-        this.DEVICE_CODE = DEVICE_CODE;
+    @JsonProperty("WEEK_AVAILABILITY")
-    }
+    private Double WEEK_AVAILABILITY;
 
-    public String getDEVICE_NAME() {
+    /** 总利用率 */
-        return DEVICE_NAME;
+    @JsonProperty("TOTAL_AVAILABILITY")
-    }
+    private Double TOTAL_AVAILABILITY;
 
-    public void setDEVICE_NAME(String DEVICE_NAME) {
-        this.DEVICE_NAME = DEVICE_NAME;
-    }
-
-    public Double getAVAILABILITY() {
-        return AVAILABILITY;
-    }
-
-    public void setAVAILABILITY(Double AVAILABILITY) {
-        this.AVAILABILITY = AVAILABILITY;
-    }
-
-    public Double getPERFORMANCE() {
-        return PERFORMANCE;
-    }
-
-    public void setPERFORMANCE(Double PERFORMANCE) {
-        this.PERFORMANCE = PERFORMANCE;
-    }
-
-    public Double getDIAGNOSTIC_PERFORMANCE() {
-        return DIAGNOSTIC_PERFORMANCE;
-    }
-
-    public void setDIAGNOSTIC_PERFORMANCE(Double DIAGNOSTIC_PERFORMANCE) {
-        this.DIAGNOSTIC_PERFORMANCE = DIAGNOSTIC_PERFORMANCE;
-    }
-
-    public Double getQUALITY() {
-        return QUALITY;
-    }
-
-    public void setQUALITY(Double QUALITY) {
-        this.QUALITY = QUALITY;
-    }
-
-    public Double getOEE() {
-        return OEE;
-    }
-
-    public void setOEE(Double OEE) {
-        this.OEE = OEE;
-    }
-
-    public Long getPLANNED_TIME_MINUTES() {
-        return PLANNED_TIME_MINUTES;
-    }
-
-    public void setPLANNED_TIME_MINUTES(Long PLANNED_TIME_MINUTES) {
-        this.PLANNED_TIME_MINUTES = PLANNED_TIME_MINUTES;
-    }
-
-    public Long getDOWNTIME_MINUTES() {
-        return DOWNTIME_MINUTES;
-    }
-
-    public void setDOWNTIME_MINUTES(Long DOWNTIME_MINUTES) {
-        this.DOWNTIME_MINUTES = DOWNTIME_MINUTES;
-    }
-
-    public Long getACTUAL_RUN_SECONDS() {
-        return ACTUAL_RUN_SECONDS;
-    }
-
-    public void setACTUAL_RUN_SECONDS(Long ACTUAL_RUN_SECONDS) {
-        this.ACTUAL_RUN_SECONDS = ACTUAL_RUN_SECONDS;
-    }
-
-    public Long getSHOTS() {
-        return SHOTS;
-    }
-
-    public void setSHOTS(Long SHOTS) {
-        this.SHOTS = SHOTS;
-    }
-
-    public Long getCAVITIES() {
-        return CAVITIES;
-    }
-
-    public void setCAVITIES(Long CAVITIES) {
-        this.CAVITIES = CAVITIES;
-    }
-
-    public Double getOUTPUT_QTY() {
-        return OUTPUT_QTY;
-    }
-
-    public void setOUTPUT_QTY(Double OUTPUT_QTY) {
-        this.OUTPUT_QTY = OUTPUT_QTY;
-    }
-
-    public Double getGOOD_QTY() {
-        return GOOD_QTY;
-    }
-
-    public void setGOOD_QTY(Double GOOD_QTY) {
-        this.GOOD_QTY = GOOD_QTY;
-    }
-
-    public Double getBAD_QTY() {
-        return BAD_QTY;
-    }
-
-    public void setBAD_QTY(Double BAD_QTY) {
-        this.BAD_QTY = BAD_QTY;
-    }
-
-    public Double getSTANDARD_CYCLE() {
-        return STANDARD_CYCLE;
-    }
-
-    public void setSTANDARD_CYCLE(Double STANDARD_CYCLE) {
-        this.STANDARD_CYCLE = STANDARD_CYCLE;
-    }
-
-    public String getCYCLE_SOURCE() {
-        return CYCLE_SOURCE;
-    }
-
-    public void setCYCLE_SOURCE(String CYCLE_SOURCE) {
-        this.CYCLE_SOURCE = CYCLE_SOURCE;
-    }
-
-    public String getQUALITY_SCOPE() {
-        return QUALITY_SCOPE;
-    }
-
-    public void setQUALITY_SCOPE(String QUALITY_SCOPE) {
-        this.QUALITY_SCOPE = QUALITY_SCOPE;
-    }
-
-    public Boolean getQUALITY_DEVICE_PRECISE() {
-        return QUALITY_DEVICE_PRECISE;
-    }
-
-    public void setQUALITY_DEVICE_PRECISE(Boolean QUALITY_DEVICE_PRECISE) {
-        this.QUALITY_DEVICE_PRECISE = QUALITY_DEVICE_PRECISE;
-    }
-
-    public String getDOWNGRADE_REASON() {
-        return DOWNGRADE_REASON;
-    }
-
-    public void setDOWNGRADE_REASON(String DOWNGRADE_REASON) {
-        this.DOWNGRADE_REASON = DOWNGRADE_REASON;
-    }
-
-    public String getSHIFT_DATE() {
-        return SHIFT_DATE;
-    }
-
-    public void setSHIFT_DATE(String SHIFT_DATE) {
-        this.SHIFT_DATE = SHIFT_DATE;
-    }
-
-    public String getSHIFT_NAME() {
-        return SHIFT_NAME;
-    }
-
-    public void setSHIFT_NAME(String SHIFT_NAME) {
-        this.SHIFT_NAME = SHIFT_NAME;
-    }
 }

aucma-report/src/main/java/com/aucma/report/mapper/InjectionOeeMapper.java

@@ -30,8 +30,10 @@ public interface InjectionOeeMapper {
      *
      * @param deviceCode            设备编码
      * @param paramName             参数名称
-     * @param beginTime      开始时间
+     * @param beginTime             统计窗口开始时间
-     * @param endTime        结束时间
+     * @param endTime               统计窗口结束时间
+     * @param autoBaselineBeginTime 自动采集设备基线开始时间
+     * @param oldBaselineBeginTime  OLD 手工设备基线开始时间
      * @param tableSuffixes         月表后缀列表
      * @return 累加增量值
      */
@@ -39,6 +41,8 @@ public interface InjectionOeeMapper {
                                           @Param("paramName") String paramName,
                                           @Param("beginTime") Date beginTime,
                                           @Param("endTime") Date endTime,
+                                          @Param("autoBaselineBeginTime") Date autoBaselineBeginTime,
+                                          @Param("oldBaselineBeginTime") Date oldBaselineBeginTime,
                                           @Param("tableSuffixes") List<String> tableSuffixes);
 
     /**
@@ -76,4 +80,18 @@ public interface InjectionOeeMapper {
      */
     Map<String, Object> selectQualitySummary(@Param("beginTime") Date beginTime,
                                             @Param("endTime") Date endTime);
+
+    /**
+     * 泛化版 "RT+DAY 合并求和" 计算指定时间段内的实际开机秒或产量等
+     *
+     * @param deviceCode 设备编码
+     * @param paramName 参数名称
+     * @param beginDate 开始日期
+     * @param endDate 结束日期
+     * @return 累计数值
+     */
+    Long sumRtAndDay(@Param("deviceCode") String deviceCode,
+                     @Param("paramName") String paramName,
+                     @Param("beginDate") Date beginDate,
+                     @Param("endDate") Date endDate);
 }

aucma-report/src/main/java/com/aucma/report/service/IInjectionOeeService.java

@@ -12,12 +12,12 @@ import java.util.List;
 public interface IInjectionOeeService {
 
     /**
-     * 获取注塑车间 OEE 及利用率分析报表数据
+     * 获取注塑车间 OEE 及设备利用率分析报表数据
      *
      * @param deviceCode   设备编码
      * @param beginTimeStr 开始日期 (格式: YYYY-MM-DD)
      * @param endTimeStr   结束日期 (格式: YYYY-MM-DD)
-     * @param shiftType    班次类型 (ALL-全天, DAY-白班, NIGHT-夜班)
+     * @param shiftType    班次类型 (ALL-全部班次, DAY-白班, NIGHT-夜班)
      * @return OEE 分析结果列表
      */
     List<InjectionOeeAnalysisVo> getInjectionOeeAnalysis(String deviceCode, String beginTimeStr, String endTimeStr, String shiftType);

aucma-report/src/main/java/com/aucma/report/service/impl/Board4ServiceImpl.java

@@ -28,9 +28,10 @@ public class Board4ServiceImpl implements IBoard4Service {
     private static final int OPENING_COUNT_AUTO_BASELINE_LOOKBACK_HOURS = 2;
     private static final int OPENING_COUNT_OLD_BASELINE_LOOKBACK_HOURS = 24;
     private static final String OLD_DEVICE_CODE_PREFIX = "OLD-";
-    private static final int OLD_DEVICE_ESTIMATE_FLOAT_BUCKETS = 17;
+    private static final double OLD_DEVICE_ESTIMATE_MIN_RATE = 0.70D;
-    private static final int OLD_DEVICE_ESTIMATE_FLOAT_CENTER = 8;
+    private static final double OLD_DEVICE_ESTIMATE_MAX_RATE = 0.90D;
-    private static final double OLD_DEVICE_ESTIMATE_FLOAT_STEP = 0.01D;
+    private static final double OLD_DEVICE_ESTIMATE_RATE_STEP = 0.01D;
+    private static final int OLD_DEVICE_ESTIMATE_RATE_BUCKETS = 21;
 
     @Autowired
     private Board4Mapper board4Mapper;
@@ -291,16 +292,13 @@ public class Board4ServiceImpl implements IBoard4Service {
 
 
     /**
-     * 使用其他有有效开模数设备的均值和中位数，为OLD设备缺失或无有效开模数时临时补估算值。
+     * 使用新设备有效开模数的均值和中位数，为OLD设备缺失或无有效开模数时临时补估算值。
      */
     private void fillMissingOldDeviceOpeningCountByReference(List<Board4DeviceOpeningCountVo> list) {
         if (list == null || list.isEmpty()) {
             return;
         }
-        List<Long> referenceCounts = buildOpeningCountReferenceValues(list, false);
+        List<Long> referenceCounts = buildOpeningCountReferenceValues(list);
-        if (referenceCounts.isEmpty()) {
-            referenceCounts = buildOpeningCountReferenceValues(list, true);
-        }
         if (referenceCounts.isEmpty()) {
             return;
         }
@@ -335,12 +333,12 @@ public class Board4ServiceImpl implements IBoard4Service {
     }
 
     /**
-     * 构造估算参考样本：优先只看非OLD设备，避免用已模拟的老设备反向影响基准。
+     * 构造估算参考样本：只看非OLD新设备，避免用旧设备真实值或模拟值反向污染新设备基准。
      */
-    private List<Long> buildOpeningCountReferenceValues(List<Board4DeviceOpeningCountVo> list, boolean includeOldDevice) {
+    private List<Long> buildOpeningCountReferenceValues(List<Board4DeviceOpeningCountVo> list) {
         List<Long> referenceCounts = new ArrayList<>();
         for (Board4DeviceOpeningCountVo item : list) {
-            if (!includeOldDevice && isOldDevice(item)) {
+            if (isOldDevice(item)) {
                 continue;
             }
             if (item.getOpeningCount() == null || item.getOpeningCount().longValue() <= 0L) {
@@ -352,7 +350,7 @@ public class Board4ServiceImpl implements IBoard4Service {
     }
 
     /**
-     * 按均值和中位数中间值附近做确定性上下浮动，保证每台OLD设备刷新稳定且数值不完全相同。
+     * 按新设备均值/中位数综合基准的70%-90%做确定性浮动，保证每台OLD设备刷新稳定且数值不完全相同。
      */
     private Long buildOldDeviceEstimateOpeningCount(Board4DeviceOpeningCountVo item,
                                                     double averageOpeningCount,
@@ -360,39 +358,67 @@ public class Board4ServiceImpl implements IBoard4Service {
                                                     int missingOldDeviceIndex,
                                                     List<Long> usedEstimatedCounts) {
         double baseOpeningCount = (averageOpeningCount + medianOpeningCount) / 2D;
-        // 为什么这样做：看板会频繁刷新，不能用随机数；用设备编码/名称生成稳定浮动，避免同一设备数值跳动。
+        long minEstimateOpeningCount = Math.max(1L, Math.round(baseOpeningCount * OLD_DEVICE_ESTIMATE_MIN_RATE));
+        long maxEstimateOpeningCount = Math.max(minEstimateOpeningCount,
+                Math.round(baseOpeningCount * OLD_DEVICE_ESTIMATE_MAX_RATE));
+        // 为什么这样做：看板会频繁刷新，不能用随机数；用设备编码/名称生成70%-90%之间的稳定比例，避免同一设备数值跳动。
         String seedText = String.valueOf(item.getDeviceCode()) + "|" + String.valueOf(item.getDeviceName());
         long hashSeed = Math.abs((long) seedText.hashCode());
-        double floatRate = ((hashSeed % OLD_DEVICE_ESTIMATE_FLOAT_BUCKETS) - OLD_DEVICE_ESTIMATE_FLOAT_CENTER)
+        double estimateRate = OLD_DEVICE_ESTIMATE_MIN_RATE
-                * OLD_DEVICE_ESTIMATE_FLOAT_STEP;
+                + (hashSeed % OLD_DEVICE_ESTIMATE_RATE_BUCKETS) * OLD_DEVICE_ESTIMATE_RATE_STEP;
-        long estimateOpeningCount = Math.max(1L, Math.round(baseOpeningCount * (1D + floatRate)));
+        long estimateOpeningCount = Math.round(baseOpeningCount * estimateRate);
-        return avoidDuplicateOldDeviceEstimate(estimateOpeningCount, baseOpeningCount, missingOldDeviceIndex,
+        estimateOpeningCount = clampEstimateOpeningCount(estimateOpeningCount,
-                usedEstimatedCounts);
+                minEstimateOpeningCount, maxEstimateOpeningCount);
+        return avoidDuplicateOldDeviceEstimate(estimateOpeningCount, minEstimateOpeningCount,
+                maxEstimateOpeningCount, missingOldDeviceIndex, usedEstimatedCounts);
     }
 
     /**
-     * 老设备模拟值尽量不要重复，避免大屏上一排OLD设备出现完全一样的“假整齐”。
+     * 老设备模拟值优先在70%-90%区间内去重，避免大屏上一排OLD设备出现完全一样的“假整齐”。
      */
     private Long avoidDuplicateOldDeviceEstimate(long estimateOpeningCount,
-                                                 double baseOpeningCount,
+                                                 long minEstimateOpeningCount,
+                                                 long maxEstimateOpeningCount,
                                                  int missingOldDeviceIndex,
                                                  List<Long> usedEstimatedCounts) {
         if (!usedEstimatedCounts.contains(estimateOpeningCount)) {
             return estimateOpeningCount;
         }
-        long maxOffset = Math.max(2L, Math.round(baseOpeningCount * 0.08D));
+        long maxOffset = Math.max(0L, maxEstimateOpeningCount - minEstimateOpeningCount);
         long direction = missingOldDeviceIndex % 2 == 0 ? 1L : -1L;
         for (long offset = 1L; offset <= maxOffset; offset++) {
-            long candidate = Math.max(1L, estimateOpeningCount + direction * offset);
+            long candidate = clampEstimateOpeningCount(estimateOpeningCount + direction * offset,
+                    minEstimateOpeningCount, maxEstimateOpeningCount);
             if (!usedEstimatedCounts.contains(candidate)) {
                 return candidate;
             }
-            candidate = Math.max(1L, estimateOpeningCount - direction * offset);
+            candidate = clampEstimateOpeningCount(estimateOpeningCount - direction * offset,
+                    minEstimateOpeningCount, maxEstimateOpeningCount);
             if (!usedEstimatedCounts.contains(candidate)) {
                 return candidate;
             }
         }
-        return Math.max(1L, estimateOpeningCount + missingOldDeviceIndex + 1L);
+        // 为什么这样做：当基准值太小导致70%-90%整数区间容量不足时，优先保证旧设备之间不重复，数值仍贴近目标区间。
+        long expandedCandidate = maxEstimateOpeningCount + missingOldDeviceIndex + 1L;
+        while (usedEstimatedCounts.contains(expandedCandidate)) {
+            expandedCandidate++;
+        }
+        return expandedCandidate;
+    }
+
+    /**
+     * 将模拟值限制在目标区间内，避免四舍五入后越界。
+     */
+    private long clampEstimateOpeningCount(long estimateOpeningCount,
+                                           long minEstimateOpeningCount,
+                                           long maxEstimateOpeningCount) {
+        if (estimateOpeningCount < minEstimateOpeningCount) {
+            return minEstimateOpeningCount;
+        }
+        if (estimateOpeningCount > maxEstimateOpeningCount) {
+            return maxEstimateOpeningCount;
+        }
+        return estimateOpeningCount;
     }
 
     /**

aucma-report/src/main/resources/mapper/report/InjectionOeeMapper.xml

@@ -19,100 +19,101 @@
         ORDER BY DEVICE_CODE
     </select>
 
-    <!-- 2. 计算累加器参数增量，支持 reset 检测和基准数据加载 -->
+    <!-- 2. 计算累加器参数增量，支持 reset 检测、基准数据加载和同时间去重 -->
     <select id="selectCounterDeltaByWindow" resultType="java.math.BigDecimal">
-        WITH combined_data AS (
+        WITH source_param AS (
-            <!-- A. 窗口内的数据 -->
             <choose>
                 <when test="tableSuffixes != null and tableSuffixes.size() > 0">
                     <foreach item="suffix" collection="tableSuffixes" separator=" UNION ALL ">
-                        SELECT v.PARAM_VALUE, v.COLLECT_TIME
+                        SELECT v.DEVICE_CODE AS device_code,
+                               v.COLLECT_TIME AS collect_time,
+                               TO_NUMBER(TRIM(v.PARAM_VALUE)) AS param_value
                         FROM BASE_DEVICE_PARAM_VAL_${suffix} v
                         WHERE v.DEVICE_CODE = #{deviceCode}
+                          AND v.DEVICE_CODE NOT LIKE 'OLD-%'
                           AND v.PARAM_NAME = #{paramName}
-                          AND v.COLLECT_TIME &gt;= #{beginTime}
+                          AND v.COLLECT_TIME &gt;= #{autoBaselineBeginTime}
                           AND v.COLLECT_TIME &lt; #{endTime}
+                          <!-- 为什么先校验再转数字：PARAM_VALUE 是字符串，直接 TO_NUMBER 会因脏数据导致整页报表失败。 -->
                           AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
                     </foreach>
                     UNION ALL
-                    SELECT v.PARAM_VALUE, v.COLLECT_TIME
+                    SELECT v.DEVICE_CODE AS device_code,
+                           v.COLLECT_TIME AS collect_time,
+                           TO_NUMBER(TRIM(v.PARAM_VALUE)) AS param_value
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME = #{paramName}
-                      AND v.COLLECT_TIME &gt;= #{beginTime}
+                      AND v.COLLECT_TIME &gt;= #{oldBaselineBeginTime}
                       AND v.COLLECT_TIME &lt; #{endTime}
                       AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
                 </when>
                 <otherwise>
-                    SELECT v.PARAM_VALUE, v.COLLECT_TIME
+                    SELECT v.DEVICE_CODE AS device_code,
+                           v.COLLECT_TIME AS collect_time,
+                           TO_NUMBER(TRIM(v.PARAM_VALUE)) AS param_value
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME = #{paramName}
-                      AND v.COLLECT_TIME &gt;= #{beginTime}
+                      AND v.COLLECT_TIME &gt;= #{oldBaselineBeginTime}
                       AND v.COLLECT_TIME &lt; #{endTime}
                       AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
                 </otherwise>
             </choose>
-            UNION ALL
+        ),
-            <!-- B. 窗口前最近的一条基准数据（用于获取窗口起点附近的基线值） -->
+        normalized_param AS (
-            SELECT PARAM_VALUE, COLLECT_TIME
+            SELECT p.device_code,
+                   p.collect_time,
+                   MAX(p.param_value) AS param_value
+            FROM source_param p
+            GROUP BY p.device_code, p.collect_time
+        ),
+        baseline_param AS (
+            SELECT device_code, collect_time, param_value
             FROM (
-                SELECT PARAM_VALUE, COLLECT_TIME,
+                SELECT p.device_code,
-                       ROW_NUMBER() OVER (ORDER BY COLLECT_TIME DESC) as rn
+                       p.collect_time,
-                FROM (
+                       p.param_value,
-                    <choose>
+                       ROW_NUMBER() OVER (
-                        <when test="tableSuffixes != null and tableSuffixes.size() > 0">
+                           PARTITION BY p.device_code
-                            <foreach item="suffix" collection="tableSuffixes" separator=" UNION ALL ">
+                           ORDER BY p.collect_time DESC
-                                SELECT v.PARAM_VALUE, v.COLLECT_TIME
+                       ) AS rn
-                                FROM BASE_DEVICE_PARAM_VAL_${suffix} v
+                FROM normalized_param p
-                                WHERE v.DEVICE_CODE = #{deviceCode}
+                WHERE p.collect_time &lt; #{beginTime}
-                                  AND v.PARAM_NAME = #{paramName}
-                                  AND v.COLLECT_TIME &lt; #{beginTime}
-                                  AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
-                            </foreach>
-                            UNION ALL
-                            SELECT v.PARAM_VALUE, v.COLLECT_TIME
-                            FROM BASE_DEVICE_PARAM_VAL v
-                            WHERE v.DEVICE_CODE = #{deviceCode}
-                              AND v.PARAM_NAME = #{paramName}
-                              AND v.COLLECT_TIME &lt; #{beginTime}
-                              AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
-                        </when>
-                        <otherwise>
-                            SELECT v.PARAM_VALUE, v.COLLECT_TIME
-                            FROM BASE_DEVICE_PARAM_VAL v
-                            WHERE v.DEVICE_CODE = #{deviceCode}
-                              AND v.PARAM_NAME = #{paramName}
-                              AND v.COLLECT_TIME &lt; #{beginTime}
-                              AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
-                        </otherwise>
-                    </choose>
             )
-            ) WHERE rn = 1
+            WHERE rn = 1
         ),
-        ordered_data AS (
+        window_param AS (
-            SELECT 
+            SELECT p.device_code, p.collect_time, p.param_value
-                TO_NUMBER(TRIM(PARAM_VALUE)) as val,
+            FROM normalized_param p
-                COLLECT_TIME,
+            WHERE p.collect_time &gt;= #{beginTime}
-                LAG(TO_NUMBER(TRIM(PARAM_VALUE))) OVER (ORDER BY COLLECT_TIME) as prev_val
+              AND p.collect_time &lt; #{endTime}
-            FROM combined_data
+            UNION ALL
+            SELECT p.device_code, p.collect_time, p.param_value
+            FROM baseline_param p
         ),
-        deltas AS (
+        ordered_param AS (
-            SELECT 
+            SELECT p.device_code,
-                COLLECT_TIME,
+                   p.collect_time,
-                val,
+                   p.param_value,
-                prev_val,
+                   LAG(p.param_value) OVER (
+                       PARTITION BY p.device_code
+                       ORDER BY p.collect_time
+                   ) AS previous_param_value
+            FROM window_param p
+        )
+        SELECT NVL(SUM(
             CASE
-                    WHEN prev_val IS NULL THEN 0
+                WHEN p.collect_time &lt; #{beginTime} THEN 0
-                    WHEN val &gt;= prev_val THEN val - prev_val
+                WHEN p.previous_param_value IS NULL THEN 0
-                    ELSE val
+                WHEN p.param_value &gt; p.previous_param_value THEN p.param_value - p.previous_param_value
-                END as delta
+                WHEN p.param_value &lt; p.previous_param_value THEN p.param_value
-            FROM ordered_data
+                ELSE 0
-        )
+            END
-        SELECT NVL(SUM(delta), 0)
+        ), 0) AS counter_delta
-        FROM deltas
+        FROM ordered_param p
-        WHERE COLLECT_TIME &gt;= #{beginTime}
-          AND COLLECT_TIME &lt; #{endTime}
     </select>
 
     <!-- 3. 获取截止时间前最新的模腔数参数值 -->
@@ -132,6 +133,7 @@
                     SELECT v.PARAM_VALUE, v.COLLECT_TIME
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME IN ('system.sv_iCavities', '机台状态-模腔数')
                       AND v.COLLECT_TIME &lt;= #{endTime}
                       AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
@@ -140,6 +142,7 @@
                     SELECT v.PARAM_VALUE, v.COLLECT_TIME
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME IN ('system.sv_iCavities', '机台状态-模腔数')
                       AND v.COLLECT_TIME &lt;= #{endTime}
                       AND REGEXP_LIKE(TRIM(v.PARAM_VALUE), '^[+-]?[0-9]+([.][0-9]+)?$')
@@ -172,6 +175,7 @@
                     SELECT v.PARAM_VALUE, v.COLLECT_TIME
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME = '机床实时参数-周期时间'
                       AND v.COLLECT_TIME &gt;= #{beginTime}
                       AND v.COLLECT_TIME &lt; #{endTime}
@@ -181,6 +185,7 @@
                     SELECT v.PARAM_VALUE, v.COLLECT_TIME
                     FROM BASE_DEVICE_PARAM_VAL v
                     WHERE v.DEVICE_CODE = #{deviceCode}
+                      AND v.DEVICE_CODE LIKE 'OLD-%'
                       AND v.PARAM_NAME = '机床实时参数-周期时间'
                       AND v.COLLECT_TIME &gt;= #{beginTime}
                       AND v.COLLECT_TIME &lt; #{endTime}
@@ -212,4 +217,22 @@
         FROM bar_defect
     </select>
 
+    <!-- 6. 泛化版 "RT+DAY 合并求和" -->
+    <select id="sumRtAndDay" resultType="java.lang.Long">
+        SELECT NVL(SUM(v), 0) FROM (
+            SELECT DAILY_PROD AS v
+              FROM DEVICE_DAILY_PRODUCTION
+             WHERE DEVICE_CODE = #{deviceCode}
+               AND PARAM_NAME  = #{paramName}
+               AND PROD_DATE BETWEEN TRUNC(#{beginDate}) AND LEAST(TRUNC(#{endDate}), TRUNC(SYSDATE) - 1)
+            UNION ALL
+            SELECT CURRENT_TOTAL AS v
+              FROM RT_DAILY_PROD_STATE
+             WHERE DEVICE_CODE = #{deviceCode}
+               AND PARAM_NAME  = #{paramName}
+               AND PROD_DATE   = TRUNC(SYSDATE)
+               AND TRUNC(SYSDATE) BETWEEN TRUNC(#{beginDate}) AND TRUNC(#{endDate})
+        )
+    </select>
+
 </mapper>