SQL for Board Exams: Complete MySQL Commands Guide for CBSE & ICSE

The Only SQL Guide You Need for CBSE & ICSE Board Exams 2027

SQL questions carry 10–15 marks in the CBSE Class 12 Computer Science theory paper and 8–12 marks in the ICSE Class 10 Computer Applications paper. Despite being one of the most predictable scoring areas, students routinely lose marks because they confuse DDL with DML, forget the correct syntax for GROUP BY with HAVING, or panic when they see a JOIN question. This guide covers every SQL command prescribed by both boards — from CREATE TABLE to multi-table JOINs — with syntax, examples on a realistic student-marks database, and the exact question patterns examiners use. Master these commands and you secure full marks in the SQL section.

In This Article

Why SQL Matters for Board Exams
Exam Weightage: CBSE vs ICSE
Sample Database Used in This Guide
DDL Commands: CREATE, ALTER, DROP
Constraints: PRIMARY KEY, FOREIGN KEY, NOT NULL, UNIQUE, DEFAULT, CHECK
DML Commands: INSERT, UPDATE, DELETE
DQL: SELECT with WHERE, ORDER BY, DISTINCT
Aggregate Functions: COUNT, SUM, AVG, MAX, MIN
GROUP BY and HAVING
JOINs: Cartesian Product, Equi-Join, Natural Join
20 Most Repeated Exam Questions with Solutions
Common Mistakes That Cost Marks
Frequently Asked Questions

Why SQL Matters for Board Exams

SQL (Structured Query Language) is the standard language for managing and querying relational databases. Both CBSE and ICSE boards include SQL as a compulsory component in their computer science and computer applications syllabi respectively. Unlike programming questions where logic can vary, SQL questions have one correct answer — either your query produces the right output or it does not. This makes SQL a pure scoring section if you know the syntax, and a guaranteed mark-loser if you do not.

The boards use MySQL as the reference implementation. While SQL standards are universal, certain syntax details (such as using backticks for identifiers, AUTO_INCREMENT instead of SERIAL, and LIMIT instead of TOP) are MySQL-specific. Every example in this guide follows MySQL syntax exactly as expected in CBSE and ICSE answer sheets.

What Makes SQL Questions Easy to Score

Predictable patterns: The same types of queries appear every year — SELECT with conditions, aggregate functions, GROUP BY, and ALTER TABLE.
No ambiguity: Unlike essay-type answers, SQL output is either correct or incorrect. Partial marks are given for correct clauses even if the full query is wrong.
Small syllabus: The entire SQL portion can be mastered in 8–10 hours of focused practice.
Direct scoring: Examiners can verify your answer by running it mentally against the given table. Clean, correct syntax gets full marks every time.

Exam Weightage: CBSE vs ICSE

Aspect	CBSE Class 12 (CS/IP)	ICSE Class 10 (Comp. App.)
Total Marks for SQL	10–15 marks (theory)	8–12 marks (Section A & B)
Question Types	Write queries, predict output, fill in blanks, identify errors	Write queries, predict output, theory questions
DDL Coverage	CREATE, ALTER, DROP	CREATE, ALTER, DROP
DML Coverage	INSERT, UPDATE, DELETE	INSERT, UPDATE, DELETE
DQL Coverage	SELECT, WHERE, ORDER BY, GROUP BY, HAVING, JOIN, aggregate functions, BETWEEN, IN, LIKE	SELECT, WHERE, ORDER BY, GROUP BY, HAVING, aggregate functions, DISTINCT
JOINs	Cartesian product, equi-join, natural join	Basic equi-join (limited)
MySQL Version	MySQL 8.0	MySQL 8.0

Sample Database Used in This Guide

Every example in this guide uses two tables from a school management database. These tables mirror the kind of data board examiners use in their question papers — student records with marks, grades, and class information. Having a consistent reference makes it easier to understand each command in context.

Table: STUDENT

RollNo	Name	Class	Section	Marks	Grade	City
101	Aarav Sharma	12	A	92	A1	Nashik
102	Priya Patel	12	B	85	A2	Pune
103	Rohan Desai	11	A	78	B1	Nashik
104	Sneha Kulkarni	12	A	95	A1	Mumbai
105	Vikram Joshi	11	B	62	B2	Pune
106	Ananya Mehta	12	B	88	A2	Nashik

Table: TEACHER

