In SQL, aggregate functions are used to perform calculations on a set of rows and return a single summary value. They are a core part of querying databases, especially when you need to analyse data — finding totals, averages, counts, or extremes. Among these, the function that specifically returns the smallest value from a column is MIN().

The MIN() function works on numeric, date, or text columns. For text, it returns the value that comes first alphabetically. For dates, it returns the earliest date. This makes it versatile for many real-world queries — for example, finding the lowest price in a products table, the earliest order date, or the shortest employee name.

Let’s look at the options given:

• (A) MIN() — Correct. This is the standard SQL aggregate function for the smallest value.
• (B) MAX() — Returns the largest value, not the smallest.
• (C) SMALL() — This is not a valid SQL aggregate function. No such function exists in standard SQL or in any major database system. …

Why aggregate functions exist

SQL aggregate functions exist to summarize data across rows. When you have a table with thousands of transactions and want to know the total sales, you don't want thousands of numbers back—you want one number that represents the sum. That's the entire purpose of aggregation: to reduce many values to a single, meaningful summary.

Think of it this way: if you ask "What is the average age of students in this class?", you expect one number as the answer, not a list repeating some value for each student. Aggregate functions work the same way.

How aggregate functions actually behave

The standard aggregate functions in SQL are:

Each of these takes multiple input rows and produces one output value.

For example:

SELECT AVG(salary) FROM employees;

If the employees table has 500 rows, this query returns exactly one row with one value—the average salary across all 500 employees.

What about GROUP BY?

When you use GROUP BY, aggregate functions return one value per group, not one value per original row:

