CCNA Large Data Volume Considerations Questions

Bulk API 2.0 is purpose-built to handle millions of records by automatically partitioning the data into optimized batches. This allows for reliable, high-throughput processing while maintaining stability in the Salesforce environment, making it the primary tool for large-scale data imports and exports.

Because a Skinny Table is a separate custom object, it does not automatically reflect changes to the main object. A synchronization process, such as a trigger or batch job, must be implemented to update the Skinny Table when the main object changes. Without synchronization, the Skinny Table would become stale and produce incorrect query results.

Sorting on a low-cardinality field like Priority__c forces the query optimizer to scan many records because the field is not selective. Removing the sort or replacing it with a sort on an indexed, high-cardinality field can dramatically improve performance. Filtering on a more selective field also reduces the number of records that need to be sorted.

Asynchronous processing allows updates to be queued and batched, preventing multiple concurrent transactions from fighting over the same parent row. This pattern is essential for high-frequency updates, as it serializes the parent-level changes and allows the system to process them efficiently without risking transactional row locks.

Master-Detail relationships enforce a lock on the parent record whenever a child is modified. When multiple batches process child records belonging to the same parent record at the same time, they compete for this parent-level lock, resulting in the UNABLE_TO_LOCK_ROW exception due to contention.

To protect system resources, Salesforce restricts queries that are non-selective on large datasets. If a query cannot be optimized via an index, it is likely to be blocked or time out, ensuring that the system maintains consistent performance for all users in the multi-tenant environment.

By keeping high-volume, low-access data in an external system, you preserve Salesforce storage and avoid the performance overhead of managing massive tables. This architecture ensures that core business objects remain performant and responsive, while secondary data remains available through a seamless, integrated user experience.

A selective query is one that effectively uses indexes to limit the search space to a small percentage of total records. By staying within the platform's selectivity thresholds, the query optimizer can retrieve results quickly without the performance penalty associated with full table scans on massive data sets.

Objects with many lookup relationships are problematic because every record update might involve locking multiple parent records. This leads to severe contention during large data imports and complex queries. These objects require careful planning, such as implementing indexing and optimizing batch processes to minimize the locking overhead.

Without an index on the custom field, the query optimizer cannot efficiently narrow down the search space. When dealing with millions of records, the lack of an index forces the system to scan every row, which is the primary cause of slow query execution and potential timeout errors.

Triggers run for every record processed, consuming CPU and database resources while creating row locks on parent or related objects. Disabling them allows the system to focus exclusively on record insertion, significantly increasing throughput and avoiding potential deadlocks caused by concurrent logic execution during the migration.

Salesforce Connect integrates external data into the org via external objects. This allows companies to keep data outside of the Salesforce database, preventing native performance degradation while ensuring users still have access to the information, which is a perfect pattern for large-scale data archival and management needs.

This is the correct approach to maintain performance. Offloading data to an external repository or Big Object reduces the record count in the transactional object, keeping indexes lean and queries fast, while still allowing access to historical data when needed for compliance or analytical purposes.

Caching related parent records in a Map ensures that SOQL queries are performed only once for the entire batch. This minimizes resource consumption and prevents governor limit violations, allowing developers to process thousands of records efficiently, which is vital for high-volume data operations in the Salesforce platform.

Custom indexing and Skinny tables are the most effective native ways to optimize read performance. By providing the database with direct access paths or denormalized data sets, these features allow the query optimizer to return results rapidly, avoiding the performance pitfalls of full table scans.

When viewing a Case record, the related list of Log__c records is displayed by querying Log__c where Case__c equals the current Case Id. This filter is highly selective because it returns only the logs for one case. With a custom index on Case__c, the query optimizer can use the index to efficiently retrieve those records, significantly improving performance.

Because each write requires an update to the corresponding index table, having many indexes adds cumulative overhead to every DML statement. This lengthens the time required to commit transactions, which can eventually lead to governor limit issues and performance bottlenecks in high-volume environments.

Large-scale deletions cause intense row-level and table-level locking. Breaking this into stages—marking records first and deleting them in batches during off-peak windows—reduces the contention for system resources, ensuring that the database remains responsive for other users while the deletion operation progresses.

Because formula fields are not indexed and must be calculated on the fly during a query, the Salesforce database engine must perform a full table scan to evaluate every record against the filter criteria. For objects with millions of records, this is a major performance bottleneck.

