Section outline

  • General

    Collapse all Expand all
    • Announcements Forum
    • Index and Course Goals Page

      🎯 Course Goals

      • Understand relational databases and SQL fundamentals.

      • Write efficient queries to extract, filter, and analyze data.

      • Perform joins, subqueries, aggregations, and window functions.

      • Work with real-world databases for business use-cases.

      • Optimize queries, design schemas, and understand transactions.

      • Prepare for SQL interviews and certifications.

      🏗 Course Structure

      Duration: 8–10 weeks (self-paced)
      Format: Text lessons, Quizzes, exercises, projects, and case studies

  • Module 1: Introduction to Databases And SQL

    • What is a Database? Lesson

      1. Definition of a Database

      A database is an organized collection of data that can be stored, managed, and retrieved efficiently using a computer system.

      Think of it as a digital filing cabinet:

      • A file cabinet stores documents → A database stores information.

      • A folder groups related documents → A table groups related records.

      • Each page in a folder has details → Each row in a table has information.

      👉 In short:

      • Data = raw facts (e.g., "John", "Salary: 50,000").

      • Database = a structured way of storing these facts so they can be searched, updated, and analyzed efficiently.

      Key Features of Databases:

      • Structured storage → Organized into tables, rows, and columns.

      • Efficient retrieval → Allows fast searching and filtering.

      • Data integrity → Ensures accuracy and consistency.

      • Security → Controls who can access or change the data.

      • Scalability → Handles growing amounts of data.

      Example:
      An Employee Database may have a table like this:

      Employee_ID Name Department Salary Hire_Date
      101 John HR 50,000 2018-05-20
      102 Alice IT 70,000 2019-01-15
      103 Raj Finance 65,000 2020-03-01

      2. Difference Between Relational (RDBMS) and Non-Relational (NoSQL) Databases

      Databases are broadly categorized into two types:

      A. Relational Databases (RDBMS)

      • Store data in tables (rows and columns).

      • Relationships are established between tables using primary keys and foreign keys.

      • Use SQL (Structured Query Language) for data retrieval and manipulation.

      • Ensure ACID properties (Atomicity, Consistency, Isolation, Durability) → reliable transactions.

      Example:

      • Employees table and Departments table linked by Department_ID.

      • Query to find all employees in IT:

         
        SELECT name FROM employees WHERE department_id = 2;

      Pros:
      ✔ Structured & reliable
      ✔ Strong data integrity
      ✔ Great for complex queries

      Cons:
      ✘ Rigid schema → not flexible for rapidly changing data
      ✘ Scaling horizontally (across many servers) can be difficult

      B. Non-Relational Databases (NoSQL)

      • Store data in flexible formats:

        • Document-based (JSON/XML) → MongoDB

        • Key-Value → Redis

        • Columnar → Cassandra

        • Graph-based → Neo4j

      • No fixed schema → data can change frequently.

      • Designed for big data and high scalability.

      • Prioritize speed and flexibility over strict consistency.

      Example (Document Database – MongoDB):

       
      { "employee_id": 101, "name": "John", "department": "IT", "skills": ["SQL", "Python", "AWS"] }

      Pros:
      ✔ Handles unstructured/semi-structured data
      ✔ Scales easily across servers
      ✔ High performance for read/write operations

      Cons:
      ✘ Weaker consistency in some models
      ✘ Not ideal for complex relational queries

      ✅ Quick Comparison:

      Feature Relational (RDBMS) Non-Relational (NoSQL)
      Data Format Tables (rows & columns) Documents, Key-Value, Graph, Columns
      Schema Fixed, structured Flexible, dynamic
      Language SQL Varies (MongoQL, CQL, APIs)
      Best For Structured data, transactions Big Data, real-time apps
      Example Systems MySQL, PostgreSQL, Oracle MongoDB, Redis, Cassandra

      3. Popular RDBMS

      Let’s look at the most widely used relational databases:

      🔹 MySQL

      • Open-source, widely used for web applications.

      • Powers platforms like WordPress, Facebook (early days).

      • Great for small to medium-sized projects.

      🔹 PostgreSQL

      • Advanced, open-source RDBMS.

      • Supports complex queries, JSON data, full-text search.

      • Strong in analytics, geospatial data, data science use cases.

      🔹 SQL Server (by Microsoft)

      • Enterprise-grade, widely used in corporate environments.

      • Deep integration with Microsoft ecosystem (Excel, Power BI, .NET).

      • Offers both on-premise and cloud (Azure SQL) options.

      🔹 Oracle Database

      • Extremely powerful, secure, and feature-rich.

      • Used by large enterprises (banking, telecom, governments).

      • Strong in performance tuning and large-scale data handling.

      🔹 SQLite

      • Lightweight, file-based database (no server required).

      • Often embedded in mobile apps, IoT devices, local tools.

      • Example: Your phone’s contact list is stored in SQLite.

      4. Use-Cases of Databases

      Databases are everywhere. Here are some industry examples:

      🔸 Banking & Finance

      • RDBMS is preferred for transactions (must be accurate & consistent).

      • Example: Storing customer accounts, tracking deposits/withdrawals.

      • Queries: Checking balance, fraud detection, loan history.

      🔸 E-commerce

      • Hybrid use (RDBMS + NoSQL).

      • RDBMS → Orders, payments, inventory.

      • NoSQL → Product recommendations, user browsing history.

      • Example: Amazon → structured transactions + NoSQL for personalization.

      🔸 Social Media

      • NoSQL dominant because of unstructured data (posts, likes, comments).

      • Example: Facebook uses Cassandra, Instagram uses PostgreSQL + NoSQL.

      • Graph Databases (Neo4j) for friend relationships.

      🔸 Analytics & Big Data

      • NoSQL + RDBMS combo.

      • Example: Netflix uses Cassandra (NoSQL) for streaming data + MySQL for user accounts.

      • Data warehouses (Snowflake, BigQuery, Redshift) for reporting.

      🎯 Summary

      • A database organizes and manages data for efficient use.

      • RDBMS = structured, reliable, SQL-based, great for transactions.

      • NoSQL = flexible, scalable, great for unstructured/big data.

      • Popular RDBMS: MySQL, PostgreSQL, SQL Server, Oracle, SQLite.

      • Real-world use-cases: banking (transactions), e-commerce (orders + recommendations), social media (user data), analytics (big data insights).

    • Understanding Tables, Rows, and Columns Lesson

      When learning SQL, the first step is to understand how data is organized inside a database.
      The three most important building blocks are:

      • Tables

      • Rows (Records)

      • Columns (Fields)

      Let’s break these down with clear examples.

      1. 🔹 What is a Table?

      • A table is like a container for data.

      • Think of it as an Excel sheet inside a database.

      • Each table stores information about a specific type of data.

      👉 Example: An Employees table stores details about employees.
      It looks like a grid with rows and columns.

      Employees Table (Example):

      EmployeeID Name Department Salary
      101 John HR 50,000
      102 Alice IT 70,000
      103 David Finance 65,000

      • Table name: Employees

      • Rows = each employee record

      • Columns = employee details (ID, Name, etc.)

      2. 🔹 What is a Row (Record)?

      • A row is a single entry in the table.

      • It represents one instance of the data type stored in the table.

      • Each row contains all the column values for that record.

      👉 Example:

       
      Row Example (Employee 101) EmployeeID: 101 Name: John Department: HR Salary: 50,000

      So, the first row in the Employees table means:

      • There is an employee named John,

      • His ID is 101,

      • He works in HR,

      • His salary is 50,000.

      3. 🔹 What is a Column (Field)?

      • A column defines an attribute or property of the data.

      • Every row must have a value (or sometimes NULL) for each column.

      👉 Example Columns in the Employees table:

      • EmployeeID → unique identifier

      • Name → employee’s name

      • Department → department name

      • Salary → salary amount

      Each column has a data type (e.g., INT, VARCHAR, DATE, etc.).
      For example:

      • EmployeeID → Integer

      • Name → Text (VARCHAR)

      • Salary → Number/Decimal

      4. 📊 Putting It All Together

      Let’s visualize:

      • Table = Excel file named Employees.xlsx

      • Column = Each Excel column → “Name”, “Salary”, “Department”

      • Row = Each Excel row → “John, 101, HR, 50000”

      So in SQL:

      • Table = container of data

      • Row = one record (employee, student, order, etc.)

      • Column = attribute/field of that record

      5. 🖥️ SQL Example

      Let’s create the Employees table in SQL:

       
      CREATE TABLE Employees ( EmployeeID INT PRIMARY KEY, Name VARCHAR(50), Department VARCHAR(50), Salary DECIMAL(10,2) );

      Insert some rows:

       
      INSERT INTO Employees (EmployeeID, Name, Department, Salary) VALUES (101, 'John', 'HR', 50000), (102, 'Alice', 'IT', 70000), (103, 'David', 'Finance', 65000);

      Retrieve data (see rows & columns):

       
      SELECT * FROM Employees;

      ✅ You now understand:

      • Tables = storage like Excel sheet

      • Rows = records (John, ID 101, etc.)

      • Columns = attributes (Name, Salary, DeptID)

      📘 Understanding Tables, Rows, and Columns (with Real-Life Examples)

      1. 📦 Use-Case: Online Shopping (E-Commerce)

      Think about Amazon or Flipkart.
      They need to store details about their products.

      Products Table Example:

      ProductID ProductName Category Price Stock
      201 iPhone 15 Mobile 80000 50
      202 Samsung TV Electronics 60000 20
      203 Nike Shoes Fashion 5000 100

      • Table: Products

      • Rows: Each row is one product (iPhone, TV, Shoes).

      • Columns: ProductID, Name, Category, Price, Stock.

      👉 SQL Example:

       
      SELECT ProductName, Price FROM Products WHERE Category = 'Mobile';

      This will list all Mobiles and their prices.

      2. 🏦 Use-Case: Banking

      A bank needs to track customers and their accounts.

      Customers Table Example:

      CustomerID Name AccountType Balance
      301 Rahul Savings 15000.00
      302 Priya Current 50000.00
      303 Arjun Savings 32000.00

      • Table: Customers

      • Rows: Each customer is a record.

      • Columns: ID, Name, Account Type, Balance.

      👉 SQL Example:

       
      SELECT Name, Balance FROM Customers WHERE Balance > 20000;

      This query shows all customers who have more than ₹20,000.

      3. 🎓 Use-Case: Education (School / College)

      A school keeps records of students.

      Students Table Example:

      StudentID Name Class Marks
      401 Neha 10 89
      402 Karan 12 76
      403 Meena 9 92

      • Table: Students

      • Rows: Each student = one row.

      • Columns: StudentID, Name, Class, Marks.

      👉 SQL Example:

       
      SELECT Name, Marks FROM Students WHERE Marks >= 90;

      This shows toppers scoring 90 or above.

      4. 🚖 Use-Case: Ride Booking (Uber/Ola)

      A ride-booking app must store trips.

      Rides Table Example:

      RideID CustomerName Pickup Drop Fare
      501 Ankit Delhi Noida 350
      502 Sonali Mumbai Pune 1200
      503 Ramesh Bangalore Airport 600

      • Table: Rides

      • Rows: Each ride = one row.

      • Columns: RideID, Customer, Pickup, Drop, Fare.

      👉 SQL Example:

       
      SELECT CustomerName, Fare FROM Rides WHERE Fare > 500;

      This lists all high-value rides.

      5. 🛒 Putting All Use-Cases Together

      • E-Commerce (Products) → what’s being sold.

      • Banking (Customers) → who owns accounts.

      • Education (Students) → who studies in school.

      • Ride Booking (Rides) → trips being tracked.

      In all these cases:

      • Table = container of data

      • Row = one record

      • Column = attribute of that record

    • Introduction to SQL Lesson

      1. 🔹 What is SQL?

      • SQL stands for Structured Query Language.

      • It is the standard language used to communicate with databases.

      • SQL helps you:

        • Create databases and tables

        • Insert, update, and delete data

        • Query (search/filter) data

        • Control access (permissions)

        • Manage transactions

      👉 In simple words: SQL is the language of databases.

      2. 🔹 Why Learn SQL?

      • Every business stores data (e-commerce, banking, education, social media).

      • SQL is used to organize and retrieve this data.

      • If you can speak SQL, you can “talk to databases” like MySQL, PostgreSQL, SQL Server, Oracle, and SQLite.

      3. 🔹 Categories of SQL Commands

      SQL commands are grouped into five main categories:

      🟦 A. DDL (Data Definition Language)

      • Deals with structure of database objects (like tables, schemas).

      • Used to create, modify, or delete tables and databases.

      Common Commands:

      • CREATE → create a new table or database.

      • ALTER → change structure (add/remove column).

      • DROP → delete a table or database.

      Example:

       
      -- Create a table CREATE TABLE Employees ( EmployeeID INT PRIMARY KEY, Name VARCHAR(50), Salary DECIMAL(10,2) ); -- Add a new column ALTER TABLE Employees ADD Department VARCHAR(50); -- Delete the table DROP TABLE Employees;

      🟩 B. DML (Data Manipulation Language)

      • Deals with data stored inside tables.

      • Used to insert, modify, or remove records.

      Common Commands:

      • INSERT → add data into a table.

      • UPDATE → modify existing data.

      • DELETE → remove data.

      Example:

       
      -- Insert data INSERT INTO Employees (EmployeeID, Name, Salary, Department) VALUES (101, 'John', 50000, 'HR'); -- Update salary UPDATE Employees SET Salary = 55000 WHERE EmployeeID = 101; -- Delete record DELETE FROM Employees WHERE EmployeeID = 101;

      🟨 C. DCL (Data Control Language)

      • Deals with access rights and permissions.

      • Used to control who can access what in the database.

      Common Commands:

      • GRANT → give permission.

      • REVOKE → take back permission.

      Example:

       
      -- Give permission to user GRANT SELECT, INSERT ON Employees TO user1; -- Revoke permission REVOKE INSERT ON Employees FROM user1;

      🟥 D. TCL (Transaction Control Language)

      • Deals with transactions (a group of SQL commands that run together).

      • Helps maintain data integrity.

      Common Commands:

      • COMMIT → save changes permanently.

      • ROLLBACK → undo changes.

      • SAVEPOINT → create a checkpoint to rollback partially.

      Example:

       
      -- Start transaction BEGIN; -- Insert new record INSERT INTO Employees (EmployeeID, Name, Salary, Department) VALUES (102, 'Alice', 70000, 'IT'); -- Save changes COMMIT; -- Or, rollback if something goes wrong ROLLBACK; -- Using savepoint SAVEPOINT sp1; UPDATE Employees SET Salary = 80000 WHERE EmployeeID = 102; ROLLBACK TO sp1;

      🟧 (Optional) DQL (Data Query Language)

      • Some books/websites treat SELECT as a separate category (DQL).

      • Used only for retrieving data.

      Example:

       
      SELECT Name, Salary FROM Employees WHERE Department = 'IT';

      4. 📊 Summary Table

      Category Full Form Purpose Examples
      DDL Data Definition Language Defines structure CREATE, ALTER, DROP
      DML Data Manipulation Language Manages data INSERT, UPDATE, DELETE
      DCL Data Control Language Controls access GRANT, REVOKE
      TCL Transaction Control Language Manages transactions COMMIT, ROLLBACK, SAVEPOINT
      DQL Data Query Language Retrieves data SELECT

      ✅ You now know:

      • What SQL is

      • Why it is important

      • The 4 (or 5) categories of SQL commands with examples

      📘 Introduction to SQL (with Real-World Use-Cases)

      1. 🔹 Banking System Example

      A bank needs to manage customers, accounts, and transactions. Let’s see how each SQL category fits in.

      🟦 A. DDL in Banking (Creating Database Structure)

      👉 When a bank creates new systems, they define tables.

       
      -- Create Accounts table CREATE TABLE Accounts ( AccountID INT PRIMARY KEY, CustomerName VARCHAR(50), AccountType VARCHAR(20), Balance DECIMAL(12,2) );

      💡 Use-case:

      • Create Accounts, Transactions, Loans tables.

      • Alter structure when rules change (e.g., add IFSC_Code).

      • Drop test tables after migration.

      🟩 B. DML in Banking (Managing Customer Data)

      👉 Once the structure is ready, banks insert and update customer details.

       
      -- Add new customer account INSERT INTO Accounts (AccountID, CustomerName, AccountType, Balance) VALUES (101, 'Rahul Sharma', 'Savings', 25000); -- Update balance after deposit UPDATE Accounts SET Balance = Balance + 5000 WHERE AccountID = 101; -- Delete closed account DELETE FROM Accounts WHERE AccountID = 101;

      💡 Use-case:

      • Insert → New account opening.

      • Update → Deposit, withdrawal, or loan repayment.

      • Delete → Account closure.

      🟨 C. DCL in Banking (Access Permissions)

      👉 A bank must control who can view/change data.

       
      -- Grant access to accountant GRANT SELECT, UPDATE ON Accounts TO AccountantUser; -- Revoke update rights if role changes REVOKE UPDATE ON Accounts FROM AccountantUser;

      💡 Use-case:

      • Clerks → Can only view accounts.

      • Managers → Can view & update balances.

      • Auditors → Can only read data, not change it.

      🟥 D. TCL in Banking (Transactions)

      👉 Money transfers involve multiple steps. If any step fails, everything must be undone to maintain accuracy.

       
      BEGIN; -- Deduct from sender UPDATE Accounts SET Balance = Balance - 10000 WHERE AccountID = 201; -- Add to receiver UPDATE Accounts SET Balance = Balance + 10000 WHERE AccountID = 202; -- Save transaction permanently COMMIT; -- If error occurs (like receiver account missing) ROLLBACK;

      💡 Use-case:

      • Ensure deposits and withdrawals happen together.

      • If system crashes midway → rollback.

      • Savepoints used for partial rollbacks in large transactions.

      2. 🔹 E-Commerce Example

      Imagine Amazon or Flipkart.

      • DDL → Create tables: Products, Orders, Customers.

      • DML → Insert new products, update stock after purchase, delete discontinued items.

      • DCL → Grant access to customer service team for Orders, revoke admin rights after employee exit.

      • TCL → Ensure product stock reduces only if payment is successful.

      Example:

       
      BEGIN; UPDATE Products SET Stock = Stock - 1 WHERE ProductID = 501; INSERT INTO Orders (OrderID, CustomerID, ProductID, Status) VALUES (1001, 301, 501, 'Confirmed'); COMMIT; -- if both succeed -- ROLLBACK; if stock < 0 or payment fails

      3. 🔹 University Example

      For managing students and exams.

      • DDL → Create Students, Courses, Results tables.

      • DML → Insert new student records, update exam marks, delete graduated students.

      • DCL → Grant professors access to marks, revoke access after semester ends.

      • TCL → Ensure all marks for one exam update together or rollback.

      4. 📊 Quick Summary (Use-Cases at a Glance)

      Category Banking Example E-Commerce Example University Example
      DDL Create Accounts table Create Products table Create Students table
      DML Insert deposits, update balance Update stock, insert orders Insert marks, update results
      DCL Grant auditor read-only rights Grant CS team access Grant professor access
      TCL Transfer money safely Payment + stock update Exam results update

      ✅ Now you not only know theory + SQL commands, but also how banks, e-commerce, and universities actually use them.

    • 1. 🔹 MySQL Installation Lesson

      MySQL is one of the most widely used open-source databases.

      🖥️ Steps for Installation:

      1. Download

      2. Install

        • Run the installer → Choose Server only or Full setup.

        • Select MySQL Server and MySQL Workbench (GUI tool).

      3. Configuration

        • Set root password (admin password for database).

        • Optionally create a user account.

        • Choose default port → 3306.

      4. Test Connection

        • Open MySQL Workbench or command line.

        • Run:

           
          mysql -u root -p

        • Enter password → you are inside MySQL!

      👉 Tools to use:

      • MySQL Workbench (GUI)

      • Command Line

    • 2. 🔹 PostgreSQL Installation Lesson

      PostgreSQL is a powerful open-source database, popular in enterprises.

      🖥️ Steps for Installation:

      1. Download

      2. Install

        • Run installer.

        • Install pgAdmin (GUI tool).

      3. Configuration

        • Set password for postgres user (super admin).

        • Default port: 5432.

      4. Test Connection

        • Open pgAdmin.

        • Connect with user: postgres and your password.

        • Run a test query:

           
          SELECT version();

      👉 Tools to use:

      • pgAdmin (GUI)

      • psql (command line)

    • 3. 🔹 SQL Server (Microsoft SQL Server) Installation Lesson

      SQL Server is a Microsoft database used in enterprises.

      🖥️ Steps for Installation:

      1. Download

      2. Install

        • Run installer → Choose Basic or Custom installation.

        • Install SQL Server Management Studio (SSMS) separately fromSSMS Download.

      3. Configuration

        • Choose Mixed Mode Authentication (SQL + Windows login).

        • Set sa password (admin).

        • Default port: 1433.

      4. Test Connection

        • Open SSMS.

        • Login with:

          • Server: localhost

          • User: sa

          • Password: your password

      👉 Tools to use:

      • SSMS (SQL Server Management Studio)

      • Azure Data Studio (alternative GUI)

    • 4. 🔹 SQLite Installation Lesson

      SQLite is the simplest and lightweight database — great for beginners.

      🖥️ Steps for Installation:

      1. Download

      2. Install

        • Extract files.

        • Add the folder path to system environment variables (for command line access).

      3. Test Connection

        • Open terminal / command prompt.

        • Run:

           
          sqlite3 test.db

        • This creates a new database file test.db.

      4. Run a Query

         
        CREATE TABLE Students (ID INT, Name TEXT); INSERT INTO Students VALUES (1, 'John'); SELECT * FROM Students;

      👉 Tools to use:

      • Command line sqlite3

      • DB Browser for SQLite (GUI)

  • Module 2: SQL Basics – Data Retrieval

    • SELECT Statement Basics Lesson

      1. 🔹 What is SELECT?

      • The SELECT statement is used to retrieve data from a database table.

      • It is the most common SQL command and forms the foundation of querying.

      👉 General Syntax:

       
      SELECT column1, column2, ... FROM table_name;

      • SELECT → specifies which columns to show.

      • FROM → tells SQL which table to get data from.

      2. 🔹 Selecting All Columns

      If you want to get all the data from a table, use * (wildcard).

       
      SELECT * FROM Employees;

      👉 Example Table: Employees

      EmployeeID Name Department Salary
      101 John HR 50000
      102 Alice IT 70000
      103 David Finance 65000

      📌 Result:
      Shows all rows and columns of the Employees table.

      3. 🔹 Selecting Specific Columns

      You can choose only the columns you want.

       
      SELECT Name, Salary FROM Employees;

      📌 Result:

      Name Salary
      John 50000
      Alice 70000
      David 65000

      4. 🔹 Using WHERE Clause (Filtering Data)

      The WHERE clause filters rows based on conditions.

       
      SELECT Name, Department FROM Employees WHERE Salary > 60000;

      📌 Result:

      Name Department
      Alice IT
      David Finance

      5. 🔹 Using Aliases (Renaming Columns)

      Aliases help make results more readable.

       
      SELECT Name AS EmployeeName, Salary AS MonthlySalary FROM Employees;

      📌 Result:

      EmployeeName MonthlySalary
      John 50000
      Alice 70000
      David 65000

      6. 🔹 Removing Duplicate Results (DISTINCT)

      The DISTINCT keyword removes duplicates.

       
      SELECT DISTINCT Department FROM Employees;

      📌 Result:

      Department
      HR
      IT
      Finance

      7. 🔹 Sorting Results (ORDER BY)

      You can sort rows in ascending (ASC) or descending (DESC) order.

       
      SELECT Name, Salary FROM Employees ORDER BY Salary DESC;

      📌 Result:

      Name Salary
      Alice 70000
      David 65000
      John 50000

      8. 🔹 Limiting Results (LIMIT / TOP)

      • In MySQL & PostgreSQL → LIMIT

      • In SQL Server → TOP

       
      -- MySQL / PostgreSQL SELECT * FROM Employees LIMIT 2; -- SQL Server SELECT TOP 2 * FROM Employees;

      📌 Result:
      Shows only the first 2 rows.

      9. 📊 Summary

      Keyword Purpose Example
      SELECT * All columns SELECT * FROM Employees;
      SELECT col1, col2 Specific columns SELECT Name, Salary FROM Employees;
      WHERE Filter rows WHERE Salary > 60000;
      AS Rename column Name AS EmployeeName
      DISTINCT Remove duplicates SELECT DISTINCT Department;
      ORDER BY Sort results ORDER BY Salary DESC;
      LIMIT / TOP Restrict rows LIMIT 5 / TOP 5

      ✅ You now know how to:

      • Select all or specific columns

      • Filter results

      • Rename columns

      • Remove duplicates

      • Sort and limit results

    • Filtering Data with WHERE Clause Lesson

      1. 🔹 What is WHERE?

      • The WHERE clause is used to filter rows based on specific conditions.

      • It tells SQL: “Only show the rows that match this rule.”

      👉 General Syntax:

       
      SELECT column1, column2, ... FROM table_name WHERE condition;

      2. 🔹 Example Table (Employees)

      EmployeeID Name Department Salary Age
      101 John HR 50000 30
      102 Alice IT 70000 28
      103 David Finance 65000 40
      104 Neha IT 80000 35
      105 Ramesh HR 45000 25

      3. 🔹 Basic Filtering

      Equality (=)

       
      SELECT Name, Department FROM Employees WHERE Department = 'IT';

      📌 Result:

      Name Department
      Alice IT
      Neha IT

      Greater Than (>)

       
      SELECT Name, Salary FROM Employees WHERE Salary > 60000;

      📌 Result:

      Name Salary
      Alice 70000
      David 65000
      Neha 80000

      Less Than (<)

       
      SELECT Name, Age FROM Employees WHERE Age < 30;

      📌 Result:

      Name Age
      Alice 28
      Ramesh 25

      4. 🔹 Combining Conditions

      AND (Both Conditions Must Be True)

       
      SELECT Name, Salary, Department FROM Employees WHERE Department = 'IT' AND Salary > 75000;

      📌 Result:

      Name Salary Department
      Neha 80000 IT

      OR (At Least One Condition Must Be True)

       
      SELECT Name, Department FROM Employees WHERE Department = 'Finance' OR Department = 'HR';

      📌 Result:

      Name Department
      John HR
      David Finance
      Ramesh HR

      NOT (Exclude Results)

       
      SELECT Name, Department FROM Employees WHERE NOT Department = 'HR';

      📌 Result:

      Name Department
      Alice IT
      David Finance
      Neha IT

      5. 🔹 Special Filtering Operators

      BETWEEN (Range)

       
      SELECT Name, Salary FROM Employees WHERE Salary BETWEEN 45000 AND 70000;

      📌 Result:

      Name Salary
      John 50000
      Alice 70000
      David 65000
      Ramesh 45000

      IN (Multiple Values)

       
      SELECT Name, Department FROM Employees WHERE Department IN ('IT', 'Finance');

      📌 Result:

      Name Department
      Alice IT
      David Finance
      Neha IT

      LIKE (Pattern Matching)

       
      SELECT Name FROM Employees WHERE Name LIKE 'A%';

      📌 Result:

      Name
      Alice

      👉 Patterns:

      • A% → starts with A

      • %a → ends with a

      • %am% → contains "am"

      IS NULL / IS NOT NULL

       
      SELECT Name FROM Employees WHERE Department IS NULL;

      👉 Finds employees with no department assigned.

      6. 📊 Summary

      Operator Example Meaning
      = Salary = 50000 Equal to
      > / < Age > 30 Greater / Less than
      AND Dept = 'IT' AND Salary > 70000 Both must be true
      OR Dept = 'HR' OR Dept = 'Finance' At least one true
      NOT NOT Dept = 'HR' Excludes HR
      BETWEEN Salary BETWEEN 40000 AND 60000 Within a range
      IN Dept IN ('IT','Finance') Matches multiple values
      LIKE Name LIKE 'A%' Pattern search
      IS NULL Dept IS NULL Missing values

      ✅ You now know how to filter data with WHERE using:

      • Basic operators (=, <, >)

      • Logical operators (AND, OR, NOT)

      • Special filters (BETWEEN, IN, LIKE, NULL)

  • Module 3: Filtering & Operators

  • Module 4: Aggregations & Grouping

  • Module 5: Joins & Relationships