Binibigyang-daan kami ng Salesforce na iproseso o isagawa ang isang partikular na bilang ng mga pahayag/tala sa isang pagkakataon. Mayroong ilang mga limitasyon para sa mga pahayag ng DML, mga klase ng Apex, atbp., upang isagawa o iproseso. Ang mga limitasyong ito ay kilala bilang mga limitasyon ng Gobernador. Sa tutorial na ito, makikita natin kung ano ang mga limitasyon ng Gobernador at kung paano ito haharapin. Gayundin, ibinibigay ng Salesforce Apex ang klase na 'Limit' upang malaman ang mga limitasyon na nauugnay sa mga callout, mga klase ng Apex, mga bahagi ng web ng kidlat, mga pahayag ng SOSL at SOQL.
Mga Limitasyon ng Gobernador
Isaalang-alang ang isang senaryo kung saan sina Alish at Subash ay dalawang tao na gumagamit ng Salesforce org. Gusto ni Alice na iproseso o isagawa ang 1000 DML statement sa isang transaksyon. Kasabay nito, gusto ni Subash na mag-load ng 5000 record sa isang pagkakataon. Kung gagawin nila ito nang magkatulad, hindi tatanggapin ng Salesforce at magiging abala. Kaya naman, makikita ang mga limitasyon ng Gobernador. Sa kasong ito, makakapagproseso si Alish ng 100 DML sa isang pagkakataon at makakapagproseso ng 500 na tala ang Subash sa isang pagkakataon. Maaari nilang gamitin ang AsynchronousBatch Apex upang gawin ang bawat transaksyon sa isang hiwalay na thread nang hindi nakakagambala sa bawat isa sa kanila at kumpletuhin ang kanilang gawain.
Karaniwan, nililimitahan ng Gobernador sa Salesforce ang pagproseso at pagpapatupad sa maraming transaksyon. Ang “Per-Transaction Apex Limits” ay binibilang para sa bawat transaksyon at ang “Size-Specific Apex Limit” ay tumutukoy sa laki ng code. Sinusuportahan ng Salesforce ang dalawang proseso: kasabay at asynchronous na mga proseso. Sa kasabay na proseso, ang Apex script ay isinasagawa sa isang solong pagtakbo habang sa asynchronous na proseso, ang Apex script ay isinasagawa sa pamamagitan ng paghahati sa maraming trabaho.
Mga Pinahihintulutang Limitasyon
Talakayin natin ang bilang ng limitasyon para sa iba't ibang mga sitwasyon:
- Posibleng magproseso/magpatakbo ng 100 SOQL query sa magkasabay na Apex at 200 SOQL query sa asynchronous na Apex.
- 50,000 record lang ang babalik mula sa isang SOQL query para sa parehong kasabay at asynchronous na tuktok.
- Kung gagamitin namin ang Database.getQueryLocator(), 10,000 lang ang ibinabalik sa isang pagkakataon para sa parehong synchronous at asynchronous na Apex.
- Sa parehong mga sitwasyon, ang bilang ng mga SOSL query na ibinigay ay 20.
- Ang laki ng heap na kinakailangan upang maproseso ang kasabay na Apex ay 6 MB. Para sa asynchronous na Apex, ang laki ng heap na kinakailangan ay doble na ginagawa itong 12 MB.
- Ang maximum na oras ng CPU na pinapayagan para sa kasabay na Apex ay 10,000 millisecond at 60,000 milliseconds para sa asynchronous na Apex.
- 10 minuto lamang ang pinapayagan para sa pagpapatupad para sa parehong Apex.
- Sa parehong mga kaso, maaari lamang kaming gumamit ng 10 sendEmail() na paraan na may 100 tatanggap.
- Ang mga character na nasa Apex class o sa Apex trigger ay dapat nasa loob ng 1 milyon.
- Sa Batch Apex (asynchronous), ang laki ay 200. Ang QueryLocator() ng klase ng “Database” ay nagbabalik ng 50 milyong talaan bawat transaksyon.
- 5 Apex na trabaho lang ang nasa pila o aktibo.
LIMIT Halimbawa ng Klase:
Maaaring tukuyin ng Apex ang mga limitasyon ng Gobernador sa klase na 'LIMIT'. Ang klase na ito ay nagbibigay ng ilang pamamaraan na nagsasabi sa mga limitasyon ng Gobernador. Tingnan natin ang sumusunod na halimbawa na nagpapakita ng ilang limitasyon ng Gobernador:
System.debug('Bilang ng pinagsama-samang mga query ay maaaring iproseso: '+ Limits.getLimitAggregateQueries());
System.debug('Bilang ng mga pahayag ng serbisyo sa Web ay maaaring iproseso: '+ Limits.getLimitCallouts());
System.debug('Bilang ng mga tala ay maaaring iproseso: '+ Limits.getLimitDmlRows());
System.debug('Bilang ng mga pahayag ng DML ay maaaring tawaging: '+ Limits.getLimitDmlStatements());
System.debug('Kabuuang halaga ng memory sa mga byte: '+ Limits.getLimitHeapSize());
System.debug('Bilang ng mga query sa SOQL ay maaaring mailabas: '+ Limits.getLimitQueries());
System.debug('Bilang ng mga tala ay maaaring mailabas: '+ Limits.getLimitQueryRows());
System.debug('Bilang ng SOSL query ay maaaring ibigay: '+ Limits.getLimitSoslQueries());
Output:
Posible ring suriin kung gaano karaming mga pahayag/row ng DML ang maaaring ibalik gamit ang mga pamamaraang 'dome' na nasa klase na 'LIMIT'.
- Limits.getDMLSstatements() ibinabalik ang kabuuang mga pahayag ng DML na ginagamit sa isang pagkakataon.
- Limits.getDMLRows() ibinabalik ang kabuuang bilang ng mga row na ibinalik ng mga pahayag ng DML.
- Limits.getCpuTime() ibinabalik ang CPU na ginamit na oras para sa kasalukuyang transaksyon sa millisecond.
Halimbawa ng Paggamit:
Sumulat tayo ng SOQL query na nagbabalik ng dalawang tala mula sa object na 'WorkOrder'. Pagkatapos nito, tanggalin ang dalawang talaan na ito gamit ang 'tanggalin' na DML.
System.debug('DML Statements:'+Limits.getDMLSstatements());System.debug('Rows: '+Limits.getDmlRows());
System.debug('CPU Time '+Limits.getCpuTime());
// SOQL Query para pumili ng 2 row mula sa WorkOrder object
Listahan
//Gumamit ng delete DML para tanggalin ang dalawang row
tanggalin ang mga account;
System.debug('**After SOQL:**');
System.debug('DML Statements:'+Limits.getDMLSstatements());
System.debug('Rows: '+Limits.getDmlRows());
System.debug('CPU Time '+Limits.getCpuTime());
Output:
Sa ibinigay na halimbawa, walang DML statement at 0 row. Ang kasalukuyang oras ng CPU ay 1 millisecond. Matapos ibalik ang 2 row mula sa SOQL query at tanggalin ang dalawang row na ito, ang kabuuang bilang ng mga DML statement na ibinalik ng Limits.getDMLSstatements() ay 1, ang kabuuang row na ibinalik ng Limits.getDMLRows() ay 2, at ang CPU Ang oras na kailangan upang maisagawa ang transaksyong ito ay 51 millisecond.
Halimbawa ng Pinakamahusay na Kasanayan: “HUWAG GAMITIN ANG DML SA LOOB NG LOOP”
Tingnan natin kung paano natin mapapatakbo ang code nang hindi nakukuha ang limitasyon ng gobernador. Gumawa muna kami ng record sa object na 'Produkto' (API – Product2) mula sa object na 'WorkOrder' sa pamamagitan ng pagtatalaga ng subject na 'WorkOrder' sa 'Pangalan ng Produkto' sa loop na 'para sa' mismo. Tingnan natin ang sumusunod na code:
Product2 prod_obj;para sa (WorkOrder wo_object : [SELECT Subject FROM WorkOrder])
{
prod_obj = bagong Produkto2(Pangalan = wo_object.Subject);
ipasok ang prod_obj;
}
Magagawa natin ito sa isang mas mahusay na paraan sa pamamagitan ng pagdedeklara ng isang listahan (prod_s) at pagkatapos ay pag-iimbak ng prod_obj sa listahan. Maaari naming ipasok ang listahang ito sa produkto sa labas ng loop.
ListahanProduct2 prod_obj;
para sa (WorkOrder wo_object : [SELECT Subject FROM WorkOrder])
{
prod_obj = bagong Produkto2(Pangalan = wo_object.Subject);
prod_s.add(prod_obj);
}
ipasok ang prod_obj;
Konklusyon
Nalaman na namin ngayon kung ano ang mga limitasyon ng Apex sa Salesforce na may detalyadong paliwanag. Mas mainam na sumama sa proseso ng Asynchronous Apex upang makakuha ng mas mahusay na mga limitasyon ng Gobernador kung ihahambing sa Synchronous Apex. Nalaman din namin ang tungkol sa mga limitasyon ng Gobernador para sa iba't ibang mga sitwasyon at nagbigay ng sample na demonstrasyon tungkol sa bilang ng limitasyon mula sa klase na 'Limit'. Na-verify din namin ang bilang ng mga DML statement, row, at oras ng CPU sa pamamagitan ng pagpapatakbo ng isang DML statement. Tinapos namin ang gabay na ito sa pamamagitan ng pagtalakay sa isang halimbawa ng pinakamahusay na kasanayan.