Match the following clauses with their respective functions. | Clause | Function | |---|---| | ALTER | Insert the values in a table | | UPDATE | Restrictions on columns | | DELETE | Table definition | | INSERT INTO | Change the name of a column | | CONSTRAINTS | Update existing information in a table | | DESC | Delete an existing row from a table | | CREATE | Create a database |

Match the following clauses with their respective – Class 11 Informatics Practices

Exercises · Q1

Match the following clauses with their respective functions.

Clause	Function
ALTER	Insert the values in a table
UPDATE	Restrictions on columns
DELETE	Table definition
INSERT INTO	Change the name of a column
CONSTRAINTS	Update existing information in a table
DESC	Delete an existing row from a table
CREATE	Create a database

West Bengal WbchseTextbookSubjective· 2mImportance★★★★★est

60% · 27/45 Questions

✓ Free question

Concept understanding — SQL Clause Functions

SQL Clause Functions — The Intuition First

Imagine you're sorting through a pile of exam answer sheets. You want to find the top 3 scores, then group them by city, and finally show only those cities where the average score is above 80. Each of these steps — sorting, grouping, filtering after grouping — is done by a clause in SQL. A clause is just a keyword that tells the database how to process the rows.

Now, a clause function is a built-in operation that works inside a clause to transform or summarise data. The most common ones are aggregate functions (like SUM, AVG, COUNT, MAX, MIN) and scalar functions (like UPPER, LENGTH, ROUND). But the key idea is this: they don't stand alone — they are used within a clause to produce a single value from many rows, or to modify each row individually.

Note

A clause function is not a clause itself. It's a tool you place inside SELECT, WHERE, HAVING, or ORDER BY to compute something.

The Precise Statement

A SQL clause function is a predefined routine that accepts input (one or more values from rows) and returns a single output value, used inside a SQL clause to perform calculations, transformations, or aggregations on data.

There are two broad families:

Family	Purpose	Example	Where used
Aggregate functions	Combine many rows into one result	`AVG(marks)`	`SELECT`, `HAVING`
Scalar functions	Operate on each row individually	`UPPER(name)`	`SELECT`, `WHERE`, `ORDER BY`

How They Work in Practice

Consider a table Students:

name	city	marks
Ravi	Delhi	85
Priya	Mumbai	92
Anil	Delhi	78
Sita	Mumbai	88

Example 1 — Aggregate in SELECT

SELECT AVG(marks) FROM Students;

AVG is the clause function. It looks at all marks values, adds them, divides by the count, and returns 85.75. The SELECT clause simply displays that single number.

Example 2 — Scalar in WHERE

SELECT name FROM Students WHERE LENGTH(name) > 4;

LENGTH is the clause function. It checks each name one by one: "Ravi" has length 4 (not >4), "Priya" has length 5 (yes), "Anil" has length 4 (no), "Sita" has length 4 (no). Only Priya is returned.

Example 3 — Aggregate in HAVING

SELECT city, AVG(marks) 
FROM Students 
GROUP BY city 
HAVING AVG(marks) > 85;

Here AVG(marks) appears twice: once in SELECT to show the average per city, and once in HAVING to filter groups. The HAVING clause is special — it's the only place you can filter after grouping, using an aggregate function.

Watch out

You cannot use an aggregate function inside WHERE. WHERE filters rows before grouping, so it doesn't know about groups yet. Use HAVING for that.

The Golden Rule

A clause function always reduces dimensionality:

An aggregate function turns many rows into one number.
A scalar function keeps the same number of rows but transforms each value.

That's the core. Everything else — COUNT(DISTINCT ...), GROUP_CONCAT, COALESCE — is just a variation on this theme. Learn to recognise which family a function belongs to, and you'll know exactly which clause it can live in.

Split them by target — structure (DDL: ALTER, CREATE, DESC, constraints) vs data (DML: INSERT INTO, UPDATE, DELETE) — and each clause finds its function:

✓Final answer

ALTER \to Change the name of a column \cdot UPDATE \to Update existing information in a table \cdot DELETE \to Delete an existing row from a table \cdot INSERT INTO \to Insert the values in a table \cdot CONSTRAINTS \to Restrictions on columns \cdot DESC \to Table definition \cdot CREATE \to Create a database.

Sort the clauses by what they act on: structure-changers (ALTER, CREATE, DESC, CONSTRAINTS) versus data-changers (INSERT INTO, UPDATE, DELETE). Once you see that split, each clause pairs with exactly one function.

The correct matching

Clause	Correct function
ALTER	Change the name of a column
UPDATE	Update existing information in a table
DELETE	Delete an existing row from a table
INSERT INTO	Insert the values in a table
CONSTRAINTS	Restrictions on columns
DESC	Table definition
CREATE	Create a database

Each pairing, proven with one line of SQL

ALTER TABLE student CHANGE name fullname VARCHAR(30);  -- ALTER: renames column 'name'
UPDATE student SET class = 12 WHERE rollno = 101;      -- UPDATE: changes existing data
DELETE FROM student WHERE rollno = 101;                -- DELETE: removes an existing row
INSERT INTO student VALUES (101, 'Aaliya', 11);        -- INSERT INTO: adds values as a new row
CREATE DATABASE school;                                -- CREATE: makes a new database
DESC student;                                          -- DESC: shows the table's definition

DESC student; (short for DESCRIBE) prints the table definition — each column's name, data type, whether it can be NULL, and its key status:

+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| rollno   | int         | NO   | PRI | NULL    |       |
| fullname | varchar(30) | YES  |     | NULL    |       |
| class    | int         | YES  |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+

CONSTRAINTS are not a command you run but the rules that restrict what a column may hold — PRIMARY KEY, NOT NULL, UNIQUE, DEFAULT, CHECK, FOREIGN KEY — declared inside CREATE TABLE/ALTER TABLE.

Why the split works: ALTER, CREATE, DESC and constraints belong to DDL (they define or describe structure), while INSERT INTO, UPDATE, DELETE belong to DML (they manipulate the rows inside that structure). Matching becomes automatic once you ask "does this touch the table's shape, or its contents?"

✓Final answer

ALTER \to Change the name of a column \cdot UPDATE \to Update existing information in a table \cdot DELETE \to Delete an existing row from a table \cdot INSERT INTO \to Insert the values in a table \cdot CONSTRAINTS \to Restrictions on columns \cdot DESC \to Table definition \cdot CREATE \to Create a database.

←Previous section · summarySummary →Next questionQ2 — Choose appropriate answer with respect to the following code snippet. …

The correct matching

Each pairing, proven with one line of SQL

🎓Unlock everything free for 14 days

Unlock everything free for 14 days