| Concept |
Explanation and Example |
| A – Apex Trigger |
Apex triggers are blocks of code that automatically execute when specific events occur in Salesforce, like record creation or updates. Example:
apex public class AccountTriggerHandler {
public static void onBeforeInsert(List newAccounts) {
// Logic to be executed before inserting new accounts
}
}
|
| B – Before Trigger |
“Before triggers” execute before records are saved to the database, allowing you to validate or modify data. Example:
apex trigger AccountBeforeInsert on Account (before insert) {
AccountTriggerHandler.onBeforeInsert(Trigger.new);
}
|
| C – Context Variables |
Salesforce provides trigger context variables like Trigger.new and Trigger.old to access new and old record data within the trigger. Example:
apex public static void onBeforeUpdate(List newAccounts, List oldAccounts) {
for (Integer i = 0; i < newAccounts.size(); i++) {
Account newAccount = newAccounts[i];
Account oldAccount = oldAccounts[i];
// Compare and modify data as needed
}
}
|
| D - DML Operations |
Triggers often involve DML (Data Manipulation Language) operations to create, update, or delete records. Example:
apex public static void onBeforeInsert(List newAccounts) {
insert newAccounts; // Insert new accounts into the database
}
|
| E - Events |
Triggers are associated with specific events like "before insert" or "after update" that trigger code execution. Example:
apex trigger AccountBeforeInsert on Account (before insert) {
// Trigger logic for before insert event
}
|
| F - For Each Record |
Triggers operate on a set of records, and you can loop through these records for processing. Example:
apex public static void onBeforeUpdate(List newAccounts) {
for (Account a : newAccounts) {
// Process each new account
}
}
|
| G - Governor Limits |
Salesforce enforces governor limits on trigger execution, including limits on DML operations and CPU time. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Perform actions within governor limits
}
|
| H - Handler Classes |
It's a best practice to organize trigger logic in separate handler classes to keep triggers focused and maintainable. Example:
apex public class AccountTriggerHandler {
public static void onBeforeInsert(List newAccounts) {
// Logic for before insert
}
}
|
| I - Insert Records |
Triggers can handle inserting new records by implementing logic to validate, modify, or associate related data. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Logic for new account records before insertion
}
|
| J - Junction Objects |
In Salesforce, triggers can be used to manage junction objects, which are used to create many-to-many relationships. Example:
apex trigger OpportunityContactJunctionTrigger on OpportunityContactJunction__c (after insert) {
// Trigger logic for junction objects
}
|
| K - Keep It Simple |
Best practice is to keep triggers simple and focused on specific tasks to ensure maintainability and avoid complexity. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Simple validation or modification logic
}
|
| L - Limits Testing |
It's crucial to test triggers with various data scenarios to ensure they operate within Salesforce's governor limits. Example:
apex @isTest public class AccountTriggerTest {
@isTest static void testAccountInsert() {
// Test trigger with various scenarios
}
}
|
| M - Multiple Events |
Triggers can respond to multiple events on the same object, such as "before insert" and "after update." Example:
apex trigger AccountTrigger on Account (before insert, after update) {
// Trigger logic for multiple events
}
|
| N - New Record Data |
Trigger.new provides access to the new record data, allowing you to work with the values of the records being inserted or updated. Example:
apex public static void onBeforeInsert(List newAccounts) {
for (Account a : newAccounts) {
String accountName = a.Name;
// Access new account data
}
}
|
| O - Old Record Data |
Trigger.old allows you to access the old record data, useful for comparing changes and performing actions based on the previous state. Example:
apex public static void onAfterUpdate(List newAccounts, List oldAccounts) {
for (Integer i = 0; i < newAccounts.size(); i++) {
Account newAccount = newAccounts[i];
Account oldAccount = oldAccounts[i];
// Compare and act on changes
}
}
|
| P - Process Order |
Triggers are executed in a specific order as part of Salesforce's order of execution, which can impact how they interact with other processes. Example:
apex trigger AccountTrigger on Account (before insert) {
// Trigger logic for before insert event
}
|
| Q - Queueable Jobs |
For long-running or complex operations within triggers, you can enqueue queueable jobs to execute asynchronously. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Enqueue a queueable job for time-consuming tasks
}
|
| R - Rollback |
You can roll back a transaction in a trigger using Database.rollback(savepoint) if an error occurs to maintain data integrity. Example:
apex public static void onBeforeInsert(List newAccounts) {
Savepoint sp = Database.setSavepoint();
try {
// Attempt transaction
// If an error occurs, roll back to the savepoint
Database.rollback(sp);
} catch (Exception e) {
// Handle the error
}
}
|
| S - Standard Objects |
Triggers can be used with standard Salesforce objects like Accounts, Contacts, Opportunities, and custom objects created in your org. Example:
apex trigger OpportunityBeforeInsert on Opportunity (before insert) {
// Trigger logic for before insert on Opportunities
}
|
| T - Testing |
Salesforce provides testing frameworks for writing unit tests to ensure trigger logic functions correctly under different scenarios. Example:
apex @isTest public class AccountTriggerTest {
@isTest static void testAccountInsert() {
// Test trigger with various scenarios
}
}
|
| U - Updates |
Triggers are commonly used for handling record updates, allowing you to enforce data consistency and execute additional actions. Example:
apex trigger AccountBeforeUpdate on Account (before update) {
// Trigger logic for before update event on Accounts
}
|
| V - Validation |
Triggers can enforce data validation rules before records are saved, ensuring that only valid data is inserted or updated. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Validate account data before insertion
}
|
W - Workflow Rules |
Triggers can work in conjunction with workflow rules and processes, allowing for complex automation and business logic. Example:
apex public static void onBeforeInsert(List newAccounts) {
// Trigger logic combined with workflow rules
}
|
| X - Execute After Save |
"After triggers" execute after records are saved, which can be used for additional actions after data has been committed to the database. Example:
apex trigger AccountAfterInsert on Account (after insert) {
// Trigger logic for after insert event
}
|
| Y - Your Use Case |
Triggers should be tailored to your specific use cases, whether it's enforcing specific data requirements, automating processes, or integrating with external systems. Example:
apex trigger CustomObjectTrigger on Custom_Object__c (before insert, after update) {
// Trigger logic for a custom object use case
}
|
| Z - Zero Errors |
Error handling and exception management are essential in triggers to ensure data integrity and avoid unexpected issues during execution. Example:
apex public static void onBeforeInsert(List newAccounts) {
try {
// Trigger logic and data operations
} catch (Exception e) {
// Handle and log errors
}
}
|
Very interesting points you have mentioned, thanks
for putting up.Raise your business