Free PDI sample questions

Correct answer: Create an Apex trigger on the Opportunity object that fires on the 'before delete' event.

The most robust solution is an Apex trigger on the 'before delete' event. Validation rules do not fire on delete operations, so they cannot be used to prevent record deletion. A 'before delete' trigger can inspect the records being deleted, check the user's profile, and use the `.addError()` method on the records that should not be deleted, effectively blocking the DML operation. This approach is secure and directly addresses the requirement which cannot be met by declarative tools.

Correct answer: An ` ` with an inner class in the custom controller to hold the Contact record and a boolean for the checkbox.

The best approach is to use a wrapper (or inner) class within a custom controller. The wrapper class will contain the Contact sObject and a boolean property to track the checkbox state. The Visualforce page will iterate over a list of these wrapper objects in an ` ` or ` `. This pattern allows the controller to easily identify which records were selected when the user submits the form, enabling efficient bulk processing.

Correct answer: The DML operation that fired the trigger has not been committed before the callout is attempted.

Salesforce prevents performing a callout after a DML operation within the same transaction to avoid data integrity issues. Even in a test context with mock callouts, this rule is enforced. The DML statement (`update account;`) starts a transaction that is not committed until the test method finishes. The `after update` trigger attempts the callout within this transaction, causing the 'uncommitted work pending' error. To resolve this, the callout logic must be moved to an asynchronous method (like a @future method), and the test must use `Test.startTest()` and `Test.stopTest()` to ensure the DML is committed before the asynchronous logic executes.

Correct answer: `Enrollment__c` has a Master-Detail relationship to `Student__c` and a Lookup relationship to `Course__c`.

This scenario describes a many-to-many relationship between Student and Course, implemented with `Enrollment__c` as the junction object. The requirement that enrollments are deleted when a student is deleted indicates a cascading delete behavior, which is a key feature of a Master-Detail relationship. Therefore, `Enrollment__c` must have a Master-Detail relationship to `Student__c`. The relationship to `Course__c` can be a Lookup, as there's no stated requirement for cascading deletion when a course is deleted. An object can have at most two master-detail relationships, but in this case, only one is strictly required by the prompt, making this the most appropriate and common configuration. erDiagram STUDENT ||--|{ ENROLLMENT : has COURSE ||..|{ ENROLLMENT : has STUDENT { string Id PK string Name } COURSE { string Id PK string CourseName } ENROLLMENT { string Id PK string StudentId FK "Master-Detail" string CourseId FK "Lookup" string Grade__c }

Correct answers: The `Database.Batchable` interface.; The `Schedulable` interface.; A `Database.QueryLocator` in the `start` method.

To process millions of records, Batch Apex (using the `Database.Batchable` interface) is the correct choice as it processes records in manageable chunks, respecting governor limits. To run the job nightly, the class must also implement the `Schedulable` interface. Within the `start` method of the batch class, a `Database.QueryLocator` must be used to build the scope of records to process. A `QueryLocator` can handle up to 50 million records, making it essential for large data volumes.

Correct answer: In the component's helper file, invoked by a `doInit` handler in the component's controller.

The standard practice for fetching data when an Aura component initializes is to use the `aura:handler` for the `init` event. The handler, typically named `doInit`, is defined in the component markup: ` `. The corresponding `doInit` function in the component's JavaScript controller should then call a function in the helper to make the server-side call to the Apex method. Placing logic in the helper promotes code reuse and better organization.

Correct answer: The query will fail to execute and throw a `System.LimitException`.

The total number of records that can be retrieved by a single SOQL query is 50,000. This is a hard governor limit enforced by the platform. Attempting to retrieve 50,001 rows in a single query, whether in Apex, the Developer Console, or another tool, will result in a `System.LimitException` indicating that the query has retrieved too many rows.

Correct answer: False

False. The `with sharing` keyword enforces the sharing rules for the current user, but it does NOT enforce object-level or field-level security. A user must have at least 'Read' permission on the object to see any records at all. If a user has 'Read' permission on the object, `with sharing` will then filter the records returned by a query based on the user's record-level access (sharing rules, role hierarchy, etc.).

Correct answer: [SELECT Id, Name, (SELECT Id, Name FROM Contacts) FROM Account]

The correct syntax for a parent-to-child subquery uses the plural child relationship name. For standard objects, this is typically the plural of the child object name (e.g., Contacts, Opportunities). For custom objects, the relationship name is the plural of the child object name appended with `__r` (e.g., `My_Custom_Objects__r`).

Correct answer: Create a Roll-Up Summary Field on Account with the `MAX` type on the Shipment's creation date field.

Roll-Up Summary Fields are a declarative feature that can perform calculations like COUNT, SUM, MIN, and MAX on records in a detail relationship. Since `Shipment__c` has a Master-Detail relationship to `Account`, a Roll-Up Summary Field can be created on the `Account` object. Using the `MAX` function on the shipment date field will efficiently find and display the date of the most recent shipment without needing Apex.