What is the difference between WHERE and HAVING?

WHERE filters individual rows before grouping, while HAVING filters groups after aggregation. You use HAVING to keep, for example, only the groups whose COUNT(*) is greater than five, which WHERE cannot do because the aggregate is not yet computed.

How does pagination differ across databases?

MySQL, PostgreSQL and SQLite use LIMIT n OFFSET m. SQL Server uses TOP n, or OFFSET ... FETCH NEXT for paging. Oracle uses FETCH FIRST n ROWS ONLY. The cheatsheet flags these differences in the LIMIT entry.

What is an upsert and how do I write one?

An upsert inserts a row or updates it if a key already exists. PostgreSQL and SQLite use INSERT ... ON CONFLICT DO UPDATE, MySQL uses INSERT ... ON DUPLICATE KEY UPDATE, and SQL Server uses the MERGE statement.

In what order does a SELECT actually run?

Although you write SELECT first, the logical order is FROM, then WHERE, then GROUP BY, then HAVING, then SELECT, then ORDER BY, then LIMIT. This is why a column alias defined in SELECT cannot be used in WHERE but can be used in ORDER BY.

Is anything I search uploaded?

No. The reference and the search both run entirely in your browser. This tool does not connect to any database or send your input anywhere.

What is the SQL Syntax Cheatsheet?

A searchable SQL reference covering ANSI syntax plus MySQL, PostgreSQL, SQLite and SQL Server variations, with the syntax pattern, a description and dialect notes for queries, joins, DML, DDL and window functions. It runs free in your browser on Gera Tools, with nothing uploaded.

SQL Syntax Cheatsheet

Name: SQL Syntax Cheatsheet
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click unsubscribe any time.

This is a searchable SQL syntax cheatsheet covering the keywords, clauses and functions you use every day. Each entry gives the syntax pattern, a one-line description, and — where the dialects diverge — notes for MySQL, PostgreSQL, SQLite and SQL Server, so you can write portable queries or adapt one to a specific engine.

How it works

SQL is largely standardised by ANSI, but every database adds its own spellings for common tasks. The reference is grouped so you can browse by area: Query (SELECT, DISTINCT, CTEs), Clause (WHERE, GROUP BY, HAVING, ORDER BY, LIMIT), Join types, DML (INSERT, UPDATE, DELETE, upsert), DDL (CREATE, ALTER, DROP, indexes), aggregate and scalar functions, window functions and transactions. Search matches the keyword, the syntax and the dialect notes, so a query for “pagination” or “auto increment” surfaces the right entries even if you do not remember the exact keyword.

Logical execution order — the most useful thing in SQL

The single most useful thing to internalise is the order in which SQL logically executes a SELECT:

FROM → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → LIMIT

This order explains several common confusions:

A column alias defined in SELECT cannot be used in WHERE (SELECT hasn’t run yet), but can be used in ORDER BY (which runs after).
WHERE filters individual rows before grouping; HAVING filters groups after aggregation. You cannot put an aggregate like COUNT(*) inside a WHERE clause.
DISTINCT runs after SELECT builds the output column list but before ORDER BY.

Key dialect differences at a glance

Feature	MySQL	PostgreSQL	SQLite	SQL Server
Auto-increment	`AUTO_INCREMENT`	`SERIAL` / `GENERATED`	`AUTOINCREMENT`	`IDENTITY`
Upsert	`INSERT ... ON DUPLICATE KEY UPDATE`	`INSERT ... ON CONFLICT DO UPDATE`	`INSERT OR REPLACE`	`MERGE`
Pagination	`LIMIT n OFFSET m`	`LIMIT n OFFSET m`	`LIMIT n OFFSET m`	`OFFSET n ROWS FETCH NEXT m ROWS ONLY`
Full outer join	Not supported	Supported	Not supported	Supported
String concat	`CONCAT(a, b)`	`a \|\| b`	`a \|\| b`	`a + b`
Current timestamp	`NOW()`	`NOW()`	`datetime('now')`	`GETDATE()`

Tips and gotchas

Watch the dialect notes for the big traps: FULL OUTER JOIN is missing in MySQL and SQLite, auto-increment is spelled four different ways, and upsert syntax differs by engine.

Common mistakes:

Using a SELECT alias in WHERE instead of HAVING or a subquery.
Forgetting that NULL != NULL — use IS NULL and IS NOT NULL, not = NULL.
LIKE with a leading wildcard (LIKE '%term') cannot use an index and causes a full scan.
Mixing implicit and explicit joins in the same query — always use explicit JOIN ... ON.

Everything runs in your browser; this tool never connects to a database or uploads your input.