O Salesforce nos permite processar ou executar um determinado número de extratos/registros por vez. Existem alguns limites para instruções DML, classes Apex, etc., para executar ou processar. Esses limites são conhecidos como limites do Governador. Neste tutorial, veremos o que são os limites do Governador e como eles podem ser tratados. Além disso, o Salesforce Apex fornece a classe “Limit” para conhecer os limites relacionados a chamadas, classes Apex, componentes da web Lightning, instruções SOSL e SOQL.
Limites do Governador
Considere um cenário em que Alish e Subash são duas pessoas usando a organização Salesforce. Alice deseja processar ou executar 1.000 instruções DML em uma transação. Em paralelo, o Subash deseja carregar 5.000 registros por vez. Se eles fizerem isso em paralelo, o Salesforce não aceitará e ficará agitado. Conseqüentemente, os limites do governador entram em cena. Nesse caso, Alish pode processar 100 DML por vez e Subash pode processar 500 registros por vez. Eles podem usar o Apex AsynchronousBatch para fazer cada transação em um thread separado sem interromper cada um deles e concluir sua tarefa.
Basicamente, os limites do Governor no Salesforce limitam o processamento e a execução em várias transações. 'Limites de Apex por transação' contam para cada transação e 'Limite de Apex por tamanho específico' lida com o tamanho do código. O Salesforce oferece suporte a dois processos: processos síncronos e assíncronos. No processo síncrono, o script Apex é executado de uma só vez, enquanto no processo assíncrono, o script Apex é executado dividindo-se em vários trabalhos.
Limites permitidos
Vamos discutir a contagem de limite para diferentes cenários:
- Pode ser possível processar/executar 100 consultas SOQL no Apex síncrono e 200 consultas SOQL no Apex assíncrono.
- Apenas 50.000 registros retornarão de uma consulta SOQL para apex síncrono e assíncrono.
- Se usarmos Database.getQueryLocator(), apenas 10.000 serão retornados por vez para Apex síncrono e assíncrono.
- Em ambos os cenários, o número de consultas SOSL emitidas é 20.
- O tamanho de heap necessário para processar o Apex síncrono é de 6 MB. Para Apex assíncrono, o tamanho de heap necessário é o dobro, o que o torna 12 MB.
- O tempo máximo de CPU permitido para Apex síncrono é de 10.000 milissegundos e 60.000 milissegundos para Apex assíncrono.
- Apenas 10 minutos são permitidos para a execução de ambos Apex.
- Em ambos os casos, podemos usar apenas 10 métodos sendEmail() com 100 destinatários.
- Os caracteres que estão presentes na classe do Apex ou no gatilho do Apex devem estar dentro de 1 milhão.
- No Batch Apex (assíncrono), o tamanho é 200. O QueryLocator() da classe “Database” retorna 50 milhões de registros por transação.
- Apenas 5 trabalhos do Apex estarão na fila ou ativos.
Exemplo de classe LIMIT:
O Apex pode especificar os limites do Governador na classe “LIMIT”. Esta classe fornece alguns métodos que informam os limites do Governador. Vejamos o exemplo a seguir, que exibe alguns limites do governador:
System.debug('Número de consultas agregadas podem ser processadas: '+ Limits.getLimitAggregateQueries());
System.debug('Número de instruções de serviço da Web que podem ser processadas: '+ Limits.getLimitCallouts());
System.debug('Número de registros podem ser processados: '+ Limits.getLimitDmlRows());
System.debug('Número de instruções DML que podem ser chamadas: '+ Limits.getLimitDmlStatements());
System.debug('Quantidade total de memória em bytes: '+ Limits.getLimitHeapSize());
System.debug('Número de consultas SOQL podem ser emitidas: '+ Limits.getLimitQueries());
System.debug('Número de registros podem ser emitidos: '+ Limits.getLimitQueryRows());
System.debug('Número de consultas SOSL podem ser emitidas: '+ Limits.getLimitSoslQueries());
Saída:
Também pode ser possível verificar quantas declarações/linhas DML podem ser retornadas usando os métodos “dome” que estão presentes na classe “LIMIT”.
- Limits.getDMLStatements() retorna o total de instruções DML usadas em uma instância.
- Limits.getDMLRows() retorna o número total de linhas retornadas pelas instruções DML.
- Limits.getCpuTime() retorna o tempo de uso da CPU para a transação atual em milissegundos.
Exemplo de uso:
Vamos escrever uma consulta SOQL que retorne os dois registros do objeto “WorkOrder”. Depois disso, exclua esses dois registros usando o DML “delete”.
System.debug('Declarações DML:'+Limits.getDMLStatements());System.debug('Linhas: '+Limits.getDmlRows());
System.debug('CPU Time '+Limits.getCpuTime());
// Consulta SOQL para selecionar 2 linhas do objeto WorkOrder
List
//Use delete DML para deletar duas linhas
excluir contas;
System.debug('**Após SOQL:**');
System.debug('Declarações DML:'+Limits.getDMLStatements());
System.debug('Linhas: '+Limits.getDmlRows());
System.debug('CPU Time '+Limits.getCpuTime());
Saída:
No exemplo fornecido, não há instruções DML e 0 linhas. O tempo de CPU existente é de 1 milissegundo. Depois de retornar 2 linhas da consulta SOQL e excluir essas duas linhas, o número total de instruções DML retornadas por Limits.getDMLStatements() é 1, o total de linhas retornadas por Limits.getDMLRows() é 2 e a CPU o tempo necessário para executar esta transação é de 51 milissegundos.
Exemplo de prática recomendada: “NUNCA USE DML DENTRO DO LOOP”
Vamos ver como podemos executar o código sem obter o limite do governador. Primeiro criamos um registro no objeto 'Product' (API – Product2) a partir do objeto 'WorkOrder' atribuindo o assunto 'WorkOrder' ao 'Nome do produto' no próprio loop 'for'. Vejamos o seguinte código:
Produto2 prod_obj;para (WorkOrder wo_object: [SELECT Subject FROM WorkOrder])
{
prod_obj = new Product2(Name = wo_object.Subject);
inserir prod_obj;
}
Podemos fazer isso de uma maneira melhor declarando uma lista (prod_s) e armazenando o prod_obj na lista. Podemos inserir essa lista no produto fora do loop.
ListProduto2 prod_obj;
para (WorkOrder wo_object: [SELECT Subject FROM WorkOrder])
{
prod_obj = new Product2(Name = wo_object.Subject);
prod_s.add(prod_obj);
}
inserir prod_obj;
Conclusão
Agora aprendemos quais são os limites do Apex no Salesforce com uma explicação detalhada. É melhor ir com o processo Apex Assíncrono para obter melhores limites do Governador quando comparado ao Apex Síncrono. Também aprendemos sobre os limites do governador para diferentes cenários e fizemos uma demonstração de exemplo sobre a contagem de limite da classe “Limit”. Também verificamos a contagem de instruções DML, linhas e tempo de CPU executando uma instrução DML. Concluímos este guia discutindo um exemplo de prática recomendada.