TID	TName	Subject	Salary	Class
T01	Mrs. Iyer	Computer Science	55000	12
T02	Mr. Khan	Mathematics	60000	12
T03	Ms. Nair	Physics	52000	11
T04	Mr. Gupta	English	48000	11

DDL Commands: CREATE, ALTER, DROP

DDL (Data Definition Language) commands define the structure of a database. They create, modify, and remove tables and databases. DDL commands auto-commit — once executed, the changes are permanent and cannot be rolled back. Board exams frequently ask students to write CREATE TABLE statements with constraints, ALTER TABLE to add or modify columns, and DROP TABLE to remove a table.

CREATE TABLE

Creates a new table with specified columns and data types.

CREATE TABLE STUDENT (
    RollNo    INT          PRIMARY KEY,
    Name      VARCHAR(50)  NOT NULL,
    Class     INT          NOT NULL,
    Section   CHAR(1)      DEFAULT 'A',
    Marks     DECIMAL(5,2),
    Grade     VARCHAR(2),
    City      VARCHAR(30)
);

ALTER TABLE

Modifies an existing table — add columns, drop columns, modify data types, or rename columns.

-- Add a new column
ALTER TABLE STUDENT ADD Email VARCHAR(60);

-- Modify a column's data type
ALTER TABLE STUDENT MODIFY Name VARCHAR(80);

-- Drop a column
ALTER TABLE STUDENT DROP COLUMN Email;

-- Rename a column (MySQL 8.0+)
ALTER TABLE STUDENT RENAME COLUMN City TO Location;

Exam tip: ALTER TABLE questions appear almost every year. The most common sub-question is “Add a column Phone of type VARCHAR(15) to the table.” Always write the full statement: ALTER TABLE STUDENT ADD Phone VARCHAR(15);

DROP TABLE

Removes a table and all its data permanently.

DROP TABLE STUDENT;

Remember: DROP deletes the table structure and data. DELETE (a DML command) removes only rows. Examiners often ask the difference between the two.

Constraints: PRIMARY KEY, FOREIGN KEY, NOT NULL, UNIQUE, DEFAULT, CHECK

Constraints enforce rules on the data in a table. They ensure data integrity and prevent invalid entries. Board exams test your knowledge of constraints both in theory (define and explain) and practical (write CREATE TABLE with constraints).

Constraint	Purpose	Example
PRIMARY KEY	Uniquely identifies each row; cannot be NULL or duplicate	`RollNo INT PRIMARY KEY`
FOREIGN KEY	Links two tables; value must exist in the referenced table	`FOREIGN KEY (Class) REFERENCES CLASSES(ClassID)`
NOT NULL	Column cannot contain NULL values	`Name VARCHAR(50) NOT NULL`
UNIQUE	All values in the column must be different (allows one NULL)	`Email VARCHAR(60) UNIQUE`
DEFAULT	Sets a default value when no value is provided during INSERT	`Section CHAR(1) DEFAULT 'A'`
CHECK	Ensures values satisfy a condition	`Marks DECIMAL(5,2) CHECK (Marks >= 0 AND Marks <= 100)`

Complete CREATE TABLE with Multiple Constraints

CREATE TABLE STUDENT (
    RollNo    INT          PRIMARY KEY,
    Name      VARCHAR(50)  NOT NULL,
    Class     INT          NOT NULL CHECK (Class BETWEEN 1 AND 12),
    Section   CHAR(1)      DEFAULT 'A',
    Marks     DECIMAL(5,2) CHECK (Marks >= 0 AND Marks <= 100),
    Grade     VARCHAR(2),
    City      VARCHAR(30)  NOT NULL
);

DML Commands: INSERT, UPDATE, DELETE

DML (Data Manipulation Language) commands modify the data inside tables without changing the table structure. Unlike DDL, DML operations can be rolled back (reversed) if used within a transaction. Board papers typically give you a table and ask you to write INSERT, UPDATE, or DELETE statements to achieve a specific change.

INSERT INTO

-- Insert with all columns specified
INSERT INTO STUDENT (RollNo, Name, Class, Section, Marks, Grade, City)
VALUES (107, 'Meera Singh', 12, 'A', 90, 'A1', 'Nashik');

-- Insert without column names (values must match table order exactly)
INSERT INTO STUDENT
VALUES (108, 'Arjun Rao', 11, 'B', 74, 'B1', 'Mumbai');

