SELECT without LIMIT: why unbounded queries hurt and how to page

VERICTO-050 Medium In CI (offline CLI): FLAGGED

SELECT id, email FROM users WHERE active; returns every active user, today and when the table is a hundred times bigger. Nothing is lost, but the database, the network and the client all have to handle the whole result: an API runs out of memory, a report times out, an AI agent gets a result far larger than it can use. Add a LIMIT and page through the rest.

Why it happens

Queries are written against small development data, where every result is short. In production the same query returns whatever the table holds. Generated SQL (ORMs, text-to-SQL, agents) often leaves the bound out unless asked to add it.

How to fix it

Bound every query a client sees, and page with a key rather than a growing OFFSET:

SELECT id, email FROM users
WHERE active AND id > $1
ORDER BY id
LIMIT 100;

SQL Server uses TOP, and the SQL standard form is FETCH FIRST 100 ROWS ONLY. Set a statement timeout as well, so a query that still scans too much is stopped.

How to stop it from happening again

VERICTO-050 · SELECT without LIMIT · Severity: Medium · AST node: SelectStmt > LimitCount = NULL

The statement the rule reports

-- report.sql
SELECT id, email FROM users WHERE active;

Real CLI output

$ npx @vericto/vericto-cli@2.3.0 check --offline report.sql
note: offline mode: 42 standard rules at default severities, engine 5.1.0. Custom rules, overrides, sensitive columns, allowlists and the audit trail apply online only.
! report.sql  FLAGGED  VERICTO-050 medium
    SelectStmt > LimitCount = NULL
    fix: SELECT ... WHERE <condition> LIMIT 1000
0 blocked · 0 allowed · 1 flagged · 0 monitored   (ruleset standard@engine-5.1.0 · mode: offline (engine 5.1.0, 42 standard rules, no workspace policy))

The CLI marks it FLAGGED and exits with 0: it is reported without stopping the job. With --fail-on flag (or fail_on = "flag" in .vericto.toml) it exits with 1 and the job fails.

The corrected version

-- report.sql
SELECT id, email FROM users WHERE active LIMIT 100;
$ npx @vericto/vericto-cli@2.3.0 check --offline report.sql
note: offline mode: 42 standard rules at default severities, engine 5.1.0. Custom rules, overrides, sensitive columns, allowlists and the audit trail apply online only.
0 blocked · 1 allowed · 0 flagged · 0 monitored   (ruleset standard@engine-5.1.0 · mode: offline (engine 5.1.0, 42 standard rules, no workspace policy))

Try it free, no account

The CLI checks your .sql files on your machine with the 42 standard rules: no sign-up, no API key, and no SQL leaves your computer. It is open source (AGPL-3.0-only).

npx @vericto/vericto-cli@2.3.0 check --offline migrations/

On every pull request

The vericto/check-sql GitHub Action (Apache-2.0) runs the same offline check on the .sql files a PR changes and annotates the findings on the PR. Save it as .github/workflows/vericto.yml:

on: pull_request
jobs:
  vericto:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with: { fetch-depth: 0 }
      - uses: vericto/check-sql@v1
        with: { offline: true, upload-sarif: false }

At runtime, for AI agents

The SQL an AI agent writes never goes through a PR. The Vericto TCP proxy checks each statement between the application or agent and the database, and the MCP check_sql tool lets the agent check SQL before it runs it. Both use the runtime profile, which also blocks schema changes.

The AST condition in the engine

The rule is a deterministic predicate over the AST, in src/rules/evaluator.rs of the open source engine (AGPL-3.0-only), at this page's commit:

"VERICTO-050" => find(stmts, |s| {
    s.kind == StatementKind::Select && !s.is_nested && !s.select_has_limit
})
.map(|s| {
    let mut v = violation(
        rule,
        s,
        Some("SELECT ... WHERE <condition> LIMIT 1000".to_string()),
    );
    v.ast_node_path = "SelectStmt > LimitCount = NULL".to_string();
    v
}),

Frequently asked questions