SOQL Query in Salesforce Apex & Examples

SOQL Query in Salesforce Apex and programming examples

Table of Contents

What is SOQL?
SOQL Cheat Sheet

SOQL Variable Binding

Keywords Used In SOQL Queries

Traversing Relationship Fields

Fetching Child Records

Fetching Parent Record

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 1 of 44
:
 Aggregate Functions

Binding Apex Variables

How to Start with SOQL?

What are the differences between SOQL, SOSL, and SQL?

How to write a basic SOQL Query?
How to find Object and Field API Names for your Queries?

How to use SOQL in Apex?

Banking & Finance SOQL Examples

Healthcare SOQL Examples

Airlines SOQL Examples
Logistics SOQL Examples
Education SOQL Examples

FAQs

What is SOQL in Salesforce?

SOQL stands for Salesforce Object Query Language. SOQL can be used to access
information stored in your organization’s database. The syntax of SOQL is similar to
that of SQL (Structured Query Language).SOQL queries can be written in Apex code
or in the Query Editor of the Developer Console. In Soql records can only be
searched on a single sObject if it meets the given criteria. Unlike SOSL, it cannot
search across multiple objects but nested queries are supported in SOQL.

Read more: Latest Salesforce interview questions and answers.

Code Example:

!" Fetching the Records via SOQL

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 2 of 44
:
 !" Create a list to store the queried invoice records
List<apex_invoice!#c> invoiceList = new List<apex_invoice!#c>();