Exam tip: Always enclose string values in single quotes. Numeric values do not need quotes. Writing '12' instead of 12 for an INT column is a common mistake that costs half a mark.

UPDATE

-- Update specific rows
UPDATE STUDENT SET Marks = 96 WHERE RollNo = 101;

-- Update multiple columns
UPDATE STUDENT SET Grade = 'A1', Section = 'A'
WHERE Marks >= 90;

-- Update all rows (no WHERE clause — be careful!)
UPDATE STUDENT SET City = 'Nashik';

Critical warning: Forgetting the WHERE clause in UPDATE affects every row in the table. Examiners sometimes ask “What happens if the WHERE clause is omitted?” — the answer is that all rows are updated.

DELETE

-- Delete specific rows
DELETE FROM STUDENT WHERE RollNo = 105;

-- Delete rows matching a condition
DELETE FROM STUDENT WHERE Marks < 40;

-- Delete all rows (table structure remains)
DELETE FROM STUDENT;

DROP vs DELETE: DROP TABLE removes the table itself (structure + data). DELETE FROM removes rows but keeps the table structure intact. This distinction is asked in almost every board paper.

DQL: SELECT with WHERE, ORDER BY, DISTINCT

DQL (Data Query Language) is the heart of SQL in board exams. The SELECT statement retrieves data from one or more tables. Almost every SQL question in the exam involves writing a SELECT query with various clauses. Mastering SELECT alone can secure you 70–80 percent of the SQL marks.

Basic SELECT Queries

-- Select all columns
SELECT * FROM STUDENT;

-- Select specific columns
SELECT Name, Marks, Grade FROM STUDENT;

-- DISTINCT — remove duplicate values
SELECT DISTINCT City FROM STUDENT;
-- Output: Nashik, Pune, Mumbai

-- Column alias
SELECT Name, Marks * 0.5 AS HalfMarks FROM STUDENT;

WHERE Clause with Operators

-- Comparison operators
SELECT * FROM STUDENT WHERE Marks >= 85;

-- AND, OR, NOT
SELECT * FROM STUDENT WHERE Class = 12 AND Marks > 90;
SELECT * FROM STUDENT WHERE City = 'Nashik' OR City = 'Pune';
SELECT * FROM STUDENT WHERE NOT Grade = 'B2';

-- BETWEEN (inclusive of both ends)
SELECT * FROM STUDENT WHERE Marks BETWEEN 80 AND 95;

-- IN (matches any value in a list)
SELECT * FROM STUDENT WHERE City IN ('Nashik', 'Mumbai');

-- LIKE (pattern matching)
SELECT * FROM STUDENT WHERE Name LIKE 'A%';    -- starts with A
SELECT * FROM STUDENT WHERE Name LIKE '%a';    -- ends with a
SELECT * FROM STUDENT WHERE Name LIKE '_r%';   -- second character is r
SELECT * FROM STUDENT WHERE Name LIKE '%sh%';  -- contains sh

-- IS NULL / IS NOT NULL
SELECT * FROM STUDENT WHERE Grade IS NOT NULL;

LIKE wildcards: % matches zero or more characters. _ (underscore) matches exactly one character. This is one of the most frequently tested topics — expect at least one LIKE question per paper.

ORDER BY Clause

-- Ascending order (default)
SELECT * FROM STUDENT ORDER BY Marks;
SELECT * FROM STUDENT ORDER BY Marks ASC;

-- Descending order
SELECT * FROM STUDENT ORDER BY Marks DESC;

-- Multiple columns
SELECT * FROM STUDENT ORDER BY Class ASC, Marks DESC;

Exam tip: ORDER BY always comes after WHERE and before LIMIT. The correct clause order is: SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT.

Aggregate Functions: COUNT, SUM, AVG, MAX, MIN

Aggregate functions perform a calculation on a set of values and return a single value. They are used with SELECT and are the building blocks for GROUP BY queries. Every board paper includes at least 2–3 questions on aggregate functions.

Function	Purpose	Example	Output
COUNT()	Counts number of rows	`SELECT COUNT(*) FROM STUDENT;`	6
SUM()	Adds all values	`SELECT SUM(Marks) FROM STUDENT;`	500
AVG()	Calculates average	`SELECT AVG(Marks) FROM STUDENT;`	83.33
MAX()	Finds highest value	`SELECT MAX(Marks) FROM STUDENT;`	95
MIN()	Finds lowest value	`SELECT MIN(Marks) FROM STUDENT;`	62