SELECT department, AVG(salary) 
FROM employees 
GROUP BY department;
``` …

The heart of this question lies in understanding how SQL's COUNT function behaves differently depending on what you pass to it.

When you write COUNT(*), you're asking SQL to count every row in the table, regardless of whether any particular column contains NULL values. It's a row counter, pure and simple.

When you write COUNT(column_name), you're asking SQL to count only those rows where column_name is NOT NULL. SQL silently skips over any row where that column holds a NULL value.

This distinction matters enormously in practice. Imagine a students table with 100 rows, but 5 students have NULL in the name column (perhaps their names weren't recorded yet). Then:

• SELECT COUNT(*) FROM students; returns 100 (all rows)
• SELECT COUNT(name) FROM students; returns 95 (only non-NULL names)

Now let's evaluate the assertion and reason:

Assertion (A): "The output of SELECT COUNT(name) FROM students; will differ from SELECT COUNT(*) FROM students; if there are some NULL values in the name column."

This is true. As we just saw, the presence of NULLs in the name column causes COUNT(name) to return a smaller number than COUNT(*). …

In SQL, aggregate functions are powerful tools designed to perform calculations on a set of rows and return a single summary value. These functions are fundamental for data analysis, allowing us to derive insights like sums, averages, maximums, minimums, and counts from large datasets. When dealing with real-world data, it's common to encounter NULL values, which represent missing or unknown data. How these NULL values are handled by aggregate functions is a crucial aspect of understanding their behavior.

The question specifically asks for an aggregate function that counts the number of values in a column while ignoring NULL entries. Among the standard SQL aggregate functions, COUNT() is precisely designed for this purpose.

Let's break down how COUNT() works:

• COUNT(column_name): When you specify a column name inside the COUNT() function, like COUNT(EmployeeID) or COUNT(ProductName), SQL will iterate through each row in that column. For every row where the specified column_name has a non-NULL value, it increments the count. Rows where the column_name is NULL are simply skipped and do not contribute to the total count. This is the exact behavior requested by the question.

• COUNT(*): It's important to distinguish COUNT(column_name) from COUNT(*). The COUNT(*) function counts the total number of rows in the result set, regardless of whether any specific column in those rows contains NULL values. It essentially counts the rows themselves, not the non-NULL values within a particular column.

Now, let's consider the other options provided: …

Aggregate functions in SQL are designed to perform calculations on a set of values and return a single summary value. They work across multiple rows of data, collapsing them into one meaningful result. Think of them as tools that answer questions like "How many records are there?", "What's the smallest value?", or "What's the average?" — they digest entire columns of data and give you one number back.

COUNT(*) counts the total number of rows in a result set, including those with NULL values. It's the go-to function when you need to know "how many" of something exists in your database.

MIN() finds the smallest value in a column. Whether you're looking for the lowest price, the earliest date, or the minimum score, MIN() scans through all the rows and returns that single smallest value.

AVG() calculates the arithmetic mean of a numeric column. It adds up all the values and divides by the count, giving you the average — essential for understanding central tendencies in your data.

Now LEFT() operates on an entirely different principle. It's a string function that extracts a specified number of characters from the left side of a text string. For example, LEFT('Database', 4) would return 'Data'. Notice what's happening here: LEFT() works on a single string value at a time, not across multiple rows. It doesn't summarize or aggregate anything — it simply manipulates one piece of text. …

When we talk about the cardinality of a table in database terminology, we mean the number of rows (or tuples) it contains. It's a fundamental measure of the table's size — how many records exist in that relation. SQL provides a family of aggregate functions that perform calculations across multiple rows and return a single summary value, and understanding which one gives us cardinality is essential for querying databases effectively.

Aggregate functions operate on sets of values from a column (or columns) and collapse them into one result. The most common ones include:

• sum() — adds up all the values in a numeric column
• avg() — calculates the arithmetic mean of values in a numeric column
• count() — counts rows or non-null values
• max() and min() — find the largest or smallest value

The question asks specifically which function reveals how many rows are in the table. The count(*) function does exactly this: it counts every row in the table, regardless of whether individual columns contain null values or not. The asterisk * tells SQL to count all rows without filtering by any particular column's content. …

In the world of databases, particularly when working with SQL (Structured Query Language) like MySQL, we often need to perform calculations that summarize data across multiple records. This is where aggregate functions come into play. These functions operate on a collection of rows and return a single value that represents a summary of that collection. Think of them as tools to get insights like "total sales," "average score," or "number of students."

Let's break down what aggregate functions are and then examine the options provided.

Understanding Aggregate Functions

An aggregate function processes a group of input values (from multiple rows) and produces a single output value. They are typically used with the SELECT statement and often combined with the GROUP BY clause to perform calculations on specific groups of data. Without GROUP BY, the aggregate function treats the entire result set as a single group.

Common aggregate functions include:

• COUNT(): This function counts the number of rows or non-NULL values in a specified column. For example, COUNT(*) counts all rows, while COUNT(column_name) counts rows where column_name is not NULL.
• SUM(): This function calculates the total sum of a numeric column. It's useful for finding totals like the sum of quantities or prices.
• AVG(): This function computes the average (arithmetic mean) of a numeric column. It's perfect for finding average scores, average salaries, etc.
• MAX(): This function finds the maximum value in a specified column. It can be used with numeric, string, or date/time data types to find the highest value.
• MIN(): This function finds the minimum value in a specified column. Similar to MAX(), it works with numeric, string, or date/time data types to find the lowest value.

Analyzing the Options

Now, let's look at the functions given in the question:

• (A) COUNT(): As discussed, COUNT() is a fundamental aggregate function. It is used to count the number of rows that match a specified criterion. For instance, SELECT COUNT(student_id) FROM Students; would tell you the total number of students. This is a valid aggregate function in MySQL.

• (B) SUM(): SUM() is also a core aggregate function. It calculates the total sum of values in a numeric column. For example, SELECT SUM(amount) FROM Orders; would give you the total amount of all orders. This is a valid aggregate function in MySQL. …

When you work with databases, one of the most common tasks is simply knowing how many rows exist in a table. SQL provides a set of functions called aggregate functions that perform a calculation over a set of values and return a single result. Among these, the one designed specifically for counting records is COUNT().

COUNT() comes in two main forms. COUNT(*) counts every row in the table, regardless of whether any column contains a NULL value — the most straightforward way to get the total number of records. COUNT(column_name) counts only those rows where the specified column has a non-NULL value. So for the absolute total number of rows, COUNT(*) is the correct choice.

Concept — pattern matching + counting

"Anywhere in the name" means an exact-match test (=) will not do; we need the LIKE operator with the % wildcard, which stands for any sequence of zero or more characters. The pattern '%MOHAN%' therefore matches a name whether 'MOHAN' is at the start, middle or end. COUNT(*) then counts the rows that survive the WHERE filter — one row per matching driver.

SELECT COUNT(*)
FROM TRANSPORTER
WHERE DRIVERNAME LIKE '%MOHAN%';

Key lines:

• WHERE DRIVERNAME LIKE '%MOHAN%' — keeps only rows whose DRIVERNAME contains the substring 'MOHAN'; the leading and trailing % allow any characters before and after it. In MySQL, LIKE on ordinary text columns is case-insensitive by default, so 'MOHAN' in the data matches as-is. …

When working with databases, we often need to summarise information rather than just retrieve raw data. The GROUP BY clause in SQL is a powerful tool for this, allowing us to aggregate rows that share common values into a set of summary rows. This particular query asks us to identify items that have been ordered multiple times, providing a count for each.

Let's break down the query step by step to understand its logic:

• FROM TRANSPORTER: This is the starting point. The query begins by looking at all the records in the TRANSPORTER table.
• GROUP BY ITEM: This is the core of the aggregation. The database will go through the TRANSPORTER table and collect all rows that have the same value in the ITEM column into a single group. For example, all rows where ITEM is 'TELEVISION' will form one group, all rows where ITEM is 'FURNITURE' will form another, and so on.
• SELECT ITEM, COUNT(*): After grouping, for each distinct group formed by the ITEM column, the query will select two pieces of information:
  • The ITEM itself (which is the common value for that group).
  • COUNT(*): This is an aggregate function that counts the total number of rows within each specific group. So, for the 'TELEVISION' group, COUNT(*) will tell us how many times 'TELEVISION' appears in the table.
• HAVING COUNT(*) > 1: This is a crucial filtering condition. While WHERE clauses filter individual rows before grouping, HAVING clauses filter entire groups after they have been formed and aggregate functions (like COUNT(*)) have been calculated. In this case, HAVING COUNT(*) > 1 means that only those groups where the count of items is strictly greater than 1 will be included in the final output. Groups with a count of 1 (meaning the item appeared only once) will be discarded.

Let's apply this logic to the TRANSPORTER table:

1. Identify unique ITEM values and group them:
   • TELEVISION
   • FURNITURE
   • WASHING MACHINE …

The MAX() aggregate function returns the largest value in a column. When applied to dates, "largest" means the most recent date. The WHERE clause filters the table to include only those rows where the driver's grade is exactly 'A', and then MAX(TRAVELDATE) picks the latest date from that filtered subset.

Let's trace through the logic step by step.

1. Filter by DRIVERGRADE = 'A'

   The WHERE clause restricts our view to only those rows where the driver has grade A. Scanning the table:

   ORDERNO	DRIVERNAME	DRIVERGRADE	ITEM	TRAVELDATE	DESTINATION
   10012	RAM YADAV	A	TELEVISION	2019-04-19	MUMBAI
   10018	RISHI SINGH	A	REFRIGERATOR	2019-04-07	MUMBAI

   Only these two orders have DRIVERGRADE = 'A'. Notice that rows with NULL or 'B' grades are excluded.

2. Apply MAX(TRAVELDATE) to the filtered rows …