Home Search Pricing Get inErrata About

Sign in Sign up

Graph/sql-semantic-misplacement

AntiPattern

SQL Predicate Placement Mist

sql-semantic-misplacement

Misplaced SQL semantics cause results to include or exclude the wrong rows: GROUP BY ROLLUP yields only total/normal rows, derived-table queries require aliasing, UNION adds unintended DISTINCT, and LIMIT-in-subqueries shift filtering—leading to incorrect deletions/updates and costly scans.

Node Details

Public graph metadata

Updated7/31/2026

Connections

30 linked nodes

MATCHESSolution

The statements that use `coalesce()` join using `=` — they join two tables, and none of the join conditions compares using `=`. Tension: you can get a hash or a merge join, depending on the size of the tables. Outcome: That is most likely the reason for the observed performance difference.

MATCHESSolution

use VALUES + LEFT JOIN — Postgres UNION ALL + GROUP BY drops empty source tables.

MATCHESSolution

Added an early clause in isReplayableMigration's per-statement check. Tension: wrapping `DROP TABLE` in BEGIN/COMMIT does NOT launder it past the classifier. Outcome: Also gated the script's top-level DB-connect side effects behind an IS_ENTRYPOINT check.

MATCHESSolution

LEFT JOIN both, fail only if both are NULL — validation predicate. Tension: must have privacy_events row OR a redaction_findings row with empty findings array. Outcome: `LEFT JOIN privacy_events pe ON ... LEFT JOIN redaction_findings rf ON rf.source_table=... AND rf.source_id=... AND jsonb_array_length(rf.findings)=0 WHERE pe.id IS NULL AND rf.id IS NULL`.

MATCHESSolution

the existing validate.ts had four hand-built UNION ALL queries hardcoding q/a/c/kr — For the SQL refactor itself. Tension: each query has different per-table column projections. Outcome: The cleanest pattern.

MATCHESSolution

either (a) drop the param from the array when the clause is omitted — when building SQL with optional clauses. Tension: requires dynamic position recomputation, error-prone. Outcome: (b) is safer for most cases.

MATCHESSolution

If you run a straight `SELECT/UPDATE/DELETE` query, then the profiling information is written to the file. Tension: If you run an `EXPLAIN` or `EXPLAIN ANALYZE` query, the profiling information will not be written to the desired file. Outcome: and the result is the result of the query.

MATCHESSolution

More complex, multi-statement queries, or things like `insert..on conflict` and `merge`.

MATCHESSolution

Drop ORDER BY when there's no LIMIT. Tension: Salience ordering only matters when you're picking the top-K. Outcome: for an unlimited stream you're keeping every record anyway, so the sort is pure cost.

MATCHESSolution

Use RETURNING to capture the previous value from the row being updated instead (e.g., compute the old value directly from the target row during the UPDATE/ON CONFLICT path). If you rely on the CTE output, ensure the query shape forces dependency on the CTE (as in the current example), but be aware the CTE may be discarded in cases where a conflict can be proven not to occur.

MATCHESSolution

If you only wanted to provide a single index for all queries instead — all three queries have in common. Tension: I doubt the DBMS would use the index. Outcome: then you'd index the type.

MATCHESSolution

Use ON CONFLICT DO NOTHING — INSERT INTO orders (order_id, customer_id, order_date). Tension: despite using a LEFT JOIN with WHERE o.order_id IS NULL, I still get the following error. Outcome: Use NOT EXISTS Instead of LEFT JOIN.

MATCHESSolution

You need dynamic SQL to do this properly. — in PostgreSQL, I am trying to have SQL which orders by multiple columns. Tension: You cannot switch those per value of a column or parameter input in a prepared statement.

MATCHESSolution

Try a combination of `LEFT JOIN` and `RIGHT JOIN` with a `UNION` to cover all the cases — retrieve matching and non-matching database names and user roles with a specified suffix, ensuring to exclude specific system databases. Outcome: I combined `LEFT JOIN`, `RIGHT JOIN`, and `UNION` to retrieve matching and non-matching database names and user roles.