try {
!" Querying the invoice records with specific criteria
!" Selecting fields Id, Name, APEX_Customer!#r.Name, APEX_Status!#c
!" from the APEX_Invoice!#c object where the record was created today
!" and the customer name is not 'Test'
invoiceList = [SELECT Id, Name, APEX_Customer!#r.Name, APEX_Status!#c
FROM APEX_Invoice!#c
WHERE CreatedDate = TODAY AND APEX_Customer!#r.Name !$ 'Test'];

!" Printing the total number of fetched records

System.debug('We have a total of ' + invoiceList.size() + ' records in the list'

!" Looping through each fetched record and printing its values
for (apex_invoice!#c objInvoice : invoiceList) {
!" Printing the record's values
System.debug('Record value: ' + objInvoice);
}
} catch (Exception e) {
!" Handling any exceptions that might occur during the query execution
System.debug('An error occurred: ' + e.getMessage());
}

Explanation:

1. Fetching Records via SOQL: We’re using a Salesforce Object Query Language
(SOQL) query to retrieve records from the APEX_Invoice__c object.
2. Query Criteria: We’re querying records created today ( CreatedDate =
TODAY ) and whose customer name is not ‘Test’ ( APEX_Customer__r.Name

!= 'Test' ).
3. Error Handling: We’ve added a try-catch block to catch any exceptions that
might occur during the query execution.

4. Printing Records: We’re printing the total number of fetched records and

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 3 of 44
:
 looping through each record to print its values using System.debug() . This

helps in debugging and understanding the data retrieved from the query.

SQL (Structured Query Language) is the standard language for managing and
manipulating databases. Here’s an overview of the basic syntax used in SQL to
perform common operations such as selecting data, inserting records, updating
records, and deleting records.

Checkout: SOSL Query in Salesforce Apex

1. SELECT Statement

The SELECT statement is used to select data from a database. Data is retrieved
from one or more tables.

Syntax:

SELECT column1, column2, !!%

FROM tableName
WHERE condition;

2. INSERT INTO Statement

The INSERT INTO statement is used to insert new records into a table.

Syntax:

INSERT INTO tableName (column1, column2, !!%)

VALUES (value1, value2, !!%);

3. UPDATE Statement

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 4 of 44
:
 The UPDATE statement is used to modify the existing records in a table.

Syntax:

UPDATE tableName
SET column1 = value1, column2 = value2, !!%
WHERE condition;

Read more: Database methods – Salesforce Apex

4. DELETE Statement

The DELETE statement is used to delete existing records from a table.

Syntax:

DELETE FROM tableName

WHERE condition;

5. CREATE TABLE Statement

The CREATE TABLE statement is used to create a new table in the database.

Syntax:

CREATE TABLE tableName (

column1 dataType constraints,
column2 dataType constraints,
!!%
);

Additional Clauses

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 5 of 44
:
 WHERE: Specifies conditions for the SELECT , UPDATE , and DELETE
statements.

ORDER BY: Orders the results according to one or more columns.

GROUP BY: Groups rows that have the same values in specified columns into
summary rows.

HAVING: Specifies a condition on the groups being created.

Read more: DML in Salesforce Apex

CRS Info Solutions offers a comprehensive and dynamic Salesforce online

course career building program for beginners, covering admin, developer, and
LWC concepts. This course features immersive real-time projects,
interactive hands-on learning, detailed daily notes, essential interview questions,
thorough certification preparation, and strategic job prep guidance. Join their
inspiring free demo to embark on an exciting Salesforce journey with expert
mentorship and unlock your full potential in the Salesforce ecosystem. Enroll for
a free demo today!

SOQL Cheat Sheet

Command Description Example

SELECT Retrieves fields from SELECT Name FROM Account

specified objects.

FROM Specifies the object SELECT Name FROM Contact

from which to
retrieve data.

WHERE Filters results based SELECT Name FROM Account WHERE

on specified Industry = 'Finance'
conditions.

LIMIT Restricts the number SELECT Name FROM Account LIMIT 5

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 6 of 44
:
 of rows returned.

ORDER BY Specifies the order SELECT Name FROM Account ORDER BY Name
of returned rows. ASC

GROUP BY Groups results by SELECT Count(), Industry FROM Account

one or more fields. GROUP BY Industry

HAVING Filters grouped SELECT Industry, Count(Id) FROM

records returned by Account GROUP BY Industry HAVING
a GROUP BY clause. Count(Id) > 5

LIKE Filters results by SELECT Name FROM Contact WHERE Email

pattern matching. LIKE '%@example.com'

IN Filters results to SELECT Name FROM Account WHERE

include specified Industry IN ('Banking', 'Insurance')

values in a field.

INCLUDES Used in multi-select SELECT Name FROM Account WHERE

picklists to select Industries__c INCLUDES ('Banking',
values. 'Insurance')

EXCLUDES Used in multi-select SELECT Name FROM Account WHERE

picklists to exclude Industries__c EXCLUDES ('Retail')
values.

TYPEOF For polymorphic SELECT TYPEOF What WHEN Account THEN

relationships, Phone, NumberOfEmployees WHEN
specifies different Opportunity THEN Amount, StageName
fields for different ELSE Name, Title END FROM Task
related objects.

SOQL Cheat Sheet

This cheat sheet covers the basic syntax and common uses of SOQL commands to
help with quick reference during development.

Read more: Strings in Salesforce Apex

SOQL Variable Binding

Whatsapp Chat
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 7 of 44
:
 Whatsapp Chat
SOQL (Salesforce Object Query Language) variable binding allows you to use a
Call us on:  IN +91 93478 54179 , 70132 83324 , USA +1 (415) 529-
single set of query string and dynamically pass 
7271 || Request Call Back || Please call to USA number during USA day time.
values to the query at runtime. This
helps prevent SOQL injection and makes your queries more efficient.

Example:

Consider a simple SOQL query without variable binding:

String name = 'John';

List<Account> accounts = [SELECT Id, Name FROM Account WHERE Name = :name];

In this example, :name is a bind variable that gets replaced with the value of the
name variable when the query is executed. This approach helps protect against
SOQL injection and allows for more flexible query construction.

Collection is one of the important concept, checkout: Collections in Salesforce

Apex

Keywords Used In SOQL Queries

In Salesforce Object Query Language (SOQL), keywords play a crucial role in

crafting precise and effective queries to retrieve data from Salesforce objects. These
keywords, such as SELECT, FROM, WHERE, and ORDER BY, among others,
provide the structure and logic necessary to filter, sort, and manipulate data
according to specific criteria. Understanding and utilizing these keywords effectively
is essential for Salesforce developers and administrators to extract meaningful
insights and drive informed decision-making within their organizations.

SELECT: Retrieves one or more fields from an object.

SELECT Id, Name FROM Account

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 8 of 44
:
 FROM: Specifies the object from which to retrieve records.

SELECT Id, Name FROM Account

WHERE: Filters records based on specified criteria.

Read more: Arrays in Salesforce Apex

SELECT Id, Name FROM Account WHERE Industry = 'Technology'

ORDER BY: Specifies the sorting order for the query results.

SELECT Id, Name FROM Account ORDER BY CreatedDate DESC

GROUP BY: Groups query results by specified fields.

SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry

HAVING: Adds additional filtering after GROUP BY.

SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry HAVING COUNT(Id) > 1

LIMIT: Specifies the maximum number of records to return.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 9 of 44
:
 SELECT Id, Name FROM Account LIMIT 10

OFFSET: Skips a specified number of records before returning results.

Checkout: DML statements in Salesforce

SELECT Id, Name FROM Account LIMIT 10 OFFSET 5

IN: Specifies a list of values for a field.

SELECT Id, Name FROM Account WHERE Industry IN ('Technology', 'Finance')

NOT IN: Specifies a list of values not to include.

SELECT Id, Name FROM Account WHERE Industry NOT IN ('Retail', 'Healthcare')

LIKE: Performs a partial match search.

SELECT Id, Name FROM Account WHERE Name LIKE '%Corp%'

AND: Combines multiple conditions in a WHERE clause.

SELECT Id, Name FROM Account WHERE Industry = 'Technology' AND AnnualRevenue > 10000

OR: Specifies multiple conditions, of which at least one must be true.

Checkout: Data types in Salesforce Apex

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 10 of 44
:
 SELECT Id, Name FROM Account WHERE Industry = 'Technology' OR Industry = 'Finance'

FOR UPDATE: Locks the selected rows for update.

SELECT Id, Name FROM Account WHERE Name = 'Acme' FOR UPDATE

ALL ROWS: Allows querying of all records, including archived and deleted records

SELECT Id, Name FROM Account WHERE Name = 'Acme' ALL ROWS

Traversing Relationship Fields in SOQL

Let’s traverse relationship fields in Salesforce using an example. Suppose we have
two custom objects: Account and Contact , where Contact has a lookup
relationship to Account called Account__c . Here’s how we can traverse the
relationship fields:

!" Querying Contacts and their related Account information

List<Contact> contactsWithAccountInfo = [SELECT Id, Name, Email, Account!#r.Name, Ac
FROM Contact];

!" Iterating through the queried contacts

for (Contact contact : contactsWithAccountInfo) {
!" Accessing contact fields
String contactName = contact.Name;
String contactEmail = contact.Email;

!" Accessing related Account fields

!" Using Account!#r.Name to access the Name field of the related Account
String accountName = contact.Account!#r.Name;

!" Using Account!#r.Industry to access the Industry field of the related Account
String accountIndustry = contact.Account!#r.Industry;

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 11 of 44
:
 !" Printing contact and related Account information
System.debug('Contact Name: ' + contactName);
System.debug('Contact Email: ' + contactEmail);
System.debug('Related Account Name: ' + accountName);
System.debug('Related Account Industry: ' + accountIndustry);
}

Explanation:

1. SOQL Query: We are querying Contact records along with their related

Account information using a SOQL query. We use Account__r.Name and

Account__r.Industry to access fields from the related Account object. The

_r signifies that we are traversing a relationship.

2. Iteration: We loop through the queried Contact records using a for loop.

3. Accessing Fields: Within the loop, we access fields of both the Contact and

its related Account using dot notation ( . ). For example,

contact.Account__r.Name accesses the Name field of the related Account

.
4. Debugging: We print out information about each Contact and its related

Account using System.debug() statements for debugging purposes.

Read more: Salesforce apex programming examples

Fetching Child Records in SOQL

Let’s fetch child records related to a parent record in Salesforce using an example.
We’ll consider a scenario where we have two custom objects: Account (parent) and
Contact (child), with a lookup relationship from Contact to Account . Here’s how
we can fetch child records ( Contact ) related to a parent record ( Account ):

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 12 of 44
:
 !" Define the ID of the parent Account record
Id parentAccountId = 'Insert_Account_ID_Here'; !" Replace with actual Account ID

!" Querying child Contact records related to the parent Account

List<Contact> childContacts = [SELECT Id, Name, Email
FROM Contact
WHERE AccountId = :parentAccountId];

!" Iterating through the queried child Contact records

for (Contact childContact : childContacts) {
!" Accessing child Contact fields
String contactName = childContact.Name;
String contactEmail = childContact.Email;

!" Printing child Contact information

System.debug('Contact Name: ' + contactName);
System.debug('Contact Email: ' + contactEmail);
}

Explanation:

1. Parent Account ID: We define the ID of the parent Account record from which

we want to fetch child Contact records. Replace

'Insert_Account_ID_Here' with the actual ID of the parent Account .

2. SOQL Query: We use a SOQL query to retrieve child Contact records (

SELECT Id, Name, Email FROM Contact WHERE AccountId =
:parentAccountId ). We filter the contacts based on the AccountId field,

which represents the lookup relationship to the parent Account .

3. Iteration: We loop through the queried child Contact records using a for loop.

4. Accessing Fields: Within the loop, we access fields of each child Contact
using dot notation ( . ). For example, childContact.Name accesses the Name
field of the child Contact .

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 13 of 44
:
 5. Debugging: We print out information about each child Contact using
System.debug() statements for debugging purposes.

Read more: Loops in Salesforce Apex

Fetching Parent Record in SOQL

Let’s fetch the parent record related to a child record in Salesforce using an
example. We’ll consider a scenario where we have two custom objects: Account
(parent) and Contact (child), with a lookup relationship from Contact to Account
. Here’s how we can fetch the parent record ( Account ) related to a child record (
Contact ):

!" Define the ID of the child Contact record

Id childContactId = 'Insert_Contact_ID_Here'; !" Replace with actual Contact ID

!" Querying the parent Account record related to the child Contact
Contact childContact = [SELECT Id, Name, Email, AccountId, Account.Name, Account.Ind
FROM Contact
WHERE Id = :childContactId];

!" Accessing parent Account fields from the related Contact record
String accountId = childContact.AccountId;
String accountName = childContact.Account.Name;
String accountIndustry = childContact.Account.Industry;

!" Printing parent Account information

System.debug('Account ID: ' + accountId);
System.debug('Account Name: ' + accountName);
System.debug('Account Industry: ' + accountIndustry);

Explanation:

1. Child Contact ID: We define the ID of the child Contact record for which we

want to fetch the related parent Account record. Replace

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 14 of 44
:
 'Insert_Contact_ID_Here' with the actual ID of the child Contact .
2. SOQL Query: We use a SOQL query to retrieve the child Contact record along
with the related parent Account information ( SELECT Id, Name, Email,

AccountId, Account.Name, Account.Industry FROM Contact

WHERE Id = :childContactId ). We use dot notation ( . ) to traverse the

relationship and access fields from the parent Account object.

3. Accessing Parent Fields: After executing the query, we access fields of the
parent Account from the related Contact record using dot notation ( . ). For

example, childContact.Account.Name accesses the Name field of the

parent Account .

4. Debugging: We print out information about the parent Account using

System.debug() statements for debugging purposes.

You can explore all the String methods in Apex, and learn those examples for each
method.

Aggregate Functions in SOQL

Aggregate functions in Salesforce are used to perform calculations on a set of
records and return a single result. Here’s an example of using aggregate functions in
SOQL:

Suppose we have a custom object called Opportunity with fields Amount

(representing the amount of the opportunity) and StageName (representing the
stage of the opportunity). We want to calculate the total amount of all opportunities
and the average amount of opportunities in each stage.

!" Querying aggregate data using SOQL

List<AggregateResult> results = [SELECT StageName, SUM(Amount) totalAmount, AVG(Amou
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 15 of 44
:
 FROM Opportunity
GROUP BY StageName];

!" Iterating through the results

for (AggregateResult ar : results) {
!" Accessing aggregated data
String stageName = (String)ar.get('StageName');
Decimal totalAmount = (Decimal)ar.get('totalAmount');
Decimal avgAmount = (Decimal)ar.get('avgAmount');

!" Printing the aggregated data

System.debug('Stage: ' + stageName);
System.debug('Total Amount: ' + totalAmount);
System.debug('Average Amount: ' + avgAmount);
}

Explanation:

1. SOQL Query with Aggregate Functions: We use a SOQL query to perform

aggregate functions on the Opportunity object. We select the StageName

field and calculate the sum of Amount (totalAmount) and the average of Amount

(avgAmount). We group the results by the StageName field.

2. AggregateResult: The query returns a list of AggregateResult objects, each
containing the aggregated data for a specific stage.

3. Accessing Aggregated Data: We iterate through the AggregateResult

objects using a for loop and access the aggregated data using the get()

method.
4. Printing: We print out the stage name, total amount, and average amount for
each stage using System.debug() statements.

Watch our FREE Salesforce online course video, it’s a full length free tutorial for
beginners.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 16 of 44
:
 Binding Apex Variables in SOQL
Binding Apex variables, also known as binding variables or bind expressions, are
used to dynamically pass values into SOQL queries, SOSL searches, and dynamic
SOQL queries in Salesforce. They help prevent SOQL injection and improve
performance. Here are examples of how to use binding variables in various contexts:

Static SOQL Query with Binding Variable:

String searchKey = 'Test'; !" Value to search for

List<Contact> contacts = [SELECT Id, Name, Email FROM Contact WHERE LastName = :sear

In this example, searchKey is a binding variable. It is used in the SOQL query to

dynamically filter contacts by the last name specified in the searchKey variable.

String searchKey = 'Test'; !" Value to search for

List<Contact> contacts = [SELECT Id, Name, Email FROM Contact WHERE LastName = :sear

Dynamic SOQL Query with Binding Variable:

String objectType = 'Contact'; !" Object type to query

String fieldName = 'LastName'; !" Field name to filter
String searchKey = 'Test'; !" Value to search for

String soqlQuery = 'SELECT Id, Name, Email FROM ' + objectType + ' WHERE ' + fieldNa
List<SObject> records = Database.query(soqlQuery);

In this example, we construct a dynamic SOQL query using variables objectType ,

fieldName , and searchKey . The searchKey variable is bound to the query
using the : syntax.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 17 of 44
:
 Read more: Workflow rules in Salesforce

SOSL Search with Binding Variable:

String searchKey = 'Test'; !" Value to search for

List<List<SObject!& searchResults = [FIND :searchKey IN ALL FIELDS RETURNING Contact

Here, searchKey is bound to the SOSL search query using the :searchKey
syntax. This searches for the specified keyword in all fields of the Contact object.

DML Statements with Binding Variables:

Account accToUpdate = new Account(Name = 'Example Account');

update accToUpdate;

In DML statements like update , insert , delete , and upsert , binding

variables are used implicitly. In this example, accToUpdate is bound to the update
operation, and its changes are persisted to the database.

Binding variables help make queries and DML operations dynamic, secure, and
efficient by allowing values to be passed dynamically into queries and DML
statements, thus preventing SOQL injection attacks and improving performance.

How to start with SOQL?

To work on SOQL you must have records in the database. So, before starting
working on Soql follow the below steps to insert some records via apex.

Step 1: Open the developer console and click on the Debug tab to open the
anonymous window as shown below the image.

Read more: Latest Salesforce interview questions and answers.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 18 of 44
:
 Step 2: In the image below, we have created an Account and associated contact and opportunity with it via apex.

Using the Query Editor, we can now write and execute a SOQL query to fetch the
above-inserted records. A SOQL query searches for data in a specific object and
optionally, you may add a condition to the WHERE clause to filter your search.

Read more: Validation Rules in Salesforce

In the image below we have queried the Account and its associated contact and
opportunity records and filtered the result by Account Name.
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 19 of 44
:
 Key Features:

1. SOQL allows you to query records from Standard and Custom objects in one go.

2. SOQL allows querying on a single object or multiple objects that are related to

one another.
3. SOQL supports aggregate functions just like SQL. We can roll up and

summarize data with aggregate functions. For example, Avg, Min, Max, etc.
4. SOQl allows binding apex variables in the query to filter the records.

5. SOQl supports Parent to Child and Child to Parent queries.

Watch our FREE Salesforce online course video, it’s a full length free tutorial for
beginners.

Frequently Asked Questions

What are the differences between SOQL, SOSL, and SQL?

SOSL, or Salesforce Object Search Language, is like a powerful tool I use to find
stuff in Salesforce. Imagine I’m searching for a specific word in a big library full of
books. SOSL helps me do just that. It’s like a magic spell that lets me search across
multiple books, not just one, to find what I need. So, instead of looking through each
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 20 of 44
:
 book one by one, SOSL quickly sifts through all the books and shows me the ones
that mention the word I’m looking for. It’s super handy when I need to find
information fast and don’t want to spend all day searching.

SOQL and SOSL are like cousins to SQL, but not identical twins. They speak a
similar language, but they have their own quirks tailored specifically for Salesforce.
Imagine SQL as the language you use to talk to a big library full of books, while
SOQL and SOSL are the languages you use to talk to a specialized library, like a
library of comic books or recipe books. They understand each other to some extent,
but they also have their own unique words and phrases that make them different.

So, while you might recognize some similarities between them, they’re not exactly
the same, just like cousins who share a family resemblance but have their own
distinct personalities. SOQL and SOSL are designed for querying data within the
Salesforce platform, each serving a specific purpose: SOQL for querying records
from Salesforce objects and SOSL for performing full-text searches across multiple
objects.

Checkout: Variables in Salesforce Apex

Examples:

SOQL Query:

SELECT Id, Name, Account.Name FROM Contact WHERE Account.Name = 'ACME'

This SOQL query retrieves the Id, Name, and the related Account’s Name of all
contacts where the related Account’s Name is ‘ACME’.

SOSL Query:

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 21 of 44
:
 FIND {ACME} IN ALL FIELDS RETURNING Contact(Id, Name), Account(Name)

This SOSL query searches for the keyword ‘ACME’ across all fields of the Contact
and Account objects and returns matching Contact records with their Id and Name,
as well as matching Account records with their Name.

SQL Query:

SELECT id, first_name, last_name FROM employees WHERE department = 'Sales'

This SOSL query searches for the keyword ‘ACME’ across all fields of the Contact
and Account objects and returns matching Contact records with their Id and Name,
as well as matching Account records with their Name.

How to write a basic SOQL Query?

To write a basic SOQL (Salesforce Object Query Language) query, you can use the
SELECT statement followed by the fields you want to retrieve from a Salesforce
object. Here’s a basic example of a SOQL query:

const query = 'SELECT Id, Name, AccountNumber FROM Account';

In this example, the query retrieves the Id , Name , and AccountNumber fields from
the Account object in Salesforce.

Checkout: Data types in Salesforce Apex

You can execute this query using Salesforce’s JavaScript Remoting, Apex, or other
Salesforce API methods depending on your use case. For example, using
JavaScript Remoting, you would define a remote action in your Apex controller and

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 22 of 44
:
 call it from your JavaScript code:

Apex Controller:

public with sharing class AccountController {

@RemoteAction
public static List<Account> getAccounts() {
return [SELECT Id, Name, AccountNumber FROM Account];
}
}

JavaScript

Visualforce.remoting.Manager.invokeAction(
'{!$RemoteAction.AccountController.getAccounts}',
function(result, event) {
if (event.status) {
!" Process the result
console.log(result);
} else {
console.error(event.message);
}
}
);

This is a basic example, and SOQL queries can be more complex, including
conditions ( WHERE clause), ordering ( ORDER BY ), and grouping ( GROUP BY ).

To write a basic SOQL (Salesforce Object Query Language) query, you first specify
the fields you want to retrieve using the SELECT clause. For instance, let’s say we
want to retrieve the “Name” and “Industry” fields from the “Account” object. We
would write the SELECT clause like this: “SELECT Name, Industry”. This tells
Salesforce to return the “Name” and “Industry” fields in the query results.

Next, we specify the object from which we want to retrieve the data using the FROM
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 23 of 44
:
 clause. In this example, we want to retrieve data from the “Account” object, so we
write “FROM Account”. This indicates that we want to query data from the “Account”
object specifically.

Putting it all together, our basic SOQL query looks like this: “SELECT Name,
Industry FROM Account”. This query tells Salesforce to retrieve the “Name” and
“Industry” fields from the “Account” object. It’s a simple yet powerful way to extract
specific information from Salesforce objects, and it forms the foundation for more
complex queries involving additional clauses like WHERE, ORDER BY, GROUP BY,
and others.

How to find Object and Field API Names for your

Queries?

To find Object and Field API Names for your queries in Salesforce, you can utilize
several methods. One common approach is to navigate to the Object Manager
within the Salesforce Setup menu. From there, you can search for the specific object
you’re interested in, such as “Account” or “Contact.” Once you locate the object, click
on it to access its details. Here, you’ll find a list of all the fields associated with that
object, along with their respective API Names. These API Names serve as unique
identifiers for each field and are crucial for referencing them accurately in your SOQL
queries.

Read more: Salesforce apex programming examples

By leveraging these methods, you can efficiently discover Object and Field API
Names required for your SOQL queries in Salesforce. Whether you’re a Salesforce
administrator, developer, or consultant, understanding how to find and utilize Object
and Field API Names is essential for effectively querying and manipulating data
within the Salesforce platform.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 24 of 44
:
 Using Developer Console:

Navigate to the Developer Console by clicking on your profile picture and

selecting “Developer Console”.

Open the “Execute Anonymous Window” by clicking on “Debug” > “Open

Execute Anonymous Window”.

Enter the following Apex code to describe the Account object and its fields:

Schema.DescribeSObjectResult accountDescribe = Account.sObjectType.getDescribe();

Map<String, Schema.SObjectField> fieldsMap = accountDescribe.fields.getMap();
for(String fieldName : fieldsMap.keySet()) {
System.debug('Field Label: ' + fieldsMap.get(fieldName).getDescribe().getLabel()
System.debug('API Name: ' + fieldsMap.get(fieldName).getDescribe().getName());
}

Click on “Execute” to run the code. The Developer Console will display the Field
Label and API Name for each field of the Account object.

To find the Object and Field API Names for your queries in Salesforce, you can use
the Schema class in Apex. Here’s a code snippet that demonstrates how to retrieve
the API Names of an object and its fields:

!" Specify the object API name for which you want to retrieve the schema
String objectApiName = 'Account';

!" Get the schema describe result for the object

Schema.DescribeSObjectResult describeResult = Schema.getGlobalDescribe().get(objectA

!" Retrieve the object API name

String objectName = describeResult.getName();
System.debug('Object API Name: ' + objectName);

!" Retrieve the field API names

List<String> fieldApiNames = new List<String>();

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 25 of 44
:
 for (Schema.SObjectField field : describeResult.fields.getMap().values()) {
fieldApiNames.add(field.getDescribe().getName());
}
System.debug('Field API Names: ' + fieldApiNames);

This code snippet demonstrates how to retrieve the API Name of an object (
Account in this case) and its fields. You can modify the objectApiName variable
to specify the object for which you want to retrieve the schema.

Read more: Methods – Salesforce Apex

How to use SOQL in Apex?

In Apex, SOQL (Salesforce Object Query Language) is employed to retrieve records
from Salesforce objects. SOQL queries in Apex are expressed as strings and can be
executed using various methods provided by the Salesforce platform. One common
approach is to write a static SOQL query directly within your Apex code. For
example, you can use a static query to fetch a list of Account records where the
Industry field is set to ‘Technology’. This involves writing the query directly within
square brackets and assigning the result to a list variable, as shown:

List<Account> accounts = [SELECT Id, Name FROM Account WHERE Industry = 'Technology'

In addition to static queries, you can construct SOQL queries dynamically at runtime
using string concatenation or by leveraging the Database.query() method. This
approach allows you to build queries based on dynamic criteria. For instance, you
might define query conditions based on user input or runtime variables. Dynamic
queries enable greater flexibility in querying data from Salesforce objects within your
Apex code. Here’s an example of constructing a dynamic SOQL query:

Read more: Array methods in Salesforce Apex

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 26 of 44
:
 String industry = 'Technology';
String soqlQuery = 'SELECT Id, Name FROM Account WHERE Industry = \'' + industry + '
List<Account> accounts = Database.query(soqlQuery);

Furthermore, SOQL supports the use of binding variables, which allow you to
dynamically pass values into the query at runtime. Binding variables are denoted by
a colon followed by the variable name. This helps prevent SOQL injection and
enhances query security. Here’s how you can use binding variables in a SOQL
query:

String industry = 'Technology';

List<Account> accounts = [SELECT Id, Name FROM Account WHERE Industry = :industry];

Moreover, SOQL allows you to query fields on related objects using relationship
fields. For example, you can query fields on child objects using parent-child
relationship fields. Once you have executed a SOQL query, you can iterate through
the query results using standard Apex iteration methods like for loops. This enables
you to process and manipulate the retrieved data as needed within your Apex code.
By leveraging SOQL in Apex, you can effectively interact with Salesforce data and
build robust applications on the Salesforce platform.

Read more: Classes – Salesforce Apex

Difference between SOQL and SOSL

SOQL (Salesforce Object Query Language) SOSL (Salesforce Object Search Language)

Used for querying data from specific Used for performing text searches in records
objects and their related objects. across multiple objects.

Allows querying of individual records Allows searching of fields with a search

similar to SQL SELECT statements. expression using keywords.

Returns records that meet specific criteria Returns records containing the search term,

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 27 of 44
:
 defined in the WHERE clause. potentially from multiple object types
simultaneously.

Query targets a specific object or a specific Searches the global index of all records that
set of objects defined in the FROM clause. meet the search criteria across multiple objects.

Supports nested queries and relationship Limited to simple search conditions; does not
queries. allow nested queries or relationship queries.

Ideal for precise, complex queries where Ideal for broad, text-based searches where the
you know the structure of the database. exact location of data is unknown.

Can include COUNT, SUM, MAX, MIN, Primarily focuses on finding text in record fields
and other functions. without aggregate functions.

Has a row limit based on context, usually Has a different limit, typically 2,000 records for
50,000 records in batch Apex. global search across objects.

For those looking for Salesforce learning, CRS Info Solutions provides an
extensive Salesforce training program designed to enhance your skills and career
opportunities. Explore our Salesforce training in India to gain practical, hands-on
experience. Our training covers all essential aspects of Salesforce, ensuring
comprehensive learning. With expert instructors and a detailed curriculum, CRS
Info Solutions is committed to your success in the Salesforce ecosystem with
our Career Building program. Whether you are a beginner or looking to advance
your skills, they offer the guidance and resources you need. Enroll for free demo
today!

Banking & Finance SOQL Examples

Example 1: Retrieving Customer Account Details

This example demonstrates how to retrieve account details for a specific customer
using their account ID.

public class CustomerService {

public Account getAccountDetails(Id accountId) {

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 28 of 44
:
 Account account = [SELECT Id, Name, BillingAddress, Phone, Industry, AnnualR
FROM Account
WHERE Id = :accountId];
return account;
}
}

This code defines a method getAccountDetails within the CustomerService

class. The method takes an account ID as a parameter and retrieves the
corresponding account’s details such as ID, name, billing address, phone, industry,
and annual revenue using an SOQL query.

Read more: Loops in Salesforce Apex

Example 2: Fetching Transactions for a Specific Account

This example fetches all transactions associated with a specific account within a
date range.

public class TransactionService {

public List<Transaction!#c> getTransactions(Id accountId, Date startDate, Date e
List<Transaction!#c> transactions = [SELECT Id, Amount!#c, Date!#c, Type!#c,
FROM Transaction!#c
WHERE Account!#c = :accountId
AND Date!#c !' :startDate
AND Date!#c !( :endDate
ORDER BY Date!#c DESC];
return transactions;
}
}

This code defines a method getTransactions within the TransactionService

class. It takes an account ID, start date, and end date as parameters and retrieves
all transactions related to that account within the specified date range. The
transactions are ordered by date in descending order.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 29 of 44
:
 Read more: Objects – Salesforce Apex

Example 3: Fetching High-Value Customers

This example identifies high-value customers based on their total assets managed
by the bank.

public class CustomerAnalysisService {

public List<Account> getHighValueCustomers(Decimal minAssets) {
List<Account> highValueCustomers = [SELECT Id, Name, AnnualRevenue, NumberOf
FROM Account
WHERE AnnualRevenue > :minAssets
ORDER BY AnnualRevenue DESC];
return highValueCustomers;
}
}

This code defines a method getHighValueCustomers within the

CustomerAnalysisService class. The method takes a minimum asset value as
a parameter and retrieves a list of accounts with annual revenue greater than the
specified minimum. The accounts are ordered by annual revenue in descending
order.

Collection is one of the important concept, checkout: Collections in Salesforce

Apex

Example 4: Fetching Loan Applications with Pending Status

This example retrieves all loan applications that are pending approval.

public class LoanService {

public List<Loan_Application!#c> getPendingLoanApplications() {
List<Loan_Application!#c> pendingLoans = [SELECT Id, Applicant_Name!#c, Loan
FROM Loan_Application!#c
WHERE Status!#c = 'Pending'

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 30 of 44
:
 ORDER BY Application_Date!#c DESC]
return pendingLoans;
}
}

This code defines a method getPendingLoanApplications within the

LoanService class. The method retrieves all loan applications with a status of
“Pending” and orders them by the application date in descending order. The fields
retrieved include ID, applicant name, loan amount, application date, and status.

Checkout: Interfaces – Salesforce Apex

Healthcare SOQL Examples

Example 1: Retrieving Patient Medical Records

This example demonstrates how to retrieve medical records for a specific patient
using their patient ID.

public class MedicalRecordService {

public List<Medical_Record!#c> getPatientMedicalRecords(Id patientId) {
List<Medical_Record!#c> records = [SELECT Id, Patient!#c, Diagnosis!#c, Trea
FROM Medical_Record!#c
WHERE Patient!#c = :patientId
ORDER BY Record_Date!#c DESC];
return records;
}
}

This code defines a method getPatientMedicalRecords within the

MedicalRecordService class. The method takes a patient ID as a parameter and
retrieves all medical records associated with that patient, ordered by the record date
in descending order. The fields retrieved include ID, patient reference, diagnosis,
treatment, and record date.

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 31 of 44
:
 Example 2: Fetching Appointments for a Specific Doctor

This example fetches all appointments scheduled for a specific doctor within a
specified date range.

public class AppointmentService {

public List<Appointment!#c> getDoctorAppointments(Id doctorId, Date startDate, D
List<Appointment!#c> appointments = [SELECT Id, Doctor!#c, Patient!#c, Appoi
FROM Appointment!#c
WHERE Doctor!#c = :doctorId
AND Appointment_Date!#c !' :startDate
AND Appointment_Date!#c !( :endDate
ORDER BY Appointment_Date!#c ASC];
return appointments;
}
}

This code defines a method getDoctorAppointments within the

AppointmentService class. The method takes a doctor ID, start date, and end
date as parameters and retrieves all appointments for that doctor within the specified
date range. The appointments are ordered by appointment date in ascending order.
The fields retrieved include ID, doctor reference, patient reference, appointment
date, status, and description.

Readmore: Decision Making in Salesforce Apex

Airlines SOQL Examples

Example 1: Retrieving Flight Details for a Specific Flight
Number

This example demonstrates how to retrieve details for a specific flight using its flight
number.

public class FlightService {

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 32 of 44
:
 public Flight!#c getFlightDetails(String flightNumber) {
Flight!#c flight = [SELECT Id, Flight_Number!#c, Departure_City!#c, Arrival_
FROM Flight!#c
WHERE Flight_Number!#c = :flightNumber];
return flight;
}
}

This code defines a method getFlightDetails within the FlightService

class. The method takes a flight number as a parameter and retrieves the
corresponding flight’s details such as ID, flight number, departure city, arrival city,
departure time, arrival time, and status using an SOQL query.

Example 2: Fetching Reservations for a Specific Passenger

This example fetches all reservations made by a specific passenger using their
passenger ID.

public class ReservationService {

public List<Reservation!#c> getPassengerReservations(Id passengerId) {
List<Reservation!#c> reservations = [SELECT Id, Passenger!#c, Flight!#c, Res
FROM Reservation!#c
WHERE Passenger!#c = :passengerId
ORDER BY Reservation_Date!#c DESC];
return reservations;
}
}

This code defines a method getPassengerReservations within the

ReservationService class. The method takes a passenger ID as a parameter
and retrieves all reservations associated with that passenger. The reservations are
ordered by reservation date in descending order. The fields retrieved include ID,
passenger reference, flight reference, reservation date, seat number, and status.

Read more: Constants in Salesforce Apex

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 33 of 44
:
 Logistics SOQL Examples
Example 1: Retrieving Shipment Details for a Specific
Shipment ID

This example demonstrates how to retrieve details for a specific shipment using its
shipment ID.

public class ShipmentService {

public Shipment!#c getShipmentDetails(Id shipmentId) {
Shipment!#c shipment = [SELECT Id, Shipment_Number!#c, Origin!#c, Destinatio
FROM Shipment!#c
WHERE Id = :shipmentId];
return shipment;
}
}

This code defines a method getShipmentDetails within the ShipmentService

class. The method takes a shipment ID as a parameter and retrieves the
corresponding shipment’s details such as ID, shipment number, origin, destination,
departure date, arrival date, and status using an SOQL query.

Example 2: Fetching Deliveries for a Specific Driver

This example fetches all deliveries assigned to a specific driver within a specified
date range.

public class DeliveryService {

public List<Delivery!#c> getDriverDeliveries(Id driverId, Date startDate, Date e
List<Delivery!#c> deliveries = [SELECT Id, Driver!#c, Shipment!#c, Delivery_
FROM Delivery!#c
WHERE Driver!#c = :driverId
AND Delivery_Date!#c !' :startDate
AND Delivery_Date!#c !( :endDate
ORDER BY Delivery_Date!#c ASC];
return deliveries;

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 34 of 44
:
 }
}

