Salesforce Apex - Limiti del governatore

Salesforce ci consente di elaborare o eseguire un numero particolare di dichiarazioni/record alla volta. Ci sono alcuni limiti per le dichiarazioni DML, le classi apice, ecc., da eseguire o elaborare. Questi limiti sono noti come limiti del governatore. In questo tutorial, vedremo quali sono i limiti del governatore e come possono essere gestiti. Inoltre, Salesforce Apex fornisce la classe "limite" per conoscere i limiti correlati a callout, classi Apex, componenti Web Lightning, dichiarazioni SOSL e SOQL.

Limiti del governatore

Considera uno scenario in cui Alish e Subash sono due persone che usano l'organizzazione di Salesforce. Alice desidera elaborare o eseguire 1000 istruzioni DML in una transazione. In parallelo, Subash vuole caricare 5000 record alla volta. Se lo fanno in parallelo, Salesforce non accetterà e diventa frenetico. Quindi, i limiti del governatore entrano in foto. In questo caso, Alish può elaborare 100 DML alla volta e Subash può elaborare 500 record alla volta. Possono usare l'apice asincronousbatch per eseguire ogni transazione su un thread separato senza disturbarne ciascuno di essi e completare il proprio compito.

Fondamentalmente, i limiti del governatore in Salesforce limitano l'elaborazione e l'esecuzione in più transazioni. I limiti di "perpastica per transazione" contano per ciascuna transazione e il limite di apice specifico per dimensione "affronta la dimensione del codice. Salesforce supporta due processi: processi sincroni e asincroni. Nel processo sincrono, lo script Apex viene eseguito in un singolo GO mentre nel processo asincrono, lo script Apex viene eseguito divisa in più lavori.

Limiti consentiti

Discutiamo del conteggio dei limiti per diversi scenari:

1. Può essere possibile elaborare/eseguire 100 query SOQL in apice sincrono e 200 query SOQL nell'apice asincrono.
2. Solo 50.000 record torneranno da una query SOQL per apice sia sincrona che asincrona.
3. Se utilizziamo il database.getQueryLocator (), solo 10.000 vengono restituiti alla volta per l'apice sincrono e asincrono.
4. In entrambi gli scenari, il numero di domande SOSL emesse è 20.
5. La dimensione del heap necessaria per elaborare l'apice sincrono è di 6 mb. Per l'apice asincrono, la dimensione dell'heap richiesta è doppia, il che lo rende 12 MB.
6. Il tempo massimo della CPU consentito per l'apice sincrono è di 10.000 millisecondi e 60.000 millisecondi per apice asincrono.
7. Sono consentiti solo 10 minuti per l'esecuzione per entrambi gli apice.
8. In entrambi i casi, possiamo utilizzare solo 10 metodi sendemail () con 100 destinatari.
9. I personaggi presenti nella classe Apex o nel trigger Apex devono essere entro 1 milione.
10. In batch apice (asincrono), la dimensione è 200. Il queryLocator () della classe "Database" restituisce 50 milioni di record per transazione.
11. Solo 5 posti di apice saranno in coda o attivi.

Esempio di classe limite:

L'apice può specificare i limiti del governatore nella classe "limite". Questa classe fornisce alcuni metodi che indicano ai limiti del governatore. Diamo un'occhiata al seguente esempio che mostra alcuni limiti del governatore:

Sistema.Debug ('Numero di query aggregate possono essere elaborati:'+ limiti.getlimitaggregateQueries ());
Sistema.Debug ('Numero di dichiarazioni di servizi Web può essere elaborato:'+ limiti.getlimitCallouts ());
Sistema.Debug ('Il numero di record può essere elaborato:'+ Limiti.getlimitdmlrows ());
Sistema.Debug ('Numero di dichiarazioni DML può essere chiamato:'+ limiti.getlimitdmlstatements ());
Sistema.Debug ("Importo totale di memoria in byte:"+ limiti.getlimitHeapSize ());
Sistema.Debug ('Numero di query SOQL è possibile emettere:'+ limiti.getlimitQueries ());
Sistema.Debug ('Numero di record può essere emesso:'+ limiti.getlimitQueryRows ());
Sistema.Debug ('Numero di query SOSL è possibile emettere:'+ limiti.getlitsoslqueries ());

