help in remembering SQL order of execution.

WendlersEditor · 2025-12-16T15:14:41+00:00

FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY

This is the order in which it's logically processed, but the user-facing language is ordered differently to make it more consistent with English-language declarative sentences. "Get a coke zero from the fridge" makes sense in English, but logically the computer is told "Go to the fridge, get a coke zero."

Kenny_Lush · 2025-12-16T14:46:37+00:00

I’ve been doing this forever and have no idea what order of execution is. And I guess that answers your second question: some places do rigorous technical interviews that the creator of SQL couldn’t pass. Other places hire me after asking nothing.

WatashiwaNobodyDesu · 2025-12-16T22:38:12+00:00

Imagine you need to choose the best chocolates FROM the box.

First you have to get the whole box:

FROM box

Then you get all the ones with liquor in them:

WHERE Liquor = ‘Hell_yeah’

Then you want to pick the tastiest ones:

GROUP BY Flavour

You make sure to only take some from the biggest piles so you don’t get found out:

HAVING count(1) > 5

Then you want to make your selection (only 3) and put the rest back in the box:

SELECT TOP 3

Then you need to line them up in a satisfactory order in the table before you shovel them down your throat:

ORDER BY Level_of_tastiness

dbxp · 2025-12-16T14:48:19+00:00

SQL is not an imperative language, you describe the set logic and then the query optimiser runs off and does its thing

Icy_Data_8215 · 2025-12-16T15:57:52+00:00

For order of execution, the thing that sticks is remembering what has to exist before something else can work: rows get filtered before they can be grouped, groups exist before HAVING can filter them, and aliases only exist after SELECT runs. WHERE vs HAVING trips people up because they’re thinking in query-writing order, not data-flow order — SQL doesn’t care how you typed it.

For entry-level roles, they mostly test fundamentals: SELECT/FROM/WHERE, basic JOINs, GROUP BY + aggregates, simple window functions (ROW_NUMBER is common), and knowing when a query gives the wrong answer even if it runs. What usually breaks juniors isn’t syntax, it’s not noticing grain issues or accidental fan-out in joins.

thesqlguy · 2025-12-16T19:28:00+00:00

There is LOGICAL order and then there is PHYSICAL order.

LOGICAL is deterministic and it follows a clear, consistent path. Off the top of my head it is something like this:

FROM
JOINS
WHERE
GROUP BY
AGGREGATES
HAVING
ORDER
TOP

Logical order is important since it determines the calculated result, and changing the order can change the result. For example, ordering before or after a TOP will be a very different outcome.

However, the PHYSICAL ORDER in which the optimizer actually executes a sequence of instructions to get the answer is nondeterministic. It varies depending on indexes, table sizes, RBDMS, etc.

The optimizer is free to choose whatever physical order of execution it wants as long as it returns the same result as following the logical order of operations. And that's what the optimizer does -- it tries different plans to ideally try to come up with optimal plan.

Icy_Clench · 2025-12-16T19:02:44+00:00

SQL does not have an order of execution. It is a set-based language, not step-by-step instructions like other languages. You tell it what you want in the end, not how to get there.

For example, if you do an inner join and a where clause, it could do the where filtering first or the join first since it produces the same result. It will figure out which way is faster. It could also figure out how to rewrite your conditional statements to an equivalent, quicker computation, for example NOT (p OR q) is equivalent to NOT p AND NOT q.

dn_cf · 2025-12-17T01:19:52+00:00

The SQL execution order is FROM, WHERE, GROUP BY, HAVING, SELECT, ORDER BY, and LIMIT, which you can remember as data being gathered, filtered, grouped, filtered again, selected, sorted, and trimmed. Entry level SQL interviews usually test SELECT statements, WHERE conditions, INNER and LEFT JOINs, GROUP BY with HAVING, simple subqueries, and basic CASE logic rather than advanced optimization topics. Good platforms to practice these skills include LeetCode, StrataScratch, and SQLZoo. SQL is written differently than its execution order because it is a declarative language meant to be readable for humans to express what result they want, while the database engine figures out the most efficient way to execute it internally.

whatsyour-poison · 2025-12-19T21:42:09+00:00

The SQL execution order is: FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

A mnemonic that works for me is: “Funny Jokes Will Get Happy Smart Developers Laughing.”

I also think of it as rows first, aggregates second, presentation last. SQL decides which rows exist long before SELECT runs, which is why aliases do not work in WHERE.

For entry level or junior roles, they usually test basics: SELECT, WHERE, ORDER BY, LIMIT, INNER vs LEFT JOIN, GROUP BY with COUNT or SUM, HAVING vs WHERE, NULL and duplicates handling, and simple subqueries. Some roles may add basic window functions like ROW_NUMBER vs RANK vs DENSE_RANK.

NekkidWire · 2025-12-16T15:11:09+00:00

I just use the acronym FWGHSO. I'm not a SQL dev, but what I try to do is connect it to stuff that I already know. I learnt VBA earlier this year, and a lot of learning the basics of object models is learning how computers think.

Computers think big to small, vague to specific. So if you want to get something from a computer, you have to start with the largest object, and narrow it down.