This code defines a method getDriverDeliveries within the

DeliveryService class. The method takes a driver ID, start date, and end date as
parameters and retrieves all deliveries assigned to that driver within the specified
date range. The deliveries are ordered by delivery date in ascending order. The
fields retrieved include ID, driver reference, shipment reference, delivery date,
status, and destination.

Read more: What is Apex?

Education SOQL Examples

Example 1: Retrieving Student Enrollment Details

This example demonstrates how to retrieve enrollment details for a specific student
using their student ID.

public class EnrollmentService {

public List<Enrollment!#c> getStudentEnrollments(Id studentId) {
List<Enrollment!#c> enrollments = [SELECT Id, Student!#c, Course!#c, Enrollm
FROM Enrollment!#c
WHERE Student!#c = :studentId
ORDER BY Enrollment_Date!#c DESC];
return enrollments;
}
}

This code defines a method getStudentEnrollments within the

EnrollmentService class. The method takes a student ID as a parameter and
retrieves all enrollment records associated with that student. The enrollments are
ordered by enrollment date in descending order. The fields retrieved include ID,

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 35 of 44
:
 student reference, course reference, enrollment date, and status.

Example 2: Fetching Courses Offered by a Specific

Department

This example fetches all courses offered by a specific department using the
department ID.

public class CourseService {

public List<Course!#c> getDepartmentCourses(Id departmentId) {
List<Course!#c> courses = [SELECT Id, Name, Department!#c, Credits!#c, Cours
FROM Course!#c
WHERE Department!#c = :departmentId
ORDER BY Name ASC];
return courses;
}
}