Big Objects are designed for large-scale archival and are queried using Async SOQL, which runs asynchronously and can handle massive datasets. Copying old records to a Big Object and deleting them from Asset__c reduces the size of the transactional object, improving performance. Async SOQL is the correct mechanism for querying Big Objects and can be invoked from a Lightning component, satisfying the audit requirement.

Indexes function like a book index, allowing the database to jump straight to the data rows that match the filter criteria. This eliminates the need for full table scans, which are prohibitively slow on tables with millions of records, and is vital for maintaining responsive application performance.

Salesforce selectivity thresholds depend on the object size; for 12 million records, a query must filter to a small percentage to use an index. Even with indexes on Status__c and Order_Date__c, if the filters are not restrictive enough, the optimizer may choose a full scan. Sorting by CreatedDate adds a sort operation that can further degrade performance when the result set is large. This combination explains the timeout.

Pre-aggregation shifts the computational load from read-time to write-time. By calculating metrics asynchronously and storing them in a summary object, the report engine only processes a small number of aggregate records rather than scanning the entire base table, significantly reducing execution time and resource consumption.

Sorting by OwnerID or a parent lookup field allows the system to process related records in a predictable order. By avoiding concurrent updates to the same parent or owner records, you reduce the likelihood of row-level lock contention, ensuring that the database engine can process the transaction blocks without waiting for locks.

Pre-aggregating into a summary object reduces the dashboard query to a small number of rows, so it remains fast regardless of Invoice__c volume. Batch Apex or scheduled flow can maintain the summary asynchronously, avoiding user-facing delays. This pattern is a standard LDV optimization because it decouples heavy aggregation from interactive reporting and keeps dashboard components selective and lightweight.

Marking a field as an External ID (or unique) creates a database index. This is a standard Salesforce optimization for large objects, ensuring that queries filtering on that field become highly performant by avoiding full table scans, which are the primary bottleneck for large-scale record retrieval.

When deleting child records, Salesforce locks the parent records referenced by lookup relationships to maintain referential integrity. This blocks concurrent updates on those Accounts, causing UNABLE_TO_LOCK_ROW errors. The 2 million deletes touch many parent Accounts, increasing collision probability with the nightly account updates.

Selectivity is the most critical factor for SOQL performance on large datasets. If the filter is not selective, the database must scan all 20 million records. Adding an index on the filter field allows the engine to jump directly to the relevant records, restoring query performance.

A composite index on both the filter field (CaseId) and the sort field (CreatedDate) allows the database to efficiently satisfy the query's WHERE and ORDER BY clauses. This reduces the need for sorting and scanning, significantly improving performance for large data volumes.

For a composite index to be used, the leading field must be selective. In this scenario, Customer__c is likely to be selective if queries filter by a specific customer. If the leading field is not selective, the optimizer may ignore the index entirely. Thus, ensuring the leading field's selectivity is critical.

Skinny tables are designed to solve specific performance issues by reducing join complexity. Because they are maintained by Salesforce Support, they add administrative overhead. They are best reserved for core objects where read performance is the primary bottleneck and standard indexing cannot provide the necessary speed.

Sorting the input file by the parent ID ensures that all children associated with the same parent are grouped together. This serializes access to the parent records, preventing multiple batch threads from attempting to lock the same parent concurrently, which is the primary cause of row contention.

A custom index can be requested on a custom field that is frequently used in filter conditions. For an object with millions of records, indexing Invoice_Date__c allows the query optimizer to avoid a full table scan, reducing report and list view timeouts. This is the appropriate declarative performance tuning step for LDV scenarios.

By denormalizing data into a single table, the database no longer needs to perform costly join operations during query execution. This drastically reduces the time required to retrieve large sets of data, providing a significant performance boost for reports and SOQL queries in high-volume environments.

Without an index on the 'Status__c' field, the database must perform a full table scan to evaluate every record. Since the object contains millions of records, this exceeds the system's threshold for selectivity, causing the query to fail to protect overall system performance and availability.

By offloading data to an external system and accessing it via OData, you maintain a smaller record count in the local Salesforce instance. This ensures that indexes remain efficient and queries on local objects stay fast, which is critical for maintaining performance as the organization scales.