Free Salesforce PDII Practice Exam with Questions & Answers | Set: 2

3233

When a requirement specifies a "non-linear" or highl34y customized layout, the high-35level lightning-record-form (A) is unsuitable because it automatically renders fields in a standard grid or based on a page layout. To achieve a custom UI—such as overlaying fields on a product image—the developer needs more granular control.

The lightning-record-edit-form (B) is the ideal container for this scenario. It provides the heavy lifting for data communication (loading and saving records) without imposing a strict visual structure. Within this form, the developer uses lightning-input-field (C) components for each Case field. These components are "context-aware," meaning they automatically inherit metadata like field labels, picklist values, and validation rules directly from the Salesforce object definition.

Because lightning-input-field components can be placed anywhere inside the lightning-record-edit-form tag, the developer can use custom CSS (absolute positioning or CSS Grid) to place them precisely over the product image as requested. Standard lightning-input (D) components could work but would require much more manual code to handle data binding, type conversion, and validation, making the combination of B and C the most efficient and platform-aligned approach.

==========

The current bottleneck is caused by the need to resolve Salesforce Internal IDs ($001...$) for the Account lookup before orders can be imported. This can be completely bypassed by using External IDs (Option D) and the Upsert operation (Option C).

External IDs: By marking a unique field from the OMS (like OMS_Account_Number__c) as an External ID in Salesforce, the developer creates a "foreign key" that Salesforce understands.

Upsert Wizard: When using the Data Loader's Upsert wizard, the user is asked which field should be used to match the parent Account. By selecting the OMS_Account_Number__c external ID, the Data Loader allows the user to map the orders directly to accounts using the OMS number found in the CSV file.

Salesforce will automatically find the correct Account ID in the background. This eliminates the "export-and-VLOOKUP" step entirely. Option A (Insert) would still require internal IDs. Option B (sorting) helps with performance in massive loads but doesn't solve the manual ID matching problem. Using Upsert with External IDs is the platform-recommended way to streamline recurring data integrations.

When querying Large Data Volumes (LDV), Salesforce relies on the Query Optimizer to decide if an index can be used. A query is considered "optimized" or "selective" if it uses an indexed field in the WHERE clause and filters the result set below a specific threshold (typically 10% of the first million records).

Option A is optimized because it filters on Customer_Number__c, which is marked as an External ID. Salesforce automatically creates a custom index for any field marked as an External ID or Unique. Even though the query also includes a non-selective filter (Name != ''), the presence of the indexed External ID field allows the optimizer to perform an index scan rather than a full table scan.

Option D is optimized because it filters by the Id field using the IN operator. The Id field is the primary key and is always indexed. Filtering by a collection of IDs is one of the most efficient ways to retrieve records in a large environment.

Options B and C are not optimized. IsDeleted is not an indexed field, and the Query Optimizer generally ignores IsDeleted = false filters when calculating selectivity. Filtering for Name != NULL or Name != '' (Option C) is considered a "negative" filter and typically results in a full table scan because it does not narrow the search results enough to utilize an index efficiently.

28

When dealing with External Users (Community/Experience Cloud users), standard sharing mechanisms like Role Hierarchies o29ften do not apply, especially for high-volume Customer Community licenses which do not use the Role Hierarchy at all.

Sharing Sets (Option B) are specifically designed to grant external users access to records associated with their Account or Contact. A Sharing Set allows an administrator to define a simple mapping: for example, "Grant access to Cases where the Case's Account matches the User's Account." This is the most efficient and scalable way to provide external partners visibility into records relevant to them without using complex Apex code.

While Apex managed sharing (Option A) could technically work, it is much more complex to maintain and is only available for "Customer Community Plus" or "Partner" licenses. Criteria-based sharing rules (Option D) are typically used for internal users or broad groups, not for granular, account-specific access for individual external partners. Sharing Sets provide a high-performance, declarative solution for controlling external record visibility.

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 Salesforce Apex, a @RemoteAction method must be defined as static. Static methods belong to the class itself rather than to a specific instance of the class. Therefore, when writing a unit test to verify the behavior of a RemoteAction, the method should be called using the class name notation (ClassName.methodName) rather than by instantiating the class first.