This code defines a method getDepartmentCourses within the CourseService

class. The method takes a department ID as a parameter and retrieves all courses
offered by that department. The courses are ordered by name in ascending order.
The fields retrieved include ID, name, department reference, credits, and course
code.

Frequently Asked Questions (FAQs)

What tool to run SOQL query in Salesforce?

To run SOQL queries in Salesforce, you can use several tools, including the
Salesforce Developer Console, Workbench, and the Query Editor in Salesforce
Setup. The Developer Console is a robust tool that provides a user-friendly interface
for writing and executing SOQL queries. Workbench is another powerful web-based
tool that allows you to run SOQL queries and interact with Salesforce data.
Additionally, the Query Editor, accessible through the Salesforce Setup, offers a
https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 36 of 44
:
 simple interface for executing SOQL queries directly within your Salesforce org.

Read: Latest important Salesforce interview questions and answers.

What is the full form of SOQL?

The full form of SOQL is Salesforce Object Query Language. It is a query language
provided by Salesforce to retrieve data from the Salesforce database. SOQL is
similar to SQL (Structured Query Language) but is specifically designed to work with
Salesforce objects and fields.

Which three data types can a SOQL query return?

A SOQL query can return three primary data types:

1. List<sObject>: A list of standard or custom objects, where each item in the list is

