Why Subqueries Are Better in This Case:

• No Duplicates: Subqueries ensure that each matching parent (Account) appears only once, even if multiple child records (Deals) match. This is perfect for deduplicated reporting or dropdown lists.
• Cleaner Result: Easier to parse and use directly in UIs or aggregations where duplicates are not useful.
• Lower Payload Size: Especially useful if you just want the Account info and don’t need Deal-level detail.

Combine JOINs and Subqueries for Smarter Filtering

• Associated with Active Campaigns
• Linked to Accounts in high-revenue Industries (Annual Revenue > 10,000,000)
• You need to fetch details from the related modules—like Account name, Campaign name, and Contact email—in the same query
  

• JOINs allow you to retrieve fields from related modules (like Contact_Name.Email )—but they do not let you dynamically filter using fields from those modules.
  
• Subqueries, on the other hand, allow you to filter based on fields from related modules (like filtering Deals based on the Annual Revenue of the associated Account)—but you can’t fetch fields from multiple related modules using just a subquery.
  

• Uses JOINs to fetch:
• Contact_Name.Email – from Contacts
• Uses a subquery to apply dynamic filtering on Deals based on the Industry of Accounts with Annual Revenue > 10000000. COQL subqueries return a maximum of 100 records. If multiple accounts satisfying the criteria share the same industry, using GROUP BY Industry ensures only unique industry values are returned. This helps stay within the 100-record limit and avoids redundant filtering.

Advanced Filtering: Nested Subqueries

For more advanced use cases, you can nest subqueries within subqueries to create complex filtering conditions.

Let's say Imagine you need to identify all Contacts associated with Accounts that meet two specific criteria:

• The Account is in the "Retail" industry.
• The Account has at least one associated Deal that is in the "Closed Won" stage and has a value greater than $50,000.

This scenario is common in sales and marketing, where you want to target high-potential customers within a specific industry. Here's how you can achieve this using a nested subquery in COQL:

{

  "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in (SELECT id FROM Accounts WHERE Industry = 'Communications' AND id in (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won' AND Amount > 50000))"

}

Innermost Subquery: (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won' AND Amount > 50000)

This subquery identifies all Account_Name values from the Deals module where the Stage is "Closed Won" and the Amount is greater than $50,000. Although the field name is Account_Name, it's a lookup to the Accounts module, so it returns the Account ID. This effectively isolates Accounts that have closed high-value deals.

Middle Subquery: (SELECT id FROM Accounts WHERE Industry = 'Retail' AND id IN (...))

This filters Accounts by the "Retail" industry and ensures that only those whose ID appears in the innermost subquery are selected.

Main Query: SELECT Full_Name, Email FROM Contacts WHERE Account_Name IN (...)

Finally, the main query retrieves the Full_Name and Email of all Contacts whose Account_Name matches the id values returned by the middle subquery.

Note: COQL supports a maximum subquery nesting depth of 5, and you can include up to 5 subqueries total within a single query. The nesting limit refers to subqueries embedded within the WHERE clause of another subquery. 

Subqueries in COQL are a game-changer for developers looking to build efficient, context-aware queries across modules—allowing dynamic filtering that was previously only possible with multiple API calls. While JOINs help you fetch rich, multi-module data in a single response, subqueries let you filter records based on conditions from related modules. And when you combine the two, you unlock a powerful mechanism to tackle real-world CRM business cases with precision and clarity.

For advanced use cases, don’t hesitate to nest subqueries—COQL allows up to five levels deep—giving you the flexibility to build truly nuanced filters. Mastering the balance between JOINs and subqueries is key to writing smarter, cleaner, and more performant queries.

We hope you found this guide useful in understanding and implementing COQL subqueries. If you have any questions or require further clarification, please don't hesitate to leave a comment below or reach out to us directly at support@zohocrm.com. 

Keep experimenting, and as always, happy querying!

      Previous Kaizen: Kaizen #184: Using Widgets in ZET CLI and ZDK CLI  |  Kaizen Directory