Produzione:

Può anche essere possibile verificare quante dichiarazioni/righe DML possono essere restituite usando i metodi "Dome" che sono presenti nella classe "limite".

1. Limiti.getDMlstatements () restituisce le dichiarazioni DML totali utilizzate in un'istanza.
2. Limiti.getDMlrows () restituisce il numero totale di righe che vengono restituite dalle dichiarazioni DML.
3. Limiti.getCputime () Restituisce la CPU utilizzata per l'attuale transazione in millisecondi.

Esempio di utilizzo:

Scriviamo una query SOQL che restituisce i due record dall'oggetto "Workorder". Successivamente, elimina questi due record usando DML "Elimina".

Sistema.Debug ("Dichiarazioni DML:"+limiti.getDMlstatements ());
Sistema.debug ('righe:'+limiti.getDMlrows ());
Sistema.Debug ("tempo della CPU"+limiti.getCputime ());
// query SOQL per selezionare 2 righe dall'oggetto Workorder
Elenca account = [Seleziona ID dal limite di workorder 2];
// Usa Elimina DML per eliminare due righe
eliminare gli account;
Sistema.debug ('** dopo soql: **');
Sistema.Debug ("Dichiarazioni DML:"+limiti.getDMlstatements ());
Sistema.debug ('righe:'+limiti.getDMlrows ());
Sistema.Debug ("tempo della CPU"+limiti.getCputime ());

Produzione:

Nell'esempio dato, non ci sono dichiarazioni DML e 0 righe. Il tempo della CPU esistente è di 1 millisecondo. Dopo aver restituito 2 righe dalla query SOQL ed eliminazione di queste due righe, il numero totale di istruzioni DML che viene restituita dai limiti.getDMlstatements () è 1, le righe totali restituite dai limiti.getdmlrows () è 2 e il tempo della CPU necessario per eseguire questa transazione è di 51 millisecondi.

Esempio di best practice: "Non usare mai DML all'interno del loop"

Vediamo come possiamo eseguire il codice senza ottenere il limite del governatore. Per prima cosa creiamo un record sull'oggetto "Product" (API - Product2) dall'oggetto "WorkOrder" assegnando il "Workorder" soggetto al "Nome prodotto" nel ciclo "per" stesso. Vediamo il seguente codice:

Product2 Prod_obj;
per (WorkOrder wo_object: [Seleziona soggetto da workorder])

Prod_obj = new Product2 (name = wo_object.Soggetto);
Inserisci Prod_Obj;

Possiamo farlo in modo migliore dichiarando un elenco (Prod_s) e quindi memorizzando il Prod_Obj nell'elenco. Possiamo inserire questo elenco nel prodotto al di fuori del loop.

Elenco prod_s = new List ();
Product2 Prod_obj;
per (WorkOrder wo_object: [Seleziona soggetto da workorder])

Prod_obj = new Product2 (name = wo_object.Soggetto);
Prod_s.Aggiungi (Prod_obj);

Inserisci Prod_Obj;

Conclusione

Ora abbiamo imparato quali sono i limiti Apex in Salesforce con una spiegazione dettagliata. È meglio andare con il processo Apex asincrono per ottenere migliori limiti del governatore rispetto all'apice sincrono. Abbiamo anche appreso i limiti del governatore per diversi scenari e abbiamo dato una dimostrazione di esempio per quanto riguarda il conteggio dei limiti dalla classe "limite". Abbiamo anche verificato il conteggio delle dichiarazioni DML, delle righe e del tempo della CPU eseguendo un'istruzione DML. Abbiamo concluso questa guida discutendo di un esempio di best practice.