Salesforce Governor Limits: Issues and Fixes

Fix: Bulkify SOQL Queries

Retrieve all necessary data in a single SOQL query before the loop using a collection to filter.

// Corrected Code
List<Account> accounts = [SELECT Id, Name FROM Account LIMIT 10];
Set<Id> accountIds = new Set<Id>();
for (Account acc : accounts) {
    accountIds.add(acc.Id);
}
List<Contact> allContacts = [SELECT Id, FirstName, LastName, AccountId FROM Contact WHERE AccountId IN :accountIds];

// Process contacts using a Map for efficient lookup
Map<Id, List<Contact>> accountContactMap = new Map<Id, List<Contact>>();
for (Contact con : allContacts) {
    if (!accountContactMap.containsKey(con.AccountId)) {
        accountContactMap.put(con.AccountId, new List<Contact>());
    }
    accountContactMap.get(con.AccountId).add(con);
}

for (Account acc : accounts) {
    if (accountContactMap.containsKey(acc.Id)) {
        for (Contact con : accountContactMap.get(acc.Id)) {
            System.debug(con.FirstName + ' ' + con.LastName);
        }
    }
}

Fix: Bulkify DML Operations

Collect all the records you want to operate on in a list and perform the DML operation on the entire list at once.

// Corrected Code
List<Account> accountsToInsert = new List<Account>();
List<Account> accountsToUpdate = new List<Account>();
for (Integer i = 0; i < 200; i++) {
    Account acc = new Account(Name = 'Temporary Account ' + i, Description = 'Initial');
    accountsToInsert.add(acc);
    Account accToUpdate = new Account(Name = 'Temporary Account ' + i, Description = 'Updated');
    accountsToUpdate.add(accToUpdate);
}
insert accountsToInsert; // Bulk DML
update accountsToUpdate; // Bulk DML
// Further processing of accountsToUpdate

Fix: Optimize Code and Algorithms

• Review and simplify complex logic.
• Avoid deeply nested loops where possible.
• Optimize SOQL queries by using appropriate filters and indexes.
• Consider using asynchronous processing (e.g., Batch Apex, Queueable Apex) for long-running operations.
• Minimize the amount of data processed in a single transaction.

// Improved Code (Illustrative)
List<Account> accountsToUpdate = new List<Account>();
List<Account> accounts = [SELECT Id, Name, Industry, AnnualRevenue FROM Account WHERE NumberOfEmployees > 1000 LIMIT 200]; // Limit the scope

for (Account acc : accounts) {
    Decimal result = calculateComplexResult(acc.Industry, acc.AnnualRevenue); // Move complex logic to a helper method
    acc.Description = String.valueOf(result);
    accountsToUpdate.add(acc);
}

if (!accountsToUpdate.isEmpty()) {
    update accountsToUpdate; // Bulk DML
}

// Helper method for complex calculation
private Decimal calculateComplexResult(String industry, Decimal revenue) {
    Decimal result = 0;
    // Optimized calculation logic
    for (Integer i = 0; i < 100; i++) { // Reduced iterations
        result += Math.log(revenue + i + 1);
    }
    return result;
}

Fix: Process Data in Batches and Avoid Unnecessary Data Storage

• Process data in smaller chunks or batches.
• Avoid storing large amounts of data in memory if it can be processed sequentially.
• Use techniques like Database.QueryLocator for processing large query results in chunks.
• Be mindful of the size of objects and collections you create.

// Corrected Code using Database.QueryLocator
Database.QueryLocator ql = Database.getQueryLocator([SELECT Id, Name FROM Account]);
Database.executeBatch(new AccountBatchProcessor(), 200); // Process accounts in batches of 200

public class AccountBatchProcessor implements Database.Batchable<sObject> {
    public Database.QueryLocator start(Database.BatchableContext bc) {
        return ql;
    }

    public void execute(Database.BatchableContext bc, List<Account> scope) {
        // Process the current batch of accounts (scope)
        for (Account acc : scope) {
            System.debug('Processing Account: ' + acc.Name);
            // Perform operations on the batch
        }
    }

    public void finish(Database.BatchableContext bc) {
        // Optional finish logic
    }
}