Python MySQL - WHERE Clause in MySQL

What You'll Learn Here

What is WHERE — filtering data in MySQL
Comparison operators — =, >, <, >=, <=, !=
Logical operators — AND, OR, NOT
LIKE operator — pattern matching with wildcards
IN operator — matching multiple values
BETWEEN operator — range filtering

What is the WHERE Clause?

The WHERE clause is one of the most important parts of SQL. It lets you filter your data and get only the rows you want.

💡 Key concept: WHERE is like a sieve that lets some data through and stops other data. It helps you ask specific questions to your database.

Think of it like searching through a large list. If you want to find all students older than 20, you would look through the list and pick only those who meet that condition. The WHERE clause does this automatically for you!

Why WHERE is Important

# ============================================================
# WHY WE NEED WHERE
# ============================================================

# Without WHERE, you get ALL rows
SELECT * FROM students;
# Returns 1000 students (including the ones you don't need)

# With WHERE, you get ONLY the rows you want
SELECT * FROM students WHERE age > 20;
# Returns only students older than 20

# ============================================================
# COMMON USE CASES
# ============================================================

# 1. Finding a specific record
SELECT * FROM students WHERE student_id = 5;

# 2. Filtering by a condition
SELECT * FROM students WHERE age >= 18;

# 3. Finding data within a range
SELECT * FROM students WHERE age BETWEEN 18 AND 25;

# 4. Pattern matching
SELECT * FROM students WHERE email LIKE '%@gmail.com';

# 5. Multiple conditions
SELECT * FROM students 
WHERE age > 20 AND first_name LIKE 'A%';

Key point: WHERE helps you find exactly what you're looking for without having to search through all the data yourself.

Quick Check: What does the WHERE clause do? (Answer: It filters rows based on a condition)

WHERE Clause Syntax

Basic WHERE Syntax

# ============================================================
# BASIC SYNTAX
# ============================================================

SELECT column1, column2 
FROM table_name 
WHERE condition;

# ============================================================
# REAL EXAMPLES
# ============================================================

# 1. Simple condition
SELECT * FROM students WHERE age = 22;

# 2. Using comparison operators
SELECT * FROM students WHERE age > 20;
SELECT * FROM students WHERE age >= 21;
SELECT * FROM students WHERE age < 25;
SELECT * FROM students WHERE age <= 24;

# 3. String comparison
SELECT * FROM students WHERE first_name = 'Rahul';

# 4. Using NOT
SELECT * FROM students WHERE age != 22;
SELECT * FROM students WHERE NOT age = 22;

# ============================================================
# IN PYTHON
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# Select students older than 20
cursor.execute("SELECT * FROM students WHERE age > 20")
results = cursor.fetchall()

for row in results:
    print(row)

cursor.close()
connection.close()

WHERE clause structure:

SELECT — specifies what columns to return
FROM — specifies the table
WHERE — specifies the filter condition
Condition — a true/false expression

Quick Check: What is the correct order of clauses? (Answer: SELECT, FROM, WHERE)

Comparison Operators

Using Comparison Operators

# ============================================================
# COMPARISON OPERATORS
# ============================================================

# =  equal to
# !=  not equal to
# >  greater than
# <  less than
# >=  greater than or equal to
# <=  less than or equal to

# ============================================================
# EXAMPLES
# ============================================================

# 1. Equal to
SELECT * FROM students WHERE age = 22;
# Returns students who are exactly 22

# 2. Not equal to
SELECT * FROM students WHERE age != 22;
# Returns students who are NOT 22

# 3. Greater than
SELECT * FROM students WHERE age > 22;
# Returns students older than 22

# 4. Less than
SELECT * FROM students WHERE age < 22;
# Returns students younger than 22

# 5. Greater than or equal to
SELECT * FROM students WHERE age >= 22;
# Returns students 22 or older

# 6. Less than or equal to
SELECT * FROM students WHERE age <= 22;
# Returns students 22 or younger

# ============================================================
# IN PYTHON
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# Different WHERE conditions
conditions = [
    ("age = 22", "age is exactly 22"),
    ("age > 22", "age is greater than 22"),
    ("age < 22", "age is less than 22"),
    ("age >= 22", "age is 22 or more"),
    ("age <= 22", "age is 22 or less"),
    ("age != 22", "age is not 22")
]