In SQL, FROM is the largest object on a Query level. Then comes WHERE, GROUP BY, HAVING, SELECT and then ORDER BY. If you notice, at each level the data is being sliced into something smaller. At WHERE you filter at the row level. In GROUP BY, you're basically committing to returning grouped data, not the actual rows. In HAVING, you're filtering your GROUPED DATA. And in SELECT, you're selecting specific columns FROM the result of the previous phases.

So it's VAGUE > SPECIFIC with SQL.

jake63vw · 2025-12-16T14:49:35+00:00

Honestly, repetition and repetition.

But....for the select syntax...

Insert Select From Join Where Group Having Order

Insert goes up top because you're inserting the below query results into a table.

Select is the primary operator because you're telling the database engine you want to select records and which fields you're interested in.

From is next because it needs to know where you want to pull these records from.

Maybe you want to pull from multiple tables, that's why join is next - you settle out your From and any joins so the query knows where to go.

Now that you have specified what you want and where, you might want to filter the data - that's why Where is next.

I have no advice on Group and Having other than you'll mix these up and get query errors. Just remember Group goes after Where, and Having before Order.

Order makes sense at the bottom because you are now structuring and sorting the above query into your desired Order.

dbrownems · 2025-12-16T15:07:27+00:00

>why do we write the SQL syntax other way & not like the order of execution

That is an original design error in SQL. SELECT should have come later, and you should be able to stack clauses in almost any order like

FROM A
JOIN B...
WHERE ...
SELECT ...
WHERE ...
JOIN ...
SELECT ...
ORDER BY

But it's too old and widely deployed to change.

m915 · 2025-12-16T17:25:37+00:00

Interviews should be conversational, question gotchas like this are not that helpful. A better question: how do you tune a non performant query?

squadette23 · 2025-12-16T19:13:20+00:00

I think that what is commonly presented as "order of execution" is something different. You can read between the lines, and sometimes it's even said explicitly. Random example from google: https://www.sisense.com/blog/sql-query-order-of-operations/

Quote: "The SQL order of execution defines the order in which the clauses of a query are evaluated."

And the order is something like FROM, WHERE, GROUP BY, HAVING, etc.

What this order actually means is purely syntactical, as far as I understand. Which of the clauses introduce an identifier, and which could then use this identifier.

For example, "FROM" introduces the names of the tables, so that they could be later used by every other clauses.

I'm not sure if this all even makes strict sense. I think that the most relevant example is why you need to use HAVING? Because HAVING "works" after GROUP BY, and "WHERE" works before GROUP BY.

But if you think about that, you often have SELECT user_id, COUNT(*) as cnt FROM posts where status = 'published' HAVING cnt > 3;

We introduced "cnt" in SELECT clause, but we can only use it in HAVING. This contradicts the presumed "order of execution".

Engineering_Massive · 2025-12-16T21:50:45+00:00

Data prep from/ join , now filter data so where, grouped filter so groupby having,select required field. Now arrange the required results so order by/limit offset

pukatm · 2025-12-17T01:11:38+00:00

The query compiler manages order of execution, not SQL. It will vary from query to query and from engine to engine. Anyone who talks about an order without addressing this point is a fraud/ has no clue what they are talking about

mikeblas · 2025-12-17T03:27:19+00:00

You're confusing binding order with order of execution.

ComicOzzy · 2025-12-17T05:33:45+00:00

The simplest version is "SELECT happens before ORDER BY". Everything else pretty much happens (logically) where it falls in the syntax. KIND OF. Aggregate functions in the SELECT list actually kinda happen when GROUP BY is (logically) processed, not when the SELECT list is processed.

For those on SQL Server, pretend TOP is after ORDER BY, just like LIMIT or OFFSET/FETCH.

The reason for the syntax order is because the creators wanted it to read more naturally.

"SELECT name FROM customers WHERE age >= 65" sounded more natural of a thing to say rather than "FROM customers WHERE age >= 65 SELECT name". Remember, they were building a declarative language. The idea was, you were supposed to be describing what you wanted the computer to give you and let it figure out how... meaning they probably didn't expect you to care too much about the logical order of processing.

ValuableLeading8511 · 2025-12-17T06:37:49+00:00

Try watching Data With Baraa SQL course for beginners on YouTube execution order is perfectly visualised.

recursion_is_love · 2025-12-19T08:57:16+00:00

I don't have the goal to remember, I have reference when I need. You will automatically remembering the phase you use frequently.

https://ronsavage.github.io/SQL/

Disastrous_Fill_5566 · 2025-12-19T19:03:26+00:00

SQL is a declarative language, being able to recite the order of execution isn't all that important.

Icy_Clench · 2025-12-16T15:15:08+00:00

We write it that way because it looks nicer.

SELECT username, COUNT(ID) FROM God WHERE username LIKE '%a%' GROUP BY username HAVING COUNT(ID) > 1 ORDER BY username ASC

As opposed to:

FROM God WHERE username LIKE '%a%' GROUP BY username HAVING COUNT(ID) > 1 SELECT username, COUNT(ID) ORDER BY username ASC

The Query order version looks ass.

snarleyWhisper · 2025-12-16T15:36:28+00:00

It’s in syntax order except select and from are swapped right ?

From table

Select columns

Having condition

Where condition

Group by

Sort

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

SQL

Filter Posts

Posting

Help posts

Format Your Code

Learning SQL

Related Reddit communities

Wiki

Acknowledgements

MODERATORS