The execution order of SQL queries is not carried out in the writing order, but follows a specific stage process. First, the database obtains the data source from the FROM and JOIN operations; second, filters rows through the WHERE clause; then, grouping data using GROUP BY; then, HAVING filters the matching groupings; then, SELECT specifies the returned fields; finally, ORDER BY sorts the results. For example: 1. FROM/JOINs determine the table involved and pull the data; 2. WHERE filter the matching rows; 3. GROUP BY is organized into groups by columns; 4. HAVING filters the aggregated grouping; 5. SELECT selects the output field and defines the alias; 6. ORDER BY sorts the results according to the specified columns. Mastering this order helps to write efficient queries.

When a SQL query runs, it doesn't execute in the same order you write it. Knowing the real execution order helps you write better queries and avoid mistakes.

Here's how it works:

1. FROM / JOINs – Where the data comes from

Before anything else, the database needs to know which tables are involved. That means FROM and any JOIN operations run first. This step pulls in the raw data that the rest of the query will work with.

For example:

 SELECT name, order_total
FROM customers
JOIN orders ON customers.id = orders.customer_id;

In this case, the database starts by joining the customers and orders tables. If you're using multiple joins, they're usually processed in the order they appear, though some databases might optimize that differently.

Tip:

• Make sure your joins are efficient here, especially if working with large tables.
• Use aliens early ( AS ) — it makes later steps easier to read.

2. WHERE – Filtering rows

Once the data is pulled in from the tables, the WHERE clause filters out rows that don't match the conditions. Only the matching rows go on to the next steps.

Example:

 WHERE order_total > 100

This would keep only orders over $100 from the earlier joined data.

Common mistake:
Putting filtering logic in HAVING instead of WHERE when it could have been done earlier. That makes the query less efficient.

3. GROUP BY – Organizing data into groups

If you're aggregating data (like using SUM , COUNT , etc.), this is where the database organizes rows into groups based on one or more columns.

Example:

 GROUP BY customers.id

Now all rows are grouped by each customer's ID, so aggregate functions can calculate per group.

Note:

• You can group by expressions too, not just column names.
• Anything in SELECT that isn't an aggregate must be in GROUP BY .

4. HAVING – Filtering groups

After grouping, you may want to filter which groups stay in the result. That's what HAVING does.

Example:

 HAVING COUNT(orders.id) > 5

This keeps only customers who placed more than five orders.

Important:

• HAVING works like WHERE but for aggregated values.
• It only makes sense after grouping.

5. SELECT – Choosing what to return

Only now does the database look at what columns or expressions you want in the final output. This is when calculated fields like SUM(order_total) get their final shape.

Also, column aliases are defined here:

 SELECT customers.name AS customer_name, SUM(orders.total) AS total_spent

But remember: you can't use customer_name until after this step.

6. ORDER BY – Sorting the results

Finally, the results are sorted based on the columns or expressions you specify.

Example:

 ORDER BY total_spent DESC

This sorts customers by how much they spend, from highest to lowest.

Quick tip:
Using expressions in ORDER BY is allowed, but it can sometimes affect performance if not used carefully.

So the full execution order is roughly:

1. FROM / JOINs
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY

And even though you write a SQL query starting with SELECT , that's actually near the end in terms of what the database does.

That's how it works — not complicated, but easy to mix up if you're thinking line-by-line.

The above is the detailed content of What is the order of execution of a SQL query. For more information, please follow other related articles on the PHP Chinese website!