Salesforce Apex - Gouverneur Grenzen

Mit Salesforce können wir eine bestimmte Anzahl von Aussagen/Datensätzen gleichzeitig verarbeiten oder ausführen. Es gibt einige Grenzen für DML -Anweisungen, Apex -Klassen usw., ausführen oder verarbeiten. Diese Grenzen sind als Gouverneur -Grenzen bekannt. In diesem Tutorial werden wir sehen, was der Gouverneur begrenzt ist und wie sie behandelt werden können. Außerdem bietet Salesforce Apex die Klasse „Limit“, um die Grenzen zu kennen, die sich auf Callouts, Apex -Klassen, Lightning -Webkomponenten, SOSL und SOQL -Anweisungen beziehen.

Gouverneur Grenzen

Betrachten Sie ein Szenario, in dem Alish und Subash zwei Personen sind, die die Salesforce Org nutzen. Alice möchte 1000 DML -Anweisungen in einer Transaktion verarbeiten oder ausführen. Parallel dazu möchte Subash jeweils 5000 Datensätze laden. Wenn sie es parallel tun, akzeptiert Salesforce nicht und wird hektisch. Daher kommen Governorgrenzen ins Bild. In diesem Fall kann Alish jeweils 100 DML verarbeiten, und Subash kann jeweils 500 Datensätze verarbeiten. Sie können die AsynchronousBatch -Apex verwenden, um jede Transaktion auf einem separaten Faden durchzuführen, ohne jede von ihnen zu stören und ihre Aufgabe zu erledigen.

Grundsätzlich begrenzen der Gouverneur die Verarbeitung und Ausführung in mehreren Transaktionen ein. "Pro transaktions Apex-Grenzwerte" zählt für jede Transaktion und "Größenspezifische Apex-Grenze" befasst sich mit der Größe des Codes. Salesforce unterstützt zwei Prozesse: synchrone und asynchrone Prozesse. Im synchronen Prozess wird das Apex -Skript in einem einzigen GO ausgeführt, während im asynchronen Prozess das Apex -Skript durch Aufteilung in mehrere Jobs ausgeführt wird.

Erlaubte Grenzen

Lassen Sie uns die Grenze für verschiedene Szenarien diskutieren:

1. Es kann möglich sein, 100 SOQL -Abfragen in synchronen Apex- und 200 SOQL -Abfragen in asynchroner Apex zu verarbeiten/auszuführen.
2. Nur 50.000 Datensätze werden von einer SOQL -Abfrage sowohl für synchrone als auch für asynchrone Apex zurückkehren.
3. Wenn wir die Datenbank verwenden.GetQueryLocator (), jeweils nur 10.000 zurückgegeben für synchrone als auch für asynchrone Apex.
4. In beiden Szenarien beträgt die Anzahl der ausgestellten SOSL -Abfragen 20 20.
5. Die Haufengröße, die erforderlich ist, um den synchronen Apex zu verarbeiten, beträgt 6 MB. Für asynchrone Apex ist die erforderliche Haufengröße doppelt, wodurch es 12 MB macht.
6. Die maximale CPU -Zeit, die synchroner Apex zulässig ist, beträgt 10.000 Millisekunden und 60.000 Millisekunden für asynchron.
7. Für beide Apex sind nur 10 Minuten für die Ausführung zulässig.
8. In beiden Fällen können wir nur 10 Sendemail () -Methoden mit 100 Empfängern anwenden.
9. Die Zeichen, die in der Apex -Klasse oder im Apex -Trigger vorhanden sind, müssen innerhalb von 1 Million liegen.
10. In Batch Apex (asynchron) beträgt die Größe 200. Der QueryLocator () der "Datenbank" -Klasse gibt 50 Millionen Datensätze pro Transaktion zurück.
11. Nur 5 Apex -Jobs werden in der Warteschlange oder aktiv sein.

Klassenbeispiel einschränken:

Apex kann die Governor -Grenzen in der Klasse „Limit“ angeben. Diese Klasse bietet einige Methoden, die den Governor -Grenzen mitteilen. Schauen wir uns das folgende Beispiel an, in dem einige Governor -Grenzen angezeigt werden:

System.Debugg ('Anzahl der aggregierten Abfragen kann bearbeitet werden:'+ Grenzwerte.getLimitaggregatequerien ());
System.Debugug ('Anzahl der Webdienstanweisungen kann verarbeitet werden:'+ Grenzwerte.getLimitCallouts ());
System.Debugg ('Anzahl der Datensätze kann verarbeitet werden:'+ Grenzen.getLimitdmlrows ());
System.Debugg ('Anzahl der DML -Anweisungen kann genannt:'+ Grenzen.getLimitdmlStatements ());
System.Debugug ('Gesamtmenge des Speichers in Bytes:'+ Grenzen.getLimitheapsize ());
System.Debugg ('Anzahl der SOQL -Abfragen kann ausgestellt werden:'+ Grenzen.getLimitQueries ());
System.Debugg ('Anzahl der Aufzeichnungen kann ausgestellt werden:'+ Grenzen.getLimitQueryRows ());
System.Debugg ('Anzahl der SOSL -Abfragen kann ausgestellt werden:'+ Grenzwerte.GetLimitsoslQueries ());

Ausgang:

Es kann auch möglich sein zu überprüfen.

1. Grenzen.getdmlStatements () Gibt die gesamten DML -Anweisungen zurück, die in einer Instanz verwendet werden.
2. Grenzen.getdmlrows () Gibt die Gesamtzahl der Zeilen zurück, die von den DML -Anweisungen zurückgegeben werden.
3. Grenzen.getCutime () Gibt die CPU zurück, die Zeit für die aktuelle Transaktion in Millisekunden genutzt hat.

Verwendungsbeispiel:

Schreiben wir eine SoQL -Abfrage, die die beiden Datensätze aus dem Objekt "WorkOrder" zurückgibt. Löschen Sie diese beiden Datensätze danach mit "DML" "Löschen".

System.Debugg ('DML -Aussagen:'+Grenzen.getdmlStatements ());
System.Debugug ('Zeilen:'+Grenzen.getDmlrows ());
System.Debugug ('CPU -Zeit'+Grenzen.getCUpTime ());
// Soql -Abfrage zum Auswählen von 2 Zeilen aus dem WorkOrder -Objekt
Listenkonten = [ID aus WorkOrder Limit 2 auswählen];
// DML DML löschen, um zwei Zeilen zu löschen
Konten löschen;
System.Debug ('** After Soql: **');
System.Debugg ('DML -Aussagen:'+Grenzen.getdmlStatements ());
System.Debugug ('Zeilen:'+Grenzen.getDmlrows ());
System.Debugug ('CPU -Zeit'+Grenzen.getCUpTime ());

Ausgang:

Im angegebenen Beispiel gibt es keine DML -Anweisungen und 0 Zeilen. Die bestehende CPU -Zeit beträgt 1 Millisekunde. Nach Rückgabe von 2 Zeilen aus der SOQL -Abfrage und dem Löschen dieser beiden Zeilen die Gesamtzahl der DML.getdmlStatements () ist 1, die Gesamtreihen, die durch die Grenzen zurückgegeben werden.getdmlrows () ist 2 und die CPU -Zeit, die für die Ausführung dieser Transaktion benötigt wird, beträgt 51 Millisekunden.

Best -Practice -Beispiel: „Verwenden Sie niemals DML in der Schleife“

Mal sehen, wie wir den Code ausführen können, ohne das Gouverneur -Grenzwert zu erhalten. Wir erstellen zunächst einen Datensatz für das „Produkt“ -Objekt (API - Product2) aus dem Objekt „Workorder“, indem wir den „WorkOrder“ dem „Produktnamen“ in der „für“ Schleife selbst zuweisen. Lassen Sie uns den folgenden Code sehen:

Product2 prod_obj;
für (WorkOrder WO_Object: [Subjekt aus WorkOrder aus auswählen])

prod_obj = new Product2 (name = wo_object.Thema);
einfügen prod_obj;

Wir können dies besser tun, indem wir eine Liste (prod_s) deklarieren und dann den prod_obj in der Liste speichern. Wir können diese Liste außerhalb der Schleife in das Produkt einfügen.

Liste prod_s = new list ();
Product2 prod_obj;
für (WorkOrder WO_Object: [Subjekt aus WorkOrder aus auswählen])

prod_obj = new Product2 (name = wo_object.Thema);
prod_s.add (prod_obj);

einfügen prod_obj;

Abschluss

Wir haben jetzt erfahren, welche Apex -Grenzen mit einer detaillierten Erklärung in Salesforce sind. Es ist besser, mit dem asynchronen Apex -Prozess einzugehen, um bessere Gouverneur -Grenzen im Vergleich zu synchroner Apex zu erlangen. Wir haben auch die Grenzen der Gouverneur für verschiedene Szenarien erfahren und eine Beispieldemonstration bezüglich der Grenzzahl aus der Klasse „Limit“ gegeben. Wir haben auch die Anzahl von DML -Anweisungen, Zeilen und CPU -Zeit überprüft, indem wir eine DML -Anweisung ausführen. Wir haben diesen Leitfaden abgeschlossen, indem wir ein Best -Practice -Beispiel diskutierten.