Option D correctly demonstrates the standard way to invoke a static method in Apex: Account a = MyRemoter.getAccount('TestAccount');. Because the method is static, it does not require the new keyword or a constructor to be called. Option A is incorrect because it attempts to call a static method on an instance variable (remote.getAccount), which is considered an illegal or improper reference in Apex. Option B is incorrect because it treats the RemoteAction like an instance method and assumes a non-existent constructor that takes a String. Option C is incorrect because it uses an undefined variable controller.

By calling the method statically in the test, the developer correctly simulates how the Visualforce Remoting engine calls the method from JavaScript at runtime. The assertion System.assertEquals then verifies that the record retrieved from the database matches the expected name, ensuring the search logic is functioning correctly.

12

In the Aura Component Framework, the $Locale global value provider (Opt13ion C) is specifically designed to handle globalization and localization. It provides direct access to the current user's locale preferences, including date and time formats, number grouping symbols, and currency symbols. Instead of manually querying the User object or creating custom settings, a developer can use expressions like {!$Locale.currencySymbol} or {!$Locale.dateFormat} directly in the component's markup or controller.

Using $Locale ensures that the application remains dynamic; if an employee moves from a US office to a European office and updates their Salesforce profile locale, the application will automatically reflect the new formatting rules without any code changes. This is more efficient than using $User (Option A), which would require additional logic to map locale strings to specific formats. $Label (Option D) is used for translated text strings, not formatting patterns. By leveraging the native $Locale provider, the developer ensures that the commission and benefit data are presented in a familiar, accurate context for every employee worldwide.

This scenario highlights a common conflict in multi-admin environments known as "the last delivery wins" problem. When multiple administrators work in isolated sandboxes, they are essentially working on different versions of the same metadata. If Admin A adds a field to a Page Layout and deploys it, and then Admin B—who does not have Admin A's changes in their sandbox—deploys their own version of that same Page Layout, Admin B's deployment will overwrite Admin A's changes in Production (Statement B). In the Metadata API (which Change Sets use), Page Layouts are treated as single files; you cannot "merge" them via a Change Set; you can only replace the destination file entirely.

To resolve this, the team needs a more sophisticated deployment pipeline. Statement D is the correct resolution: the company should implement a "Staging" or "Integration" sandbox. In this model, all admins deploy their Change Sets to a single unified sandbox first. This allows them to identify conflicts and "merge" their changes (manually or via source control) before a final, combined deployment is made to Production. Statement A is technically incorrect because Change Sets cannot "delete" components; they can only overwrite or add. Statement C is a myth; Page Layouts can be safely deployed, but only if the underlying fields and security settings are also included and coordinated.

To create a responsive design in Salesforce Aura components, the lightning:layout and lightning:layoutItem components utilize a 12-column grid system based on the Salesforce Lightning Design System (SLDS). The issue in the original code is that size="6" is hardcoded, which forces each item to occupy 50% of the container width regardless of the screen size. On small mobile screens, 50% width is often insufficient for text content, leading to horizontal scrolling or overlapping.

Option B resolves this by using device-specific size attributes. By setting smallDeviceSize="12", each item is instructed to take up the full width (12 out of 12 columns) on mobile devices. This causes the items to stack vertically instead of sitting side-by-side. The mediumDeviceSize="6" and largeDeviceSize="6" attributes ensure that on tablets and desktop screens, the items return to a side-by-side layout (50% width each).

For this stacking to occur, the parent lightning:layout must have the multipleRows="true" attribute enabled. This allows the layout to wrap items to a new line once the total column count in a single row exceeds 12. Without multipleRows="true", the items would try to squeeze into a single line regardless of their individual size settings, which would not solve the horizontal scrolling problem. Option B is the only choice that correctly applies the grid logic to handle multiple breakpoints effectively.

Loading "thousands" of records at once into a Visualforce page causes performance issues primarily due to the heavy DOM processing required to render thousands of table rows and the large View State generated.

The most effective way to improve performance and user experience in this scenario is pagination. Instead of rendering all records simultaneously, pagination displays a subset (e.g., 20 records) at a time. Using the StandardSetController (which is implied by "standard Account List controller" in the context of lists) allows for efficient server-side pagination. It queries and retrieves only the records needed for the current page view, drastically reducing the View State size and the DOM elements the browser must render. While JavaScript Remoting (Option D) is fast for data retrieval, pagination is the fundamental pattern required to solve the "render time" issue for large lists.