for condition, description in conditions:
    query = f"SELECT COUNT(*) FROM students WHERE {condition}"
    cursor.execute(query)
    count = cursor.fetchone()[0]
    print(f"{description}: {count} students")

cursor.close()
connection.close()

Comparison operators summary:

= — equals (exact match)
!= — not equals
> — greater than
< — less than
>= — greater than or equal
<= — less than or equal

Quick Check: What operator is used for "not equal to"? (Answer: !=)

Logical Operators (AND, OR, NOT)

Combining Multiple Conditions

# ============================================================
# LOGICAL OPERATORS
# ============================================================

# AND - both conditions must be true
# OR - at least one condition must be true
# NOT - reverses the condition

# ============================================================
# AND OPERATOR
# ============================================================

# Students who are older than 20 AND younger than 25
SELECT * FROM students 
WHERE age > 20 AND age < 25;

# Students named Rahul AND older than 20
SELECT * FROM students 
WHERE first_name = 'Rahul' AND age > 20;

# ============================================================
# OR OPERATOR
# ============================================================

# Students who are 22 OR 25 years old
SELECT * FROM students 
WHERE age = 22 OR age = 25;

# Students named Rahul OR Priya
SELECT * FROM students 
WHERE first_name = 'Rahul' OR first_name = 'Priya';

# ============================================================
# NOT OPERATOR
# ============================================================

# Students who are NOT 22 years old
SELECT * FROM students 
WHERE NOT age = 22;

# Students whose name is NOT Rahul
SELECT * FROM students 
WHERE NOT first_name = 'Rahul';

# ============================================================
# COMBINING AND + OR
# ============================================================

# Students older than 20 AND (named Rahul OR Priya)
SELECT * FROM students 
WHERE age > 20 AND (first_name = 'Rahul' OR first_name = 'Priya');

# ============================================================
# IN PYTHON
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# AND condition
cursor.execute("SELECT * FROM students WHERE age > 20 AND age < 25")
results = cursor.fetchall()
print(f"Students between 21 and 24: {len(results)}")

# OR condition
cursor.execute("SELECT * FROM students WHERE age = 22 OR age = 25")
results = cursor.fetchall()
print(f"Students aged 22 or 25: {len(results)}")

# NOT condition
cursor.execute("SELECT * FROM students WHERE NOT age = 22")
results = cursor.fetchall()
print(f"Students not aged 22: {len(results)}")

cursor.close()
connection.close()

Logical operators summary:

AND — both conditions must be true
OR — at least one condition must be true
NOT — reverses the condition
Use parentheses to group conditions

Quick Check: What does AND do in a WHERE clause? (Answer: Both conditions must be true)

LIKE Operator for Pattern Matching

Finding Patterns in Text

# ============================================================
# LIKE OPERATOR
# ============================================================

# % - matches any number of characters
# _ - matches exactly one character

# ============================================================
# EXAMPLES WITH %
# ============================================================

# Names starting with 'R'
SELECT * FROM students WHERE first_name LIKE 'R%';
# Returns: Rahul, Ravi, etc.

# Names ending with 'a'
SELECT * FROM students WHERE first_name LIKE '%a';
# Returns: Priya, Sneha, etc.

# Names containing 'a' anywhere
SELECT * FROM students WHERE first_name LIKE '%a%';
# Returns: Rahul, Priya, Sneha, etc.

# Emails ending with '@gmail.com'
SELECT * FROM students WHERE email LIKE '%@gmail.com';

# Emails starting with 'r'
SELECT * FROM students WHERE email LIKE 'r%';

# ============================================================
# EXAMPLES WITH _
# ============================================================

# Names with exactly 5 characters
SELECT * FROM students WHERE first_name LIKE '_____';

# Names starting with 'R' and exactly 5 characters
SELECT * FROM students WHERE first_name LIKE 'R____';

# ============================================================
# IN PYTHON - Using LIKE with Parameterized Queries
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# Search for names starting with 'R'
search_term = "R%"
cursor.execute("SELECT * FROM students WHERE first_name LIKE %s", (search_term,))
results = cursor.fetchall()
print(f"Names starting with 'R': {len(results)}")

