🗓️ Day 2: Functions and Grouping Data Deep Dive 📊

The focus of Day 2 is on transforming and summarizing data, which is essential for reporting and
analysis. This involves using Functions (to change individual data values) and Aggregate
Functions (to calculate summaries of groups of data).

2.1 Single-Row Functions 🔢

Single-row functions operate on one row at a time and return one result per row. They can be
used anywhere a column or expression can be used (in SELECT, WHERE, ORDER BY).

Function
Function Description Example
Type
UPPER(), LOWER(), Changes casing of a SELECT UPPER(last_name)
Character FROM employees;
INITCAP() string.
SUBSTR(str, start, SELECT SUBSTR('Oracle', 1,
len) Extracts a substring. 3) FROM DUAL; (Returns 'Ora')

LENGTH()
Returns the number of SELECT LENGTH('SQL') FROM
characters. DUAL;
Rounds a number to a SELECT ROUND(45.923, 1)
Numeric ROUND(n, precision) specified number of
FROM DUAL; (Returns 45.9)
decimal places.
TRUNC(n, precision)
Truncates (cuts off) a SELECT TRUNC(45.923, 1)
number. FROM DUAL; (Returns 45.9)
Returns the current date
Date SYSDATE SELECT SYSDATE FROM DUAL;
and time on the server.
Returns the number of
MONTHS_BETWEEN(d1,
d2) months between two
dates.
Converts a date or
TO_CHAR(value, TO_CHAR(hire_date, 'YYYY-
Conversion format) number to a character MM-DD')
string.
TO_DATE(string, Converts a character TO_DATE('13-NOV-2025', 'DD-
format) string to a date. MON-YYYY')

SQL Functions and Grouping Data: A Deep Dive

Page 1: Introduction - The "What" and "Why"

At its core, SQL is a language for managing and manipulating sets of data. While simple SELECT
statements can retrieve raw data, the true analytical power of SQL is unlocked through
Functions and Grouping. These features transform SQL from a simple data retrieval tool into a
powerful engine for aggregation, summarization, and transformation.

The Core Problem They Solve:

Imagine a database table with millions of sales records. A question like "What was our total
revenue?" is impossible to answer by looking at individual rows. You need a way to collapse all
those rows into a single, meaningful value. This is the fundamental purpose of aggregation and
grouping.

 Functions perform operations on data, either on individual values (scalar functions) or on

sets of values (aggregate functions), to produce a new result.
 Grouping (GROUP BY) allows you to partition your dataset into distinct subsets, and then
apply aggregate functions to each subset, enabling comparisons and summaries across
categories.

Together, they allow you to answer complex business questions:

 "What is the average salary for each department?"

 "What is the total sales by region and by quarter?"
 "Who are our top 10 customers by total order value?"

This deep dive will dissect the types of functions, the mechanics of GROUP BY and HAVING, and
culminate in advanced grouping operations.

Page 2: A Taxonomy of SQL Functions

SQL functions are broadly categorized by their operating domain: single values vs. sets of
values.

1. Scalar Functions (Row-by-Row)

Scalar functions operate on a single value from a single row and return a single result for each
row processed. They do not change the number of rows returned.

 String Functions:
o UPPER(column_name), LOWER(column_name): Change case.
o LENGTH(column_name): Returns the length of a string.
o SUBSTRING(column_name, start, length): Extracts a portion of a string.
o TRIM(column_name): Removes leading and trailing spaces.
 Numeric Functions:
o ROUND(column_name, decimals): Rounds a number.
 o CEIL(), FLOOR(): Rounds up or down to the nearest integer.
o ABS(column_name): Returns the absolute value.
 Date/Time Functions:
o YEAR(date_column), MONTH(), DAY(): Extract parts of a date.
o DATEADD(interval, number, date): Adds to a date.
o DATEDIFF(interval, start_date, end_date): Calculates the difference
between two dates.
o GETDATE(), NOW(): Returns the current date and time.

Example:

sql

SELECT
first_name,
UPPER(last_name) AS last_name_upper,
YEAR(birth_date) AS birth_year
FROM employees;

This processes each row individually, transforming the data without summarizing it.

2. Aggregate Functions (Set-Based)

Aggregate functions operate on a set of rows (a column from multiple rows) and return a single,
summarizing value. They are the cornerstone of data analysis in SQL.

 COUNT(*): Counts the number of rows in the set, including NULLs.

 COUNT(column_name): Counts the number of non-NULL values in a specific column.
 SUM(column_name): Calculates the total sum of a numeric column.
 AVG(column_name): Calculates the average of a numeric column.
 MIN(column_name), MAX(column_name): Finds the minimum and maximum value.
 STRING_AGG(column_name, separator): (In some DBMS like PostgreSQL/SQL
Server) Concatenates values from multiple rows into a single string.

Crucial Point: When you use an aggregate function in a SELECT clause without a GROUP BY, it
collapses the entire result set into a single row.

Example:

sql

SELECT
COUNT(*) AS total_employees,
AVG(salary) AS average_salary,
MAX(salary) AS highest_salary
FROM employees;

This query returns exactly one row, summarizing the entire employees table.
Page 3: The Mechanics of GROUP BY - Creating Subsets

The GROUP BY clause is what allows you to apply aggregate functions to subsets of your data. It
partitions the result set into groups of rows that have matching values in the specified column(s).
The aggregate function is then calculated for each group independently.

Syntax and Logic:

sql

SELECT column1, aggregate_function(column2)

FROM table
GROUP BY column1;

The Mental Model:

1. FROM: The database reads the entire table.

2. WHERE: (Optional) Filters out individual rows that do not meet the criteria.
3. GROUP BY: The remaining rows are sorted into "buckets" or "groups." Each unique
combination of the GROUP BY columns gets its own bucket.
4. SELECT: For each bucket, the SELECT clause outputs:
o The value of the GROUP BY column(s).
o The result of the aggregate function calculated only on the rows within that
bucket.

Example: Total Sales by Region

sql

SELECT
region,
SUM(sale_amount) AS total_sales
FROM sales
GROUP BY region;

Visualizing the Process:

sale_id region sale_amount

1 North 100

2 South 150

3 North 200

4 South 50
sale_id region sale_amount

The GROUP BY region creates two buckets:

 North Bucket: Rows 1 & 3 -> SUM(sale_amount) = 300

 South Bucket: Rows 2 & 4 -> SUM(sale_amount) = 200

Result:

region total_sales

North 300

South 200

Page 4: The HAVING Clause - The Filter for Groups

The WHERE clause filters rows before they are aggregated. But what if you want to filter the
results of the aggregation? This is the job of the HAVING clause.

WHERE vs. HAVING: A Critical Distinction

 WHERE: Filters individual rows based on column values. It cannot use aggregate functions.
 HAVING: Filters groups based on the results of aggregate functions. It cannot use regular
column values (unless they are in the GROUP BY).

Use Case: Find regions with total sales greater than 250.

sql

SELECT
region,
SUM(sale_amount) AS total_sales
FROM sales
GROUP BY region
HAVING SUM(sale_amount) > 250; -- Filter on the aggregate result

Following our previous example, the HAVING clause would eliminate the "South" group
(total_sales = 200) and only return the "North" group.

You can use both together: Find the total sales for the 'North' and 'South' regions, but only
show them if their total sales exceed 250.
sql

SELECT
region,
SUM(sale_amount) AS total_sales
FROM sales
WHERE region IN ('North', 'South') -- Row-level filter
GROUP BY region
HAVING SUM(sale_amount) > 250; -- Group-level filter

The Complete Logical Query Processing Order:

Understanding this order is key to mastering SQL:

1. FROM & JOINs

2. WHERE
3. GROUP BY
4. HAVING
5. SELECT (including window functions, which we'll touch on)
6. ORDER BY

Page 5: Advanced Grouping Concepts

1. Grouping Sets, ROLLUP, and CUBE

Sometimes, you need multiple levels of aggregation in a single query. Modern SQL provides
extensions to GROUP BY for this.

 GROUPING SETS: Allows you to specify multiple grouping lists. It's the foundation for
ROLLUP and CUBE.

sql

-- Get totals by (region), by (product), and a grand total (())

SELECT region, product, SUM(sales)
FROM sales_data
GROUP BY GROUPING SETS (
(region),
(product),
() -- Grand Total
);

ROLLUP: Creates a hierarchy of aggregates, from the most detailed to a grand total. It's perfect for
subtotals.

sql

-- Gets: (Year, Quarter), (Year), and Grand Total

SELECT YEAR(order_date) AS OrderYear, QUARTER(order_date) AS OrderQtr,
SUM(amount)
FROM orders
GROUP BY ROLLUP (OrderYear, OrderQtr);

 Result:

OrderYear OrderQtr SUM(amount)

2023 1 1000

2023 2 1500

2023 NULL 2500 <-- Subtotal for 2023

NULL NULL 2500 <-- Grand Total

 CUBE: Generates all possible combination of aggregates for the specified columns.

sql

-- Gets all combinations: (Region, Product), (Region), (Product), Grand Total.

SELECT Region, Product, SUM(sales)
FROM sales_data
GROUP BY CUBE (Region, Product);

2. The OVER() Clause - Window Functions (A Brief Preview)

While not strictly "grouping," the OVER() clause is the next evolutionary step in aggregation. It
allows you to perform aggregate calculations without collapsing the result set. You get aggregate
results alongside the original row-level data.

sql

SELECT
employee_id,
department,
salary,
AVG(salary) OVER (PARTITION BY department) AS avg_department_salary
FROM employees;

This query returns every employee, their salary, and alongside it, the average salary for their
entire department. The PARTITION BY within the OVER() clause acts like a "soft" GROUP BY that
doesn't reduce the rows.
Page 6: Summary and Best Practices

Summary:

 Scalar Functions transform data row-by-row.

 Aggregate Functions (SUM, AVG, COUNT) summarize a set of rows into a single value.
 GROUP BY is used to apply aggregate functions to subsets of data defined by one or more
columns.
 HAVING is the only way to filter the results of aggregate functions, acting as a filter for
groups created by GROUP BY.
 Advanced Grouping (ROLLUP, CUBE) and Window Functions (OVER()) provide
powerful tools for multi-level analysis and row-level aggregates.

Common Pitfalls and Best Practices:

1. GROUP BY Mismatch: Every column in the SELECT list that is not an argument to an
aggregate function must be included in the GROUP BY clause. This is the most common
error.
o Wrong: SELECT region, product, SUM(sales) FROM sales GROUP BY
region;
o Right: SELECT region, product, SUM(sales) FROM sales GROUP BY
region, product;
2. Filtering with HAVING instead of WHERE: Using HAVING to filter on non-aggregated
columns is inefficient. Always use WHERE for row-level filters to reduce the number of
rows the database has to group.
3. COUNT(*) vs. COUNT(column_name): Remember that COUNT(*) counts all rows, while
COUNT(column_name) counts only non-NULL values in that column. Choose the one that
matches your intent.
4. NULLs in Grouping: GROUP BY treats all NULL values as a single, separate group. Be
aware of this, as it can sometimes lead to an unexpected "NULL" group in your results.

By deeply understanding these concepts, you move from simply writing queries to architecting
them, allowing you to extract profound insights and build robust reporting directly from your
database.