How is HAVING different from WHERE when filtering grouped results?

Put the transaction-level condition in WHERE and the group-total condition in HAVING. In this example, WHERE amount > 0 removes any row with a zero or negative amount before it contributes to a salesperson’s total. Then GROUP BY forms one group per salesperson, and HAVING SUM(amount) >= 100 keeps only groups whose calculated total meets the threshold. [S1]

A simple SELECT applies WHERE before grouping and HAVING after groups are formed. [S1] The short version is: WHERE asks, “Does this row qualify?” HAVING asks, “Does this group qualify?”

Assume these invented sales rows; the names and amounts are just an example:

• Ana: 40
• Ana: -10
• Ana: 80
• Bo: 60
• Bo: 50
• Cy: -20
• Cy: 150

With WHERE amount > 0, Ana’s -10 and Cy’s -20 are excluded before totals are formed. The remaining totals are Ana 120, Bo 110, and Cy 150. Applying HAVING SUM(amount) >= 115 leaves Ana and Cy; Bo’s 110 does not meet the threshold.

Here is the paired query:

SELECT salesperson, SUM(amount) AS total_amount
FROM sales
WHERE amount > 0
GROUP BY salesperson
HAVING SUM(amount) >= 115;

The result is Ana — 120 and Cy — 150. The WHERE condition changes which transactions contribute to each total; the HAVING condition decides which completed totals appear. This follows the described SQLite SELECT behavior. [S1]

If you remove WHERE but leave HAVING SUM(amount) >= 115, the negative rows still contribute to their groups: Ana totals 110, Bo 110, and Cy 130. Only Cy then meets 115. That is a different calculation, not merely a different way to express the same filter.

A condition such as amount > 0 describes individual transaction rows, so it belongs in WHERE when you want to exclude those rows before totals are calculated. HAVING is for a condition evaluated on each completed group, commonly using an aggregate such as SUM. [S1] Avoid moving a row-level test to HAVING when doing so would change which records contribute to the aggregate.

Use this shape, replacing the bracketed names and conditions with yours:

SELECT [group_column], [aggregate_function]([value_column]) AS [summary]
FROM [table_name]
WHERE [row_condition]
GROUP BY [group_column]
HAVING [aggregate_function]([value_column]) [comparison] [threshold];

For the sales example, the row condition is amount > 0, the grouping column is salesperson, and the group condition is SUM(amount) >= 115. Check each condition by asking what it refers to: one source row, or a group summary? Then hand-calculate one small group to confirm which rows contribute and whether its final total passes HAVING.

The example demonstrates SQLite’s stated SELECT semantics; it does not establish behavior for every database system or every query feature. If you use another database, check its documentation for details specific to your query. [S1]