# Search for Gmail users
cursor.execute("SELECT * FROM students WHERE email LIKE %s", ("%@gmail.com",))
results = cursor.fetchall()
print(f"Gmail users: {len(results)}")

cursor.close()
connection.close()

LIKE pattern wildcards:

% — matches any number of characters
_ — matches exactly one character
Use LIKE for partial text searches
Use parameterized queries with LIKE

Quick Check: What does % mean in a LIKE pattern? (Answer: Any number of characters)

IN Operator

Matching Multiple Values

# ============================================================
# IN OPERATOR
# ============================================================

# IN checks if a value matches any value in a list

# ============================================================
# BASIC IN EXAMPLE
# ============================================================

# Students aged 22, 25, or 27
SELECT * FROM students 
WHERE age IN (22, 25, 27);

# Same as using OR but cleaner:
# WHERE age = 22 OR age = 25 OR age = 27

# ============================================================
# IN WITH TEXT
# ============================================================

# Students named Rahul, Priya, or Amit
SELECT * FROM students 
WHERE first_name IN ('Rahul', 'Priya', 'Amit');

# ============================================================
# NOT IN
# ============================================================

# Students NOT aged 22, 25, or 27
SELECT * FROM students 
WHERE age NOT IN (22, 25, 27);

# ============================================================
# IN WITH SUBQUERY (Advanced)
# ============================================================

# Students who have placed orders
SELECT * FROM students 
WHERE student_id IN (SELECT DISTINCT student_id FROM orders);

# ============================================================
# IN PYTHON
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# Using IN with a list of ages
ages = (22, 25, 27)
placeholders = ', '.join(['%s'] * len(ages))
query = f"SELECT * FROM students WHERE age IN ({placeholders})"
cursor.execute(query, ages)
results = cursor.fetchall()
print(f"Students aged 22, 25, or 27: {len(results)}")

# Using IN with names
names = ('Rahul', 'Priya', 'Amit')
placeholders = ', '.join(['%s'] * len(names))
query = f"SELECT * FROM students WHERE first_name IN ({placeholders})"
cursor.execute(query, names)
results = cursor.fetchall()
print(f"Students named Rahul, Priya, or Amit: {len(results)}")

cursor.close()
connection.close()

IN operator features:

IN — matches any value in a list
NOT IN — excludes values in a list
Much cleaner than multiple OR conditions
Works with subqueries as well

Quick Check: What does IN do? (Answer: Checks if a value matches any value in a list)

BETWEEN Operator

Checking for Values Within a Range

# ============================================================
# BETWEEN OPERATOR
# ============================================================

# BETWEEN checks if a value is within a range (inclusive)

# ============================================================
# BASIC BETWEEN EXAMPLES
# ============================================================

# Students aged between 20 and 25 (including 20 and 25)
SELECT * FROM students 
WHERE age BETWEEN 20 AND 25;

# Same as:
# WHERE age >= 20 AND age <= 25

# ============================================================
# BETWEEN WITH DATES
# ============================================================

# Students who joined between two dates
SELECT * FROM students 
WHERE joined_date BETWEEN '2024-01-01' AND '2024-12-31';

# ============================================================
# NOT BETWEEN
# ============================================================

# Students NOT aged between 20 and 25
SELECT * FROM students 
WHERE age NOT BETWEEN 20 AND 25;

# ============================================================
# BETWEEN IN PYTHON
# ============================================================

import mysql.connector

connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="secret",
    database="myapp_db"
)

cursor = connection.cursor()

# Students aged 20-25
cursor.execute("SELECT * FROM students WHERE age BETWEEN %s AND %s", (20, 25))
results = cursor.fetchall()
print(f"Students aged 20-25: {len(results)}")

# Students aged 25-30
cursor.execute("SELECT * FROM students WHERE age BETWEEN %s AND %s", (25, 30))
results = cursor.fetchall()
print(f"Students aged 25-30: {len(results)}")

cursor.close()
connection.close()

BETWEEN operator features:

BETWEEN — checks if a value is in a range
NOT BETWEEN — checks if a value is outside a range
Includes the start and end values
Works with numbers, dates, and text

