SQL Query Order of Execution

SQL Query Order of
Execution
GROUP ORDER
FROM JOIN WHERE HAVING SELECT LIMIT
BY BY
Ashish Zope
Data Engineer at Bajaj Finserv
SQL Query Order of Execution
FROM
JOIN
WHERE
GROUP BY
HAVING
SELECT
ORDER BY
LIMIT
SQL Query Execution Plan
➢ The SQL query flow involving `SELECT`, `FROM`, `JOIN`,
`GROUP BY`, `HAVING`, ÒRDER BY`, and `LIMIT` follows a
specific logical order.
➢ Logical order is slightly different from the order in which the

query is written.
➢ Here's a step-by-step breakdown of how the database

processes this type of query:
1. FROM Clause (with JOINs)
Execution: The first step is to determine which tables or subqueries
will be queried.
JOIN Operations: If the query involves a `JOIN`, the database engine
evaluates it during this step. It decides how to
combine the rows from multiple tables based on
the `JOIN` conditions (e.g., ÌNNER JOIN`, `LEFT
JOIN`, etc.).
Result: The result at this stage is a set of rows combining data from
all the relevant tables.
Example:
FROM employees
INNER JOIN departments
ON employees.department_id = departments.id
2. WHERE Clause (Filtering Data)
Execution: The `WHERE` clause is used to filter rows based on
specified conditions. Only rows that satisfy the `WHERE`
condition move to the next step.
Result: After filtering, you have a subset of rows that match the
condition.
Example:
WHERE departments.name = 'Sales’

3. GROUP BY Clause (Grouping Data)
Execution: If the query has a `GROUP BY` clause, the rows are
grouped based on the specified columns. This step is
essential when performing aggregate calculations (e.g.,
`SUM`, `COUNT`, ÀVG`).
Result: The rows are grouped into collections based on the values of
one or more columns.
Example:
GROUP BY employees.department_id
4. HAVING Clause (Filtering Groups)
Execution: Once the data is grouped, the `HAVING` clause filters
these groups. It’s similar to the `WHERE` clause but
applies to grouped data, usually involving aggregate
functions like `COUNT()`, `SUM()`, ÀVG()`, etc.
Result: Only groups that meet the `HAVING` conditions are included
in the result set.
Example:
HAVING COUNT(employees.id) > 5

5. SELECT Clause (Selecting Columns)
Execution: The `SELECT` clause specifies which columns (or aggregate
functions) to include in the final result set. It also applies
any calculations, transformations, or aliases.
Result: A subset of columns (or computed results) is prepared based
on the grouped and filtered rows.
Example:
SELECT departments.name, AVG(employees.salary) AS

avg_salary
6. ORDER BY Clause (Sorting Data)
Execution: The ÒRDER BY` clause sorts the result set based on one
or more columns, either in ascending (ÀSC`) or
descending (`DESC`) order.
Result: The final result set is ordered as requested.
Example:
ORDER BY avg_salary DESC

7. LIMIT Clause (Restricting Rows)
Execution: The `LIMIT` clause restricts the number of rows returned
by the query. This is useful for pagination or returning the
top results.
Result: The database returns only the specified number of rows.
Example:
LIMIT 10
Full Example Workflow:
Consider the following query:
SELECT departments.name, AVG(employees.salary) AS avg_salary

FROM employees
INNER JOIN departments
ON employees.department_id = departments.id
WHERE departments.name = 'Sales'
GROUP BY departments.name
HAVING AVG(employees.salary) > 50000
ORDER BY avg_salary DESC
LIMIT 5;
Execution Flow:
1. FROM (with JOIN): Join the èmployees` and `departments`
tables on the `department_id`.
2. WHERE: Filter the rows where the department name is 'Sales'.
3. GROUP BY: Group the remaining rows by `departments.name`.
4. HAVING: Filter groups where the average salary is greater than
50,000.
5. SELECT: Select the department name and calculate the average
salary for each group.
6. ORDER BY: Sort the results in descending order based on the
average salary.
7. LIMIT: Restrict the result set to the top 5 departments.
Execution Order (Logical Flow vs. Query Order):
Logical Execution:
`FROM` → `JOIN` → `WHERE` → `GROUP BY` → `HAVING` → `SELECT`

→ ÒRDER BY` → `LIMIT`
Query Written Order:
`SELECT` → `FROM` → `JOIN` → `WHERE` → `GROUP BY` → `HAVING`

→ ÒRDER BY` → `LIMIT`
Ashish Zope
THANK YOU Data Engineer at Bajaj Finserv
If you find this helpful, Repost and follow for more content.
Submit corrections in comments, if any.

SQL Query Order of Execution

Uploaded by

SQL Query Order of Execution

Uploaded by

SQL Query Order of

➢ Logical order is slightly different from the order in which the

➢ Here's a step-by-step breakdown of how the database

WHERE departments.name = 'Sales’

HAVING COUNT(employees.id) > 5

SELECT departments.name, AVG(employees.salary) AS

ORDER BY avg_salary DESC

SELECT departments.name, AVG(employees.salary) AS avg_salary

`FROM` → `JOIN` → `WHERE` → `GROUP BY` → `HAVING` → `SELECT`

Query Written Order:

`SELECT` → `FROM` → `JOIN` → `WHERE` → `GROUP BY` → `HAVING`

You might also like