Salesforce 在批处理中使用AggregateResult进行限制

我最近刚刚遇到一个使用带有AggregateResult对象的Batch Apex的调控器限制，我希望有人能清楚地解释这个限制。我认为batch APEX可以支持多达5000万条记录，但当我使用AggregateResult时，我达到了管理器的限制，即使对象中的记录总数约为250000条

AggregateResult限制在批次APEX中如何应用

请解释如何应用此限制以及如何克服此限制。我应该避免在batch APEX中使用AggregateResult吗？或者，如果我真的使用它，我如何确定何时会达到这个极限

下面是我使用AggregateResult编写的一个简单批处理程序。它每月运行一次，我正在按用户聚合与案例相关的任务。我如何确定这是否会达到极限

global class MemberCaseAchievementBatch implements Database.Batchable<sObject> {

public string query =  'select Id, Enhancement_Value__c from Case where RecordType.DeveloperName = \'SF_Enhancement\' AND Stage__c = \'Deployed\' AND ClosedDate = THIS_MONTH';
public Set<Id> caseIds = new Set<Id>();
public Set<Id> allCaseIds = new Set<Id>();
Integer totalCompletedCases = 0;
Integer totalAssignedCases = 0;
Double totalCompletedValue = 0;

global database.querylocator start(Database.BatchableContext BC)
{
    return Database.getQueryLocator(query);
}

global void execute(Database.BatchableContext BC, Sobject[] scope)
{
    for(Case c : (List<Case>)scope) {
        caseIds.add(c.Id);
        totalCompletedCases++;
        if(c.Enhancement_Value__c == null) {
            totalCompletedValue = c.Enhancement_Value__c;
        }
        else {
            totalCompletedValue += c.Enhancement_Value__c;
        }
    }

    for(Case c : [select Id from Case where RecordType.DeveloperName = 'SF_Enhancement' AND CreatedDate = THIS_MONTH]) {
        allCaseIds.add(c.Id);
        totalAssignedCases++;
    }

    Map<Id, Member_Goal__c> memberGoalsMap = getMemberGoals();
    List<Member_Case_Achievement__c> achievementsToInsert = new List<Member_Case_Achievement__c>();
    AggregateResult[] results = getMemberAchievementMetrics(caseIds);
    Map<String, AggregateResult> tasksAssigned = getMemberTotalTasksAssigned(allCaseIds);
    Date firstDayOfMonth = System.today().toStartOfMonth();
    Date lastDayOfMonth = firstDayOfMonth.addDays(Date.daysInMonth(firstDayOfMonth.year(), firstDayOfMonth.month()) - 1);

    for(AggregateResult ar : results) {
        Member_Case_Achievement__c mca = new Member_Case_Achievement__c();
        if(memberGoalsMap.containsKey(String.valueOf(ar.get('OwnerId')))) mca.Member_Goal__c = memberGoalsMap.get(String.valueOf(ar.get('OwnerId'))).Id;
        AggregateResult aggResult = tasksAssigned.get(String.valueOf(ar.get('OwnerId')));
        mca.Total_Assigned_Tasks__c = (Integer)aggResult.get('expr0');
        mca.Total_Completed_Tasks__c = (Integer)ar.get('expr1');
        mca.Total_Completed_Task_Value__c = (Double)ar.get('expr0');
        mca.Total_Assigned_Cases__c = totalAssignedCases;
        mca.Total_Completed_Cases__c = totalCompletedCases;
        mca.Total_Completed_Value__c = totalCompletedValue;
        mca.Period_Start_Date__c = firstDayOfMonth;
        mca.Period_End_Date__c = lastDayOfMonth;
        achievementsToInsert.add(mca);      
    }
    if(!achievementsToInsert.isEmpty() && achievementsToInsert.size() > 0) {
        insert achievementsToInsert;
    }
}

global void finish(Database.BatchableContext BC) {

}

private AggregateResult[] getMemberAchievementMetrics(Set<Id> caseids) {
    AggregateResult[] groupedResults = [select OwnerId, SUM(Task_Value__c), Count(Id) from Task where WhatId in: caseids AND Subject in ('Requirements','Design','Develop / Config','Unit Testing') group by OwnerId];
    return groupedResults;
}

private Map<String, AggregateResult> getMemberTotalTasksAssigned(Set<Id> caseids) {
    Map<String, AggregateResult> aggregateResultMap = new  Map<String, AggregateResult>();
    for(AggregateResult ar : [select OwnerId, Count(Id) from Task where WhatId in: caseids AND Subject in ('Requirements','Design','Develop / Config','Unit Testing') group by OwnerId]) {
        aggregateResultMap.put(String.valueOf(ar.get('OwnerId')), ar);
    }
    return aggregateResultMap;
}

private Map<Id, Member_Goal__c> getMemberGoals() {
    Map<Id, Member_Goal__c> memberGoalMap = new Map<Id, Member_Goal__c>();
    for(Member_Goal__c mg : [select Id, Member__c from Member_Goal__c where Goal_Period__r.Period_Start_Date__c = THIS_MONTH]) {
        memberGoalMap.put(mg.Member__c, mg);
    }
    return memberGoalMap;
}

全局类MemberCaseAccessivementBatch实现数据库。可批处理{
公共字符串查询='从RecordType.DeveloperName=\'SF\U Enhancement\'和Stage\UU c=\'Deployed\'和ClosedDate=本月的案例中选择Id、增强\U值\uU c'；
公共集合caseIds=新集合（）；
public Set allCaseIds=new Set（）；
整数totalCompletedCases=0；
整数totalAssignedCases=0；
双重totalCompletedValue=0；
global database.querylocator启动（database.BatchableContext BC）
{
返回数据库.getQueryLocator（查询）；
}
全局void execute（Database.BatchableContext BC，Sobject[]范围）
{
（案例c：（列表）范围）{
案例编号。添加（c.Id）；
totalCompletedCases++；
如果（c.U值c==null）{
totalCompletedValue=c；
}
否则{
totalCompletedValue+=c.U\U值\U\c；
}
}
对于（案例c:[从RecordType.DeveloperName='SF\u Enhancement'和CreatedDate=本月的案例中选择Id]）{
添加（c.Id）；
totalAssignedCases++；
}
Map memberGoalsMap=getMemberGoals（）；
List achievementsToInsert=新建列表（）；
AggregateResult[]results=getMemberAchievementMetrics（caseId）；
Map tasksAssigned=getMemberTotalTasksAssigned（allCaseIds）；
Date firstDayOfMonth=System.today（）.toStartOfMonth（）；
Date lastDayOfMonth=firstDayOfMonth.addDays（Date.daysInMonth（firstDayOfMonth.year（），firstDayOfMonth.month（））-1）；
对于（聚合结果：结果）{
成员\案例\成就\案例c mca=新成员\案例\成就\案例c（）；
if（memberGoalsMap.containsKey（String.valueOf（ar.get（'OwnerId'）））mca.Member\u Goal\u c=memberGoalsMap.get（String.valueOf（ar.get（'OwnerId'）））.Id；
AggregateResult-Accessult=tasksAssigned.get（String.valueOf（ar.get（'OwnerId'））；
mca.Total_Assigned_Tasks_uuc=（整数）aggressult.get（'expr0'）；
mca.Total_Completed_Tasks_uuc=（整数）ar.get（'expr1'）；
mca.Total_Completed_Task_Value_uuc=（Double）ar.get（'expr0'）；
mca.Total_Assigned_Cases_uuc=totalAssignedCases；
mca.Total_Completed_Cases_uuc=totalCompletedCases；
mca.Total\u Completed\u Value\uu c=totalCompletedValue；
mca.Period\u Start\u Date\u c=月的第一天；
mca.Period\u End\u Date\u c=每月的最后一天；
achievementsToInsert.add（mca）；
}
如果（！achievementsToInsert.isEmpty（）&&achievementsToInsert.size（）>0）{
插入achievementsToInsert；
}
}
全局void完成（Database.BatchableContext BC）{
}
私有聚合结果[]getMemberAchievementMetrics（设置caseId）{
AggregateResult[]groupedResults=[按所有者Id选择OwnerId、SUM（任务值）、Count（Id），从任务中选择WhatId in:CaseID和Subject in（'Requirements'、'Design'、'Development/Config'、'Unit Testing'）分组]；
返回分组结果；
}
私有映射getMemberTotalTasksAssigned（设置caseID）{
Map aggregateResultMap=新映射（）；
对于（AggregateResult ar:[选择OwnerId，从任务中计数（Id），其中WhatId in:CaseID和Subject in（'Requirements'、'Design'、'Development/Config'、'Unit Testing'）组中的OwnerId]）{
aggregateResultMap.put（String.valueOf（ar.get（'OwnerId'）），ar）；
}
返回聚合结果图；
}
私有映射getMemberGoals（）{
Map memberGoalMap=newmap（）；
对于（成员目标管理：[从成员目标中选择Id、成员c，其中目标期开始日期=本月]）{
memberGoalMap.put（mg.Member_u_uc，mg）；
}
返回成员goalmap；
}

}

---

限制是否由范围决定？或者，它是由AggregateResult查询确定的？

Batch apex允许您运行多达5000万条记录的批处理。因此，在你的情况下，你可以批量超过5000万箱。正常顶点限制仍然适用，但在每个批次内

您可以尝试通过

Database.executeBatch（yourBatch，scopeSize）限制每个批的作用域大小其中
scopeSize
是一个介于1和2000之间的整数。将此值设置为较低的数字（默认值为200）将减少每个批运行的案例数，实际上也希望减少聚合结果的大小