Quick Check: Does BETWEEN include the start and end values? (Answer: Yes, it's inclusive)

Real-World Example: Advanced Search

Building an Advanced Search System

# ============================================================
# ADVANCED SEARCH SYSTEM
# ============================================================

import mysql.connector

class AdvancedSearch:
    """Advanced search with multiple filters"""
    
    def __init__(self, db_config):
        self.db_config = db_config
        self.connection = None
        self.cursor = None
    
    def connect(self):
        try:
            self.connection = mysql.connector.connect(**self.db_config)
            self.cursor = self.connection.cursor()
            return True
        except mysql.connector.Error as e:
            print(f"Connection failed: {e}")
            return False
    
    def search_students(self, first_name=None, last_name=None, min_age=None, 
                        max_age=None, email_domain=None, exact_name=False):
        """
        Search students with multiple filters
        """
        conditions = []
        params = []
        
        # Build conditions dynamically
        if first_name:
            if exact_name:
                conditions.append("first_name = %s")
                params.append(first_name)
            else:
                conditions.append("first_name LIKE %s")
                params.append(f"%{first_name}%")
        
        if last_name:
            conditions.append("last_name LIKE %s")
            params.append(f"%{last_name}%")
        
        if min_age is not None:
            conditions.append("age >= %s")
            params.append(min_age)
        
        if max_age is not None:
            conditions.append("age <= %s")
            params.append(max_age)
        
        if email_domain:
            conditions.append("email LIKE %s")
            params.append(f"%@{email_domain}")
        
        # Build query
        query = "SELECT * FROM students"
        if conditions:
            query += " WHERE " + " AND ".join(conditions)
        
        # Execute query
        self.cursor.execute(query, params)
        return self.cursor.fetchall()
    
    def display_results(self, results, title="Search Results"):
        """Display results"""
        if not results:
            print(f"\n{title}: No results found")
            return
        
        print(f"\n{title}: {len(results)} students found")
        print("-" * 60)
        for row in results:
            print(f"ID: {row[0]} | {row[1]} {row[2]} | Age: {row[3]} | {row[4]}")
    
    def close(self):
        if self.cursor:
            self.cursor.close()
        if self.connection:
            self.connection.close()

# ============================================================
# DEMONSTRATION
# ============================================================

db_config = {
    "host": "localhost",
    "user": "root",
    "password": "secret",
    "database": "myapp_db"
}

search = AdvancedSearch(db_config)
if search.connect():
    
    # 1. Search by name (partial match)
    results = search.search_students(first_name="Ra")
    search.display_results(results, "Search: first_name contains 'Ra'")
    
    # 2. Search by age range
    results = search.search_students(min_age=22, max_age=26)
    search.display_results(results, "Search: age between 22 and 26")
    
    # 3. Search by email domain
    results = search.search_students(email_domain="gmail.com")
    search.display_results(results, "Search: Gmail users")
    
    # 4. Multiple filters
    results = search.search_students(
        first_name="R", 
        min_age=22, 
        max_age=30,
        email_domain="email.com"
    )
    search.display_results(results, "Search: name starts with 'R', age 22-30, email domain 'email.com'")
    
    # 5. Exact name match
    results = search.search_students(first_name="Rahul", exact_name=True)
    search.display_results(results, "Search: exact match for 'Rahul'")
    
    search.close()

This example shows:

Building dynamic WHERE clauses
Using multiple filters together
LIKE with pattern matching
BETWEEN for age ranges
Exact match vs partial match
Parameterized queries for safety

Quick Check: What is the advantage of building WHERE clauses dynamically? (Answer: You can create flexible search filters based on user input)

Best Practices

Tips for Using WHERE Effectively

# ============================================================
# BEST PRACTICES FOR WHERE CLAUSE
# ============================================================

print("1. USE PARAMETERIZED QUERIES")
print("   - Always use %s placeholders")
print("   - Never use string concatenation for SQL")
print("   - Protects against SQL injection")

print("\n2. BE SPECIFIC WITH CONDITIONS")
print("   - Use the most restrictive conditions first")
print("   - This improves performance")
print("   - Example: age > 20 AND age < 25")

print("\n3. USE INDEXES FOR FILTERED COLUMNS")
print("   - Columns used in WHERE should be indexed")
print("   - This speeds up queries significantly")

print("\n4. AVOID USING FUNCTIONS ON INDEXED COLUMNS")
print("   - WHERE YEAR(date_column) = 2024 is slower")
print("   - Use WHERE date_column BETWEEN '2024-01-01' AND '2024-12-31'")

print("\n5. USE LIKE CAREFULLY")
print("   - 'name%' is faster than '%name%'")
print("   - Leading % makes the query slower")
print("   - Consider full-text search for complex text searches")

print("\n6. USE NOT OPERATORS WISELY")
print("   - NOT IN and NOT LIKE can be slow")
print("   - Consider alternative approaches for large datasets")

Summary of best practices:

Parameterized queries — always for security
Specific conditions — better performance
Indexes — speed up WHERE clauses
Avoid functions on indexed columns — slows queries
Use LIKE wisely — avoid leading % when possible

Quick Check: Why should you use parameterized queries? (Answer: To prevent SQL injection attacks)

Try It Yourself

Experiment with WHERE clauses in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python MySQL WHERE Clause - Practice

print("=" * 40)
print("WHERE CLAUSE - PRACTICE")
print("=" * 40)

# Simulated Database for learning
class SimulatedDB:
    students = [
        {"id": 1, "first_name": "Rahul", "last_name": "Sharma", "age": 22, "email": "rahul@email.com"},
        {"id": 2, "first_name": "Priya", "last_name": "Patel", "age": 25, "email": "priya@email.com"},
        {"id": 3, "first_name": "Amit", "last_name": "Singh", "age": 24, "email": "amit@email.com"},
        {"id": 4, "first_name": "Sneha", "last_name": "Reddy", "age": 23, "email": "sneha@email.com"},
        {"id": 5, "first_name": "Vikram", "last_name": "Kumar", "age": 26, "email": "vikram@email.com"},
        {"id": 6, "first_name": "Anjali", "last_name": "Nair", "age": 21, "email": "anjali@email.com"},
        {"id": 7, "first_name": "Ravi", "last_name": "Desai", "age": 27, "email": "ravi@email.com"},
        {"id": 8, "first_name": "Meera", "last_name": "Iyer", "age": 23, "email": "meera@email.com"}
    ]
    
    @classmethod
    def filter(cls, condition_func):
        """Filter students using a condition function"""
        return [s for s in cls.students if condition_func(s)]
    
    @classmethod
    def display_results(cls, results, title="Results"):
        """Display filtered results"""
        if not results:
            print(f"\n{title}: No results found")
            return
        print(f"\n{title}: {len(results)} students")
        print("-" * 55)
        for s in results:
            print(f"  ID: {s['id']:1} | {s['first_name']:8} {s['last_name']:8} | Age: {s['age']:2} | {s['email']}")

print("\n1. COMPARISON OPERATORS")
print("-" * 40)

# Age equals 23
results = SimulatedDB.filter(lambda s: s["age"] == 23)
SimulatedDB.display_results(results, "Age = 23")

# Age greater than 24
results = SimulatedDB.filter(lambda s: s["age"] > 24)
SimulatedDB.display_results(results, "Age > 24")

# Age less than 24
results = SimulatedDB.filter(lambda s: s["age"] < 24)
SimulatedDB.display_results(results, "Age < 24")

print("\n2. LOGICAL OPERATORS")
print("-" * 40)

# AND: Age between 22 and 25
results = SimulatedDB.filter(lambda s: s["age"] >= 22 and s["age"] <= 25)
SimulatedDB.display_results(results, "Age 22-25 (AND)")

# OR: Age 22 or 25
results = SimulatedDB.filter(lambda s: s["age"] == 22 or s["age"] == 25)
SimulatedDB.display_results(results, "Age 22 or 25 (OR)")

print("\n3. LIKE PATTERN MATCHING")
print("-" * 40)

# Name starts with 'R'
results = SimulatedDB.filter(lambda s: s["first_name"].startswith("R"))
SimulatedDB.display_results(results, "Name starts with 'R'")

# Name contains 'a'
results = SimulatedDB.filter(lambda s: "a" in s["first_name"].lower())
SimulatedDB.display_results(results, "Name contains 'a'")

# Email ends with 'email.com'
results = SimulatedDB.filter(lambda s: s["email"].endswith("email.com"))
SimulatedDB.display_results(results, "Email ends with 'email.com'")

print("\n4. MULTIPLE CONDITIONS")
print("-" * 40)

# Name starts with 'R' AND age > 24
results = SimulatedDB.filter(lambda s: s["first_name"].startswith("R") and s["age"] > 24)
SimulatedDB.display_results(results, "Name starts with 'R' AND age > 24")

print("\n✅ WHERE clauses make data filtering powerful!")

🏆

You've Got It!

You now understand how to use the WHERE clause in MySQL with Python. You know comparison operators, logical operators, LIKE, IN, and BETWEEN.

Quick Quiz

Test what you've learned:

1. What does the WHERE clause do in SQL?

A) Sorts the results B) Filters the rows C) Groups the rows D) Joins tables