a record that matches the query criteria.

2. List<AggregateResult>: A list of aggregate result objects, typically used when

performing aggregate queries such as COUNT, SUM, AVG, MIN, and MAX.
3. Integer: An integer value, usually returned when using aggregate functions like

COUNT to determine the number of records that match the query criteria.

What is the maximum length of a SOQL query?

The maximum length of a SOQL query is 20,000 characters. This limit includes the
query string and any variable bindings used in the query. It is important to be mindful
of this limit when constructing complex queries to ensure they do not exceed the
maximum allowed length.

Read more: Methods – Salesforce Apex

How many records we can query in SOQL?

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 37 of 44
:
 In a single SOQL query, you can retrieve up to 50,000 records. This limit applies to
the total number of records returned by the query. If you need to process more
records, you may need to use pagination techniques or batch Apex to handle larger
datasets efficiently.

How do I get a single record in SOQL?

To get a single record in SOQL, you can use the LIMIT clause to restrict the query
result to one record. For example:

Account singleAccount = [SELECT Id, Name FROM Account LIMIT 1];

This query retrieves the first account record from the Account object. It’s important to
note that if you expect only one record, you can directly assign the result to a single
sObject variable.

How do I fetch all records in SOQL?

To fetch all records in SOQL, you write a query without any filtering criteria.
However, it’s important to be mindful of Salesforce’s governor limits. Here’s an
example:

List<Account> allAccounts = [SELECT Id, Name FROM Account];

This query retrieves all account records. If the number of records exceeds the
governor limits, you might need to use batch processing or pagination to handle the
data efficiently.

Read more: Classes – Salesforce Apex

What are the different types of SOQL queries?

The different types of SOQL queries include:

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 38 of 44
:
 1. Basic Queries: Simple queries that retrieve data from a single object.

SELECT Id, Name FROM Account;

2. Relationship Queries: Queries that retrieve data from related objects using

child-to-parent or parent-to-child relationships.

// Child-to-parent SELECT Name,
Account.Name FROM Contact;

// Parent-to-child
SELECT Name, (SELECT LastName FROM Contacts) FROM Account;
3. Aggregate Queries: Queries that perform aggregate functions such as COUNT,

SUM, AVG, MIN, and MAX.

SELECT COUNT(Id) FROM Account;

How many levels we can query in SOQL?

In SOQL, you can query up to five levels of parent-child relationships in a single

query. However, there are some limitations on the number of parent-to-child
subqueries you can include. The query depth limit in Salesforce ensures that
complex queries remain performant and within governor limits.

How do I resolve too many SOQL queries?

To resolve the “too many SOQL queries” error, you can:

1. Optimize Queries: Ensure your queries are efficient and retrieve only necessary

