第二门课程是为:Database Developer 准备的
第1天的学习内容: An Introduction and History of the SQL Language
1.1 - Course Introduction - What Is Covered in this Course?
1.2 - Course Introduction - Who Should Take this Course?
1.3 - Why this Course is So Important: Is It the Greatest Course Ever?
1.4 - What SQL Is and Isn’t
1.5 - Terms You Should Know
1.6 - ISO and ANSI SQL: Who’s in Charge Here?
1.7 - What is Transact-SQL and How Does It Fit?
1.8 - What Versions of SQL Server Does this Course Use?
1.9 - SQL Coding Conventions and T-SQL Coding Conventions
1.10 - How to Get the Most Out of this Course
第2,3天的学习内容: Writing Single Table Queries - Building Your Foundation
2.1 - Chapter Introduction: What is Included in this Chapter
2.2 - SQL Fundamentals: Terms You Should Know
2.3 - SQL Fundamentals: Things You Should Know Before You Begin Writing SQL Queries
2.4 - SQL Fundamentals: How to Take the Guesswork Out of Writing Queries
2.5 - How to Use Database Diagrams in SSMS
2.6 - How to Create a Database Diagram Using SQL Server Management Studio
2.7 - Exercise: Create Your Database Diagram for LearnItFirstWorks_Lite
2.8 - LearnItFirstWorks_Lite Demo: Understanding the Database (Demo)
2.9 - Exercise: Understanding the LearnItFirstWorks_Lite Database
2.10 - LearnItFirstWorks_200x Demo: Understanding the Database (Demo)
2.11 - SELECT: The Basics of the SELECT Statement
2.12 - SELECT: Column Aliases and Table Aliases
2.13 - ORDER BY: The Basics of the ORDER BY Clause
2.14 - Exercise: Writing Basic SELECT Statements and Sorting Data
2.15 - WHERE: Writing Single Predicate WHERE Clauses
2.16 - WHERE: Think Positive!
2.17 - WHERE: Using the Conditional Operators
2.18 - WHERE: Using IN and NOT IN
2.19 - WHERE: Using BETWEEN and NOT BETWEEN
2.20 - WHERE: Using LIKE for Pattern Matching
2.21 - WHERE: FAQs About Working with LIKE
2.22 - Exercise: Writing Single Predicate Queries (Conditional Operators)
2.23 - Exercise: Writing Single Predicate Queries (IN, BETWEEN, and LIKE)
2.24 - Understanding How SQL Processes Queries and a Discussion About Using Column Aliases
2.25 - WHERE: Case sensitivity and Collations
2.26 - WHERE: Writing Multiple Predicate WHERE Clauses
2.27 - WHERE: Using AND, Or, and Parentheses Correctly
2.28 - WHERE: Working with Date and Time Data in All Editions of SQL Server
2.29 - WHERE: Working with SQL Server 2012’s New Date and Time Data Types
2.30 - Exercise: Writing Multiple Predicate Queries
2.31 - Working with NULLs in Expressions
2.32 - Working with NULLs in the WHERE Clause
2.33 - Working with NULLs in Expressions, WHERE, and ORDER BY
2.34 - Exercise: Working with NULL Data
2.35 - Writing Distinct and Top Queries and the Processing Sequence for Single Table Queries
2.36 - Exercise: Working with TOP and DISTINCT
2.37 - Quality Control in SQL Statements: How Do You Know You Are Right?
2.38 - Using Execution Plans to Test Your Query’s Performance
第4,5天的学习内容: Using and Understanding Scalar Functions and Data Types
3.1 - Chapter Introduction: What Are Scalar Functions?
3.2 - Working with NULLs in Expressions
3.3 - Introduction to NULLIF, ISNULL, and COALESCE
3.4 - ISNULL and COALESCE: The Two Trickiest Functions You Will Ever Meet
3.5 - Exercise: Working with NULL Data in Expressions
3.6 - What Happens When You Mix Data Types in Expressions and Predicates?
3.7- CAST and CONVERT: Two of the Most Useful Functions You Will Ever Meet
3.8 - Gotchas of Working with CAST and CONVERT
3.9 - The Style Parameter of the CONVERT Function
3.10 - Working with Strings (Manipulation, Capitalization, and Middle of String)
3.11 - -Working with Strings (Trimming, Length, Replacement)
3.12 - Rounding and Truncating with the ROUND Function
3.13 - Exercise: Working with Strings
3.14 - Exercise: Working with the ROUND Function
3.15 - Functions for Working with Dates: DATEPART, DATENAME, YEAR, MONTH and more
3.16 - Formatting Dates with the CONVERT Function’s Style Parameter
3.17 - DATEADD, DATEDIFF, and the Secrets They Hide
3.18 - SQL Server 2008’s Date Data Types Overview
3.19 - Exercise: Working with Dates
3.20 - An Introduction to the CASE Statement and Using the Simple CASE Format
3.21 - More on Using CASE: The Searched Format and Best Practices
3.22 - Using CASE Statements in the SELECT Column List
3.23 - Using CASE in the WHERE and ORDER BY Clauses
3.24 - An Introduction to the Ranking and Window Functions
3.25 - Looking at ROW_NUMBER(), RANK(), DENSE_RANK(), and NTILE()
3.26 - Exercise: Working with CASE and the Windowing Functions
第6,7天的学习内容: Writing JOINs and UNIONs - The Tools of the Trade
4.1 - Chapter Introduction: What is Included in this Chapter
4.2 - Understanding the Difference Between Set Operators and Joins
4.3 - UNION Queries
4.4 - More UNION Query Examples and Syntax
4.5 - EXCEPT and INTERSECT Queries
4.6 - Exercise: UNION Queries
4.7- - How to Decide When to Use a UNION or a JOIN
4.8 - How to Master the Art of the JOIN Through Visualization
4.9 - The Syntax and Types of JOINs and JOIN Conditions
4.10 - INNER JOIN: Writing Two Table INNER Joins, Part 1
4.11 - INNER JOIN: Writing Two Table INNER Joins, Part 2
4.12 - JOIN Style: Creating Readable, Maintainable, and Extensible Queries
4.13 - The Key to Understanding 95% of All JOINs
4.14 - Design Pattern for Two Table Foreign Key Joins
4.15 - The JOIN Condition is the Key to Writing JOINs
4.16 - ANSI-89 Syntax and WHERE Clause Processing
4.17 - Exercise: Writing Two Table INNER JOINs, Part 1
4.18 - Exercise: Writing Two Table INNER JOINs, Part 2
4.19 - Working with Non-Foreign Key-based JOIN Conditions
4.20 - Concepts of a Theta JOIN: Equi Join and Non-Equi JOINs
4.21 - Understanding When to Use a Self Join
4.22 - More on Writing Self Joins
4.23 - 3+ Table Joins and How SQL Server Processes Your Queries
4.24 - 3+ Table Joins - Visualizing the JOIN
4.25 - 3+ Table Joins - Understanding the How and Why
4.26 - Exercise: Theta JOINs and Self JOINs
4.27 - Exercise: 3+ Table JOINs
4.28 - The Mysterious OUTER JOIN
4.29 - LEFT and RIGHT JOINs Demystified
4.30 - Design Pattern for Two Table Foreign Key OUTER JOINs
4.31 - Examples of Writing Two Table LEFT and RIGHT JOINs
4.32 - Rewriting a LEFT JOIN to be a RIGHT JOIN
4.33 - Identifying NULLs in OUTER JOIN Results
4.34 - Understanding the JOIN Processing Sequence is Critical
4.35 - WHERE Clause or JOIN Condition: Which One to Use?
4.36 - Finding Only ‘A’ or Only ‘B’ (i.e. Missing Data Pattern)
4.37 - Self OUTER Joins - Whew!
4.38 - Exercise: Two Table OUTER JOINs
4.39 - 3+ Table OUTER JOIN Syntax and Processing Sequence
4.40 - More 3+ Table OUTER JOINs and Chaining
4.41 - ANSI-89 OUTER JOIN Sytnax
4.42 - Exercise: 3+ Table OUTER JOINs
第8天的学习内容: Writing Aggregate Queries, GROUP BY, and More
5.1 - Chapter Introduction: What is Included in this Chapter
5.2 - Understanding How Aggregates Change Everything
5.3 - The Basic Aggregates: Examples and Syntax
5.4 - How Aggregates Handle NULLs and Data Types
5.5 - A Tale of Three COUNTs
5.6 - Using GROUP BY with Aggregates
5.7 - GROUP BY on Multiple Columns and NULLs
5.8 - How Many Rows Will My Aggregate Query Return?
5.9 - Exercise: Using GROUP BY
5.10 - GROUP BY with a JOIN
5.11 - Pivot Tables and Cross Tab Queries
5.12 - Design Pattern #1 for Pivot Tables and Crosstabs
5.13 - Exercise: JOINs, Aggregates, and Crosstabs
5.14 - The HAVING Clause: A Filter for Your Aggregates
5.15 - How to Decide Between WHERE and HAVING
5.16 - Design Pattern #1 for Finding Duplicate Data (HAVING)
5.17 - How Many Rows Will My Aggregate Query Return
5.18 - Exercise: Filtering Aggregates
5.19 - Subtotals and Grand Totals in SQL: ROLLUP
5.20 - Subtotals and Grand Totals in SQL: CUBE and the GROUPING Function
5.21 - Subtotals and Grand Totals in SQL: GROUPING SETS
5.22 - Aggregates and Window Functions - Breakin’ the Rulez
5.23 - Exercise: Advanced Aggregates
第9天的学习内容: Complex SQL: Subqueries, CTEs, Derived Tables and More
6.1 - Chapter Introduction: What is Included in this Chapter
6.2 - An Introduction to Subqueries 101
6.3 - Simple Subqueries in the WHERE Clause
6.4 - How to Decide Between WHERE, HAVING, or Simple Subquery
6.5 - Subqueries and Operators - Know the Rules!
6.6 - Working with NULLs and Simple Subqueries
6.7 - How to Decide Between a JOIN and a Subquery
6.8 - Design Pattern for Finding Non-Matched Rows with a Simple Subquery
6.9 - Simple Subqueries in the SELECT Column List and CASE
6.10 - Simple Subqueries in the HAVING Clause
6.11 - Exercise: Writing Simple Subqueries
6.12 - Correlated Subqueries: Understanding the Processing Sequence
6.13 - Correlated Subqueries in the SELECT Column List
6.14 - Column Prefixes and Scoping in Subqueries
6.15 - Design Pattern: How to Calculate Running Totals in SQL
6.16 - Exercise: Writing Correlated Subqueries in the Column List
6.17 - Correlated Subqueries in the WHERE Clause with EXISTS()
6.18 - Using EXISTS() with Correlated Subqueries
6.19 - Design Pattern: Rewriting a Natural JOIN to Become a Subquery
6.20 - Design Pattern #2 for Finding Duplicate Data (EXISTS)
6.21 - Exercise: Writing Correlated Subqueries in the WHERE Clauses
6.22 - Derived Tables: What They Are and How to Use Them
6.23 - How to Nest Aggregates Using Derived Tables
6.24 - Using a Derived Table to Replace Repeated Aggregates in Subqueries
6.25 - Filtering on Window Functions Using Derived Tables
6.26 - Design Pattern #3 for Finding Duplicate Data (RANK)
6.27 - PIVOT and Crosstab Queries with Derived Tables
6.28 - Design Pattern #2 for Pivot Tables and Crosstabs
6.29 - Exercise: Partying Hard with Derived Tables
6.30 - Common Table Expressions (CTEs): What They Are and How to Use Them
6.31 - How to Rewrite Derived Tables to Become CTEs
6.32 - Nested CTEs: Syntax and Concepts
6.33 - Recursive Queries: An Introduction
6.34 - Recursive CTEs with SQL Server 2005
6.35 - How to Sort Recursive CTEs in SQL Server 2005, Part 1
6.36 - SQL Server 2008’s HierarchyID Data Type
6.37 - Recursive CTEs with SQL Server 2008
6.38 - Exercise: Writing CTEs
第10天的学习内容: SQL Design Patterns
7.1 - Chapter Introduction: What is Included in this Chapter
7.2 - Two Table JOIN Pattern: INNER Natural JOINs
7.3 - Three Table JOIN Pattern: INNER Natural JOINs
7.4 - Two Table JOIN Pattern: OUTER Natural JOINs
7.5 - Two Table JOIN Pattern: Finding Only Non-Matched Rows
7.6 - Design Pattern #1 for Pivot Tables and Crosstabs
7.7 - Design Pattern #1 for Finding Duplicate Data (HAVING)
7.8 - Design Pattern for Finding Non-Matched Rows with a Simple Subquery
7.9 - How to Calculate Running Totals in SQL
7.10 - Design Pattern: Rewriting a Natural JOIN to Become a Subquery
7.11 - Design Pattern #2 for Finding Duplicate Data (EXISTS)
7.12 - Design Pattern #3 for Finding Duplicate Data (RANK)
7.13 - Design Pattern #2 for Pivot Tables and Crosstabs