Database Specialist (1D0-541)
1 Introduction to Databases
1-1 Definition and Purpose of Databases
1-2 Types of Databases
1-3 Database Management Systems (DBMS)
1-4 Evolution of Databases
2 Relational Database Concepts
2-1 Relational Model
2-2 Tables, Rows, and Columns
2-3 Keys (Primary, Foreign, Composite)
2-4 Relationships (One-to-One, One-to-Many, Many-to-Many)
2-5 Normalization (1NF, 2NF, 3NF, BCNF)
3 SQL Fundamentals
3-1 Introduction to SQL
3-2 Data Definition Language (DDL)
3-2 1 CREATE, ALTER, DROP
3-3 Data Manipulation Language (DML)
3-3 1 SELECT, INSERT, UPDATE, DELETE
3-4 Data Control Language (DCL)
3-4 1 GRANT, REVOKE
3-5 Transaction Control Language (TCL)
3-5 1 COMMIT, ROLLBACK, SAVEPOINT
4 Advanced SQL
4-1 Subqueries
4-2 Joins (INNER, OUTER, CROSS)
4-3 Set Operations (UNION, INTERSECT, EXCEPT)
4-4 Aggregation Functions (COUNT, SUM, AVG, MAX, MIN)
4-5 Grouping and Filtering (GROUP BY, HAVING)
4-6 Window Functions
5 Database Design
5-1 Entity-Relationship (ER) Modeling
5-2 ER Diagrams
5-3 Mapping ER Diagrams to Relational Schemas
5-4 Design Considerations (Performance, Scalability, Security)
6 Indexing and Performance Tuning
6-1 Indexes (Clustered, Non-Clustered)
6-2 Index Types (B-Tree, Bitmap)
6-3 Indexing Strategies
6-4 Query Optimization Techniques
6-5 Performance Monitoring and Tuning
7 Database Security
7-1 Authentication and Authorization
7-2 Role-Based Access Control (RBAC)
7-3 Data Encryption (Symmetric, Asymmetric)
7-4 Auditing and Logging
7-5 Backup and Recovery Strategies
8 Data Warehousing and Business Intelligence
8-1 Introduction to Data Warehousing
8-2 ETL Processes (Extract, Transform, Load)
8-3 Dimensional Modeling
8-4 OLAP (Online Analytical Processing)
8-5 Business Intelligence Tools
9 NoSQL Databases
9-1 Introduction to NoSQL
9-2 Types of NoSQL Databases (Key-Value, Document, Column-Family, Graph)
9-3 CAP Theorem
9-4 NoSQL Data Models
9-5 NoSQL Use Cases
10 Database Administration
10-1 Installation and Configuration
10-2 User Management
10-3 Backup and Recovery
10-4 Monitoring and Maintenance
10-5 Disaster Recovery Planning
11 Emerging Trends in Databases
11-1 Cloud Databases
11-2 Distributed Databases
11-3 NewSQL
11-4 Blockchain and Databases
11-5 AI and Machine Learning in Databases
4-1 Subqueries Explained

4-1 Subqueries Explained

Key Concepts

Subquery Definition

A subquery is a query nested inside another query. It allows you to perform a query on the results of another query. Subqueries can be used in various parts of a SQL statement, such as the SELECT, FROM, WHERE, and HAVING clauses.

Types of Subqueries

There are two main types of subqueries:

Correlated Subqueries

A correlated subquery is a subquery that depends on the outer query for its values. Unlike standard subqueries, which are executed once, correlated subqueries are executed once for each row processed by the outer query. This makes them more resource-intensive but also more powerful for certain types of queries.

Subquery Best Practices

When using subqueries, consider the following best practices:

Examples and Analogies

Consider a library system: A subquery can be thought of as a librarian searching for a specific book within a list of books returned by another query. For example, a query might first find all books by a specific author, and then a subquery could find the most recent book in that list.

Example: Finding the most recent book by an author named "Jane Doe."

        SELECT Title, PublicationDate
        FROM Books
        WHERE PublicationDate = (
            SELECT MAX(PublicationDate)
            FROM Books
            WHERE Author = 'Jane Doe'
        );
    

In this example, the subquery finds the most recent publication date for books by "Jane Doe," and the outer query uses that date to find the corresponding book title.

Correlated Subquery Example: Finding books that have more pages than the average book by the same author.

        SELECT Title, Pages
        FROM Books b1
        WHERE Pages > (
            SELECT AVG(Pages)
            FROM Books b2
            WHERE b2.Author = b1.Author
        );
    

In this example, the correlated subquery calculates the average number of pages for books by the same author, and the outer query compares each book's page count to this average.