Sf Soql Constraints

SOQL Constraints

When to Use

This skill auto-activates when writing, reviewing, or optimizing any SOQL query, SOSL search, or Apex database operation. It enforces query safety rules, selectivity requirements, and governor limit compliance for all database operations.

Hard rules for every SOQL query, SOSL search, and Apex database operation. Violations cause governor limit failures, security vulnerabilities, or production outages. See @../reference/SOQLPATTERNS.md for selectivity thresholds and @../reference/GOVERNORLIMITS.md for per-transaction budgets.

Never Rules

1. Never place SOQL or SOSL inside a loop. Every iteration consumes one

of the per-transaction SOQL query budget (see @../reference/GOVERNORLIMITS.md). Query once before the loop, store results in a Map, then iterate.

1. Never write a non-selective query on objects with >200,000 rows. The

query optimizer will full-table-scan and the query fails in trigger context. Every WHERE clause must target an indexed field below the selectivity threshold (see @../reference/SOQLPATTERNS.md, Selectivity Thresholds table).

1. **Never use FIELDS(ALL) or FIELDS(CUSTOM) in triggers, service classes,

or production paths.** Select only the fields the calling code actually reads. FIELDS() directives are for exploration and debugging only.

1. Never hardcode Salesforce record IDs. IDs differ between orgs and

sandboxes. Use Schema.SObjectType, Custom Metadata, or Custom Labels to resolve IDs at runtime.

1. Never omit LIMIT on unbounded queries. Any query that could return an

unknown number of rows must include a LIMIT clause to stay within the per-transaction row limit (see @../reference/GOVERNORLIMITS.md).

1. Never concatenate user input into dynamic SOQL strings. This creates

SOQL injection vulnerabilities. Use bind variables (:variable) for inline SOQL or Database.queryWithBinds() for dynamic SOQL.

1. Never use a leading wildcard in LIKE filters (LIKE '%term%').

Leading wildcards prevent index use and cause full table scans. Use SOSL (FIND) for full-text search instead.

1. Never use != or NOT IN as the sole WHERE filter. These operators

are non-optimizable and always produce table scans (see @../reference/SOQLPATTERNS.md, Optimizable vs Non-Optimizable Operators).

1. Never omit security enforcement on user-facing queries. Queries

triggered by user actions (LWC, Aura, VF, REST endpoints) must include WITH USER_MODE or equivalent FLS/CRUD enforcement.

1. Never load all records just to count them. Use SELECT COUNT() FROM

or aggregate queries instead of querying records and calling .size().

Always Rules

1. Always bulkify database operations. Collect IDs in a Set, query

once with WHERE Id IN :idSet, and store results in a Map.

1. Always use bind variables (:variable) in inline SOQL. For dynamic

SOQL, always use Database.queryWithBinds() with a bind map.

1. Always use WITH USER_MODE (see @../reference/APIVERSIONS.md for minimum version) on queries executed in

user-facing contexts (LWC controllers, Aura controllers, VF controllers, REST resources). Use WITH SYSTEM_MODE only for documented system processes (batch jobs, integrations) with explicit justification.

1. Always filter on indexed fields. Prefer Id, Name, OwnerId,

RecordTypeId, CreatedDate, SystemModstamp, lookup/master-detail fields, or External ID fields. See @../reference/SOQLPATTERNS.md, Standard Indexed Fields table for the full list.

1. Always add LIMIT when only one record is expected (LIMIT 1) or

when displaying a bounded list.

1. Always use relationship queries (parent-to-child subqueries or

child-to-parent dot notation) instead of separate queries when fetching related data. Subqueries do not count as separate SOQL queries.

1. Always use SOSL instead of LIKE for text search across objects.

SOSL uses the search index and is far more efficient than LIKE on large-volume objects.

1. Always validate object and field names via Schema.getGlobalDescribe()

before building dynamic SOQL. Never trust external input for object or field names.

1. Always test triggers and services with 200 records (the standard

trigger batch size) to validate bulk safety against governor limits.

Anti-Pattern Table

| Problem | Correct Pattern | |---|---| | SOQL inside for loop | Query before loop, store in Map | | SELECT FIELDS(ALL) FROM Account in service class | SELECT Id, Name FROM Account -- explicit fields only | | WHERE Description LIKE '%keyword%' | FIND 'keyword' IN ALL FIELDS RETURNING Account(Id, Name) (SOSL) | | WHERE Custom_Field__c = 'value' on non-indexed field (LDV) | Add indexed field to WHERE, or request custom index | | String query = '...WHERE Name = \'' + input + '\'' | [SELECT Id FROM Account WHERE Name = :input] or Database.queryWithBinds() | | List all = [SELECT Id FROM Account]; Integer c = all.size(); | Integer c = [SELECT COUNT() FROM Account]; | | Hardcoded WHERE Id = '001xx000003DGXXX' | WHERE Id = :accountId with runtime-resolved variable | | No WITH USER_MODE on LWC controller query | Add WITH USER_MODE to enforce FLS + sharing | | Separate queries for parent and child records | Use subquery: SELECT Id, (SELECT Id FROM Contacts) FROM Account | | WHERE Status__c != 'Closed' as only filter | Add a selective indexed filter: WHERE RecordTypeId = :rtId AND Status__c != 'Closed' |

Limit Budgets (Quick Reference)

Do not memorize raw numbers -- always check @../reference/GOVERNORLIMITS.md for the authoritative table. Key constraint categories that shape every query decision:

• SOQL query limit per synchronous/asynchronous transaction (see @../reference/GOVERNORLIMITS.md)
• Total rows returned per transaction (see @../reference/GOVERNORLIMITS.md)
• Heap size synchronous/asynchronous (see @../reference/GOVERNORLIMITS.md)
• CPU time synchronous/asynchronous (see @../reference/GOVERNORLIMITS.md)

Use Limits.getQueries() / Limits.getLimitQueries() to check remaining budget at runtime before issuing additional queries.

Related

• sf-soql-optimization -- Action skill for interactive query optimization,

index strategy guidance, and Query Plan Tool usage.

• sf-apex-constraints -- Apex-level constraint rules (bulkification, DML

patterns, CPU/heap management).

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: jiten-singh-shahi
• Source: jiten-singh-shahi/salesforce-claude-code
• License: MIT
• Homepage: https://www.npmjs.com/package/scc-universal

Install and usage instructions live in the source repository linked above.