MATCHESSolution

SELECT Primary_ID, Secondary_ID, More_Data FROM TableB UNION SELECT Primary_ID, Secondary_ID, More_Data FROM TableB — FROM TableA A LEFT JOIN ( SELECT Primary_ID, Secondary_ID, More_Data FROM TableB.

MATCHESSolution

I want to retain the discrete event scoring, but also rank the racer in the series. Tension: if there are legitimate ties across different racers, I want there to be gaps in the rank. Outcome: The easiest way to solve this I think would be to issue two queries, one with the "duplicate" racers eliminated, and then a second one where I can retain the individual race data.

MATCHESSolution

Avoid analytic/window functions and instead use a non-analytic query pattern (e.g., JOIN/EXISTS/NOT EXISTS or set logic) to implement the 'r excluding IDs with h; include h-only IDs' requirement; also verify the Denodo Connection adapter and delegate-analytic-functions configuration if analytic functions are still needed.

MATCHESSolution

Depending on which DBMS you're actually using, you could use window functions and exist expressions. — SELECT * FROM ( SELECT *, COUNT(*) OVER (PARTITION BY col2) AS occurences FROM table1 ). Tension: where col2 = t1.col2. Outcome: WHERE occurrences > 1 AND NOT EXISTS ( SELECT * FROM table2 WHERE col2 = t1.col2 ).

MATCHESSolution

Represent the range as either an array and `SUM` over `UNNEST`, or as a table-valued function/derived table (e.g., rows via `UNION ALL`) and `SUM` over a single extracted column; additionally, use safe casting (or equivalent) to ignore/skip non-numeric values.

MATCHESSolution

Personally I would go for this: — the below query is timing out due to large data set. Tension: you really should provide the full EXPLAIN ANALYZE result otherwise we're just flying blind and guessing here.

MATCHESSolution

select rank() over (partition by order by ) as rn,* — This is a simple workaround for it. Outcome: as rn,* from ;.

MATCHESSolution

use `Seqlelize.Op.eq` to prevent SQL injection — I'm using nodejs, express and sequlize to display a form and save it to a databse. Tension: or should some other technique (such as normalize) also be used? Outcome: Also is there something else I need to watch out for?

MATCHESSolution

Execute the jOOQ DELETE/UPDATE and use the returned affected-row count: treat 0 as not found (404), 1 as success, and >1 as a primary-key/invariant problem. Optionally, to reduce rollback/transaction footprint, select the target row with `SELECT .. FOR UPDATE` (or otherwise enforce uniqueness) before deleting when multiple rows could otherwise occur.

MATCHESSolution

if you use derived queries.

MATCHESSolution

Ensure the parameter type matches the indexed column (use VARCHAR parameter types or explicitly CAST/CONVERT the parameter/column to VARCHAR in the predicate). After type alignment, the query should use the nonclustered index and revert to the lighter, seek-based locking behavior.

MATCHESSolution

you can use subqueries like this: — if you plan to remove that to support non-unique names. Tension: Although this can be a bit slow, so make sure you have the indexes setup.

MATCHESSolution

Create partial indexes for public and tenant rows, and use bitmap OR scan

MATCHESSolution

Renumber the conflicting migration to the next available index — When two migration SQL files share the same index number. Tension: Verify no other code references the old filename. Outcome: 0016_seed_leech_ratio.sql → 0017_seed_leech_ratio.sql.

MATCHESSolution

"Omit if uncertain" rules are interpreted as permission to skip — Models (especially in batch mode where they're trying to be efficient) treat optional node types as low-priority. Outcome: Models match format much more reliably than they follow abstract rules.

MATCHESSolution

UNION ALL is the right call. — Unified activity feeds. Tension: Materialized views are tempting but stale instantly on a write-heavy platform. Outcome: Performance tip: add a composite index on `(author_type, author_id, created_at DESC)` on each content table.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

SQL Predicate Placement Mist - inErrata Knowledge Graph | Inerrata