Authentic Salesforce Certification Exam PDII Questions Answers

This scenario illustrates a classic trigger recursion issue triggered by the Salesforce Order of Execution. When a record is updated, Salesforce runs through a specific sequence: first, it executes "Before-Save" Record-Triggered Flows, then "Before" triggers, followed by "After" triggers, and finally "After-Save" flows and processes. If a process or flow updates the same record that initiated the transaction, the entire cycle of Apex triggers can be re-invoked within that single transaction.

To prevent logic from running multiple times during these re-entrant cycles, developers implement a static boolean variable as a "recursion guard." Static variables in Apex persist for the entire duration of a single transaction. By checking the value of a static boolean at the start of the trigger, the code can determine if it has already processed the current set of records.

Option B is the correct implementation of this pattern. It defines `public static Boolean firstRun = true;` in the handler class. The trigger checks if `firstRun` is true, executes the handler logic, and then immediately sets `firstRun` to false. Any subsequent execution of the Case trigger within the same transaction will find the variable set to false and skip the increment logic.

Option A is incorrect because it resets `firstRun` to true every time the trigger starts, defeating the guard. Option C incorrectly uses an instance variable (non-static), which is recreated for every call. Option D uses a local variable within the trigger body, which is re-initialized to true every time the trigger fires, providing no protection against recursion.

In Visualforce, the "View State" is a hidden form field that maintains the state of the page (and the controller's variables) across postbacks to the server. If the View State becomes too large, it can slow down page loads and eventually hit the Salesforce View State limit (170KB), causing the page to crash.

The transient keyword is used to declare instance variables in Apex controllers that should not be saved in the View State. When a variable is marked as transient, its value is discarded after the request finishes and is not transmitted back to the client. This effectively reduces the size of the View State. It is commonly used for data that is needed only for the duration of the current request (like a large list of records displayed in a read-only table) and can be easily requeried or recalculated if needed.

This requirement calls for "Transactional Atomicity," meaning either both database operations (Account creation and Contact creation) succeed, or neither is committed to the database. In Apex, each DML statement normally acts as its own individual transaction unless managed by Savepoints.

The correct approach is to use Database.setSavepoint() and Database.rollback() within a try-catch block (Option A). The developer sets a savepoint immediately before the Account is inserted. If the Account is created successfully but the subsequent Contact insertion fails (due to a validation rule, trigger error, or system exception), the code enters the catch block. Within the catch block, the developer executes Database.rollback(sp), which reverts the database to the state it was in before the Account was ever inserted.

Option B is technically similar but "A" provides the standard programmatic pattern name. Option C (allOrNone=false) only applies to a single list of records in one DML call and cannot link the success of an Account to a Contact. Option D (manual deletion) is an unreliable "cleanup" strategy that fails if the system crashes or if there are secondary side effects from the initial insertion. Using Savepoints ensures the platform handles the rollback safely and completely.