2. Which operator is used for "not equal to" in SQL?

A) = B) != C) == D) NOT =

3. What does LIKE '%@gmail.com' find?

A) Emails starting with @gmail.com B) Emails ending with @gmail.com C) Emails containing @gmail.com D) Emails exactly @gmail.com

4. What does the IN operator do?

A) Checks if a value is in a range B) Checks if a value matches any value in a list C) Checks if a value is NULL D) Checks if a value matches a pattern

5. What does BETWEEN 20 AND 25 include?

A) Only 20 and 25 B) 20, 21, 22, 23, 24, and 25 C) Only numbers between 20 and 25 D) 21, 22, 23, and 24

Frequently Asked Questions

What is the difference between WHERE and HAVING?

WHERE filters rows before grouping. HAVING filters groups after grouping (used with GROUP BY). WHERE is for individual rows, HAVING is for groups.

Can I use multiple conditions with WHERE?

Yes, you can combine multiple conditions using AND, OR, and NOT. Use parentheses to group conditions and control the order of evaluation.

What is the difference between LIKE and IN?

LIKE is used for pattern matching with wildcards (% and _). IN checks if a value matches any value in a list. Use LIKE for text patterns and IN for matching against specific values.

What is a common interview question about WHERE?

Common questions include: "Explain the difference between WHERE and HAVING," "How do you use LIKE with wildcards?" and "Write a query to find all users with Gmail accounts."