Important Notes on Aggregate Functions

COUNT(*) counts all rows including NULLs. COUNT(column_name) counts only non-NULL values. This distinction is a favourite exam question.
Aggregate functions ignore NULL values (except COUNT(*)).
You cannot use an aggregate function in a WHERE clause. Use HAVING instead. Writing WHERE AVG(Marks) > 80 is a syntax error.
You can combine aggregate functions with WHERE to filter before aggregation: SELECT AVG(Marks) FROM STUDENT WHERE Class = 12;

GROUP BY and HAVING

GROUP BY groups rows that share a common value into summary rows. It is always used with aggregate functions. HAVING is the filter for grouped results — it is to GROUP BY what WHERE is to SELECT. This is the single most confused topic in SQL for board exam students, so pay close attention.

GROUP BY Examples

-- Count students in each class
SELECT Class, COUNT(*) AS Total
FROM STUDENT
GROUP BY Class;
-- Output: Class 11 → 2, Class 12 → 4

-- Average marks per city
SELECT City, AVG(Marks) AS AvgMarks
FROM STUDENT
GROUP BY City;

-- Maximum marks per grade
SELECT Grade, MAX(Marks) AS TopMarks
FROM STUDENT
GROUP BY Grade;

HAVING Clause (Filter After Grouping)

-- Cities with more than 1 student
SELECT City, COUNT(*) AS Total
FROM STUDENT
GROUP BY City
HAVING COUNT(*) > 1;

-- Classes where average marks exceed 80
SELECT Class, AVG(Marks) AS AvgMarks
FROM STUDENT
GROUP BY Class
HAVING AVG(Marks) > 80;

WHERE vs HAVING — The Most Important Distinction

WHERE filters individual rows before grouping. It cannot use aggregate functions.
HAVING filters groups after GROUP BY. It works with aggregate functions.
Execution order: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
Example: “Show the average marks per city, but only for Class 12 students, and only if the city has more than one student.”

SELECT City, AVG(Marks) AS AvgMarks
FROM STUDENT
WHERE Class = 12          -- filters rows BEFORE grouping
GROUP BY City
HAVING COUNT(*) > 1;     -- filters groups AFTER grouping

JOINs: Cartesian Product, Equi-Join, Natural Join

JOIN operations combine rows from two or more tables based on a related column. CBSE Class 12 specifically covers three types of joins. ICSE Class 10 covers basic equi-joins. Understanding joins is critical because 4–5 mark questions are often dedicated solely to writing a JOIN query.

Cartesian Product (Cross Join)

Combines every row from the first table with every row from the second table. If STUDENT has 6 rows and TEACHER has 4 rows, the result has 6 × 4 = 24 rows.

SELECT * FROM STUDENT, TEACHER;
-- Returns 24 rows (6 × 4) — every possible combination

Cartesian products are rarely useful on their own but form the theoretical basis of all joins.

Equi-Join

Joins two tables based on a matching condition using the equality operator (=). This is the most common join type in board exams.

-- Show student names with their teacher names (matching on Class)
SELECT S.Name, S.Class, S.Marks, T.TName, T.Subject
FROM STUDENT S, TEACHER T
WHERE S.Class = T.Class;

-- Same query using JOIN keyword (modern syntax)
SELECT S.Name, S.Class, S.Marks, T.TName, T.Subject
FROM STUDENT S
JOIN TEACHER T ON S.Class = T.Class;

Exam tip: Both syntaxes — comma-separated with WHERE and explicit JOIN with ON — are accepted in board exams. The comma syntax is more commonly shown in CBSE textbooks. Use table aliases (S, T) to avoid ambiguity when both tables have a column with the same name.

Natural Join

Automatically joins tables on all columns with the same name. No ON or WHERE condition is needed.

SELECT Name, Class, Marks, TName, Subject
FROM STUDENT NATURAL JOIN TEACHER;
-- Joins on the 'Class' column (common to both tables)
-- The 'Class' column appears only once in the result

Important: In a natural join, the common column appears only once in the output (not duplicated). If the two tables have multiple columns with the same name, the natural join matches on all of them, which can produce unexpected results.

20 Most Repeated Exam Questions with Solutions

These questions are drawn from CBSE and ICSE board papers from 2018 to 2026. They represent the exact patterns examiners use. Practise each one until you can write the query without hesitation.

