RESULT

NOTE! 🚨 All examples use inline queries built with the SOQL Lib Query Builder. If you are using a selector, replace SOQL.of(...) with YourSelectorName.query().

toId

Apex

Traditional Approach

Id accountId = [SELECT Id FROM Account LIMIT 1].Id;

SOQL Lib

SOQL Lib Approach

Id accountId = SOQL.of(Account.SObjectType).setLimit(1).toId();

toIds

Apex

Traditional Approach

Set<Id> accountIds = new Set<Id>();

for (Account acc : [SELECT Id FROM Account WHERE Industry = 'Technology']) {
    accountIds.add(acc.Id);
}

SOQL Lib

SOQL Lib Approach

Set<Id> accountIds = SOQL.of(Account.SObjectType)
    .whereAre(SOQL.Filter.with(Account.Industry).equal('Technology'))
    .toIds();

toIdsOf

Apex

Traditional Approach

Set<Id> ownerIds = new Set<Id>();

for (Account acc : [SELECT OwnerId FROM Account WHERE Industry = 'Technology']) {
    ownerIds.add(acc.OwnerId);
}

SOQL Lib

SOQL Lib Approach

Set<Id> ownerIds = SOQL.of(Account.SObjectType)
    .whereAre(SOQL.Filter.with(Account.Industry).equal('Technology'))
    .toIdsOf(Account.OwnerId);

toIdsOf related field

Apex

Traditional Approach

Set<Id> parentAccountIds = new Set<Id>();

for (Account acc : [SELECT Parent.Id FROM Account WHERE Industry = 'Technology']) {
    parentAccountIds.add(acc.Parent.Id);
}

SOQL Lib

SOQL Lib Approach

Set<Id> parentAccountIds = SOQL.of(Account.SObjectType)
    .whereAre(SOQL.Filter.with(Account.Industry).equal('Technology'))
    .toIdsOf('Parent', Account.Id);

doExist

Apex

Traditional Approach

Integer accountsWithMoreThan100Employees = [
    SELECT COUNT()
    FROM Account
    WHERE NumberOfEmployees > 100
];

Boolean hasAccountsWithMoreThan100Employees = accountsWithMoreThan100Employees > 0;

SOQL Lib

SOQL Lib Approach

Boolean hasAccountsWithMoreThan100Employees = SOQL.of(Account.SObjectType)
    .whereAre(SOQL.Filter(Account.NumberOfEmployees).greaterThan(100))
    .doExist();

toValueOf

Apex

Traditional Approach

String accountName = [SELECT Name FROM Account WHERE Id = '1234'].Name;

SOQL Lib

SOQL Lib Approach

String accountName = (String) SOQL.of(Account.SObjectType)
    .byId('1234')
    .toValueOf(Account.Name);

toValuesOf

Apex

Traditional Approach

Set<String> accountNames = new Set<String>();

for (Account acc : [SELECT Name FROM Account]) {
    accountNames.add(acc.Name);
}

SOQL Lib

SOQL Lib Approach

Set<String> accountNames = SOQL.of(Account.SObjectType)
    .toValuesOf(Account.Name);

toValuesOf related field

Apex

Traditional Approach

Set<String> parentAccountNames = new Set<String>();

for (Account acc : [SELECT Name, Parent.Name FROM Account]) {
    parentAccountNames.add(acc.Parent.Name);
}

SOQL Lib

SOQL Lib Approach

Set<String> parentAccountNames = SOQL.of(Account.SObjectType)
    .toValuesOf('Parent', Account.Name);

toInteger

Apex

Traditional Approach

Integer amountOfExistingAccounts = [SELECT COUNT() FROM Account];

SOQL Lib

SOQL Lib Approach

Integer amountOfExistingAccounts = SOQL.of(Account.SObjectType).toInteger();

toObject

Apex

Traditional Approach

Account account = [
    SELECT Id, Name
    FROM Account
    WHERE Id = '1234'
];

SOQL Lib

SOQL Lib Approach

Account account = (Account) SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .byId('1234')
    .toObject();

toList

Apex

Traditional Approach

Account account = [SELECT Id, Name FROM Account];

SOQL Lib

SOQL Lib Approach

List<Account> accounts = SOQL.of(Account.SObjectType).with(Account.Id, Account.Name).toList();

toAggregated

Apex

Traditional Approach

List<AggregateResult> result = [
    SELECT LeadSource
    FROM Lead
    GROUP BY LeadSource
];

SOQL Lib

SOQL Lib Approach

List<AggregateResult> result = SOQL.of(Lead.SObjectType)
    .with(Lead.LeadSource)
    .groupBy(Lead.LeadSource)
    .toAggregated();

toMap

Apex

Traditional Approach

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

SOQL Lib

SOQL Lib Approach

Map<Id, Account> idToAccount = (Map<Id, Account>) SOQL.of(Account.SObjectType).toMap();

toMap with custom key

Apex

Traditional Approach

Map<String, Account> nameToAccount = new Map<String, Account>();

for (Account acc : [SELECT Id, Name FROM Account]) {
    nameToAccount.put(acc.Name, acc);
}

SOQL Lib

SOQL Lib Approach

Map<String, Account> nameToAccount = (Map<String, Account>) SOQL.of(Account.SObjectType)
    .toMap(Account.Name);

toMap with custom relationship key

Apex

Traditional Approach

Map<String, Account> parentCreatedByEmailToAccount = new Map<String, Account>();

for (Account acc : [SELECT Id, Parent.CreatedBy.Email FROM Account]) {
    parentCreatedByEmailToAccount.put(acc.Parent.CreatedBy.Email, acc);
}