fields and records.

2. Reduce Loop Queries: Avoid placing SOQL queries inside loops. Instead, use

bulk queries outside of loops.

3. Use Collections: Retrieve records in bulk and use collections (lists, sets, maps)

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 39 of 44
:
 to process the data.
4. Use Batch Apex: For large data operations, consider using Batch Apex to

process records in manageable chunks.

5. Leverage Caching: Cache results when appropriate to avoid repetitive queries.

How to retrieve more than 50,000 records in Salesforce

SOQL?

To retrieve more than 50,000 records in Salesforce SOQL, you can use one of the
following approaches:

Batch Apex: Use Batch Apex to process records in batches of up to 200 records per
batch, allowing you to handle large data sets efficiently.

public class MyBatchClass implements Database.Batchable

Batchable
Batchable<sObject> {
public Database.QueryLocator start(Database.BatchableContext bc) {
return Database.getQueryLocator('SELECT Id, Name FROM Account');
}
public void execute(Database.BatchableContext bc, List<Account> scope) {
!" Process each batch of records
}
public void finish(Database.BatchableContext bc) {
!" Finalize batch processing
}
}

Query Pagination: Use query pagination to retrieve records in smaller chunks. This
involves using the OFFSET clause or maintaining a cursor to fetch subsequent sets
of records.