Questions 1–5: Basic SELECT and WHERE

Display names and marks of all students who scored above 85.
SELECT Name, Marks FROM STUDENT WHERE Marks > 85;
Display all details of students from Nashik or Mumbai.
SELECT * FROM STUDENT WHERE City IN ('Nashik', 'Mumbai');
Display names of students whose name starts with 'A'.
SELECT Name FROM STUDENT WHERE Name LIKE 'A%';
Display students with marks between 75 and 90 (inclusive).
SELECT * FROM STUDENT WHERE Marks BETWEEN 75 AND 90;
Display all unique cities from the STUDENT table.
SELECT DISTINCT City FROM STUDENT;

Questions 6–10: ORDER BY and Aggregate Functions

Display all students in descending order of marks.
SELECT * FROM STUDENT ORDER BY Marks DESC;
Display the total number of students in Class 12.
SELECT COUNT(*) FROM STUDENT WHERE Class = 12;
Display the highest and lowest marks in the table.
SELECT MAX(Marks) AS Highest, MIN(Marks) AS Lowest FROM STUDENT;
Display the average marks of all students.
SELECT AVG(Marks) AS AverageMarks FROM STUDENT;
Display the sum of marks of students from Nashik.
SELECT SUM(Marks) FROM STUDENT WHERE City = 'Nashik';

Questions 11–15: GROUP BY, HAVING, and DDL/DML

Display the number of students in each city.
SELECT City, COUNT(*) AS Total FROM STUDENT GROUP BY City;
Display cities where more than one student is enrolled.
SELECT City, COUNT(*) AS Total FROM STUDENT GROUP BY City HAVING COUNT(*) > 1;
Display the average marks per class, only for classes with average above 80.
SELECT Class, AVG(Marks) AS AvgMarks FROM STUDENT GROUP BY Class HAVING AVG(Marks) > 80;
Add a column 'Phone' of type VARCHAR(15) to the STUDENT table.
ALTER TABLE STUDENT ADD Phone VARCHAR(15);
Increase marks of all students in Class 11 by 5.
UPDATE STUDENT SET Marks = Marks + 5 WHERE Class = 11;

Questions 16–20: JOINs and Advanced Queries

Display student names along with their teacher names (join on Class).
SELECT S.Name, T.TName FROM STUDENT S, TEACHER T WHERE S.Class = T.Class;
Display the Cartesian product of STUDENT and TEACHER. How many rows will appear?
SELECT * FROM STUDENT, TEACHER;
Answer: 6 × 4 = 24 rows.
Delete all students who scored below 65.
DELETE FROM STUDENT WHERE Marks < 65;
Display names of students who belong to the same city as 'Aarav Sharma'.
SELECT Name FROM STUDENT WHERE City = (SELECT City FROM STUDENT WHERE Name = 'Aarav Sharma');
Display the name, marks, and grade of the student with the highest marks.
SELECT Name, Marks, Grade FROM STUDENT WHERE Marks = (SELECT MAX(Marks) FROM STUDENT);

Common Mistakes That Cost Marks

These are the errors examiners see most often. Avoiding them is worth 2–4 marks per paper.

Mistake	Wrong	Correct
Using aggregate in WHERE	`WHERE AVG(Marks) > 80`	`HAVING AVG(Marks) > 80`
Missing quotes on strings	`WHERE City = Nashik`	`WHERE City = 'Nashik'`
Wrong clause order	`HAVING ... GROUP BY`	`GROUP BY ... HAVING`
Confusing = with LIKE	`WHERE Name = 'A%'`	`WHERE Name LIKE 'A%'`
Using = for NULL check	`WHERE Grade = NULL`	`WHERE Grade IS NULL`
Forgetting semicolon	`SELECT * FROM STUDENT`	`SELECT * FROM STUDENT;`
Non-aggregated column without GROUP BY	`SELECT City, AVG(Marks) FROM STUDENT;`	`SELECT City, AVG(Marks) FROM STUDENT GROUP BY City;`

Quick-Reference: Clause Execution Order

Memorise this order — it determines where you can use which keywords:
1. FROM (choose the table) → 2. WHERE (filter rows) → 3. GROUP BY (group remaining rows) → 4. HAVING (filter groups) → 5. SELECT (choose columns) → 6. ORDER BY (sort results) → 7. LIMIT (restrict output rows)

Frequently Asked Questions

Q: Is SQL case-sensitive in board exams?

