11 - SQL Commands for Complex Queries — Topics & Learning Outcomes

Module Topics

Introduction to Complex SQL Queries

• What Are Complex SQL Queries? — Complex SQL queries go beyond simple single-table SELECT statements to retrieve, filter, and analyze data across multiple tables and conditions.
• Why Complex Queries Are Essential — Relational databases store data across many related tables, making advanced querying skills necessary to extract meaningful insights.
• Core Building Blocks of Complex Queries — Several key SQL clauses work together to form complex queries, each serving a distinct role in shaping the final result set.
• Understanding Relational Database Structure — To write effective complex queries, it is important to understand how relational databases organize data using tables, primary keys, and foreign keys.
• From Simple to Complex: The Query Progression — Complex queries are built incrementally, starting from a basic SELECT and adding clauses to meet increasingly specific data requirements.

JOIN Types and Multi-Table Queries

• Understanding the Purpose of JOINs — JOINs allow SQL queries to combine rows from two or more tables based on a related column, enabling retrieval of meaningful data spread across a relational database.
• INNER JOIN: Matching Records Only — An INNER JOIN returns only the rows where there is a matching value in both tables based on the specified join condition.
• LEFT JOIN: Preserving All Left-Table Records — A LEFT JOIN (also called LEFT OUTER JOIN) returns all rows from the left table and the matching rows from the right table, filling in NULL for any unmatched right-table columns.
• RIGHT JOIN: Preserving All Right-Table Records — A RIGHT JOIN (also called RIGHT OUTER JOIN) returns all rows from the right table and only the matching rows from the left table, with NULLs filling unmatched left-table columns.
• FULL JOIN: Combining All Records from Both Tables — A FULL JOIN (also called FULL OUTER JOIN) returns all rows from both tables, placing NULLs wherever there is no matching row on either side.
• Choosing the Right JOIN for Your Query — Selecting the appropriate JOIN type depends on which records must be preserved and whether unmatched rows carry meaningful information for the analysis.
• Writing Multi-Table Queries with JOINs — Multi-table queries can chain multiple JOIN clauses together, allowing a single SELECT statement to combine data from three or more tables simultaneously.

Filtering Data with WHERE Clauses

• Introduction to the WHERE Clause — The WHERE clause is used in SQL SELECT statements to filter rows returned by a query based on one or more specified conditions.
• Comparison Operators in WHERE Conditions — Comparison operators allow you to evaluate relationships between a column value and a specified expression or literal.
• Logical Operators: AND, OR, and NOT — Logical operators let you combine multiple conditions within a single WHERE clause to create more precise filters.
• Pattern Matching with LIKE and Wildcards — The LIKE operator enables filtering based on partial string matches using wildcard characters, making it useful for searching text data.
• Filtering with IN and NOT IN — The IN operator allows you to filter rows where a column value matches any value within a specified list, serving as a concise alternative to multiple OR conditions.
• Handling NULL Values with IS NULL and IS NOT NULL — NULL represents missing or unknown data in SQL, and standard comparison operators cannot be used to test for NULL — dedicated IS NULL and IS NOT NULL operators must be used instead.
• Combining Multiple Conditions Effectively — Complex queries often require combining several WHERE conditions using logical operators and parentheses to precisely define filtering logic.

Sorting Results with ORDER BY

• Purpose of the ORDER BY Clause — The ORDER BY clause controls the sequence in which rows are returned by a SELECT query, making results easier to read and analyze.
• Ascending Order (ASC) — By default, ORDER BY sorts results in ascending order, meaning lowest to highest for numbers, earliest to latest for dates, and A to Z for text.
• Descending Order (DESC) — Adding the DESC keyword after a column name in ORDER BY reverses the sort, returning rows from highest to lowest value.
• Sorting by Multiple Columns — ORDER BY can accept a comma-separated list of columns, applying each sort level sequentially to break ties from the previous column.
• Sorting by Column Position — Instead of naming a column, you can reference it by its numeric position in the SELECT list within ORDER BY.
• Sorting Across Different Data Types — ORDER BY behaves differently depending on the data type of the column being sorted, requiring an understanding of how each type is compared.

Aggregating Data with GROUP BY and HAVING

• Purpose of GROUP BY — The GROUP BY clause organizes rows that share the same values in one or more specified columns into summary groups, enabling aggregate calculations to be performed on each group independently.
• Common Aggregate Functions Used with GROUP BY — Aggregate functions compute a single summary value from a set of rows within each group, forming the core output of GROUP BY queries.
• Filtering Groups with the HAVING Clause — HAVING is used to filter the results of a GROUP BY query based on conditions applied to aggregate values, acting as the group-level counterpart to the row-level WHERE clause.
• WHERE vs. HAVING: Knowing When to Use Each — WHERE and HAVING both filter data, but they operate at different stages of query execution and on different targets — individual rows versus aggregated groups.
• Query Execution Order with GROUP BY and HAVING — Understanding the logical order in which SQL processes clauses helps explain why certain column references and aggregate functions are valid only in specific clauses.
• Writing Combined GROUP BY and HAVING Queries — Combining GROUP BY and HAVING in a single query allows analysts to produce targeted statistical summaries that include only the groups meeting specific aggregate criteria.

Writing and Using Subqueries

• What Is a Subquery? — A subquery is a SELECT statement nested inside another SQL query, allowing you to use the result of one query as input for another.
• Subqueries in the WHERE Clause — Placing a subquery in the WHERE clause lets you filter rows based on values dynamically retrieved from another query.
• Subqueries in the FROM Clause (Derived Tables) — A subquery placed in the FROM clause acts as a temporary, inline table — often called a derived table — that the outer query can select from.
• Subqueries in the SELECT Clause (Scalar Subqueries) — A subquery in the SELECT clause returns a single value for each row of the outer query, allowing computed or looked-up values to appear as columns in the result set.
• Correlated vs. Non-Correlated Subqueries — Subqueries are classified as either non-correlated (independent of the outer query) or correlated (referencing columns from the outer query), each with different execution behavior.
• Using EXISTS and NOT EXISTS with Subqueries — The EXISTS operator tests whether a subquery returns any rows at all, enabling efficient conditional filtering based on the presence or absence of related data.
• Best Practices for Writing Subqueries — Writing clear, efficient subqueries requires attention to readability, correctness, and query performance.

Student Learning Outcomes

By the end of this module, students will be able to:

Course Outcomes (reference)