Skip to content

Commit 9b77fe6

Browse files
sanjay-kvsanjay-kv
authored
Merge pull request #1012 from dinesh-2047/clauses
Added SQL Clauses Documentation
2 parents d95150d + c26e83a commit 9b77fe6

File tree

3 files changed

+293
-0
lines changed

3 files changed

+293
-0
lines changed

‎docs/sql/SQL-basics/assets/33-sql-clause.png‎

304 KB
Loading

‎docs/sql/SQL-basics/sql-clauses.md‎

Lines changed: 292 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,292 @@
1+
---
2+
id: sql-clauses
3+
title: SQL Clauses
4+
sidebar_label: SQL Clauses
5+
sidebar_position: 11
6+
tags: [sql, clauses, database, relational-databases]
7+
description: In this super beginner-friendly guide, you’ll learn about SQL clauses—the building blocks that structure your queries to select, filter, group, and sort data in the correct order!
8+
keywords: [sql, clauses, sql tutorial, sql basics, database management, relational databases, sql clauses tutorial, sql for beginners, sql in 2025]
9+
---
10+
11+
12+
13+
## 📙 Welcome to SQL Clauses!
14+
15+
Hey there, SQL beginner! Clauses are the essential parts of an SQL query that tell the database what data to retrieve and how to process it. Think of them as the steps in a recipe—each clause has a specific job, and they must be written in a strict order to work correctly. We’ll use a simple `students` table (with columns like `id`, `name`, `age`, `marks`, and `city`) to explain everything with clear examples. Let’s dive in step by step, following the correct order of clauses in a SELECT query!
16+
17+
![SQL Query Execution Order Diagram](assets/33-sql-clause.png)
18+
19+
### 📘 What Are Clauses?
20+
21+
Clauses are components of SQL statements that perform tasks like selecting columns, filtering rows, or sorting results. In a SELECT query, they must appear in this order: **SELECT → FROM → JOIN → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT**. However, the database *executes* them differently: **FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT**. Understanding both orders helps you write correct and efficient queries.
22+
23+
> **Pro Tip**: Always write clauses in the syntactic order (SELECT first, LIMIT last), but think about execution order when optimizing performance!
24+
25+
### 📘 SELECT Clause (Choosing What to Show!)
26+
27+
The SELECT clause is where you pick what data to display—columns, calculations, or even subqueries. Use `*` for all columns, list specific ones, or add aliases with AS. You can also use functions like COUNT or DISTINCT to shape your results.
28+
29+
**Examples**:
30+
:::info
31+
<Tabs>
32+
<TabItem value="Basic SELECT" label="Basic SELECT">
33+
```sql title="Basic SELECT with Alias"
34+
SELECT name AS student_name, age
35+
FROM students;
36+
```
37+
</TabItem>
38+
39+
<TabItem value="Basic Output" label="Basic Output">
40+
| student_name | age |
41+
|--------------|-----|
42+
| Alice | 20 |
43+
| Bob | 22 |
44+
| Carol | 19 |
45+
</TabItem>
46+
47+
<TabItem value="DISTINCT" label="DISTINCT">
48+
```sql title="Using DISTINCT to Avoid Duplicates"
49+
SELECT DISTINCT city
50+
FROM students;
51+
```
52+
</TabItem>
53+
54+
<TabItem value="DISTINCT Output" label="DISTINCT Output">
55+
| city |
56+
|--------|
57+
| Mumbai |
58+
| Delhi |
59+
</TabItem>
60+
61+
<TabItem value="Aggregate" label="Aggregate">
62+
```sql title="Using Aggregate Function"
63+
SELECT COUNT(id) AS total_students, AVG(marks) AS avg_marks
64+
FROM students;
65+
```
66+
</TabItem>
67+
68+
<TabItem value="Aggregate Output" label="Aggregate Output">
69+
| total_students | avg_marks |
70+
|----------------|-----------|
71+
| 3 | 84.0 |
72+
</TabItem>
73+
74+
<TabItem value="Subquery" label="Subquery">
75+
```sql title="Using Subquery in SELECT"
76+
SELECT name, marks,
77+
(SELECT AVG(marks) FROM students) AS avg_all_marks
78+
FROM students;
79+
```
80+
</TabItem>
81+
82+
<TabItem value="Subquery Output" label="Subquery Output">
83+
| name | marks | avg_all_marks |
84+
|-------|-------|---------------|
85+
| Alice | 85 | 84.0 |
86+
| Bob | 92 | 84.0 |
87+
| Carol | 75 | 84.0 |
88+
</TabItem>
89+
</Tabs>
90+
:::
91+
92+
> **What NOT to Do**:
93+
> - Don’t use SELECT without FROM—it’ll error in most databases!
94+
> - Avoid SELECT * in production—it’s inefficient; list only needed columns.
95+
> - Don’t use column aliases in WHERE or GROUP BY—aliases are for output only.
96+
97+
### 🔄 FROM Clause (Where the Data Lives!)
98+
99+
The FROM clause names the table(s) or view(s) your data comes from. It’s the starting point of your query and sets the stage for everything else.
100+
101+
**Example**:
102+
:::info
103+
<Tabs>
104+
<TabItem value="SQL Code" label="SQL Code">
105+
```sql title="Using FROM Clause"
106+
SELECT id, name
107+
FROM students;
108+
```
109+
</TabItem>
110+
111+
<TabItem value="Output" label="Output">
112+
| id | name |
113+
|----|-------|
114+
| 1 | Alice |
115+
| 2 | Bob |
116+
| 3 | Carol |
117+
</TabItem>
118+
</Tabs>
119+
:::
120+
121+
> **What NOT to Do**: Don’t misspell table names (e.g., FROM studnets)—it’ll cause a “table not found” error!
122+
123+
### 🔄 JOIN Clause (Combining Tables!)
124+
125+
JOIN, used within FROM, combines data from multiple tables based on a condition (e.g., INNER JOIN, LEFT JOIN). It’s crucial for linking related data.
126+
127+
**Example**:
128+
:::info
129+
<Tabs>
130+
<TabItem value="SQL Code" label="SQL Code">
131+
```sql title="Using JOIN Clause"
132+
SELECT s.id, s.name, c.course_name
133+
FROM students s
134+
INNER JOIN courses c ON s.id = c.student_id; -- Assume courses table
135+
```
136+
</TabItem>
137+
138+
<TabItem value="Output" label="Output">
139+
| id | name | course_name |
140+
|----|-------|-------------|
141+
| 1 | Alice | Math |
142+
| 2 | Bob | Science |
143+
</TabItem>
144+
</Tabs>
145+
:::
146+
147+
> **What NOT to Do**: Don’t forget the ON condition—it can create a massive Cartesian product, slowing your query!
148+
149+
### 📘 WHERE Clause (Filtering the Rows!)
150+
151+
The WHERE clause filters rows based on conditions using operators like =, >, or LIKE. It narrows down your result set before grouping or sorting.
152+
153+
**Example**:
154+
:::info
155+
<Tabs>
156+
<TabItem value="SQL Code" label="SQL Code">
157+
```sql title="Using WHERE Clause"
158+
SELECT id, name, marks
159+
FROM students
160+
WHERE marks > 80;
161+
```
162+
</TabItem>
163+
164+
<TabItem value="Output" label="Output">
165+
| id | name | marks |
166+
|----|-------|-------|
167+
| 1 | Alice | 85 |
168+
| 2 | Bob | 92 |
169+
</TabItem>
170+
</Tabs>
171+
:::
172+
173+
> **What NOT to Do**: Don’t use aggregate functions (e.g., AVG(marks)) in WHERE—use HAVING for that!
174+
175+
### 🔄 GROUP BY Clause (Organizing Data into Groups!)
176+
177+
GROUP BY groups rows with the same values into summary rows, typically used with aggregates like COUNT, SUM, or AVG.
178+
179+
**Example**:
180+
:::info
181+
<Tabs>
182+
<TabItem value="SQL Code" label="SQL Code">
183+
```sql title="Using GROUP BY Clause"
184+
SELECT city, COUNT(id) AS num_students
185+
FROM students
186+
GROUP BY city;
187+
```
188+
</TabItem>
189+
190+
<TabItem value="Output" label="Output">
191+
| city | num_students |
192+
|--------|--------------|
193+
| Mumbai | 2 |
194+
| Delhi | 1 |
195+
</TabItem>
196+
</Tabs>
197+
:::
198+
199+
> **What NOT to Do**: Don’t include non-aggregated columns in SELECT without grouping them—it can cause errors or inconsistent results!
200+
201+
### 📘 HAVING Clause (Filtering Groups!)
202+
203+
HAVING filters grouped data after GROUP BY, using aggregates like AVG or COUNT. It’s like WHERE but for groups.
204+
205+
**Example**:
206+
:::info
207+
<Tabs>
208+
<TabItem value="SQL Code" label="SQL Code">
209+
```sql title="Using HAVING Clause"
210+
SELECT city, AVG(marks) AS avg_marks
211+
FROM students
212+
GROUP BY city
213+
HAVING AVG(marks) > 80;
214+
```
215+
</TabItem>
216+
217+
<TabItem value="Output" label="Output">
218+
| city | avg_marks |
219+
|--------|-----------|
220+
| Mumbai | 88.5 |
221+
</TabItem>
222+
</Tabs>
223+
:::
224+
225+
> **What NOT to Do**: Don’t use HAVING for row-level conditions—use WHERE for those to keep your query clear!
226+
227+
### 🔄 ORDER BY Clause (Sorting the Results!)
228+
229+
ORDER BY sorts the result set by one or more columns, using ASC (ascending, default) or DESC (descending).
230+
231+
**Example**:
232+
:::info
233+
<Tabs>
234+
<TabItem value="SQL Code" label="SQL Code">
235+
```sql title="Using ORDER BY Clause"
236+
SELECT id, name, marks
237+
FROM students
238+
ORDER BY marks DESC;
239+
```
240+
</TabItem>
241+
242+
<TabItem value="Output" label="Output">
243+
| id | name | marks |
244+
|----|-------|-------|
245+
| 2 | Bob | 92 |
246+
| 1 | Alice | 85 |
247+
| 3 | Carol | 75 |
248+
</TabItem>
249+
</Tabs>
250+
:::
251+
252+
> **What NOT to Do**: Don’t use aliases in ORDER BY in some databases (e.g., ORDER BY student_name)—use the original column name!
253+
254+
### 📘 LIMIT Clause (Controlling Output Size!)
255+
256+
LIMIT restricts the number of rows returned, often paired with OFFSET for pagination. (Note: Some databases use TOP or ROWNUM.)
257+
258+
**Example**:
259+
:::info
260+
<Tabs>
261+
<TabItem value="SQL Code" label="SQL Code">
262+
```sql title="Using LIMIT Clause"
263+
SELECT id, name
264+
FROM students
265+
LIMIT 2;
266+
```
267+
</TabItem>
268+
269+
<TabItem value="Output" label="Output">
270+
| id | name |
271+
|----|-------|
272+
| 1 | Alice |
273+
| 2 | Bob |
274+
</TabItem>
275+
</Tabs>
276+
:::
277+
278+
> **What NOT to Do**: Don’t use LIMIT without ORDER BY if you need consistent results—it may return random rows!
279+
280+
## ✅ What You’ve Learned
281+
282+
You’re now a master of SQL clauses in their correct order! You’ve explored:
283+
- **SELECT**: Picking columns, with aliases, DISTINCT, aggregates, or subqueries.
284+
- **FROM**: Specifying data sources.
285+
- **JOIN**: Combining tables.
286+
- **WHERE**: Filtering individual rows.
287+
- **GROUP BY**: Grouping rows for aggregation.
288+
- **HAVING**: Filtering grouped data.
289+
- **ORDER BY**: Sorting results.
290+
- **LIMIT**: Controlling output size.
291+
292+
Practice combining these clauses in order using the `students` table. Follow the “What NOT to Do” tips to write clean, efficient queries!

‎sidebars.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,7 @@ const sidebars: SidebarsConfig = {
127127
"sql/SQL-basics/sql-datatypes",
128128
"sql/SQL-basics/primary-key-foreign-key",
129129
"sql/SQL-basics/sql-operators",
130+
"sql/SQL-basics/sql-clauses"
130131
],
131132
},
132133
{

0 commit comments

Comments
 (0)