Triggers in Salesforce

What are the triggers in Salesforce?

Apex is one of the many programming languages that Salesforce uses to perform actions. Since the Salesforce triggers are built with Apex code, they are also called Apex triggers. An action that needs to be performed before or after data manipulation language (DML) events occurs is called a trigger. The Salesforce triggers are used to trigger Apex code before or after changes to Salesforce records like insertions, updates, or deletions.

The Salesforce triggers help in defining custom actions on the data. They are used to perform operations based on specific conditions. We can define triggers for top-level standard objects like contact, account, custom objects, standard child objects, and custom objects. When we create triggers, they will be active by default. So, when a database event occurs, the Salesforce will fire the active triggers automatically. Triggers will be helpful when we can't perform some tasks with point-and-click tools in the Salesforce user interface. 

For instance, we can set a trigger to run after records have been deleted, or when a record is restored from the recycle bin, or before inserting an object's records.

Wish to make a career in the world of salesforce? Start with HKR'S  Salesforce Training in Hyderabad !

Types of triggers

The triggers in Salesforce are mainly of two types - before and after triggers.

Before triggers 

When we want to update or validate record values before saving them to a database, we can run a before trigger. We can set a before trigger before a record is inserted, updated, or deleted. 

After triggers 

The after triggers are used to access field values that are set by the system and to affect the changes in the records. The records that fire after triggers will be in read-only mode. This trigger is used when a record is inserted, updated, or deleted. The records that have a relationship with the trigger fired record will get modified.

Bulky Triggers

All triggers in Salesforce are referred to as bulky triggers as they operate on multiple records at a time. Bulky triggers will be able to handle both bulk operations and single record based operations. Here are the operations that the bulky trigger handles.

Data import

• Lightning Platform Bulk API calls
• Mass actions like record owner deletes and updates
• Recursive Apex methods and triggers that invoke bulk DML statements

Salesforce Training

• Master Your Craft
• Lifetime LMS & Faculty Access
• 24/7 online expert support
• Real-world & Project Based Learning

Explore Curriculum

Syntax of triggers

Here is the syntax for defining a Salesforce trigger,

trigger TriggerName on ObjectName (TriggerEvents) {


                     

                    }

The TriggerEvents can be of the following events.

• Before insert
• Before update
• Before delete
• After insert
• After update
• After delete
• After undelete

We can use multiple trigger events in a single trigger by giving them in a list separated by commas. Here is an example of a trigger.

trigger AccountTrigger on Account (before insert, before delete) {

    

}

Here are a few points that will help you while working with triggers.

• We should not use the static keyword inside the code block. 
• We don't have to commit changes made by a trigger to a database manually. 
• On successful completion of a trigger, the database changes will get committed automatically. 
• If a trigger has failed, any database changes will be rolled back.

Context variables in triggers

Salesforce provides some implicit variables that can be defined by triggers to access run-time context. These context variables will be available in the System.Trigger class.

Context variable considerations

Here are a few considerations to be aware of to trigger context variables.

• We cannot use trigger.new and trigger.old in Apex DML operations.
• With trigger.new, we can use an object to change its own field values in before triggers. The trigger.new will not get saved in after triggers, so it will result in a runtime exception.
• The trigger.old context variable will always be read-only.
• We cannot delete the trigger.new context variable.

The following table depicts the considerations of actions for different trigger events.

Click here to get frequently asked Salesforce interview questions & answers

Subscribe to our YouTube channel to get new updates..!

Subscribe

Conclusion

Triggers are an important concept in Salesforce for both developers and admins. They ease the work of developers, administrators, and salespeople by managing records effectively. When you write Apex triggers, you have to keep in mind that the code should support bulk operations. There is a chance to prevent DML operations from occurring with the help of the addError() method. The custom error message will get displayed in the application interface when exceptions are used in Trigger.new records in insert and update triggers, and on Trigger.old records in delete triggers. If any trigger in the database throws an unhandled exception, all the records will be marked with an error. There won't be any further processing tasks executed on the error records. It will be difficult to understand all the triggers at once. But when you practice enough, you will find that the triggers are the best and easy way to perform some operations efficiently and accurately.

Related Articles:

• Triggers in Salesforce
• Salesforce Validation

• Pega Vs Salesforce