SOQL Lib

SOQL Lib Approach

Map<String, Account> parentCreatedByEmailToAccount = (Map<String, Account>) SOQL.of(Account.SObjectType)
    .toMap('Parent.CreatedBy', User.Email);

toMap with custom key and value

Apex

Traditional Approach

Map<String, String> accountNameToIndustry = new Map<String, String>();

for (Account acc : [SELECT Id, Name, Industry FROM Account]) {
    accountNameToIndustry.put(acc.Name, acc.Industry);
}

SOQL Lib

SOQL Lib Approach

Map<String, String> accountNameToIndustry = SOQL.of(Account.SObjectType)
    .toMap(Account.Name, Account.Industry);

toAggregatedMap

Apex

Traditional Approach

Map<String, List<Account>> industryToAccounts = new Map<String, List<Account>>();

for (Account acc : [SELECT Id, Name, Industry FROM Account]) {
    if (!industryToAccounts.containsKey(acc.Industry)) {
        industryToAccounts.put(acc.Industry, new List<Acccount>());
    }

    industryToAccounts.get(acc.Industry).put(acc);
}

SOQL Lib

SOQL Lib Approach

Map<String, List<Account>> industryToAccounts = (Map<String, List<Account>>) SOQL.of(Account.SObjectType)
    .toAggregatedMap(Account.Industry);

toAggregatedMap with relationship key

Apex

Traditional Approach

Map<String, List<Account>> parentCreatedByEmailToAccounts = new Map<String, List<Account>>();

for (Account acc : [SELECT Id, Name, Parent.CreatedBy.Email FROM Account]) {
    if (!parentCreatedByEmailToAccounts.containsKey(acc.Parent.CreatedBy.Email)) {
        parentCreatedByEmailToAccounts.put(acc.Parent.CreatedBy.Email, new List<Account>());
    }

    parentCreatedByEmailToAccounts.get(acc.Parent.CreatedBy.Email).put(acc);
}

SOQL Lib

SOQL Lib Approach

Map<String, List<Account>> parentCreatedByEmailToAccounts = (Map<String, List<Account>>) SOQL.of(Account.SObjectType)
    .toAggregatedMap('Parent.CreatedBy', User.Email);

toAggregatedMap with custom key and value

Apex

Traditional Approach

Map<String, List<Account>> accountNamesByIndustry = new Map<String, List<String>>();

for (Account acc : [SELECT Id, Name, Industry FROM Account]) {
    if (!accountNamesByIndustry.containsKey(acc.Industry)) {
        accountNamesByIndustry.put(acc.Industry, new List<String>());
    }

    accountNamesByIndustry.get(acc.Industry).put(acc.Name);
}

SOQL Lib

SOQL Lib Approach

Map<String, List<String>> accountNamesByIndustry = SOQL.of(Account.SObjectType)
    .toAggregatedMap(Account.Industry, Account.Name);

toIdMapBy

Apex

Traditional Approach

Map<Id, Account> ownerIdToAccount = new Map<Id, Account>();

for (Account acc : [SELECT Id, Name, OwnerId FROM Account WHERE OwnerId != null]) {
    ownerIdToAccount.put(acc.OwnerId, acc);
}

SOQL Lib

SOQL Lib Approach

Map<Id, Account> ownerIdToAccount = (Map<Id, Account>) SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .toIdMapBy(Account.OwnerId);

toIdMapBy with relationship

Apex

Traditional Approach

Map<Id, Account> parentIdToAccount = new Map<Id, Account>();

for (Account acc : [SELECT Id, Name, Parent.Id FROM Account WHERE Parent.Id != null]) {
    parentIdToAccount.put(acc.Parent.Id, acc);
}

SOQL Lib

SOQL Lib Approach

Map<Id, Account> parentIdToAccount = (Map<Id, Account>) SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .toIdMapBy('Parent', Account.Id);

toAggregatedIdMapBy

Apex

Traditional Approach

Map<Id, List<Account>> ownerIdToAccounts = new Map<Id, List<Account>>();

for (Account acc : [SELECT Id, Name, OwnerId FROM Account WHERE OwnerId != null]) {
    if (!ownerIdToAccounts.containsKey(acc.OwnerId)) {
        ownerIdToAccounts.put(acc.OwnerId, new List<Account>());
    }

    ownerIdToAccounts.get(acc.OwnerId).add(acc);
}

SOQL Lib

SOQL Lib Approach

Map<Id, List<Account>> ownerIdToAccounts = (Map<Id, List<Account>>) SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .toAggregatedIdMapBy(Account.OwnerId);

toAggregatedIdMapBy with relationship

Apex

Traditional Approach

Map<Id, List<Account>> parentIdToAccounts = new Map<Id, List<Account>>();

for (Account acc : [SELECT Id, Name, Parent.Id FROM Account WHERE Parent.Id != null]) {
    if (!parentIdToAccounts.containsKey(acc.Parent.Id)) {
        parentIdToAccounts.put(acc.Parent.Id, new List<Account>());
    }

    parentIdToAccounts.get(acc.Parent.Id).add(acc);
}

SOQL Lib

SOQL Lib Approach

Map<Id, List<Account>> parentIdToAccounts = (Map<Id, List<Account>>) SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .toAggregatedIdMapBy('Parent', Account.Id);

toQueryLocator

Apex

Traditional Approach

Database.QueryLocator queryLocator = Database.getQueryLocator('SELECT Id FROM ACCOUNT');

SOQL Lib

SOQL Lib Approach

Database.QueryLocator queryLocator = SOQL.of(Account.SObjectType)
    .with(Account.Id, Account.Name)
    .toQueryLocator();