Querying a SOQL Query Directly into a Map in Apex

If you're working with a lot of data in Salesforce, you may need to query a SOQL query directly into a map. This can be a great way to improve performance, as it avoids creating a list of records and then converting it to a map.

In this article, we'll show you how to query a SOQL query directly into a map in Apex. We'll also provide some examples of how to use this technique to improve your code's performance.

Storing query results directly into a Map data structure in Apex

In Apex, you can store SOQL query results directly into a Map by querying the records and using a constructor or loop. Here’s a quick example:

Map<Id, Account> accountMap = new Map<Id, Account>([SELECT Id, Name FROM Account]);

This code runs a SOQL query to fetch Account records and stores them in a Map where the key is the Id and the value is the Account record. This allows quick access to records using their Id.

An example of filling out a `Map` in a loop:

Map<Id, Account> accountMap = new Map<Id, Account>();
List<Account> accounts = [SELECT Id, Name FROM Account];

for (Account acc : accounts) {
    accountMap.put(acc.Id, acc);
}

The Map<Id, Account> is initialized as an empty map.

A list of Account records is queried.

In the loop, each account is added to the map using put(), with the Id as the key and the account record as the value.

This approach is useful when you need more control over the data being processed, like filtering or transformations.

Utilizing the AggregateResult and Map aggregate functions

In Apex, you can use the AggregateResult with Map to query data directly into a map using SOQL. This is useful when you want to group or summarize records, such as calculating totals or counts, and store them in a map for quick access.

Here’s how you can do it:

SOQL query with AggregateResult: Use GROUP BY in your query to group records.

Store results in a map: You can iterate over the AggregateResult and store the key-value pairs in a map.

Example:

// Query to get the total amount of opportunities grouped by AccountId
List<AggregateResult> groupedResults = [SELECT AccountId, SUM(Amount) totalAmount FROM Opportunity GROUP BY AccountId];

// Create a map to store AccountId and their corresponding total opportunity amounts
Map<Id, Decimal> accountOpportunityMap = new Map<Id, Decimal>();

// Loop through the aggregate results and populate the map
for (AggregateResult ar : groupedResults) {
    accountOpportunityMap.put((Id)ar.get('AccountId'), (Decimal)ar.get('totalAmount'));
}

// Now you can easily access the total amount for any AccountId

This way, you can quickly reference data from the map using the AccountId as a key without needing to run additional queries.

Common use cases for querying data directly into a Map

Querying a SOQL query directly into a Map in Apex is useful when you need to easily access records using their unique identifiers or some other key. Here are three common use cases:

Retrieve Records by ID

When you want to retrieve a set of records and access them by their ID quickly, using a Map<Id, SObject> makes it simple.

Map<Id, Account> accountMap = new Map<Id, Account>(
    [SELECT Id, Name FROM Account WHERE BillingState = 'CA']
);
// Access a specific account by its ID
Account acc = accountMap.get(someAccountId);

Grouping Records by a Field (e.g., External ID)

If you're working with a field other than the record's ID (like an external ID), you can use Map<String, SObject> to group by that field.

Map<String, Account> accountByExtId = new Map<String, Account>(
    [SELECT External_Id__c, Name FROM Account WHERE BillingState = 'CA']
);
// Access an account by its External ID
Account acc = accountByExtId.get('EXT123');

Handling Parent-Child Relationships

When querying for child records and you want to group them by the parent’s ID, you can use Map<Id, List<SObject>> for easy lookup.

Map<Id, List<Contact>> accountToContactsMap = new Map<Id, List<Contact>>();
for(Contact con : [SELECT AccountId, Name FROM Contact WHERE Account.BillingState = 'CA']) {
    if(!accountToContactsMap.containsKey(con.AccountId)) {
        accountToContactsMap.put(con.AccountId, new List<Contact>());
    }
    accountToContactsMap.get(con.AccountId).add(con);
}
// Get all contacts for a specific account
List<Contact> contactsForAccount = accountToContactsMap.get(someAccountId);

These use cases streamline data retrieval and organization, reducing code complexity and improving efficiency when working with collections of records in Salesforce Apex.

Conclusion

In conclusion, storing SOQL query results directly into a Map in Apex offers a powerful and efficient way to organize and access data. By leveraging the Map data structure, developers can quickly retrieve key-value pairs, benefiting from faster lookup times and easy manipulation. Whether working with large or small datasets, querying directly into a Map proves advantageous in various scenarios, including data aggregation, filtering, and dynamic computations. Understanding when to use a Map over other data structures like Lists or Sets is crucial for optimizing code performance and data management in Apex.

SalesForce Simplified