SQL keywords (SELECT, FROM, WHERE) are not case-sensitive in MySQL. You can write select, SELECT, or Select — all are accepted. However, string comparisons depend on the collation. In board exams, examiners accept any case for keywords. It is best practice to write SQL keywords in uppercase and table/column names as given in the question paper for clarity and to show you understand the syntax.

Q: What is the difference between DELETE, DROP, and TRUNCATE?

DELETE removes specific rows (or all rows if no WHERE clause) and can be rolled back. DROP removes the entire table including its structure and cannot be rolled back. TRUNCATE removes all rows but keeps the table structure — it is faster than DELETE for clearing a table and resets AUTO_INCREMENT counters. CBSE covers DELETE and DROP. TRUNCATE is not in the CBSE/ICSE syllabus but knowing it helps in output prediction questions.

Q: Can I use JOIN keyword syntax instead of comma syntax in board exams?

Yes. Both SELECT * FROM A, B WHERE A.id = B.id and SELECT * FROM A JOIN B ON A.id = B.id are accepted by CBSE and ICSE examiners. The NCERT textbook uses the comma syntax with WHERE, so that is what most teachers recommend. However, the JOIN keyword syntax is considered modern best practice and is equally valid.

Q: How many marks can I score just from SQL in CBSE Class 12?

In the CBSE Class 12 Computer Science theory paper (70 marks), SQL questions typically carry 10–15 marks. This includes 2–3 marks for DDL/DML theory, 4–5 marks for writing queries on a given table, and 3–4 marks for output prediction. In Informatics Practices (IP), SQL carries even more weight — up to 18–20 marks. Combined with the practical exam where Python-MySQL connectivity is tested, SQL knowledge contributes to nearly 20–25 marks of your total score.

Q: Do I need to learn subqueries for the board exam?

Subqueries (nested SELECT statements) are part of the CBSE Class 12 syllabus under “SQL queries using IN, BETWEEN, LIKE, and subqueries.” Simple single-row subqueries like WHERE Marks = (SELECT MAX(Marks) FROM STUDENT) appear frequently. Multi-row subqueries using IN also appear. You should be comfortable with at least these two patterns. ICSE Class 10 does not explicitly include subqueries, but understanding them gives you an edge in competitive programming and higher studies.

Q: What is the best way to practise SQL for the board exam?

Install MySQL on your computer (MySQL Community Server is free) and create the sample tables from your textbook. Write every query by hand first, then execute it in MySQL to verify the output. Focus on three things: (1) writing correct syntax from memory, (2) predicting output for given queries, and (3) identifying errors in incorrect queries. Practise all previous year board paper SQL questions from 2018 onwards — the patterns repeat with minor variations. Aim to solve 5–8 SQL questions daily for two weeks before the exam.

Q: What are the most important MySQL functions apart from aggregates?

For CBSE Class 12, you should also know string functions (UPPER(), LOWER(), LENGTH(), LEFT(), RIGHT(), MID()/SUBSTRING(), TRIM(), CONCAT()), numeric functions (MOD(), ROUND(), TRUNCATE(), POWER()), and date functions (NOW(), CURDATE(), DATE(), MONTH(), YEAR(), DAY(), DAYNAME()). These carry 2–4 marks and are often tested as “predict the output” questions. ICSE Class 10 covers a smaller subset focusing mainly on aggregate and basic string functions.

SQL Is the Easiest Section to Score Full Marks — If You Practise the Syntax

Unlike essay-type answers where marks depend on presentation, SQL questions have objective, verifiable answers. Every query you practise today is a mark you secure tomorrow. Use the sample tables above, work through all 20 practice questions by hand, memorise the clause order (FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY), and walk into the exam with complete confidence in SQL.

Need structured coaching for CBSE or ICSE Computer Science? Bright Tutorials offers expert guidance with hands-on MySQL lab sessions, previous year paper analysis, and personalised doubt-clearing. Reach out today.

About Bright Tutorials

Bright Tutorials is a trusted coaching institute in Nashik, providing expert guidance for CBSE, ICSE, SSC, and competitive exam preparation since 2015.

Address: Shop No. 53-57, Business Signature, Hariom Nagar, Nashik Road, Nashik, Maharashtra 422101

Google Maps: Get Directions

Phone: +91 94037 81999 | +91 94047 81990

Email: info@brighttutorials.in | Website: brighttutorials.in