How can I speed up WHERE queries?

To speed up WHERE queries: create indexes on columns used in WHERE, avoid functions on indexed columns, use specific conditions instead of general ones, and avoid leading % in LIKE patterns when possible.

Where to Go From Here

Now that you know how to filter data with WHERE, check out these related topics:

Previous: Select Data Next: Update Data →

Python

Python: WHERE Clause in MySQL

What is the WHERE Clause?

Why WHERE is Important

WHERE Clause Syntax

Basic WHERE Syntax

Comparison Operators

Using Comparison Operators

Logical Operators (AND, OR, NOT)

Combining Multiple Conditions

LIKE Operator for Pattern Matching

Finding Patterns in Text

IN Operator

Matching Multiple Values

BETWEEN Operator

Checking for Values Within a Range

Real-World Example: Advanced Search

Building an Advanced Search System

Best Practices

Tips for Using WHERE Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between WHERE and HAVING?

Can I use multiple conditions with WHERE?

What is the difference between LIKE and IN?

What is a common interview question about WHERE?

How can I speed up WHERE queries?

Where to Go From Here

Select Data

Update Data

Delete Data

Python

Python: WHERE Clause in MySQL

What is the WHERE Clause?

Why WHERE is Important

WHERE Clause Syntax

Basic WHERE Syntax

Comparison Operators

Using Comparison Operators

Logical Operators (AND, OR, NOT)

Combining Multiple Conditions

LIKE Operator for Pattern Matching

Finding Patterns in Text

IN Operator

Matching Multiple Values

BETWEEN Operator

Checking for Values Within a Range

Real-World Example: Advanced Search

Building an Advanced Search System

Best Practices

Tips for Using WHERE Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between WHERE and HAVING? ▼

Can I use multiple conditions with WHERE? ▼

What is the difference between LIKE and IN? ▼

What is a common interview question about WHERE? ▼

How can I speed up WHERE queries? ▼

Where to Go From Here

Select Data

Update Data

Delete Data

What is the difference between WHERE and HAVING?

Can I use multiple conditions with WHERE?

What is the difference between LIKE and IN?

What is a common interview question about WHERE?

How can I speed up WHERE queries?