List<Account> accounts = [SELECT Id, Name FROM Account LIMIT 200 OFFSET 0];
!" Repeat with different offsets to retrieve subsequent records

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 40 of 44
:
 Next chapter is Security and previous chapter is SOSL Query.

← How to pass parameters to Scheduled Apex class? Mastering Single Sign-On in Salesforce →

Comments are closed.

Apex Tutorials

Overview - Salesforce Apex

Environment - Salesforce Apex

Examples - Salesforce Apex

Data Types - Salesforce Apex

Variables - Salesforce Apex

Strings - Salesforce Apex

Arrays - Salesforce Apex

Constants - Salesforce Apex

Decision Making - Salesforce Apex

Loops - Salesforce Apex

Collections - Salesforce Apex

Map Class - Salesforce Apex

Classes - Salesforce Apex

Methods - Salesforce Apex

Objects - Salesforce Apex

Interfaces - Salesforce Apex

DML - Salesforce Apex

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 41 of 44
:
 Database methods - Salesforce Apex

SOSL Query - Salesforce Apex

SOQL Query - Salesforce Apex

Security - Salesforce Apex

Invoking - Salesforce Apex

REGISTER FOR DEMO

Name *

Name

Email address *

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 42 of 44
:
 Email address

Phone *

Phone

Select Course
Salesforce

Country (for suitable batch-timing) *

India

Type the characters *

SEND QUERY

RECENT POSTS
TCS Java Interview Questions

Salesforce Email Studio in Marketing Cloud

Salesforce OWD Interview Questions and answers

The History of Salesforce: A Year-by-Year Timeline

Salesforce Business Analyst Interview Questions

Infosys React JS Interview Questions

Java Interview Questions for Freshers

Visualforce Pages in Salesforce

Salesforce Characters and Mascots

Product Configuration in Salesforce CPQ

Latest Articles Other Links Useful Links

Why You Should Get Salesforce CertifiedEasy Salesforce Admin TutorialHome

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 43 of 44
:
 Salesforce Admin Certification Guide Apex Tutorial Chapter 1 About us

Why CRS Info Solutions? Bengaluru Student Registration

What is Cloud Computing? Hyderabad Faculty Registration

What is Salesforce? Pune Contact us

Recent Posts

TCS Java Interview Questions

Salesforce Email Studio in Marketing Cloud

Salesforce OWD Interview Questions and answers

Copyright © 2024 CRS Info Solutions. All Rights Reserved.

Terms of Use Privacy Policy Disclaimer Contact Us

https://www.crsinfosolutions.com/salesforce-apex-tutorial-chapter-19-apex-soql-query/#soql-cheatsheet 8/21/24, 1 37 PM
Page 44 of 44
: