Querying Microsoft SQL Server 2012

Querying Microsoft SQL Server 2012
Cursusduur: 5 Dagen Cursuscode: M10774
Beschrijving:
Deze cursus is vervangen door cursus M20461 Querying Microsoft SQL Server.
This course has been replaced by course M20461 Querying Microsoft SQL Server..
In deze vijfdaagse cursus onder leiding van een docent doen deelnemers de technische vaardigheden op voor het schrijven van eenvoudige
Transact-SQL-query’s voor Microsoft SQL Server 2012. Deze cursus is het fundament voor alle disciplines die gerelateerd zijn aan SQL
Server: databasebeheer, databaseontwikkeling en business intelligence.==================================================
This 5-day instructor led course provides students with the technical skills required to write basic Transact-SQL queries for Microsoft SQL
Server 2012. This course is the foundation for all SQL Server-related disciplines; namely, Database Administration, Database Development
and Business Intelligence.
Doelgroep:
Deze cursus is bedoeld voor databasebeheerders, databaseontwikkelaars en business intelligence-professionals. De cursus zal waarschijnlijk
ook SQL-powerusers van pas komen die niet per se databasegericht zijn of examen willen doen; denk hierbij aan opstellers van rapportages,
bedrijfsanalisten en ontwikkelaars van klantapplicaties.
==================================================
This course is intended for Database Administrators, Database Developers, and Business Intelligence professionals. The course will very likely
be well attended by SQL power users who aren’t necessarily database-focused or plan on taking the exam; namely, report writers, business
analysts and client application developers.
Doelstelling:
After completing this course, students will be able to:
Write SELECT Queries Implementing Transactions
Query Multiple Tables Use Table Expressions
Use Built-In Functions Sort and Filter Data
Use Subqueries Use Window Ranking, Offset and Aggregate Functions
Execute Stored Procedures Query SQL Server Metadata
Use Set Operators Program with T-SQL
Implement Error Handling Improve Query Performance
Vereiste kennis en vaardigheden: Examens en certificering

Working knowledge of relational databases. This course helps you prepare for exam 70-461 .
Basic knowledge of the Microsoft Windows operating system and
M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

its core functionality.
Vervolgcursussen:
M10775 Administering Microsoft SQL Server 2012 Databases

Cursusinhoud:
Module 1: Introduction to Microsoft SQL Server
2012 line line
line Getting Started with SQL Server Getting Started with SQL Server
Management Studio Management Studio
This module introduces the SQL Server Work with SQL Server Management Work with SQL Server Management
platform and major tools. It discusses editions, Studio. Studio.
versions, tools used to query, documentation Working with SQL AzureAfter completing Working with SQL AzureAfter completing
sources, and the logical structure of databases. this module, students will be able to: this module, students will be able to:
line Describe the basic features of SQL Describe the basic features of SQL Azure.
Introducing Microsoft SQL Server 2012 Azure. Provision a SQL Azure server and
Provision a SQL Azure server and configure its security.
configure its security. Understanding Sets
line Understanding Sets Understanding Predicate Logic
Getting Started with SQL Server Understanding Predicate Logic Understanding the Logical Order of
Management Studio Understanding the Logical Order of Operations in SELECT statementsAfter
Work with SQL Server Management Studio. Operations in SELECT statementsAfter completing this module, students will be
Working with SQL AzureAfter completing completing this module, students will be able to:
this module, students will be able to: able to: Describe the elements of T-SQL and their
Describe the basic features of SQL Azure. Describe the elements of T-SQL and their role in writing queries
Provision a SQL Azure server and configure role in writing queries Describe the use of sets in SQL Server
its security. Describe the use of sets in SQL Server Describe the use of predicate logic in SQL
Understanding Sets Describe the use of predicate logic in Server
Understanding Predicate Logic SQL Server Describe the logical order of operations in
Understanding the Logical Order of Describe the logical order of operations in SELECT statements
Operations in SELECT statementsAfter SELECT statements Eliminating Duplicates with DISTINCT
completing this module, students will be able Eliminating Duplicates with DISTINCT Using Column and Table Aliases
to: Using Column and Table Aliases Writing Simple CASE Expressions
Describe the elements of T-SQL and their Writing Simple CASE Expressions Eliminate duplicates using the DISTINCT
role in writing queries Eliminate duplicates using the DISTINCT clause.
Describe the use of sets in SQL Server clause. Use column and table aliases.
Describe the use of predicate logic in SQL Use column and table aliases. Write simple CASE expressions.
Server Write simple CASE expressions. Querying with Inner Joins
Describe the logical order of operations in Querying with Inner Joins Querying with Outer Joins
SELECT statements Querying with Outer Joins Querying with Cross Joins and Self
Eliminating Duplicates with DISTINCT Querying with Cross Joins and Self JoinsAfter completing this module,
Using Column and Table Aliases JoinsAfter completing this module, students will be able to:
Writing Simple CASE Expressions students will be able to: Describe how multiple tables may be
Eliminate duplicates using the DISTINCT Describe how multiple tables may be queried in a SELECT statement using
clause. queried in a SELECT statement using joins.
Use column and table aliases. joins. Write queries that use inner joins.
Write simple CASE expressions. Write queries that use inner joins. Write queries that use outer joins.
Querying with Inner Joins Write queries that use outer joins. Write queries that use self-joins and cross
Querying with Outer Joins Write queries that use self-joins and joins.
Querying with Cross Joins and Self cross joins. Filtering Data with a WHERE Clause
JoinsAfter completing this module, students Filtering Data with a WHERE Clause Filtering with the TOP and
will be able to: Filtering with the TOP and OFFSET-FETCH Options
Describe how multiple tables may be OFFSET-FETCH Options Working with Unknown and Missing
queried in a SELECT statement using joins. Working with Unknown and Missing ValuesAfter completing this module,
Write queries that use inner joins. ValuesAfter completing this module, students will be able to:
Write queries that use outer joins. students will be able to: Filter data with predicates in the WHERE
Write queries that use self-joins and cross Filter data with predicates in the WHERE clause.
joins. clause. Sort data using ORDER BY.
Filtering Data with a WHERE Clause Sort data using ORDER BY. Filter data in the SELECT clause with
Filtering with the TOP and OFFSET-FETCH Filter data in the SELECT clause with TOP.
Options TOP. Filter data with OFFSET and FETCH.
Working with Unknown and Missing Filter data with OFFSET and FETCH. Working with Character Data
ValuesAfter completing this module, Working with Character Data Working with Date and Time DataAfter
students will be able to: Working with Date and Time DataAfter completing this module, students will be
Filter data with predicates in the WHERE completing this module, students will be able to:
clause. able to: Describe numeric data types, type
Sort data using ORDER BY. Describe numeric data types, type precedence and type conversions.
Filter data in the SELECT clause with TOP. precedence and type conversions. Write queries using character data types.
Filter data with OFFSET and FETCH. Write queries using character data types. Write queries using date and time data
Working with Character Data Write queries using date and time data types.

Working with Date and Time DataAfter types. Using Conversion Functions
completing this module, students will be able Using Conversion Functions Using Logical Functions
to: Using Logical Functions Using Functions to Work with NULLAfter
Describe numeric data types, type Using Functions to Work with NULLAfter completing this module, students will be
precedence and type conversions. completing this module, students will be able to:
Write queries using character data types. able to: Write queries with built-in scalar functions.
Write queries using date and time data Write queries with built-in scalar Use conversion functions.
types. functions. Use logical functions.
Using Conversion Functions Use conversion functions. Use functions that work with NULL.
Using Logical Functions Use logical functions. Using the GROUP BY Clause
Using Functions to Work with NULLAfter Use functions that work with NULL. Filtering Groups with HAVINGAfter
completing this module, students will be able Using the GROUP BY Clause completing this module, students will be
to: Filtering Groups with HAVINGAfter able to:
Write queries with built-in scalar functions. completing this module, students will be Write queries which summarize data using
Use conversion functions. able to: built-in aggregate functions.
Use logical functions. Write queries which summarize data Use the GROUP BY clause to arrange
Use functions that work with NULL. using built-in aggregate functions. rows into groups.
Using the GROUP BY Clause Use the GROUP BY clause to arrange Use the HAVING clause to filter out groups
Filtering Groups with HAVINGAfter rows into groups. based on a search condition.
completing this module, students will be able Use the HAVING clause to filter out Writing Correlated Subqueries
to: groups based on a search condition. Using the EXISTS Predicate with
Write queries which summarize data using Writing Correlated Subqueries SubqueriesAfter completing this module,
built-in aggregate functions. Using the EXISTS Predicate with students will be able to:
Use the GROUP BY clause to arrange rows SubqueriesAfter completing this module, Describe the uses of queries which are
into groups. students will be able to: nested within other queries.
Use the HAVING clause to filter out groups Describe the uses of queries which are Write self-contained subqueries which
based on a search condition. nested within other queries. return scalar or multi-valued results.
Writing Correlated Subqueries Write self-contained subqueries which Write correlated subqueries which return
Using the EXISTS Predicate with return scalar or multi-valued results. scalar or multi-valued results.
SubqueriesAfter completing this module, Write correlated subqueries which return Use the EXISTS predicate to efficiently
students will be able to: scalar or multi-valued results. check for the existence of rows in a
Describe the uses of queries which are Use the EXISTS predicate to efficiently subquery.
nested within other queries. check for the existence of rows in a Using Common Table Expressions
Write self-contained subqueries which return subquery. Using Views
scalar or multi-valued results. Using Common Table Expressions Using Inline Table-Valued FunctionsAfter
Write correlated subqueries which return Using Views completing this module, students will be
scalar or multi-valued results. Using Inline Table-Valued FunctionsAfter able to:
Use the EXISTS predicate to efficiently completing this module, students will be Write queries which use derived tables.
check for the existence of rows in a able to: Write queries which use common table
subquery. Write queries which use derived tables. expressions.
Using Common Table Expressions Write queries which use common table Create simple views and write queries
Using Views expressions. against them.
Using Inline Table-Valued FunctionsAfter Create simple views and write queries Create simple inline table-valued functions
completing this module, students will be able against them. and write queries against them.
to: Create simple inline table-valued Using EXCEPT and INTERSECT
Write queries which use derived tables. functions and write queries against them. Using APPLYAfter completing this module,
Write queries which use common table Using EXCEPT and INTERSECT students will be able to:
expressions. Using APPLYAfter completing this Write queries which combine data using
Create simple views and write queries module, students will be able to: the UNION operator
against them. Write queries which combine data using Write queries which compare sets using
Create simple inline table-valued functions the UNION operator the INTERSECT and EXCEPT operators
and write queries against them. Write queries which compare sets using Write queries which manipulate rows in a
Using EXCEPT and INTERSECT the INTERSECT and EXCEPT operators table by using APPLY with the results of a
Using APPLYAfter completing this module, Write queries which manipulate rows in a derived table or function
students will be able to: table by using APPLY with the results of Exploring Window Functions
Write queries which combine data using the a derived table or function Restrict window functions to rows defined
UNION operator Exploring Window Functions in an OVER clause, including partitions
Write queries which compare sets using the Restrict window functions to rows defined and frames.
INTERSECT and EXCEPT operators in an OVER clause, including partitions Write queries which use window functions
Write queries which manipulate rows in a and frames. to operate on a window of rows and return
table by using APPLY with the results of a Write queries which use window ranking, aggregation and offset
derived table or function functions to operate on a window of rows comparison results.
Exploring Window Functions and return ranking, aggregation and Working with Grouping SetsAfter
Restrict window functions to rows defined in offset comparison results. completing this module, students will be
an OVER clause, including partitions and Working with Grouping SetsAfter able to:
frames. completing this module, students will be Write queries which pivot and unpivot

Write queries which use window functions to able to: result sets
operate on a window of rows and return Write queries which pivot and unpivot Write queries which specify multiple
ranking, aggregation and offset comparison result sets groupings with grouping sets
results. Write queries which specify multiple Executing System Stored Procedures
Working with Grouping SetsAfter completing groupings with grouping sets Querying Dynamic Management
this module, students will be able to: Executing System Stored Procedures ObjectsAfter completing this module,
Write queries which pivot and unpivot result Querying Dynamic Management students will be able to:
sets ObjectsAfter completing this module, Write queries that retrieve system
Write queries which specify multiple students will be able to: metadata using system views and
groupings with grouping sets Write queries that retrieve system functions.
Executing System Stored Procedures metadata using system views and Execute system stored procedures to
Querying Dynamic Management functions. return system information.
ObjectsAfter completing this module, Execute system stored procedures to Write queries that retrieve system
students will be able to: return system information. metadata and state information using
Write queries that retrieve system metadata Write queries that retrieve system system dynamic management views and
using system views and functions. metadata and state information using functions.
Execute system stored procedures to return system dynamic management views and Passing Parameters to Stored Procedures
system information. functions. Creating Simple Stored Procedures
Write queries that retrieve system metadata Passing Parameters to Stored Working with Dynamic SQLAfter
and state information using system dynamic Procedures completing this module, students will be
management views and functions. Creating Simple Stored Procedures able to:
Passing Parameters to Stored Procedures Working with Dynamic SQLAfter Return results by executing stored
Creating Simple Stored Procedures completing this module, students will be procedures.
Working with Dynamic SQLAfter completing able to: Pass parameters to procedures.
this module, students will be able to: Return results by executing stored Create simple stored procedures which
Return results by executing stored procedures. encapsulate a SELECT statement.
procedures. Pass parameters to procedures. Construct and execute dynamic SQL with
Pass parameters to procedures. Create simple stored procedures which EXEC and sp_executesql.
Create simple stored procedures which encapsulate a SELECT statement. Controlling Program FlowAfter completing
encapsulate a SELECT statement. Construct and execute dynamic SQL with this module, students will be able to:
Construct and execute dynamic SQL with EXEC and sp_executesql. Describe the language elements of T-SQL
EXEC and sp_executesql. Controlling Program FlowAfter used for simple programming tasks.
Controlling Program FlowAfter completing completing this module, students will be Describe batches and how they are
this module, students will be able to: able to: handled by SQL Server.
Describe the language elements of T-SQL Describe the language elements of Declare and assign variables and
used for simple programming tasks. T-SQL used for simple programming synonyms.
Describe batches and how they are handled tasks. Use IF and WHILE blocks to control
by SQL Server. Describe batches and how they are program flow.
Declare and assign variables and synonyms. handled by SQL Server. Working with Error InformationAfter
Use IF and WHILE blocks to control Declare and assign variables and completing this module, students will be
program flow. synonyms. able to:
Working with Error InformationAfter Use IF and WHILE blocks to control Describe SQL Server's behavior when
completing this module, students will be able program flow. errors occur in T-SQL code.
to: Working with Error InformationAfter Implement structured exception handling in
Describe SQL Server's behavior when errors completing this module, students will be T-SQL.
occur in T-SQL code. able to: Return information about errors from
Implement structured exception handling in Describe SQL Server's behavior when system objects.
T-SQL. errors occur in T-SQL code. Raise user-defined errors and pass system
Return information about errors from system Implement structured exception handling errors in T-SQL code.
objects. in T-SQL. Controlling TransactionsAfter completing
Raise user-defined errors and pass system Return information about errors from this module, students will be able to:
errors in T-SQL code. system objects. Describe transactions and the differences
Controlling TransactionsAfter completing Raise user-defined errors and pass between batches and transactions.
this module, students will be able to: system errors in T-SQL code. Describe batches and how they are
Describe transactions and the differences Controlling TransactionsAfter completing handled by SQL Server.
between batches and transactions. this module, students will be able to: Create and manage transactions with
Describe batches and how they are handled Describe transactions and the differences transaction control language statements.
by SQL Server. between batches and transactions. Use SET XACT_ABORT to define SQL
Create and manage transactions with Describe batches and how they are Server's handling of transactions outside
transaction control language statements. handled by SQL Server. TRY / CATCH blocks.
Use SET XACT_ABORT to define SQL Create and manage transactions with Displaying Query Performance DataAfter
Server's handling of transactions outside transaction control language statements. completing this module, students will be
TRY / CATCH blocks. Use SET XACT_ABORT to define SQL able to:
Displaying Query Performance DataAfter Server's handling of transactions outside Describe components of well-performing
completing this module, students will be able TRY / CATCH blocks. queries.
to: Displaying Query Performance DataAfter Describe the role of indexes and statistics

Describe components of well-performing completing this module, students will be in SQL Server
queries. able to: Display and interpret basic query plans
Describe the role of indexes and statistics in Describe components of well-performing Display and interpret basic query
SQL Server queries. performance data
Display and interpret basic query plans Describe the role of indexes and statistics
Display and interpret basic query in SQL Server Module 14: Pivoting and Grouping Sets
performance data Display and interpret basic query plans line
Display and interpret basic query
After completing this module, students will be performance data This module discusses techniques for pivoting
able to: data in T-SQL as well to introduce the
line fundamentals of the GROUPING SETS
Describe the architecture and editions of line clause. It will also cover the use of GROUP
SQL Server 2012. Getting Started with SQL Server BY ROLLUP and GROUP BY CUBE syntax in
Describe the benefits to using window Management Studio SQL Server 2012.
functions. Work with SQL Server Management line
Studio. Writing Queries with PIVOT and UNPIVOT
Working with SQL AzureAfter completing
line this module, students will be able to:
Getting Started with SQL Server Describe the basic features of SQL line
Management Studio Azure. Getting Started with SQL Server
Work with SQL Server Management Studio. Provision a SQL Azure server and Management Studio
Working with SQL AzureAfter completing configure its security. Work with SQL Server Management
this module, students will be able to: Understanding Sets Studio.
Describe the basic features of SQL Azure. Understanding Predicate Logic Working with SQL AzureAfter completing
Provision a SQL Azure server and configure Understanding the Logical Order of this module, students will be able to:
its security. Operations in SELECT statementsAfter Describe the basic features of SQL Azure.
Understanding Sets completing this module, students will be Provision a SQL Azure server and
Understanding Predicate Logic able to: configure its security.
Understanding the Logical Order of Describe the elements of T-SQL and their Understanding Sets
Operations in SELECT statementsAfter role in writing queries Understanding Predicate Logic
completing this module, students will be able Describe the use of sets in SQL Server Understanding the Logical Order of
to: Describe the use of predicate logic in Operations in SELECT statementsAfter
Describe the elements of T-SQL and their SQL Server completing this module, students will be
role in writing queries Describe the logical order of operations in able to:
Describe the use of sets in SQL Server SELECT statements Describe the elements of T-SQL and their
Describe the use of predicate logic in SQL Eliminating Duplicates with DISTINCT role in writing queries
Server Using Column and Table Aliases Describe the use of sets in SQL Server
Describe the logical order of operations in Writing Simple CASE Expressions Describe the use of predicate logic in SQL
SELECT statements Eliminate duplicates using the DISTINCT Server
Eliminating Duplicates with DISTINCT clause. Describe the logical order of operations in
Using Column and Table Aliases Use column and table aliases. SELECT statements
Writing Simple CASE Expressions Write simple CASE expressions. Eliminating Duplicates with DISTINCT
Eliminate duplicates using the DISTINCT Querying with Inner Joins Using Column and Table Aliases
clause. Querying with Outer Joins Writing Simple CASE Expressions
Use column and table aliases. Querying with Cross Joins and Self Eliminate duplicates using the DISTINCT
Write simple CASE expressions. JoinsAfter completing this module, clause.
Querying with Inner Joins students will be able to: Use column and table aliases.
Querying with Outer Joins Describe how multiple tables may be Write simple CASE expressions.
Querying with Cross Joins and Self queried in a SELECT statement using Querying with Inner Joins
JoinsAfter completing this module, students joins. Querying with Outer Joins
will be able to: Write queries that use inner joins. Querying with Cross Joins and Self
Describe how multiple tables may be Write queries that use outer joins. JoinsAfter completing this module,
queried in a SELECT statement using joins. Write queries that use self-joins and students will be able to:
Write queries that use inner joins. cross joins. Describe how multiple tables may be
Write queries that use outer joins. Filtering Data with a WHERE Clause queried in a SELECT statement using
Write queries that use self-joins and cross Filtering with the TOP and joins.
joins. OFFSET-FETCH Options Write queries that use inner joins.
Filtering Data with a WHERE Clause Working with Unknown and Missing Write queries that use outer joins.
Filtering with the TOP and OFFSET-FETCH ValuesAfter completing this module, Write queries that use self-joins and cross
Options students will be able to: joins.
Working with Unknown and Missing Filter data with predicates in the WHERE Filtering Data with a WHERE Clause
ValuesAfter completing this module, clause. Filtering with the TOP and
students will be able to: Sort data using ORDER BY. OFFSET-FETCH Options
Filter data with predicates in the WHERE Filter data in the SELECT clause with Working with Unknown and Missing
clause. TOP. ValuesAfter completing this module,
Sort data using ORDER BY. Filter data with OFFSET and FETCH. students will be able to:

Filter data in the SELECT clause with TOP. Working with Character Data Filter data with predicates in the WHERE
Filter data with OFFSET and FETCH. Working with Date and Time DataAfter clause.
Working with Character Data completing this module, students will be Sort data using ORDER BY.
Working with Date and Time DataAfter able to: Filter data in the SELECT clause with
completing this module, students will be able Describe numeric data types, type TOP.
to: precedence and type conversions. Filter data with OFFSET and FETCH.
Describe numeric data types, type Write queries using character data types. Working with Character Data
precedence and type conversions. Write queries using date and time data Working with Date and Time DataAfter
Write queries using character data types. types. completing this module, students will be
Write queries using date and time data Using Conversion Functions able to:
types. Using Logical Functions Describe numeric data types, type
Using Conversion Functions Using Functions to Work with NULLAfter precedence and type conversions.
Using Logical Functions completing this module, students will be Write queries using character data types.
Using Functions to Work with NULLAfter able to: Write queries using date and time data
completing this module, students will be able Write queries with built-in scalar types.
to: functions. Using Conversion Functions
Write queries with built-in scalar functions. Use conversion functions. Using Logical Functions
Use conversion functions. Use logical functions. Using Functions to Work with NULLAfter
Use logical functions. Use functions that work with NULL. completing this module, students will be
Use functions that work with NULL. Using the GROUP BY Clause able to:
Using the GROUP BY Clause Filtering Groups with HAVINGAfter Write queries with built-in scalar functions.
Filtering Groups with HAVINGAfter completing this module, students will be Use conversion functions.
completing this module, students will be able able to: Use logical functions.
to: Write queries which summarize data Use functions that work with NULL.
Write queries which summarize data using using built-in aggregate functions. Using the GROUP BY Clause
built-in aggregate functions. Use the GROUP BY clause to arrange Filtering Groups with HAVINGAfter
Use the GROUP BY clause to arrange rows rows into groups. completing this module, students will be
into groups. Use the HAVING clause to filter out able to:
Use the HAVING clause to filter out groups groups based on a search condition. Write queries which summarize data using
based on a search condition. Writing Correlated Subqueries built-in aggregate functions.
Writing Correlated Subqueries Using the EXISTS Predicate with Use the GROUP BY clause to arrange
Using the EXISTS Predicate with SubqueriesAfter completing this module, rows into groups.
SubqueriesAfter completing this module, students will be able to: Use the HAVING clause to filter out groups
students will be able to: Describe the uses of queries which are based on a search condition.
Describe the uses of queries which are nested within other queries. Writing Correlated Subqueries
nested within other queries. Write self-contained subqueries which Using the EXISTS Predicate with
Write self-contained subqueries which return return scalar or multi-valued results. SubqueriesAfter completing this module,
scalar or multi-valued results. Write correlated subqueries which return students will be able to:
Write correlated subqueries which return scalar or multi-valued results. Describe the uses of queries which are
scalar or multi-valued results. Use the EXISTS predicate to efficiently nested within other queries.
Use the EXISTS predicate to efficiently check for the existence of rows in a Write self-contained subqueries which
check for the existence of rows in a subquery. return scalar or multi-valued results.
subquery. Using Common Table Expressions Write correlated subqueries which return
Using Common Table Expressions Using Views scalar or multi-valued results.
Using Views Using Inline Table-Valued FunctionsAfter Use the EXISTS predicate to efficiently
Using Inline Table-Valued FunctionsAfter completing this module, students will be check for the existence of rows in a
completing this module, students will be able able to: subquery.
to: Write queries which use derived tables. Using Common Table Expressions
Write queries which use derived tables. Write queries which use common table Using Views
Write queries which use common table expressions. Using Inline Table-Valued FunctionsAfter
expressions. Create simple views and write queries completing this module, students will be
Create simple views and write queries against them. able to:
against them. Create simple inline table-valued Write queries which use derived tables.
Create simple inline table-valued functions functions and write queries against them. Write queries which use common table
and write queries against them. Using EXCEPT and INTERSECT expressions.
Using EXCEPT and INTERSECT Using APPLYAfter completing this Create simple views and write queries
Using APPLYAfter completing this module, module, students will be able to: against them.
students will be able to: Write queries which combine data using Create simple inline table-valued functions
Write queries which combine data using the the UNION operator and write queries against them.
UNION operator Write queries which compare sets using Using EXCEPT and INTERSECT
Write queries which compare sets using the the INTERSECT and EXCEPT operators Using APPLYAfter completing this module,
INTERSECT and EXCEPT operators Write queries which manipulate rows in a students will be able to:
Write queries which manipulate rows in a table by using APPLY with the results of Write queries which combine data using
table by using APPLY with the results of a a derived table or function the UNION operator
derived table or function Exploring Window Functions Write queries which compare sets using
Exploring Window Functions Restrict window functions to rows defined the INTERSECT and EXCEPT operators

Restrict window functions to rows defined in in an OVER clause, including partitions Write queries which manipulate rows in a
an OVER clause, including partitions and and frames. table by using APPLY with the results of a
frames. Write queries which use window derived table or function
Write queries which use window functions to functions to operate on a window of rows Exploring Window Functions
operate on a window of rows and return and return ranking, aggregation and Restrict window functions to rows defined
ranking, aggregation and offset comparison offset comparison results. in an OVER clause, including partitions
results. Working with Grouping SetsAfter and frames.
Working with Grouping SetsAfter completing completing this module, students will be Write queries which use window functions
this module, students will be able to: able to: to operate on a window of rows and return
Write queries which pivot and unpivot result Write queries which pivot and unpivot ranking, aggregation and offset
sets result sets comparison results.
Write queries which specify multiple Write queries which specify multiple Working with Grouping SetsAfter
groupings with grouping sets groupings with grouping sets completing this module, students will be
Executing System Stored Procedures Executing System Stored Procedures able to:
Querying Dynamic Management Querying Dynamic Management Write queries which pivot and unpivot
ObjectsAfter completing this module, ObjectsAfter completing this module, result sets
students will be able to: students will be able to: Write queries which specify multiple
Write queries that retrieve system metadata Write queries that retrieve system groupings with grouping sets
using system views and functions. metadata using system views and Executing System Stored Procedures
Execute system stored procedures to return functions. Querying Dynamic Management
system information. Execute system stored procedures to ObjectsAfter completing this module,
Write queries that retrieve system metadata return system information. students will be able to:
and state information using system dynamic Write queries that retrieve system Write queries that retrieve system
management views and functions. metadata and state information using metadata using system views and
Passing Parameters to Stored Procedures system dynamic management views and functions.
Creating Simple Stored Procedures functions. Execute system stored procedures to
Working with Dynamic SQLAfter completing Passing Parameters to Stored return system information.
this module, students will be able to: Procedures Write queries that retrieve system
Return results by executing stored Creating Simple Stored Procedures metadata and state information using
procedures. Working with Dynamic SQLAfter system dynamic management views and
Pass parameters to procedures. completing this module, students will be functions.
Create simple stored procedures which able to: Passing Parameters to Stored Procedures
encapsulate a SELECT statement. Return results by executing stored Creating Simple Stored Procedures
Construct and execute dynamic SQL with procedures. Working with Dynamic SQLAfter
EXEC and sp_executesql. Pass parameters to procedures. completing this module, students will be
Controlling Program FlowAfter completing Create simple stored procedures which able to:
this module, students will be able to: encapsulate a SELECT statement. Return results by executing stored
Describe the language elements of T-SQL Construct and execute dynamic SQL with procedures.
used for simple programming tasks. EXEC and sp_executesql. Pass parameters to procedures.
Describe batches and how they are handled Controlling Program FlowAfter Create simple stored procedures which
by SQL Server. completing this module, students will be encapsulate a SELECT statement.
Declare and assign variables and synonyms. able to: Construct and execute dynamic SQL with
Use IF and WHILE blocks to control Describe the language elements of EXEC and sp_executesql.
program flow. T-SQL used for simple programming Controlling Program FlowAfter completing
Working with Error InformationAfter tasks. this module, students will be able to:
completing this module, students will be able Describe batches and how they are Describe the language elements of T-SQL
to: handled by SQL Server. used for simple programming tasks.
Describe SQL Server's behavior when errors Declare and assign variables and Describe batches and how they are
occur in T-SQL code. synonyms. handled by SQL Server.
Implement structured exception handling in Use IF and WHILE blocks to control Declare and assign variables and
T-SQL. program flow. synonyms.
Return information about errors from system Working with Error InformationAfter Use IF and WHILE blocks to control
objects. completing this module, students will be program flow.
Raise user-defined errors and pass system able to: Working with Error InformationAfter
errors in T-SQL code. Describe SQL Server's behavior when completing this module, students will be
Controlling TransactionsAfter completing errors occur in T-SQL code. able to:
this module, students will be able to: Implement structured exception handling Describe SQL Server's behavior when
Describe transactions and the differences in T-SQL. errors occur in T-SQL code.
between batches and transactions. Return information about errors from Implement structured exception handling in
Describe batches and how they are handled system objects. T-SQL.
by SQL Server. Raise user-defined errors and pass Return information about errors from
Create and manage transactions with system errors in T-SQL code. system objects.
transaction control language statements. Controlling TransactionsAfter completing Raise user-defined errors and pass system
Use SET XACT_ABORT to define SQL this module, students will be able to: errors in T-SQL code.
Server's handling of transactions outside Describe transactions and the differences Controlling TransactionsAfter completing
TRY / CATCH blocks. between batches and transactions. this module, students will be able to:

Displaying Query Performance DataAfter Describe batches and how they are Describe transactions and the differences
completing this module, students will be able handled by SQL Server. between batches and transactions.
to: Create and manage transactions with Describe batches and how they are
Describe components of well-performing transaction control language statements. handled by SQL Server.
queries. Use SET XACT_ABORT to define SQL Create and manage transactions with
Describe the role of indexes and statistics in Server's handling of transactions outside transaction control language statements.
SQL Server TRY / CATCH blocks. Use SET XACT_ABORT to define SQL
Display and interpret basic query plans Displaying Query Performance DataAfter Server's handling of transactions outside
Display and interpret basic query completing this module, students will be TRY / CATCH blocks.
performance data able to: Displaying Query Performance DataAfter
Describe components of well-performing completing this module, students will be
Module 2: Getting Started with SQL Azure queries. able to:
line Describe the role of indexes and statistics Describe components of well-performing
in SQL Server queries.
Display and interpret basic query plans Describe the role of indexes and statistics
Overview of SQL Azure Display and interpret basic query in SQL Server
performance data Display and interpret basic query plans
line performance data
Getting Started with SQL Server line
Management Studio Getting Started with SQL Server
Work with SQL Server Management Studio. Management Studio line
Working with SQL AzureAfter completing Work with SQL Server Management Getting Started with SQL Server
this module, students will be able to: Studio. Management Studio
Describe the basic features of SQL Azure. Working with SQL AzureAfter completing Work with SQL Server Management
Provision a SQL Azure server and configure this module, students will be able to: Studio.
its security. Describe the basic features of SQL Working with SQL AzureAfter completing
Understanding Sets Azure. this module, students will be able to:
Understanding Predicate Logic Provision a SQL Azure server and Describe the basic features of SQL Azure.
Understanding the Logical Order of configure its security. Provision a SQL Azure server and
Operations in SELECT statementsAfter Understanding Sets configure its security.
completing this module, students will be able Understanding Predicate Logic Understanding Sets
to: Understanding the Logical Order of Understanding Predicate Logic
Describe the elements of T-SQL and their Operations in SELECT statementsAfter Understanding the Logical Order of
role in writing queries completing this module, students will be Operations in SELECT statementsAfter
Describe the use of sets in SQL Server able to: completing this module, students will be
Describe the use of predicate logic in SQL Describe the elements of T-SQL and their able to:
Server role in writing queries Describe the elements of T-SQL and their
Describe the logical order of operations in Describe the use of sets in SQL Server role in writing queries
SELECT statements Describe the use of predicate logic in Describe the use of sets in SQL Server
Eliminating Duplicates with DISTINCT SQL Server Describe the use of predicate logic in SQL
Using Column and Table Aliases Describe the logical order of operations in Server
Writing Simple CASE Expressions SELECT statements Describe the logical order of operations in
Eliminate duplicates using the DISTINCT Eliminating Duplicates with DISTINCT SELECT statements
clause. Using Column and Table Aliases Eliminating Duplicates with DISTINCT
Use column and table aliases. Writing Simple CASE Expressions Using Column and Table Aliases
Write simple CASE expressions. Eliminate duplicates using the DISTINCT Writing Simple CASE Expressions
Querying with Inner Joins clause. Eliminate duplicates using the DISTINCT
Querying with Outer Joins Use column and table aliases. clause.
Querying with Cross Joins and Self Write simple CASE expressions. Use column and table aliases.
JoinsAfter completing this module, students Querying with Inner Joins Write simple CASE expressions.
will be able to: Querying with Outer Joins Querying with Inner Joins
Describe how multiple tables may be Querying with Cross Joins and Self Querying with Outer Joins
queried in a SELECT statement using joins. JoinsAfter completing this module, Querying with Cross Joins and Self
Write queries that use inner joins. students will be able to: JoinsAfter completing this module,
Write queries that use outer joins. Describe how multiple tables may be students will be able to:
Write queries that use self-joins and cross queried in a SELECT statement using Describe how multiple tables may be
joins. joins. queried in a SELECT statement using
Filtering Data with a WHERE Clause Write queries that use inner joins. joins.
Filtering with the TOP and OFFSET-FETCH Write queries that use outer joins. Write queries that use inner joins.
Options Write queries that use self-joins and Write queries that use outer joins.
Working with Unknown and Missing cross joins. Write queries that use self-joins and cross
ValuesAfter completing this module, Filtering Data with a WHERE Clause joins.
students will be able to: Filtering with the TOP and Filtering Data with a WHERE Clause
Filter data with predicates in the WHERE OFFSET-FETCH Options Filtering with the TOP and
clause. Working with Unknown and Missing OFFSET-FETCH Options

Sort data using ORDER BY. ValuesAfter completing this module, Working with Unknown and Missing
Filter data in the SELECT clause with TOP. students will be able to: ValuesAfter completing this module,
Filter data with OFFSET and FETCH. Filter data with predicates in the WHERE students will be able to:
Working with Character Data clause. Filter data with predicates in the WHERE
Working with Date and Time DataAfter Sort data using ORDER BY. clause.
completing this module, students will be able Filter data in the SELECT clause with Sort data using ORDER BY.
to: TOP. Filter data in the SELECT clause with
Describe numeric data types, type Filter data with OFFSET and FETCH. TOP.
precedence and type conversions. Working with Character Data Filter data with OFFSET and FETCH.
Write queries using character data types. Working with Date and Time DataAfter Working with Character Data
Write queries using date and time data completing this module, students will be Working with Date and Time DataAfter
types. able to: completing this module, students will be
Using Conversion Functions Describe numeric data types, type able to:
Using Logical Functions precedence and type conversions. Describe numeric data types, type
Using Functions to Work with NULLAfter Write queries using character data types. precedence and type conversions.
completing this module, students will be able Write queries using date and time data Write queries using character data types.
to: types. Write queries using date and time data
Write queries with built-in scalar functions. Using Conversion Functions types.
Use conversion functions. Using Logical Functions Using Conversion Functions
Use logical functions. Using Functions to Work with NULLAfter Using Logical Functions
Use functions that work with NULL. completing this module, students will be Using Functions to Work with NULLAfter
Using the GROUP BY Clause able to: completing this module, students will be
Filtering Groups with HAVINGAfter Write queries with built-in scalar able to:
completing this module, students will be able functions. Write queries with built-in scalar functions.
to: Use conversion functions. Use conversion functions.
Write queries which summarize data using Use logical functions. Use logical functions.
built-in aggregate functions. Use functions that work with NULL. Use functions that work with NULL.
Use the GROUP BY clause to arrange rows Using the GROUP BY Clause Using the GROUP BY Clause
into groups. Filtering Groups with HAVINGAfter Filtering Groups with HAVINGAfter
Use the HAVING clause to filter out groups completing this module, students will be completing this module, students will be
based on a search condition. able to: able to:
Writing Correlated Subqueries Write queries which summarize data Write queries which summarize data using
Using the EXISTS Predicate with using built-in aggregate functions. built-in aggregate functions.
SubqueriesAfter completing this module, Use the GROUP BY clause to arrange Use the GROUP BY clause to arrange
students will be able to: rows into groups. rows into groups.
Describe the uses of queries which are Use the HAVING clause to filter out Use the HAVING clause to filter out groups
nested within other queries. groups based on a search condition. based on a search condition.
Write self-contained subqueries which return Writing Correlated Subqueries Writing Correlated Subqueries
scalar or multi-valued results. Using the EXISTS Predicate with Using the EXISTS Predicate with
Write correlated subqueries which return SubqueriesAfter completing this module, SubqueriesAfter completing this module,
scalar or multi-valued results. students will be able to: students will be able to:
Use the EXISTS predicate to efficiently Describe the uses of queries which are Describe the uses of queries which are
check for the existence of rows in a nested within other queries. nested within other queries.
subquery. Write self-contained subqueries which Write self-contained subqueries which
Using Common Table Expressions return scalar or multi-valued results. return scalar or multi-valued results.
Using Views Write correlated subqueries which return Write correlated subqueries which return
Using Inline Table-Valued FunctionsAfter scalar or multi-valued results. scalar or multi-valued results.
completing this module, students will be able Use the EXISTS predicate to efficiently Use the EXISTS predicate to efficiently
to: check for the existence of rows in a check for the existence of rows in a
Write queries which use derived tables. subquery. subquery.
Write queries which use common table Using Common Table Expressions Using Common Table Expressions
expressions. Using Views Using Views
Create simple views and write queries Using Inline Table-Valued FunctionsAfter Using Inline Table-Valued FunctionsAfter
against them. completing this module, students will be completing this module, students will be
Create simple inline table-valued functions able to: able to:
and write queries against them. Write queries which use derived tables. Write queries which use derived tables.
Using EXCEPT and INTERSECT Write queries which use common table Write queries which use common table
Using APPLYAfter completing this module, expressions. expressions.
students will be able to: Create simple views and write queries Create simple views and write queries
Write queries which combine data using the against them. against them.
UNION operator Create simple inline table-valued Create simple inline table-valued functions
Write queries which compare sets using the functions and write queries against them. and write queries against them.
INTERSECT and EXCEPT operators Using EXCEPT and INTERSECT Using EXCEPT and INTERSECT
Write queries which manipulate rows in a Using APPLYAfter completing this Using APPLYAfter completing this module,
table by using APPLY with the results of a module, students will be able to: students will be able to:
derived table or function Write queries which combine data using Write queries which combine data using

Exploring Window Functions the UNION operator the UNION operator
Restrict window functions to rows defined in Write queries which compare sets using Write queries which compare sets using
an OVER clause, including partitions and the INTERSECT and EXCEPT operators the INTERSECT and EXCEPT operators
frames. Write queries which manipulate rows in a Write queries which manipulate rows in a
Write queries which use window functions to table by using APPLY with the results of table by using APPLY with the results of a
operate on a window of rows and return a derived table or function derived table or function
ranking, aggregation and offset comparison Exploring Window Functions Exploring Window Functions
results. Restrict window functions to rows defined Restrict window functions to rows defined
Working with Grouping SetsAfter completing in an OVER clause, including partitions in an OVER clause, including partitions
this module, students will be able to: and frames. and frames.
Write queries which pivot and unpivot result Write queries which use window Write queries which use window functions
sets functions to operate on a window of rows to operate on a window of rows and return
Write queries which specify multiple and return ranking, aggregation and ranking, aggregation and offset
groupings with grouping sets offset comparison results. comparison results.
Executing System Stored Procedures Working with Grouping SetsAfter Working with Grouping SetsAfter
Querying Dynamic Management completing this module, students will be completing this module, students will be
ObjectsAfter completing this module, able to: able to:
students will be able to: Write queries which pivot and unpivot Write queries which pivot and unpivot
Write queries that retrieve system metadata result sets result sets
using system views and functions. Write queries which specify multiple Write queries which specify multiple
Execute system stored procedures to return groupings with grouping sets groupings with grouping sets
system information. Executing System Stored Procedures Executing System Stored Procedures
Write queries that retrieve system metadata Querying Dynamic Management Querying Dynamic Management
and state information using system dynamic ObjectsAfter completing this module, ObjectsAfter completing this module,
management views and functions. students will be able to: students will be able to:
Passing Parameters to Stored Procedures Write queries that retrieve system Write queries that retrieve system
Creating Simple Stored Procedures metadata using system views and metadata using system views and
Working with Dynamic SQLAfter completing functions. functions.
this module, students will be able to: Execute system stored procedures to Execute system stored procedures to
Return results by executing stored return system information. return system information.
procedures. Write queries that retrieve system Write queries that retrieve system
Pass parameters to procedures. metadata and state information using metadata and state information using
Create simple stored procedures which system dynamic management views and system dynamic management views and
encapsulate a SELECT statement. functions. functions.
Construct and execute dynamic SQL with Passing Parameters to Stored Passing Parameters to Stored Procedures
EXEC and sp_executesql. Procedures Creating Simple Stored Procedures
Controlling Program FlowAfter completing Creating Simple Stored Procedures Working with Dynamic SQLAfter
this module, students will be able to: Working with Dynamic SQLAfter completing this module, students will be
Describe the language elements of T-SQL completing this module, students will be able to:
used for simple programming tasks. able to: Return results by executing stored
Describe batches and how they are handled Return results by executing stored procedures.
by SQL Server. procedures. Pass parameters to procedures.
Declare and assign variables and synonyms. Pass parameters to procedures. Create simple stored procedures which
Use IF and WHILE blocks to control Create simple stored procedures which encapsulate a SELECT statement.
program flow. encapsulate a SELECT statement. Construct and execute dynamic SQL with
Working with Error InformationAfter Construct and execute dynamic SQL with EXEC and sp_executesql.
completing this module, students will be able EXEC and sp_executesql. Controlling Program FlowAfter completing
to: Controlling Program FlowAfter this module, students will be able to:
Describe SQL Server's behavior when errors completing this module, students will be Describe the language elements of T-SQL
occur in T-SQL code. able to: used for simple programming tasks.
Implement structured exception handling in Describe the language elements of Describe batches and how they are
T-SQL. T-SQL used for simple programming handled by SQL Server.
Return information about errors from system tasks. Declare and assign variables and
objects. Describe batches and how they are synonyms.
Raise user-defined errors and pass system handled by SQL Server. Use IF and WHILE blocks to control
errors in T-SQL code. Declare and assign variables and program flow.
Controlling TransactionsAfter completing synonyms. Working with Error InformationAfter
this module, students will be able to: Use IF and WHILE blocks to control completing this module, students will be
Describe transactions and the differences program flow. able to:
between batches and transactions. Working with Error InformationAfter Describe SQL Server's behavior when
Describe batches and how they are handled completing this module, students will be errors occur in T-SQL code.
by SQL Server. able to: Implement structured exception handling in
Create and manage transactions with Describe SQL Server's behavior when T-SQL.
transaction control language statements. errors occur in T-SQL code. Return information about errors from
Use SET XACT_ABORT to define SQL Implement structured exception handling system objects.
Server's handling of transactions outside in T-SQL. Raise user-defined errors and pass system

TRY / CATCH blocks. Return information about errors from errors in T-SQL code.
Displaying Query Performance DataAfter system objects. Controlling TransactionsAfter completing
completing this module, students will be able Raise user-defined errors and pass this module, students will be able to:
to: system errors in T-SQL code. Describe transactions and the differences
Describe components of well-performing Controlling TransactionsAfter completing between batches and transactions.
queries. this module, students will be able to: Describe batches and how they are
Describe the role of indexes and statistics in Describe transactions and the differences handled by SQL Server.
SQL Server between batches and transactions. Create and manage transactions with
Display and interpret basic query plans Describe batches and how they are transaction control language statements.
Display and interpret basic query handled by SQL Server. Use SET XACT_ABORT to define SQL
performance data Create and manage transactions with Server's handling of transactions outside
transaction control language statements. TRY / CATCH blocks.
Use SET XACT_ABORT to define SQL Displaying Query Performance DataAfter
line Server's handling of transactions outside completing this module, students will be
Getting Started with SQL Server TRY / CATCH blocks. able to:
Management Studio Displaying Query Performance DataAfter Describe components of well-performing
Work with SQL Server Management Studio. completing this module, students will be queries.
Working with SQL AzureAfter completing able to: Describe the role of indexes and statistics
this module, students will be able to: Describe components of well-performing in SQL Server
Describe the basic features of SQL Azure. queries. Display and interpret basic query plans
Provision a SQL Azure server and configure Describe the role of indexes and statistics Display and interpret basic query
its security. in SQL Server performance data
Understanding Sets Display and interpret basic query plans
Understanding Predicate Logic Display and interpret basic query Module 15: Querying SQL Server Metadata
Understanding the Logical Order of performance data line
Operations in SELECT statementsAfter
completing this module, students will be able This module introduces the use of SQL
to: line Server system objects in T-SQL queries. It
Describe the elements of T-SQL and their Getting Started with SQL Server will cover the use of system catalog views,
role in writing queries Management Studio system stored procedures, system functions,
Describe the use of sets in SQL Server Work with SQL Server Management and dynamic management objects.
Describe the use of predicate logic in SQL Studio. line
Server Working with SQL AzureAfter completing Querying System Catalog Views and
Describe the logical order of operations in this module, students will be able to: Functions
SELECT statements Describe the basic features of SQL
Eliminating Duplicates with DISTINCT Azure.
Using Column and Table Aliases Provision a SQL Azure server and line
Writing Simple CASE Expressions configure its security. Getting Started with SQL Server
Eliminate duplicates using the DISTINCT Understanding Sets Management Studio
clause. Understanding Predicate Logic Work with SQL Server Management
Use column and table aliases. Understanding the Logical Order of Studio.
Write simple CASE expressions. Operations in SELECT statementsAfter Working with SQL AzureAfter completing
Querying with Inner Joins completing this module, students will be this module, students will be able to:
Querying with Outer Joins able to: Describe the basic features of SQL Azure.
Querying with Cross Joins and Self Describe the elements of T-SQL and their Provision a SQL Azure server and
JoinsAfter completing this module, students role in writing queries configure its security.
will be able to: Describe the use of sets in SQL Server Understanding Sets
Describe how multiple tables may be Describe the use of predicate logic in Understanding Predicate Logic
queried in a SELECT statement using joins. SQL Server Understanding the Logical Order of
Write queries that use inner joins. Describe the logical order of operations in Operations in SELECT statementsAfter
Write queries that use outer joins. SELECT statements completing this module, students will be
Write queries that use self-joins and cross Eliminating Duplicates with DISTINCT able to:
joins. Using Column and Table Aliases Describe the elements of T-SQL and their
Filtering Data with a WHERE Clause Writing Simple CASE Expressions role in writing queries
Filtering with the TOP and OFFSET-FETCH Eliminate duplicates using the DISTINCT Describe the use of sets in SQL Server
Options clause. Describe the use of predicate logic in SQL
Working with Unknown and Missing Use column and table aliases. Server
ValuesAfter completing this module, Write simple CASE expressions. Describe the logical order of operations in
students will be able to: Querying with Inner Joins SELECT statements
Filter data with predicates in the WHERE Querying with Outer Joins Eliminating Duplicates with DISTINCT
clause. Querying with Cross Joins and Self Using Column and Table Aliases
Sort data using ORDER BY. JoinsAfter completing this module, Writing Simple CASE Expressions
Filter data in the SELECT clause with TOP. students will be able to: Eliminate duplicates using the DISTINCT
Filter data with OFFSET and FETCH. Describe how multiple tables may be clause.
Working with Character Data queried in a SELECT statement using Use column and table aliases.
Working with Date and Time DataAfter joins. Write simple CASE expressions.

completing this module, students will be able Write queries that use inner joins. Querying with Inner Joins
to: Write queries that use outer joins. Querying with Outer Joins
Describe numeric data types, type Write queries that use self-joins and Querying with Cross Joins and Self
precedence and type conversions. cross joins. JoinsAfter completing this module,
Write queries using character data types. Filtering Data with a WHERE Clause students will be able to:
Write queries using date and time data Filtering with the TOP and Describe how multiple tables may be
types. OFFSET-FETCH Options queried in a SELECT statement using
Using Conversion Functions Working with Unknown and Missing joins.
Using Logical Functions ValuesAfter completing this module, Write queries that use inner joins.
Using Functions to Work with NULLAfter students will be able to: Write queries that use outer joins.
completing this module, students will be able Filter data with predicates in the WHERE Write queries that use self-joins and cross
to: clause. joins.
Write queries with built-in scalar functions. Sort data using ORDER BY. Filtering Data with a WHERE Clause
Use conversion functions. Filter data in the SELECT clause with Filtering with the TOP and
Use logical functions. TOP. OFFSET-FETCH Options
Use functions that work with NULL. Filter data with OFFSET and FETCH. Working with Unknown and Missing
Using the GROUP BY Clause Working with Character Data ValuesAfter completing this module,
Filtering Groups with HAVINGAfter Working with Date and Time DataAfter students will be able to:
completing this module, students will be able completing this module, students will be Filter data with predicates in the WHERE
to: able to: clause.
Write queries which summarize data using Describe numeric data types, type Sort data using ORDER BY.
built-in aggregate functions. precedence and type conversions. Filter data in the SELECT clause with
Use the GROUP BY clause to arrange rows Write queries using character data types. TOP.
into groups. Write queries using date and time data Filter data with OFFSET and FETCH.
Use the HAVING clause to filter out groups types. Working with Character Data
based on a search condition. Using Conversion Functions Working with Date and Time DataAfter
Writing Correlated Subqueries Using Logical Functions completing this module, students will be
Using the EXISTS Predicate with Using Functions to Work with NULLAfter able to:
SubqueriesAfter completing this module, completing this module, students will be Describe numeric data types, type
students will be able to: able to: precedence and type conversions.
Describe the uses of queries which are Write queries with built-in scalar Write queries using character data types.
nested within other queries. functions. Write queries using date and time data
Write self-contained subqueries which return Use conversion functions. types.
scalar or multi-valued results. Use logical functions. Using Conversion Functions
Write correlated subqueries which return Use functions that work with NULL. Using Logical Functions
scalar or multi-valued results. Using the GROUP BY Clause Using Functions to Work with NULLAfter
Use the EXISTS predicate to efficiently Filtering Groups with HAVINGAfter completing this module, students will be
check for the existence of rows in a completing this module, students will be able to:
subquery. able to: Write queries with built-in scalar functions.
Using Common Table Expressions Write queries which summarize data Use conversion functions.
Using Views using built-in aggregate functions. Use logical functions.
Using Inline Table-Valued FunctionsAfter Use the GROUP BY clause to arrange Use functions that work with NULL.
completing this module, students will be able rows into groups. Using the GROUP BY Clause
to: Use the HAVING clause to filter out Filtering Groups with HAVINGAfter
Write queries which use derived tables. groups based on a search condition. completing this module, students will be
Write queries which use common table Writing Correlated Subqueries able to:
expressions. Using the EXISTS Predicate with Write queries which summarize data using
Create simple views and write queries SubqueriesAfter completing this module, built-in aggregate functions.
against them. students will be able to: Use the GROUP BY clause to arrange
Create simple inline table-valued functions Describe the uses of queries which are rows into groups.
and write queries against them. nested within other queries. Use the HAVING clause to filter out groups
Using EXCEPT and INTERSECT Write self-contained subqueries which based on a search condition.
Using APPLYAfter completing this module, return scalar or multi-valued results. Writing Correlated Subqueries
students will be able to: Write correlated subqueries which return Using the EXISTS Predicate with
Write queries which combine data using the scalar or multi-valued results. SubqueriesAfter completing this module,
UNION operator Use the EXISTS predicate to efficiently students will be able to:
Write queries which compare sets using the check for the existence of rows in a Describe the uses of queries which are
INTERSECT and EXCEPT operators subquery. nested within other queries.
Write queries which manipulate rows in a Using Common Table Expressions Write self-contained subqueries which
table by using APPLY with the results of a Using Views return scalar or multi-valued results.
derived table or function Using Inline Table-Valued FunctionsAfter Write correlated subqueries which return
Exploring Window Functions completing this module, students will be scalar or multi-valued results.
Restrict window functions to rows defined in able to: Use the EXISTS predicate to efficiently
an OVER clause, including partitions and Write queries which use derived tables. check for the existence of rows in a
frames. Write queries which use common table subquery.
Write queries which use window functions to expressions. Using Common Table Expressions

operate on a window of rows and return Create simple views and write queries Using Views
ranking, aggregation and offset comparison against them. Using Inline Table-Valued FunctionsAfter
results. Create simple inline table-valued completing this module, students will be
Working with Grouping SetsAfter completing functions and write queries against them. able to:
this module, students will be able to: Using EXCEPT and INTERSECT Write queries which use derived tables.
Write queries which pivot and unpivot result Using APPLYAfter completing this Write queries which use common table
sets module, students will be able to: expressions.
Write queries which specify multiple Write queries which combine data using Create simple views and write queries
groupings with grouping sets the UNION operator against them.
Executing System Stored Procedures Write queries which compare sets using Create simple inline table-valued functions
Querying Dynamic Management the INTERSECT and EXCEPT operators and write queries against them.
ObjectsAfter completing this module, Write queries which manipulate rows in a Using EXCEPT and INTERSECT
students will be able to: table by using APPLY with the results of Using APPLYAfter completing this module,
Write queries that retrieve system metadata a derived table or function students will be able to:
using system views and functions. Exploring Window Functions Write queries which combine data using
Execute system stored procedures to return Restrict window functions to rows defined the UNION operator
system information. in an OVER clause, including partitions Write queries which compare sets using
Write queries that retrieve system metadata and frames. the INTERSECT and EXCEPT operators
and state information using system dynamic Write queries which use window Write queries which manipulate rows in a
management views and functions. functions to operate on a window of rows table by using APPLY with the results of a
Passing Parameters to Stored Procedures and return ranking, aggregation and derived table or function
Creating Simple Stored Procedures offset comparison results. Exploring Window Functions
Working with Dynamic SQLAfter completing Working with Grouping SetsAfter Restrict window functions to rows defined
this module, students will be able to: completing this module, students will be in an OVER clause, including partitions
Return results by executing stored able to: and frames.
procedures. Write queries which pivot and unpivot Write queries which use window functions
Pass parameters to procedures. result sets to operate on a window of rows and return
Create simple stored procedures which Write queries which specify multiple ranking, aggregation and offset
encapsulate a SELECT statement. groupings with grouping sets comparison results.
Construct and execute dynamic SQL with Executing System Stored Procedures Working with Grouping SetsAfter
EXEC and sp_executesql. Querying Dynamic Management completing this module, students will be
Controlling Program FlowAfter completing ObjectsAfter completing this module, able to:
this module, students will be able to: students will be able to: Write queries which pivot and unpivot
Describe the language elements of T-SQL Write queries that retrieve system result sets
used for simple programming tasks. metadata using system views and Write queries which specify multiple
Describe batches and how they are handled functions. groupings with grouping sets
by SQL Server. Execute system stored procedures to Executing System Stored Procedures
Declare and assign variables and synonyms. return system information. Querying Dynamic Management
Use IF and WHILE blocks to control Write queries that retrieve system ObjectsAfter completing this module,
program flow. metadata and state information using students will be able to:
Working with Error InformationAfter system dynamic management views and Write queries that retrieve system
completing this module, students will be able functions. metadata using system views and
to: Passing Parameters to Stored functions.
Describe SQL Server's behavior when errors Procedures Execute system stored procedures to
occur in T-SQL code. Creating Simple Stored Procedures return system information.
Implement structured exception handling in Working with Dynamic SQLAfter Write queries that retrieve system
T-SQL. completing this module, students will be metadata and state information using
Return information about errors from system able to: system dynamic management views and
objects. Return results by executing stored functions.
Raise user-defined errors and pass system procedures. Passing Parameters to Stored Procedures
errors in T-SQL code. Pass parameters to procedures. Creating Simple Stored Procedures
Controlling TransactionsAfter completing Create simple stored procedures which Working with Dynamic SQLAfter
this module, students will be able to: encapsulate a SELECT statement. completing this module, students will be
Describe transactions and the differences Construct and execute dynamic SQL with able to:
between batches and transactions. EXEC and sp_executesql. Return results by executing stored
Describe batches and how they are handled Controlling Program FlowAfter procedures.
by SQL Server. completing this module, students will be Pass parameters to procedures.
Create and manage transactions with able to: Create simple stored procedures which
transaction control language statements. Describe the language elements of encapsulate a SELECT statement.
Use SET XACT_ABORT to define SQL T-SQL used for simple programming Construct and execute dynamic SQL with
Server's handling of transactions outside tasks. EXEC and sp_executesql.
TRY / CATCH blocks. Describe batches and how they are Controlling Program FlowAfter completing
Displaying Query Performance DataAfter handled by SQL Server. this module, students will be able to:
completing this module, students will be able Declare and assign variables and Describe the language elements of T-SQL
to: synonyms. used for simple programming tasks.
Describe components of well-performing Use IF and WHILE blocks to control Describe batches and how they are

queries. program flow. handled by SQL Server.
Describe the role of indexes and statistics in Working with Error InformationAfter Declare and assign variables and
SQL Server completing this module, students will be synonyms.
Display and interpret basic query plans able to: Use IF and WHILE blocks to control
Display and interpret basic query Describe SQL Server's behavior when program flow.
performance data errors occur in T-SQL code. Working with Error InformationAfter
Implement structured exception handling completing this module, students will be
Module 3: Introduction to T-SQL Querying in T-SQL. able to:
line Return information about errors from Describe SQL Server's behavior when
system objects. errors occur in T-SQL code.
This module introduces Transact SQL as the Raise user-defined errors and pass Implement structured exception handling in
primary querying language of SQL Server. It system errors in T-SQL code. T-SQL.
discusses the basic structure of T-SQL queries, Controlling TransactionsAfter completing Return information about errors from
the logical flow of a SELECT statement, and this module, students will be able to: system objects.
introduces concepts such as predicates and Describe transactions and the differences Raise user-defined errors and pass system
set-based operations. between batches and transactions. errors in T-SQL code.
line Describe batches and how they are Controlling TransactionsAfter completing
Introducing T-SQL handled by SQL Server. this module, students will be able to:
Create and manage transactions with Describe transactions and the differences
transaction control language statements. between batches and transactions.
line Use SET XACT_ABORT to define SQL Describe batches and how they are
Getting Started with SQL Server Server's handling of transactions outside handled by SQL Server.
Management Studio TRY / CATCH blocks. Create and manage transactions with
Work with SQL Server Management Studio. Displaying Query Performance DataAfter transaction control language statements.
Working with SQL AzureAfter completing completing this module, students will be Use SET XACT_ABORT to define SQL
this module, students will be able to: able to: Server's handling of transactions outside
Describe the basic features of SQL Azure. Describe components of well-performing TRY / CATCH blocks.
Provision a SQL Azure server and configure queries. Displaying Query Performance DataAfter
its security. Describe the role of indexes and statistics completing this module, students will be
Understanding Sets in SQL Server able to:
Understanding Predicate Logic Display and interpret basic query plans Describe components of well-performing
Understanding the Logical Order of Display and interpret basic query queries.
Operations in SELECT statementsAfter performance data Describe the role of indexes and statistics
completing this module, students will be able in SQL Server
to: Module 8: Using Built-In Functions Display and interpret basic query plans
Describe the elements of T-SQL and their line Display and interpret basic query
role in writing queries performance data
Describe the use of sets in SQL Server This module introduces the use of functions
Describe the use of predicate logic in SQL that are built in to SQL Server Denali, and will
Server discuss some common usages including data line
Describe the logical order of operations in type conversion, testing for logical results and Getting Started with SQL Server
SELECT statements nullability. Management Studio
Eliminating Duplicates with DISTINCT line Work with SQL Server Management
Using Column and Table Aliases Writing Queries with Built-In Functions Studio.
Writing Simple CASE Expressions Working with SQL AzureAfter completing
Eliminate duplicates using the DISTINCT this module, students will be able to:
clause. line Describe the basic features of SQL Azure.
Use column and table aliases. Getting Started with SQL Server Provision a SQL Azure server and
Write simple CASE expressions. Management Studio configure its security.
Querying with Inner Joins Work with SQL Server Management Understanding Sets
Querying with Outer Joins Studio. Understanding Predicate Logic
Querying with Cross Joins and Self Working with SQL AzureAfter completing Understanding the Logical Order of
JoinsAfter completing this module, students this module, students will be able to: Operations in SELECT statementsAfter
will be able to: Describe the basic features of SQL completing this module, students will be
Describe how multiple tables may be Azure. able to:
queried in a SELECT statement using joins. Provision a SQL Azure server and Describe the elements of T-SQL and their
Write queries that use inner joins. configure its security. role in writing queries
Write queries that use outer joins. Understanding Sets Describe the use of sets in SQL Server
Write queries that use self-joins and cross Understanding Predicate Logic Describe the use of predicate logic in SQL
joins. Understanding the Logical Order of Server
Filtering Data with a WHERE Clause Operations in SELECT statementsAfter Describe the logical order of operations in
Filtering with the TOP and OFFSET-FETCH completing this module, students will be SELECT statements
Options able to: Eliminating Duplicates with DISTINCT
Working with Unknown and Missing Describe the elements of T-SQL and their Using Column and Table Aliases
ValuesAfter completing this module, role in writing queries Writing Simple CASE Expressions
students will be able to: Describe the use of sets in SQL Server Eliminate duplicates using the DISTINCT

Filter data with predicates in the WHERE Describe the use of predicate logic in clause.
clause. SQL Server Use column and table aliases.
Sort data using ORDER BY. Describe the logical order of operations in Write simple CASE expressions.
Filter data in the SELECT clause with TOP. SELECT statements Querying with Inner Joins
Filter data with OFFSET and FETCH. Eliminating Duplicates with DISTINCT Querying with Outer Joins
Working with Character Data Using Column and Table Aliases Querying with Cross Joins and Self
Working with Date and Time DataAfter Writing Simple CASE Expressions JoinsAfter completing this module,
completing this module, students will be able Eliminate duplicates using the DISTINCT students will be able to:
to: clause. Describe how multiple tables may be
Describe numeric data types, type Use column and table aliases. queried in a SELECT statement using
precedence and type conversions. Write simple CASE expressions. joins.
Write queries using character data types. Querying with Inner Joins Write queries that use inner joins.
Write queries using date and time data Querying with Outer Joins Write queries that use outer joins.
types. Querying with Cross Joins and Self Write queries that use self-joins and cross
Using Conversion Functions JoinsAfter completing this module, joins.
Using Logical Functions students will be able to: Filtering Data with a WHERE Clause
Using Functions to Work with NULLAfter Describe how multiple tables may be Filtering with the TOP and
completing this module, students will be able queried in a SELECT statement using OFFSET-FETCH Options
to: joins. Working with Unknown and Missing
Write queries with built-in scalar functions. Write queries that use inner joins. ValuesAfter completing this module,
Use conversion functions. Write queries that use outer joins. students will be able to:
Use logical functions. Write queries that use self-joins and Filter data with predicates in the WHERE
Use functions that work with NULL. cross joins. clause.
Using the GROUP BY Clause Filtering Data with a WHERE Clause Sort data using ORDER BY.
Filtering Groups with HAVINGAfter Filtering with the TOP and Filter data in the SELECT clause with
completing this module, students will be able OFFSET-FETCH Options TOP.
to: Working with Unknown and Missing Filter data with OFFSET and FETCH.
Write queries which summarize data using ValuesAfter completing this module, Working with Character Data
built-in aggregate functions. students will be able to: Working with Date and Time DataAfter
Use the GROUP BY clause to arrange rows Filter data with predicates in the WHERE completing this module, students will be
into groups. clause. able to:
Use the HAVING clause to filter out groups Sort data using ORDER BY. Describe numeric data types, type
based on a search condition. Filter data in the SELECT clause with precedence and type conversions.
Writing Correlated Subqueries TOP. Write queries using character data types.
Using the EXISTS Predicate with Filter data with OFFSET and FETCH. Write queries using date and time data
SubqueriesAfter completing this module, Working with Character Data types.
students will be able to: Working with Date and Time DataAfter Using Conversion Functions
Describe the uses of queries which are completing this module, students will be Using Logical Functions
nested within other queries. able to: Using Functions to Work with NULLAfter
Write self-contained subqueries which return Describe numeric data types, type completing this module, students will be
scalar or multi-valued results. precedence and type conversions. able to:
Write correlated subqueries which return Write queries using character data types. Write queries with built-in scalar functions.
scalar or multi-valued results. Write queries using date and time data Use conversion functions.
Use the EXISTS predicate to efficiently types. Use logical functions.
check for the existence of rows in a Using Conversion Functions Use functions that work with NULL.
subquery. Using Logical Functions Using the GROUP BY Clause
Using Common Table Expressions Using Functions to Work with NULLAfter Filtering Groups with HAVINGAfter
Using Views completing this module, students will be completing this module, students will be
Using Inline Table-Valued FunctionsAfter able to: able to:
completing this module, students will be able Write queries with built-in scalar Write queries which summarize data using
to: functions. built-in aggregate functions.
Write queries which use derived tables. Use conversion functions. Use the GROUP BY clause to arrange
Write queries which use common table Use logical functions. rows into groups.
expressions. Use functions that work with NULL. Use the HAVING clause to filter out groups
Create simple views and write queries Using the GROUP BY Clause based on a search condition.
against them. Filtering Groups with HAVINGAfter Writing Correlated Subqueries
Create simple inline table-valued functions completing this module, students will be Using the EXISTS Predicate with
and write queries against them. able to: SubqueriesAfter completing this module,
Using EXCEPT and INTERSECT Write queries which summarize data students will be able to:
Using APPLYAfter completing this module, using built-in aggregate functions. Describe the uses of queries which are
students will be able to: Use the GROUP BY clause to arrange nested within other queries.
Write queries which combine data using the rows into groups. Write self-contained subqueries which
UNION operator Use the HAVING clause to filter out return scalar or multi-valued results.
Write queries which compare sets using the groups based on a search condition. Write correlated subqueries which return
INTERSECT and EXCEPT operators Writing Correlated Subqueries scalar or multi-valued results.
Write queries which manipulate rows in a Using the EXISTS Predicate with Use the EXISTS predicate to efficiently

table by using APPLY with the results of a SubqueriesAfter completing this module, check for the existence of rows in a
derived table or function students will be able to: subquery.
Exploring Window Functions Describe the uses of queries which are Using Common Table Expressions
Restrict window functions to rows defined in nested within other queries. Using Views
an OVER clause, including partitions and Write self-contained subqueries which Using Inline Table-Valued FunctionsAfter
frames. return scalar or multi-valued results. completing this module, students will be
Write queries which use window functions to Write correlated subqueries which return able to:
operate on a window of rows and return scalar or multi-valued results. Write queries which use derived tables.
ranking, aggregation and offset comparison Use the EXISTS predicate to efficiently Write queries which use common table
results. check for the existence of rows in a expressions.
Working with Grouping SetsAfter completing subquery. Create simple views and write queries
this module, students will be able to: Using Common Table Expressions against them.
Write queries which pivot and unpivot result Using Views Create simple inline table-valued functions
sets Using Inline Table-Valued FunctionsAfter and write queries against them.
Write queries which specify multiple completing this module, students will be Using EXCEPT and INTERSECT
groupings with grouping sets able to: Using APPLYAfter completing this module,
Executing System Stored Procedures Write queries which use derived tables. students will be able to:
Querying Dynamic Management Write queries which use common table Write queries which combine data using
ObjectsAfter completing this module, expressions. the UNION operator
students will be able to: Create simple views and write queries Write queries which compare sets using
Write queries that retrieve system metadata against them. the INTERSECT and EXCEPT operators
using system views and functions. Create simple inline table-valued Write queries which manipulate rows in a
Execute system stored procedures to return functions and write queries against them. table by using APPLY with the results of a
system information. Using EXCEPT and INTERSECT derived table or function
Write queries that retrieve system metadata Using APPLYAfter completing this Exploring Window Functions
and state information using system dynamic module, students will be able to: Restrict window functions to rows defined
management views and functions. Write queries which combine data using in an OVER clause, including partitions
Passing Parameters to Stored Procedures the UNION operator and frames.
Creating Simple Stored Procedures Write queries which compare sets using Write queries which use window functions
Working with Dynamic SQLAfter completing the INTERSECT and EXCEPT operators to operate on a window of rows and return
this module, students will be able to: Write queries which manipulate rows in a ranking, aggregation and offset
Return results by executing stored table by using APPLY with the results of comparison results.
procedures. a derived table or function Working with Grouping SetsAfter
Pass parameters to procedures. Exploring Window Functions completing this module, students will be
Create simple stored procedures which Restrict window functions to rows defined able to:
encapsulate a SELECT statement. in an OVER clause, including partitions Write queries which pivot and unpivot
Construct and execute dynamic SQL with and frames. result sets
EXEC and sp_executesql. Write queries which use window Write queries which specify multiple
Controlling Program FlowAfter completing functions to operate on a window of rows groupings with grouping sets
this module, students will be able to: and return ranking, aggregation and Executing System Stored Procedures
Describe the language elements of T-SQL offset comparison results. Querying Dynamic Management
used for simple programming tasks. Working with Grouping SetsAfter ObjectsAfter completing this module,
Describe batches and how they are handled completing this module, students will be students will be able to:
by SQL Server. able to: Write queries that retrieve system
Declare and assign variables and synonyms. Write queries which pivot and unpivot metadata using system views and
Use IF and WHILE blocks to control result sets functions.
program flow. Write queries which specify multiple Execute system stored procedures to
Working with Error InformationAfter groupings with grouping sets return system information.
completing this module, students will be able Executing System Stored Procedures Write queries that retrieve system
to: Querying Dynamic Management metadata and state information using
Describe SQL Server's behavior when errors ObjectsAfter completing this module, system dynamic management views and
occur in T-SQL code. students will be able to: functions.
Implement structured exception handling in Write queries that retrieve system Passing Parameters to Stored Procedures
T-SQL. metadata using system views and Creating Simple Stored Procedures
Return information about errors from system functions. Working with Dynamic SQLAfter
objects. Execute system stored procedures to completing this module, students will be
Raise user-defined errors and pass system return system information. able to:
errors in T-SQL code. Write queries that retrieve system Return results by executing stored
Controlling TransactionsAfter completing metadata and state information using procedures.
this module, students will be able to: system dynamic management views and Pass parameters to procedures.
Describe transactions and the differences functions. Create simple stored procedures which
between batches and transactions. Passing Parameters to Stored encapsulate a SELECT statement.
Describe batches and how they are handled Procedures Construct and execute dynamic SQL with
by SQL Server. Creating Simple Stored Procedures EXEC and sp_executesql.
Create and manage transactions with Working with Dynamic SQLAfter Controlling Program FlowAfter completing
transaction control language statements. completing this module, students will be this module, students will be able to:

Use SET XACT_ABORT to define SQL able to: Describe the language elements of T-SQL
Server's handling of transactions outside Return results by executing stored used for simple programming tasks.
TRY / CATCH blocks. procedures. Describe batches and how they are
Displaying Query Performance DataAfter Pass parameters to procedures. handled by SQL Server.
completing this module, students will be able Create simple stored procedures which Declare and assign variables and
to: encapsulate a SELECT statement. synonyms.
Describe components of well-performing Construct and execute dynamic SQL with Use IF and WHILE blocks to control
queries. EXEC and sp_executesql. program flow.
Describe the role of indexes and statistics in Controlling Program FlowAfter Working with Error InformationAfter
SQL Server completing this module, students will be completing this module, students will be
Display and interpret basic query plans able to: able to:
Display and interpret basic query Describe the language elements of Describe SQL Server's behavior when
performance data T-SQL used for simple programming errors occur in T-SQL code.
tasks. Implement structured exception handling in
Describe batches and how they are T-SQL.
line handled by SQL Server. Return information about errors from
Getting Started with SQL Server Declare and assign variables and system objects.
Management Studio synonyms. Raise user-defined errors and pass system
Work with SQL Server Management Studio. Use IF and WHILE blocks to control errors in T-SQL code.
Working with SQL AzureAfter completing program flow. Controlling TransactionsAfter completing
this module, students will be able to: Working with Error InformationAfter this module, students will be able to:
Describe the basic features of SQL Azure. completing this module, students will be Describe transactions and the differences
Provision a SQL Azure server and configure able to: between batches and transactions.
its security. Describe SQL Server's behavior when Describe batches and how they are
Understanding Sets errors occur in T-SQL code. handled by SQL Server.
Understanding Predicate Logic Implement structured exception handling Create and manage transactions with
Understanding the Logical Order of in T-SQL. transaction control language statements.
Operations in SELECT statementsAfter Return information about errors from Use SET XACT_ABORT to define SQL
completing this module, students will be able system objects. Server's handling of transactions outside
to: Raise user-defined errors and pass TRY / CATCH blocks.
Describe the elements of T-SQL and their system errors in T-SQL code. Displaying Query Performance DataAfter
role in writing queries Controlling TransactionsAfter completing completing this module, students will be
Describe the use of sets in SQL Server this module, students will be able to: able to:
Describe the use of predicate logic in SQL Describe transactions and the differences Describe components of well-performing
Server between batches and transactions. queries.
Describe the logical order of operations in Describe batches and how they are Describe the role of indexes and statistics
SELECT statements handled by SQL Server. in SQL Server
Eliminating Duplicates with DISTINCT Create and manage transactions with Display and interpret basic query plans
Using Column and Table Aliases transaction control language statements. Display and interpret basic query
Writing Simple CASE Expressions Use SET XACT_ABORT to define SQL performance data
Eliminate duplicates using the DISTINCT Server's handling of transactions outside
clause. TRY / CATCH blocks.
Use column and table aliases. Displaying Query Performance DataAfter line
Write simple CASE expressions. completing this module, students will be Getting Started with SQL Server
Querying with Inner Joins able to: Management Studio
Querying with Outer Joins Describe components of well-performing Work with SQL Server Management
Querying with Cross Joins and Self queries. Studio.
JoinsAfter completing this module, students Describe the role of indexes and statistics Working with SQL AzureAfter completing
will be able to: in SQL Server this module, students will be able to:
Describe how multiple tables may be Display and interpret basic query plans Describe the basic features of SQL Azure.
queried in a SELECT statement using joins. Display and interpret basic query Provision a SQL Azure server and
Write queries that use inner joins. performance data configure its security.
Write queries that use outer joins. Understanding Sets
Write queries that use self-joins and cross Understanding Predicate Logic
joins. line Understanding the Logical Order of
Filtering Data with a WHERE Clause Getting Started with SQL Server Operations in SELECT statementsAfter
Filtering with the TOP and OFFSET-FETCH Management Studio completing this module, students will be
Options Work with SQL Server Management able to:
Working with Unknown and Missing Studio. Describe the elements of T-SQL and their
ValuesAfter completing this module, Working with SQL AzureAfter completing role in writing queries
students will be able to: this module, students will be able to: Describe the use of sets in SQL Server
Filter data with predicates in the WHERE Describe the basic features of SQL Describe the use of predicate logic in SQL
clause. Azure. Server
Sort data using ORDER BY. Provision a SQL Azure server and Describe the logical order of operations in
Filter data in the SELECT clause with TOP. configure its security. SELECT statements
Filter data with OFFSET and FETCH. Understanding Sets Eliminating Duplicates with DISTINCT

Working with Character Data Understanding Predicate Logic Using Column and Table Aliases
Working with Date and Time DataAfter Understanding the Logical Order of Writing Simple CASE Expressions
completing this module, students will be able Operations in SELECT statementsAfter Eliminate duplicates using the DISTINCT
to: completing this module, students will be clause.
Describe numeric data types, type able to: Use column and table aliases.
precedence and type conversions. Describe the elements of T-SQL and their Write simple CASE expressions.
Write queries using character data types. role in writing queries Querying with Inner Joins
Write queries using date and time data Describe the use of sets in SQL Server Querying with Outer Joins
types. Describe the use of predicate logic in Querying with Cross Joins and Self
Using Conversion Functions SQL Server JoinsAfter completing this module,
Using Logical Functions Describe the logical order of operations in students will be able to:
Using Functions to Work with NULLAfter SELECT statements Describe how multiple tables may be
completing this module, students will be able Eliminating Duplicates with DISTINCT queried in a SELECT statement using
to: Using Column and Table Aliases joins.
Write queries with built-in scalar functions. Writing Simple CASE Expressions Write queries that use inner joins.
Use conversion functions. Eliminate duplicates using the DISTINCT Write queries that use outer joins.
Use logical functions. clause. Write queries that use self-joins and cross
Use functions that work with NULL. Use column and table aliases. joins.
Using the GROUP BY Clause Write simple CASE expressions. Filtering Data with a WHERE Clause
Filtering Groups with HAVINGAfter Querying with Inner Joins Filtering with the TOP and
completing this module, students will be able Querying with Outer Joins OFFSET-FETCH Options
to: Querying with Cross Joins and Self Working with Unknown and Missing
Write queries which summarize data using JoinsAfter completing this module, ValuesAfter completing this module,
built-in aggregate functions. students will be able to: students will be able to:
Use the GROUP BY clause to arrange rows Describe how multiple tables may be Filter data with predicates in the WHERE
into groups. queried in a SELECT statement using clause.
Use the HAVING clause to filter out groups joins. Sort data using ORDER BY.
based on a search condition. Write queries that use inner joins. Filter data in the SELECT clause with
Writing Correlated Subqueries Write queries that use outer joins. TOP.
Using the EXISTS Predicate with Write queries that use self-joins and Filter data with OFFSET and FETCH.
SubqueriesAfter completing this module, cross joins. Working with Character Data
students will be able to: Filtering Data with a WHERE Clause Working with Date and Time DataAfter
Describe the uses of queries which are Filtering with the TOP and completing this module, students will be
nested within other queries. OFFSET-FETCH Options able to:
Write self-contained subqueries which return Working with Unknown and Missing Describe numeric data types, type
scalar or multi-valued results. ValuesAfter completing this module, precedence and type conversions.
Write correlated subqueries which return students will be able to: Write queries using character data types.
scalar or multi-valued results. Filter data with predicates in the WHERE Write queries using date and time data
Use the EXISTS predicate to efficiently clause. types.
check for the existence of rows in a Sort data using ORDER BY. Using Conversion Functions
subquery. Filter data in the SELECT clause with Using Logical Functions
Using Common Table Expressions TOP. Using Functions to Work with NULLAfter
Using Views Filter data with OFFSET and FETCH. completing this module, students will be
Using Inline Table-Valued FunctionsAfter Working with Character Data able to:
completing this module, students will be able Working with Date and Time DataAfter Write queries with built-in scalar functions.
to: completing this module, students will be Use conversion functions.
Write queries which use derived tables. able to: Use logical functions.
Write queries which use common table Describe numeric data types, type Use functions that work with NULL.
expressions. precedence and type conversions. Using the GROUP BY Clause
Create simple views and write queries Write queries using character data types. Filtering Groups with HAVINGAfter
against them. Write queries using date and time data completing this module, students will be
Create simple inline table-valued functions types. able to:
and write queries against them. Using Conversion Functions Write queries which summarize data using
Using EXCEPT and INTERSECT Using Logical Functions built-in aggregate functions.
Using APPLYAfter completing this module, Using Functions to Work with NULLAfter Use the GROUP BY clause to arrange
students will be able to: completing this module, students will be rows into groups.
Write queries which combine data using the able to: Use the HAVING clause to filter out groups
UNION operator Write queries with built-in scalar based on a search condition.
Write queries which compare sets using the functions. Writing Correlated Subqueries
INTERSECT and EXCEPT operators Use conversion functions. Using the EXISTS Predicate with
Write queries which manipulate rows in a Use logical functions. SubqueriesAfter completing this module,
table by using APPLY with the results of a Use functions that work with NULL. students will be able to:
derived table or function Using the GROUP BY Clause Describe the uses of queries which are
Exploring Window Functions Filtering Groups with HAVINGAfter nested within other queries.
Restrict window functions to rows defined in completing this module, students will be Write self-contained subqueries which
an OVER clause, including partitions and able to: return scalar or multi-valued results.

frames. Write queries which summarize data Write correlated subqueries which return
Write queries which use window functions to using built-in aggregate functions. scalar or multi-valued results.
operate on a window of rows and return Use the GROUP BY clause to arrange Use the EXISTS predicate to efficiently
ranking, aggregation and offset comparison rows into groups. check for the existence of rows in a
results. Use the HAVING clause to filter out subquery.
Working with Grouping SetsAfter completing groups based on a search condition. Using Common Table Expressions
this module, students will be able to: Writing Correlated Subqueries Using Views
Write queries which pivot and unpivot result Using the EXISTS Predicate with Using Inline Table-Valued FunctionsAfter
sets SubqueriesAfter completing this module, completing this module, students will be
Write queries which specify multiple students will be able to: able to:
groupings with grouping sets Describe the uses of queries which are Write queries which use derived tables.
Executing System Stored Procedures nested within other queries. Write queries which use common table
Querying Dynamic Management Write self-contained subqueries which expressions.
ObjectsAfter completing this module, return scalar or multi-valued results. Create simple views and write queries
students will be able to: Write correlated subqueries which return against them.
Write queries that retrieve system metadata scalar or multi-valued results. Create simple inline table-valued functions
using system views and functions. Use the EXISTS predicate to efficiently and write queries against them.
Execute system stored procedures to return check for the existence of rows in a Using EXCEPT and INTERSECT
system information. subquery. Using APPLYAfter completing this module,
Write queries that retrieve system metadata Using Common Table Expressions students will be able to:
and state information using system dynamic Using Views Write queries which combine data using
management views and functions. Using Inline Table-Valued FunctionsAfter the UNION operator
Passing Parameters to Stored Procedures completing this module, students will be Write queries which compare sets using
Creating Simple Stored Procedures able to: the INTERSECT and EXCEPT operators
Working with Dynamic SQLAfter completing Write queries which use derived tables. Write queries which manipulate rows in a
this module, students will be able to: Write queries which use common table table by using APPLY with the results of a
Return results by executing stored expressions. derived table or function
procedures. Create simple views and write queries Exploring Window Functions
Pass parameters to procedures. against them. Restrict window functions to rows defined
Create simple stored procedures which Create simple inline table-valued in an OVER clause, including partitions
encapsulate a SELECT statement. functions and write queries against them. and frames.
Construct and execute dynamic SQL with Using EXCEPT and INTERSECT Write queries which use window functions
EXEC and sp_executesql. Using APPLYAfter completing this to operate on a window of rows and return
Controlling Program FlowAfter completing module, students will be able to: ranking, aggregation and offset
this module, students will be able to: Write queries which combine data using comparison results.
Describe the language elements of T-SQL the UNION operator Working with Grouping SetsAfter
used for simple programming tasks. Write queries which compare sets using completing this module, students will be
Describe batches and how they are handled the INTERSECT and EXCEPT operators able to:
by SQL Server. Write queries which manipulate rows in a Write queries which pivot and unpivot
Declare and assign variables and synonyms. table by using APPLY with the results of result sets
Use IF and WHILE blocks to control a derived table or function Write queries which specify multiple
program flow. Exploring Window Functions groupings with grouping sets
Working with Error InformationAfter Restrict window functions to rows defined Executing System Stored Procedures
completing this module, students will be able in an OVER clause, including partitions Querying Dynamic Management
to: and frames. ObjectsAfter completing this module,
Describe SQL Server's behavior when errors Write queries which use window students will be able to:
occur in T-SQL code. functions to operate on a window of rows Write queries that retrieve system
Implement structured exception handling in and return ranking, aggregation and metadata using system views and
T-SQL. offset comparison results. functions.
Return information about errors from system Working with Grouping SetsAfter Execute system stored procedures to
objects. completing this module, students will be return system information.
Raise user-defined errors and pass system able to: Write queries that retrieve system
errors in T-SQL code. Write queries which pivot and unpivot metadata and state information using
Controlling TransactionsAfter completing result sets system dynamic management views and
this module, students will be able to: Write queries which specify multiple functions.
Describe transactions and the differences groupings with grouping sets Passing Parameters to Stored Procedures
between batches and transactions. Executing System Stored Procedures Creating Simple Stored Procedures
Describe batches and how they are handled Querying Dynamic Management Working with Dynamic SQLAfter
by SQL Server. ObjectsAfter completing this module, completing this module, students will be
Create and manage transactions with students will be able to: able to:
transaction control language statements. Write queries that retrieve system Return results by executing stored
Use SET XACT_ABORT to define SQL metadata using system views and procedures.
Server's handling of transactions outside functions. Pass parameters to procedures.
TRY / CATCH blocks. Execute system stored procedures to Create simple stored procedures which
Displaying Query Performance DataAfter return system information. encapsulate a SELECT statement.
completing this module, students will be able Write queries that retrieve system Construct and execute dynamic SQL with

to: metadata and state information using EXEC and sp_executesql.
Describe components of well-performing system dynamic management views and Controlling Program FlowAfter completing
queries. functions. this module, students will be able to:
Describe the role of indexes and statistics in Passing Parameters to Stored Describe the language elements of T-SQL
SQL Server Procedures used for simple programming tasks.
Display and interpret basic query plans Creating Simple Stored Procedures Describe batches and how they are
Display and interpret basic query Working with Dynamic SQLAfter handled by SQL Server.
performance data completing this module, students will be Declare and assign variables and
able to: synonyms.
Return results by executing stored Use IF and WHILE blocks to control
line procedures. program flow.
Getting Started with SQL Server Pass parameters to procedures. Working with Error InformationAfter
Management Studio Create simple stored procedures which completing this module, students will be
Work with SQL Server Management Studio. encapsulate a SELECT statement. able to:
Working with SQL AzureAfter completing Construct and execute dynamic SQL with Describe SQL Server's behavior when
this module, students will be able to: EXEC and sp_executesql. errors occur in T-SQL code.
Describe the basic features of SQL Azure. Controlling Program FlowAfter Implement structured exception handling in
Provision a SQL Azure server and configure completing this module, students will be T-SQL.
its security. able to: Return information about errors from
Understanding Sets Describe the language elements of system objects.
Understanding Predicate Logic T-SQL used for simple programming Raise user-defined errors and pass system
Understanding the Logical Order of tasks. errors in T-SQL code.
Operations in SELECT statementsAfter Describe batches and how they are Controlling TransactionsAfter completing
completing this module, students will be able handled by SQL Server. this module, students will be able to:
to: Declare and assign variables and Describe transactions and the differences
Describe the elements of T-SQL and their synonyms. between batches and transactions.
role in writing queries Use IF and WHILE blocks to control Describe batches and how they are
Describe the use of sets in SQL Server program flow. handled by SQL Server.
Describe the use of predicate logic in SQL Working with Error InformationAfter Create and manage transactions with
Server completing this module, students will be transaction control language statements.
Describe the logical order of operations in able to: Use SET XACT_ABORT to define SQL
SELECT statements Describe SQL Server's behavior when Server's handling of transactions outside
Eliminating Duplicates with DISTINCT errors occur in T-SQL code. TRY / CATCH blocks.
Using Column and Table Aliases Implement structured exception handling Displaying Query Performance DataAfter
Writing Simple CASE Expressions in T-SQL. completing this module, students will be
Eliminate duplicates using the DISTINCT Return information about errors from able to:
clause. system objects. Describe components of well-performing
Use column and table aliases. Raise user-defined errors and pass queries.
Write simple CASE expressions. system errors in T-SQL code. Describe the role of indexes and statistics
Querying with Inner Joins Controlling TransactionsAfter completing in SQL Server
Querying with Outer Joins this module, students will be able to: Display and interpret basic query plans
Querying with Cross Joins and Self Describe transactions and the differences Display and interpret basic query
JoinsAfter completing this module, students between batches and transactions. performance data
will be able to: Describe batches and how they are
Describe how multiple tables may be handled by SQL Server.
queried in a SELECT statement using joins. Create and manage transactions with line
Write queries that use inner joins. transaction control language statements. Getting Started with SQL Server
Write queries that use outer joins. Use SET XACT_ABORT to define SQL Management Studio
Write queries that use self-joins and cross Server's handling of transactions outside Work with SQL Server Management
joins. TRY / CATCH blocks. Studio.
Filtering Data with a WHERE Clause Displaying Query Performance DataAfter Working with SQL AzureAfter completing
Filtering with the TOP and OFFSET-FETCH completing this module, students will be this module, students will be able to:
Options able to: Describe the basic features of SQL Azure.
Working with Unknown and Missing Describe components of well-performing Provision a SQL Azure server and
ValuesAfter completing this module, queries. configure its security.
students will be able to: Describe the role of indexes and statistics Understanding Sets
Filter data with predicates in the WHERE in SQL Server Understanding Predicate Logic
clause. Display and interpret basic query plans Understanding the Logical Order of
Sort data using ORDER BY. Display and interpret basic query Operations in SELECT statementsAfter
Filter data in the SELECT clause with TOP. performance data completing this module, students will be
Filter data with OFFSET and FETCH. able to:
Working with Character Data Describe the elements of T-SQL and their
Working with Date and Time DataAfter line role in writing queries
completing this module, students will be able Getting Started with SQL Server Describe the use of sets in SQL Server
to: Management Studio Describe the use of predicate logic in SQL
Describe numeric data types, type Work with SQL Server Management Server

precedence and type conversions. Studio. Describe the logical order of operations in
Write queries using character data types. Working with SQL AzureAfter completing SELECT statements
Write queries using date and time data this module, students will be able to: Eliminating Duplicates with DISTINCT
types. Describe the basic features of SQL Using Column and Table Aliases
Using Conversion Functions Azure. Writing Simple CASE Expressions
Using Logical Functions Provision a SQL Azure server and Eliminate duplicates using the DISTINCT
Using Functions to Work with NULLAfter configure its security. clause.
completing this module, students will be able Understanding Sets Use column and table aliases.
to: Understanding Predicate Logic Write simple CASE expressions.
Write queries with built-in scalar functions. Understanding the Logical Order of Querying with Inner Joins
Use conversion functions. Operations in SELECT statementsAfter Querying with Outer Joins
Use logical functions. completing this module, students will be Querying with Cross Joins and Self
Use functions that work with NULL. able to: JoinsAfter completing this module,
Using the GROUP BY Clause Describe the elements of T-SQL and their students will be able to:
Filtering Groups with HAVINGAfter role in writing queries Describe how multiple tables may be
completing this module, students will be able Describe the use of sets in SQL Server queried in a SELECT statement using
to: Describe the use of predicate logic in joins.
Write queries which summarize data using SQL Server Write queries that use inner joins.
built-in aggregate functions. Describe the logical order of operations in Write queries that use outer joins.
Use the GROUP BY clause to arrange rows SELECT statements Write queries that use self-joins and cross
into groups. Eliminating Duplicates with DISTINCT joins.
Use the HAVING clause to filter out groups Using Column and Table Aliases Filtering Data with a WHERE Clause
based on a search condition. Writing Simple CASE Expressions Filtering with the TOP and
Writing Correlated Subqueries Eliminate duplicates using the DISTINCT OFFSET-FETCH Options
Using the EXISTS Predicate with clause. Working with Unknown and Missing
SubqueriesAfter completing this module, Use column and table aliases. ValuesAfter completing this module,
students will be able to: Write simple CASE expressions. students will be able to:
Describe the uses of queries which are Querying with Inner Joins Filter data with predicates in the WHERE
nested within other queries. Querying with Outer Joins clause.
Write self-contained subqueries which return Querying with Cross Joins and Self Sort data using ORDER BY.
scalar or multi-valued results. JoinsAfter completing this module, Filter data in the SELECT clause with
Write correlated subqueries which return students will be able to: TOP.
scalar or multi-valued results. Describe how multiple tables may be Filter data with OFFSET and FETCH.
Use the EXISTS predicate to efficiently queried in a SELECT statement using Working with Character Data
check for the existence of rows in a joins. Working with Date and Time DataAfter
subquery. Write queries that use inner joins. completing this module, students will be
Using Common Table Expressions Write queries that use outer joins. able to:
Using Views Write queries that use self-joins and Describe numeric data types, type
Using Inline Table-Valued FunctionsAfter cross joins. precedence and type conversions.
completing this module, students will be able Filtering Data with a WHERE Clause Write queries using character data types.
to: Filtering with the TOP and Write queries using date and time data
Write queries which use derived tables. OFFSET-FETCH Options types.
Write queries which use common table Working with Unknown and Missing Using Conversion Functions
expressions. ValuesAfter completing this module, Using Logical Functions
Create simple views and write queries students will be able to: Using Functions to Work with NULLAfter
against them. Filter data with predicates in the WHERE completing this module, students will be
Create simple inline table-valued functions clause. able to:
and write queries against them. Sort data using ORDER BY. Write queries with built-in scalar functions.
Using EXCEPT and INTERSECT Filter data in the SELECT clause with Use conversion functions.
Using APPLYAfter completing this module, TOP. Use logical functions.
students will be able to: Filter data with OFFSET and FETCH. Use functions that work with NULL.
Write queries which combine data using the Working with Character Data Using the GROUP BY Clause
UNION operator Working with Date and Time DataAfter Filtering Groups with HAVINGAfter
Write queries which compare sets using the completing this module, students will be completing this module, students will be
INTERSECT and EXCEPT operators able to: able to:
Write queries which manipulate rows in a Describe numeric data types, type Write queries which summarize data using
table by using APPLY with the results of a precedence and type conversions. built-in aggregate functions.
derived table or function Write queries using character data types. Use the GROUP BY clause to arrange
Exploring Window Functions Write queries using date and time data rows into groups.
Restrict window functions to rows defined in types. Use the HAVING clause to filter out groups
an OVER clause, including partitions and Using Conversion Functions based on a search condition.
frames. Using Logical Functions Writing Correlated Subqueries
Write queries which use window functions to Using Functions to Work with NULLAfter Using the EXISTS Predicate with
operate on a window of rows and return completing this module, students will be SubqueriesAfter completing this module,
ranking, aggregation and offset comparison able to: students will be able to:
results. Write queries with built-in scalar Describe the uses of queries which are

Working with Grouping SetsAfter completing functions. nested within other queries.
this module, students will be able to: Use conversion functions. Write self-contained subqueries which
Write queries which pivot and unpivot result Use logical functions. return scalar or multi-valued results.
sets Use functions that work with NULL. Write correlated subqueries which return
Write queries which specify multiple Using the GROUP BY Clause scalar or multi-valued results.
groupings with grouping sets Filtering Groups with HAVINGAfter Use the EXISTS predicate to efficiently
Executing System Stored Procedures completing this module, students will be check for the existence of rows in a
Querying Dynamic Management able to: subquery.
ObjectsAfter completing this module, Write queries which summarize data Using Common Table Expressions
students will be able to: using built-in aggregate functions. Using Views
Write queries that retrieve system metadata Use the GROUP BY clause to arrange Using Inline Table-Valued FunctionsAfter
using system views and functions. rows into groups. completing this module, students will be
Execute system stored procedures to return Use the HAVING clause to filter out able to:
system information. groups based on a search condition. Write queries which use derived tables.
Write queries that retrieve system metadata Writing Correlated Subqueries Write queries which use common table
and state information using system dynamic Using the EXISTS Predicate with expressions.
management views and functions. SubqueriesAfter completing this module, Create simple views and write queries
Passing Parameters to Stored Procedures students will be able to: against them.
Creating Simple Stored Procedures Describe the uses of queries which are Create simple inline table-valued functions
Working with Dynamic SQLAfter completing nested within other queries. and write queries against them.
this module, students will be able to: Write self-contained subqueries which Using EXCEPT and INTERSECT
Return results by executing stored return scalar or multi-valued results. Using APPLYAfter completing this module,
procedures. Write correlated subqueries which return students will be able to:
Pass parameters to procedures. scalar or multi-valued results. Write queries which combine data using
Create simple stored procedures which Use the EXISTS predicate to efficiently the UNION operator
encapsulate a SELECT statement. check for the existence of rows in a Write queries which compare sets using
Construct and execute dynamic SQL with subquery. the INTERSECT and EXCEPT operators
EXEC and sp_executesql. Using Common Table Expressions Write queries which manipulate rows in a
Controlling Program FlowAfter completing Using Views table by using APPLY with the results of a
this module, students will be able to: Using Inline Table-Valued FunctionsAfter derived table or function
Describe the language elements of T-SQL completing this module, students will be Exploring Window Functions
used for simple programming tasks. able to: Restrict window functions to rows defined
Describe batches and how they are handled Write queries which use derived tables. in an OVER clause, including partitions
by SQL Server. Write queries which use common table and frames.
Declare and assign variables and synonyms. expressions. Write queries which use window functions
Use IF and WHILE blocks to control Create simple views and write queries to operate on a window of rows and return
program flow. against them. ranking, aggregation and offset
Working with Error InformationAfter Create simple inline table-valued comparison results.
completing this module, students will be able functions and write queries against them. Working with Grouping SetsAfter
to: Using EXCEPT and INTERSECT completing this module, students will be
Describe SQL Server's behavior when errors Using APPLYAfter completing this able to:
occur in T-SQL code. module, students will be able to: Write queries which pivot and unpivot
Implement structured exception handling in Write queries which combine data using result sets
T-SQL. the UNION operator Write queries which specify multiple
Return information about errors from system Write queries which compare sets using groupings with grouping sets
objects. the INTERSECT and EXCEPT operators Executing System Stored Procedures
Raise user-defined errors and pass system Write queries which manipulate rows in a Querying Dynamic Management
errors in T-SQL code. table by using APPLY with the results of ObjectsAfter completing this module,
Controlling TransactionsAfter completing a derived table or function students will be able to:
this module, students will be able to: Exploring Window Functions Write queries that retrieve system
Describe transactions and the differences Restrict window functions to rows defined metadata using system views and
between batches and transactions. in an OVER clause, including partitions functions.
Describe batches and how they are handled and frames. Execute system stored procedures to
by SQL Server. Write queries which use window return system information.
Create and manage transactions with functions to operate on a window of rows Write queries that retrieve system
transaction control language statements. and return ranking, aggregation and metadata and state information using
Use SET XACT_ABORT to define SQL offset comparison results. system dynamic management views and
Server's handling of transactions outside Working with Grouping SetsAfter functions.
TRY / CATCH blocks. completing this module, students will be Passing Parameters to Stored Procedures
Displaying Query Performance DataAfter able to: Creating Simple Stored Procedures
completing this module, students will be able Write queries which pivot and unpivot Working with Dynamic SQLAfter
to: result sets completing this module, students will be
Describe components of well-performing Write queries which specify multiple able to:
queries. groupings with grouping sets Return results by executing stored
Describe the role of indexes and statistics in Executing System Stored Procedures procedures.
SQL Server Querying Dynamic Management Pass parameters to procedures.

Display and interpret basic query plans ObjectsAfter completing this module, Create simple stored procedures which
Display and interpret basic query students will be able to: encapsulate a SELECT statement.
performance data Write queries that retrieve system Construct and execute dynamic SQL with
metadata using system views and EXEC and sp_executesql.
functions. Controlling Program FlowAfter completing
line Execute system stored procedures to this module, students will be able to:
Getting Started with SQL Server return system information. Describe the language elements of T-SQL
Management Studio Write queries that retrieve system used for simple programming tasks.
Work with SQL Server Management Studio. metadata and state information using Describe batches and how they are
Working with SQL AzureAfter completing system dynamic management views and handled by SQL Server.
this module, students will be able to: functions. Declare and assign variables and
Describe the basic features of SQL Azure. Passing Parameters to Stored synonyms.
Provision a SQL Azure server and configure Procedures Use IF and WHILE blocks to control
its security. Creating Simple Stored Procedures program flow.
Understanding Sets Working with Dynamic SQLAfter Working with Error InformationAfter
Understanding Predicate Logic completing this module, students will be completing this module, students will be
Understanding the Logical Order of able to: able to:
Operations in SELECT statementsAfter Return results by executing stored Describe SQL Server's behavior when
completing this module, students will be able procedures. errors occur in T-SQL code.
to: Pass parameters to procedures. Implement structured exception handling in
Describe the elements of T-SQL and their Create simple stored procedures which T-SQL.
role in writing queries encapsulate a SELECT statement. Return information about errors from
Describe the use of sets in SQL Server Construct and execute dynamic SQL with system objects.
Describe the use of predicate logic in SQL EXEC and sp_executesql. Raise user-defined errors and pass system
Server Controlling Program FlowAfter errors in T-SQL code.
Describe the logical order of operations in completing this module, students will be Controlling TransactionsAfter completing
SELECT statements able to: this module, students will be able to:
Eliminating Duplicates with DISTINCT Describe the language elements of Describe transactions and the differences
Using Column and Table Aliases T-SQL used for simple programming between batches and transactions.
Writing Simple CASE Expressions tasks. Describe batches and how they are
Eliminate duplicates using the DISTINCT Describe batches and how they are handled by SQL Server.
clause. handled by SQL Server. Create and manage transactions with
Use column and table aliases. Declare and assign variables and transaction control language statements.
Write simple CASE expressions. synonyms. Use SET XACT_ABORT to define SQL
Querying with Inner Joins Use IF and WHILE blocks to control Server's handling of transactions outside
Querying with Outer Joins program flow. TRY / CATCH blocks.
Querying with Cross Joins and Self Working with Error InformationAfter Displaying Query Performance DataAfter
JoinsAfter completing this module, students completing this module, students will be completing this module, students will be
will be able to: able to: able to:
Describe how multiple tables may be Describe SQL Server's behavior when Describe components of well-performing
queried in a SELECT statement using joins. errors occur in T-SQL code. queries.
Write queries that use inner joins. Implement structured exception handling Describe the role of indexes and statistics
Write queries that use outer joins. in T-SQL. in SQL Server
Write queries that use self-joins and cross Return information about errors from Display and interpret basic query plans
joins. system objects. Display and interpret basic query
Filtering Data with a WHERE Clause Raise user-defined errors and pass performance data
Filtering with the TOP and OFFSET-FETCH system errors in T-SQL code.
Options Controlling TransactionsAfter completing Module 16: Executing Stored Procedures
Working with Unknown and Missing this module, students will be able to: line
ValuesAfter completing this module, Describe transactions and the differences
students will be able to: between batches and transactions. This module introduces the use of existing
Filter data with predicates in the WHERE Describe batches and how they are stored procedures in a T-SQL querying
clause. handled by SQL Server. environment. It discusses the use of
Sort data using ORDER BY. Create and manage transactions with EXECUTE, how to pass input and output
Filter data in the SELECT clause with TOP. transaction control language statements. parameters to a procedure, and how to invoke
Filter data with OFFSET and FETCH. Use SET XACT_ABORT to define SQL system stored procedures.
Working with Character Data Server's handling of transactions outside line
Working with Date and Time DataAfter TRY / CATCH blocks. Querying Data with Stored Procedures
completing this module, students will be able Displaying Query Performance DataAfter
to: completing this module, students will be
Describe numeric data types, type able to: line
precedence and type conversions. Describe components of well-performing Getting Started with SQL Server
Write queries using character data types. queries. Management Studio
Write queries using date and time data Describe the role of indexes and statistics Work with SQL Server Management
types. in SQL Server Studio.
Using Conversion Functions Display and interpret basic query plans Working with SQL AzureAfter completing

Using Logical Functions Display and interpret basic query this module, students will be able to:
Using Functions to Work with NULLAfter performance data Describe the basic features of SQL Azure.
completing this module, students will be able Provision a SQL Azure server and
to: configure its security.
Write queries with built-in scalar functions. line Understanding Sets
Use conversion functions. Getting Started with SQL Server Understanding Predicate Logic
Use logical functions. Management Studio Understanding the Logical Order of
Use functions that work with NULL. Work with SQL Server Management Operations in SELECT statementsAfter
Using the GROUP BY Clause Studio. completing this module, students will be
Filtering Groups with HAVINGAfter Working with SQL AzureAfter completing able to:
completing this module, students will be able this module, students will be able to: Describe the elements of T-SQL and their
to: Describe the basic features of SQL role in writing queries
Write queries which summarize data using Azure. Describe the use of sets in SQL Server
built-in aggregate functions. Provision a SQL Azure server and Describe the use of predicate logic in SQL
Use the GROUP BY clause to arrange rows configure its security. Server
into groups. Understanding Sets Describe the logical order of operations in
Use the HAVING clause to filter out groups Understanding Predicate Logic SELECT statements
based on a search condition. Understanding the Logical Order of Eliminating Duplicates with DISTINCT
Writing Correlated Subqueries Operations in SELECT statementsAfter Using Column and Table Aliases
Using the EXISTS Predicate with completing this module, students will be Writing Simple CASE Expressions
SubqueriesAfter completing this module, able to: Eliminate duplicates using the DISTINCT
students will be able to: Describe the elements of T-SQL and their clause.
Describe the uses of queries which are role in writing queries Use column and table aliases.
nested within other queries. Describe the use of sets in SQL Server Write simple CASE expressions.
Write self-contained subqueries which return Describe the use of predicate logic in Querying with Inner Joins
scalar or multi-valued results. SQL Server Querying with Outer Joins
Write correlated subqueries which return Describe the logical order of operations in Querying with Cross Joins and Self
scalar or multi-valued results. SELECT statements JoinsAfter completing this module,
Use the EXISTS predicate to efficiently Eliminating Duplicates with DISTINCT students will be able to:
check for the existence of rows in a Using Column and Table Aliases Describe how multiple tables may be
subquery. Writing Simple CASE Expressions queried in a SELECT statement using
Using Common Table Expressions Eliminate duplicates using the DISTINCT joins.
Using Views clause. Write queries that use inner joins.
Using Inline Table-Valued FunctionsAfter Use column and table aliases. Write queries that use outer joins.
completing this module, students will be able Write simple CASE expressions. Write queries that use self-joins and cross
to: Querying with Inner Joins joins.
Write queries which use derived tables. Querying with Outer Joins Filtering Data with a WHERE Clause
Write queries which use common table Querying with Cross Joins and Self Filtering with the TOP and
expressions. JoinsAfter completing this module, OFFSET-FETCH Options
Create simple views and write queries students will be able to: Working with Unknown and Missing
against them. Describe how multiple tables may be ValuesAfter completing this module,
Create simple inline table-valued functions queried in a SELECT statement using students will be able to:
and write queries against them. joins. Filter data with predicates in the WHERE
Using EXCEPT and INTERSECT Write queries that use inner joins. clause.
Using APPLYAfter completing this module, Write queries that use outer joins. Sort data using ORDER BY.
students will be able to: Write queries that use self-joins and Filter data in the SELECT clause with
Write queries which combine data using the cross joins. TOP.
UNION operator Filtering Data with a WHERE Clause Filter data with OFFSET and FETCH.
Write queries which compare sets using the Filtering with the TOP and Working with Character Data
INTERSECT and EXCEPT operators OFFSET-FETCH Options Working with Date and Time DataAfter
Write queries which manipulate rows in a Working with Unknown and Missing completing this module, students will be
table by using APPLY with the results of a ValuesAfter completing this module, able to:
derived table or function students will be able to: Describe numeric data types, type
Exploring Window Functions Filter data with predicates in the WHERE precedence and type conversions.
Restrict window functions to rows defined in clause. Write queries using character data types.
an OVER clause, including partitions and Sort data using ORDER BY. Write queries using date and time data
frames. Filter data in the SELECT clause with types.
Write queries which use window functions to TOP. Using Conversion Functions
operate on a window of rows and return Filter data with OFFSET and FETCH. Using Logical Functions
ranking, aggregation and offset comparison Working with Character Data Using Functions to Work with NULLAfter
results. Working with Date and Time DataAfter completing this module, students will be
Working with Grouping SetsAfter completing completing this module, students will be able to:
this module, students will be able to: able to: Write queries with built-in scalar functions.
Write queries which pivot and unpivot result Describe numeric data types, type Use conversion functions.
sets precedence and type conversions. Use logical functions.
Write queries which specify multiple Write queries using character data types. Use functions that work with NULL.

groupings with grouping sets Write queries using date and time data Using the GROUP BY Clause
Executing System Stored Procedures types. Filtering Groups with HAVINGAfter
Querying Dynamic Management Using Conversion Functions completing this module, students will be
ObjectsAfter completing this module, Using Logical Functions able to:
students will be able to: Using Functions to Work with NULLAfter Write queries which summarize data using
Write queries that retrieve system metadata completing this module, students will be built-in aggregate functions.
using system views and functions. able to: Use the GROUP BY clause to arrange
Execute system stored procedures to return Write queries with built-in scalar rows into groups.
system information. functions. Use the HAVING clause to filter out groups
Write queries that retrieve system metadata Use conversion functions. based on a search condition.
and state information using system dynamic Use logical functions. Writing Correlated Subqueries
management views and functions. Use functions that work with NULL. Using the EXISTS Predicate with
Passing Parameters to Stored Procedures Using the GROUP BY Clause SubqueriesAfter completing this module,
Creating Simple Stored Procedures Filtering Groups with HAVINGAfter students will be able to:
Working with Dynamic SQLAfter completing completing this module, students will be Describe the uses of queries which are
this module, students will be able to: able to: nested within other queries.
Return results by executing stored Write queries which summarize data Write self-contained subqueries which
procedures. using built-in aggregate functions. return scalar or multi-valued results.
Pass parameters to procedures. Use the GROUP BY clause to arrange Write correlated subqueries which return
Create simple stored procedures which rows into groups. scalar or multi-valued results.
encapsulate a SELECT statement. Use the HAVING clause to filter out Use the EXISTS predicate to efficiently
Construct and execute dynamic SQL with groups based on a search condition. check for the existence of rows in a
EXEC and sp_executesql. Writing Correlated Subqueries subquery.
Controlling Program FlowAfter completing Using the EXISTS Predicate with Using Common Table Expressions
this module, students will be able to: SubqueriesAfter completing this module, Using Views
Describe the language elements of T-SQL students will be able to: Using Inline Table-Valued FunctionsAfter
used for simple programming tasks. Describe the uses of queries which are completing this module, students will be
Describe batches and how they are handled nested within other queries. able to:
by SQL Server. Write self-contained subqueries which Write queries which use derived tables.
Declare and assign variables and synonyms. return scalar or multi-valued results. Write queries which use common table
Use IF and WHILE blocks to control Write correlated subqueries which return expressions.
program flow. scalar or multi-valued results. Create simple views and write queries
Working with Error InformationAfter Use the EXISTS predicate to efficiently against them.
completing this module, students will be able check for the existence of rows in a Create simple inline table-valued functions
to: subquery. and write queries against them.
Describe SQL Server's behavior when errors Using Common Table Expressions Using EXCEPT and INTERSECT
occur in T-SQL code. Using Views Using APPLYAfter completing this module,
Implement structured exception handling in Using Inline Table-Valued FunctionsAfter students will be able to:
T-SQL. completing this module, students will be Write queries which combine data using
Return information about errors from system able to: the UNION operator
objects. Write queries which use derived tables. Write queries which compare sets using
Raise user-defined errors and pass system Write queries which use common table the INTERSECT and EXCEPT operators
errors in T-SQL code. expressions. Write queries which manipulate rows in a
Controlling TransactionsAfter completing Create simple views and write queries table by using APPLY with the results of a
this module, students will be able to: against them. derived table or function
Describe transactions and the differences Create simple inline table-valued Exploring Window Functions
between batches and transactions. functions and write queries against them. Restrict window functions to rows defined
Describe batches and how they are handled Using EXCEPT and INTERSECT in an OVER clause, including partitions
by SQL Server. Using APPLYAfter completing this and frames.
Create and manage transactions with module, students will be able to: Write queries which use window functions
transaction control language statements. Write queries which combine data using to operate on a window of rows and return
Use SET XACT_ABORT to define SQL the UNION operator ranking, aggregation and offset
Server's handling of transactions outside Write queries which compare sets using comparison results.
TRY / CATCH blocks. the INTERSECT and EXCEPT operators Working with Grouping SetsAfter
Displaying Query Performance DataAfter Write queries which manipulate rows in a completing this module, students will be
completing this module, students will be able table by using APPLY with the results of able to:
to: a derived table or function Write queries which pivot and unpivot
Describe components of well-performing Exploring Window Functions result sets
queries. Restrict window functions to rows defined Write queries which specify multiple
Describe the role of indexes and statistics in in an OVER clause, including partitions groupings with grouping sets
SQL Server and frames. Executing System Stored Procedures
Display and interpret basic query plans Write queries which use window Querying Dynamic Management
Display and interpret basic query functions to operate on a window of rows ObjectsAfter completing this module,
performance data and return ranking, aggregation and students will be able to:
offset comparison results. Write queries that retrieve system
Working with Grouping SetsAfter metadata using system views and

line completing this module, students will be functions.
Getting Started with SQL Server able to: Execute system stored procedures to
Management Studio Write queries which pivot and unpivot return system information.
Work with SQL Server Management Studio. result sets Write queries that retrieve system
Working with SQL AzureAfter completing Write queries which specify multiple metadata and state information using
this module, students will be able to: groupings with grouping sets system dynamic management views and
Describe the basic features of SQL Azure. Executing System Stored Procedures functions.
Provision a SQL Azure server and configure Querying Dynamic Management Passing Parameters to Stored Procedures
its security. ObjectsAfter completing this module, Creating Simple Stored Procedures
Understanding Sets students will be able to: Working with Dynamic SQLAfter
Understanding Predicate Logic Write queries that retrieve system completing this module, students will be
Understanding the Logical Order of metadata using system views and able to:
Operations in SELECT statementsAfter functions. Return results by executing stored
completing this module, students will be able Execute system stored procedures to procedures.
to: return system information. Pass parameters to procedures.
Describe the elements of T-SQL and their Write queries that retrieve system Create simple stored procedures which
role in writing queries metadata and state information using encapsulate a SELECT statement.
Describe the use of sets in SQL Server system dynamic management views and Construct and execute dynamic SQL with
Describe the use of predicate logic in SQL functions. EXEC and sp_executesql.
Server Passing Parameters to Stored Controlling Program FlowAfter completing
Describe the logical order of operations in Procedures this module, students will be able to:
SELECT statements Creating Simple Stored Procedures Describe the language elements of T-SQL
Eliminating Duplicates with DISTINCT Working with Dynamic SQLAfter used for simple programming tasks.
Using Column and Table Aliases completing this module, students will be Describe batches and how they are
Writing Simple CASE Expressions able to: handled by SQL Server.
Eliminate duplicates using the DISTINCT Return results by executing stored Declare and assign variables and
clause. procedures. synonyms.
Use column and table aliases. Pass parameters to procedures. Use IF and WHILE blocks to control
Write simple CASE expressions. Create simple stored procedures which program flow.
Querying with Inner Joins encapsulate a SELECT statement. Working with Error InformationAfter
Querying with Outer Joins Construct and execute dynamic SQL with completing this module, students will be
Querying with Cross Joins and Self EXEC and sp_executesql. able to:
JoinsAfter completing this module, students Controlling Program FlowAfter Describe SQL Server's behavior when
will be able to: completing this module, students will be errors occur in T-SQL code.
Describe how multiple tables may be able to: Implement structured exception handling in
queried in a SELECT statement using joins. Describe the language elements of T-SQL.
Write queries that use inner joins. T-SQL used for simple programming Return information about errors from
Write queries that use outer joins. tasks. system objects.
Write queries that use self-joins and cross Describe batches and how they are Raise user-defined errors and pass system
joins. handled by SQL Server. errors in T-SQL code.
Filtering Data with a WHERE Clause Declare and assign variables and Controlling TransactionsAfter completing
Filtering with the TOP and OFFSET-FETCH synonyms. this module, students will be able to:
Options Use IF and WHILE blocks to control Describe transactions and the differences
Working with Unknown and Missing program flow. between batches and transactions.
ValuesAfter completing this module, Working with Error InformationAfter Describe batches and how they are
students will be able to: completing this module, students will be handled by SQL Server.
Filter data with predicates in the WHERE able to: Create and manage transactions with
clause. Describe SQL Server's behavior when transaction control language statements.
Sort data using ORDER BY. errors occur in T-SQL code. Use SET XACT_ABORT to define SQL
Filter data in the SELECT clause with TOP. Implement structured exception handling Server's handling of transactions outside
Filter data with OFFSET and FETCH. in T-SQL. TRY / CATCH blocks.
Working with Character Data Return information about errors from Displaying Query Performance DataAfter
Working with Date and Time DataAfter system objects. completing this module, students will be
completing this module, students will be able Raise user-defined errors and pass able to:
to: system errors in T-SQL code. Describe components of well-performing
Describe numeric data types, type Controlling TransactionsAfter completing queries.
precedence and type conversions. this module, students will be able to: Describe the role of indexes and statistics
Write queries using character data types. Describe transactions and the differences in SQL Server
Write queries using date and time data between batches and transactions. Display and interpret basic query plans
types. Describe batches and how they are Display and interpret basic query
Using Conversion Functions handled by SQL Server. performance data
Using Logical Functions Create and manage transactions with
Using Functions to Work with NULLAfter transaction control language statements.
completing this module, students will be able Use SET XACT_ABORT to define SQL line
to: Server's handling of transactions outside Getting Started with SQL Server
Write queries with built-in scalar functions. TRY / CATCH blocks. Management Studio

Use conversion functions. Displaying Query Performance DataAfter Work with SQL Server Management
Use logical functions. completing this module, students will be Studio.
Use functions that work with NULL. able to: Working with SQL AzureAfter completing
Using the GROUP BY Clause Describe components of well-performing this module, students will be able to:
Filtering Groups with HAVINGAfter queries. Describe the basic features of SQL Azure.
completing this module, students will be able Describe the role of indexes and statistics Provision a SQL Azure server and
to: in SQL Server configure its security.
Write queries which summarize data using Display and interpret basic query plans Understanding Sets
built-in aggregate functions. Display and interpret basic query Understanding Predicate Logic
Use the GROUP BY clause to arrange rows performance data Understanding the Logical Order of
into groups. Operations in SELECT statementsAfter
Use the HAVING clause to filter out groups completing this module, students will be
based on a search condition. line able to:
Writing Correlated Subqueries Getting Started with SQL Server Describe the elements of T-SQL and their
Using the EXISTS Predicate with Management Studio role in writing queries
SubqueriesAfter completing this module, Work with SQL Server Management Describe the use of sets in SQL Server
students will be able to: Studio. Describe the use of predicate logic in SQL
Describe the uses of queries which are Working with SQL AzureAfter completing Server
nested within other queries. this module, students will be able to: Describe the logical order of operations in
Write self-contained subqueries which return Describe the basic features of SQL SELECT statements
scalar or multi-valued results. Azure. Eliminating Duplicates with DISTINCT
Write correlated subqueries which return Provision a SQL Azure server and Using Column and Table Aliases
scalar or multi-valued results. configure its security. Writing Simple CASE Expressions
Use the EXISTS predicate to efficiently Understanding Sets Eliminate duplicates using the DISTINCT
check for the existence of rows in a Understanding Predicate Logic clause.
subquery. Understanding the Logical Order of Use column and table aliases.
Using Common Table Expressions Operations in SELECT statementsAfter Write simple CASE expressions.
Using Views completing this module, students will be Querying with Inner Joins
Using Inline Table-Valued FunctionsAfter able to: Querying with Outer Joins
completing this module, students will be able Describe the elements of T-SQL and their Querying with Cross Joins and Self
to: role in writing queries JoinsAfter completing this module,
Write queries which use derived tables. Describe the use of sets in SQL Server students will be able to:
Write queries which use common table Describe the use of predicate logic in Describe how multiple tables may be
expressions. SQL Server queried in a SELECT statement using
Create simple views and write queries Describe the logical order of operations in joins.
against them. SELECT statements Write queries that use inner joins.
Create simple inline table-valued functions Eliminating Duplicates with DISTINCT Write queries that use outer joins.
and write queries against them. Using Column and Table Aliases Write queries that use self-joins and cross
Using EXCEPT and INTERSECT Writing Simple CASE Expressions joins.
Using APPLYAfter completing this module, Eliminate duplicates using the DISTINCT Filtering Data with a WHERE Clause
students will be able to: clause. Filtering with the TOP and
Write queries which combine data using the Use column and table aliases. OFFSET-FETCH Options
UNION operator Write simple CASE expressions. Working with Unknown and Missing
Write queries which compare sets using the Querying with Inner Joins ValuesAfter completing this module,
INTERSECT and EXCEPT operators Querying with Outer Joins students will be able to:
Write queries which manipulate rows in a Querying with Cross Joins and Self Filter data with predicates in the WHERE
table by using APPLY with the results of a JoinsAfter completing this module, clause.
derived table or function students will be able to: Sort data using ORDER BY.
Exploring Window Functions Describe how multiple tables may be Filter data in the SELECT clause with
Restrict window functions to rows defined in queried in a SELECT statement using TOP.
an OVER clause, including partitions and joins. Filter data with OFFSET and FETCH.
frames. Write queries that use inner joins. Working with Character Data
Write queries which use window functions to Write queries that use outer joins. Working with Date and Time DataAfter
operate on a window of rows and return Write queries that use self-joins and completing this module, students will be
ranking, aggregation and offset comparison cross joins. able to:
results. Filtering Data with a WHERE Clause Describe numeric data types, type
Working with Grouping SetsAfter completing Filtering with the TOP and precedence and type conversions.
this module, students will be able to: OFFSET-FETCH Options Write queries using character data types.
Write queries which pivot and unpivot result Working with Unknown and Missing Write queries using date and time data
sets ValuesAfter completing this module, types.
Write queries which specify multiple students will be able to: Using Conversion Functions
groupings with grouping sets Filter data with predicates in the WHERE Using Logical Functions
Executing System Stored Procedures clause. Using Functions to Work with NULLAfter
Querying Dynamic Management Sort data using ORDER BY. completing this module, students will be
ObjectsAfter completing this module, Filter data in the SELECT clause with able to:
students will be able to: TOP. Write queries with built-in scalar functions.

Write queries that retrieve system metadata Filter data with OFFSET and FETCH. Use conversion functions.
using system views and functions. Working with Character Data Use logical functions.
Execute system stored procedures to return Working with Date and Time DataAfter Use functions that work with NULL.
system information. completing this module, students will be Using the GROUP BY Clause
Write queries that retrieve system metadata able to: Filtering Groups with HAVINGAfter
and state information using system dynamic Describe numeric data types, type completing this module, students will be
management views and functions. precedence and type conversions. able to:
Passing Parameters to Stored Procedures Write queries using character data types. Write queries which summarize data using
Creating Simple Stored Procedures Write queries using date and time data built-in aggregate functions.
Working with Dynamic SQLAfter completing types. Use the GROUP BY clause to arrange
this module, students will be able to: Using Conversion Functions rows into groups.
Return results by executing stored Using Logical Functions Use the HAVING clause to filter out groups
procedures. Using Functions to Work with NULLAfter based on a search condition.
Pass parameters to procedures. completing this module, students will be Writing Correlated Subqueries
Create simple stored procedures which able to: Using the EXISTS Predicate with
encapsulate a SELECT statement. Write queries with built-in scalar SubqueriesAfter completing this module,
Construct and execute dynamic SQL with functions. students will be able to:
EXEC and sp_executesql. Use conversion functions. Describe the uses of queries which are
Controlling Program FlowAfter completing Use logical functions. nested within other queries.
this module, students will be able to: Use functions that work with NULL. Write self-contained subqueries which
Describe the language elements of T-SQL Using the GROUP BY Clause return scalar or multi-valued results.
used for simple programming tasks. Filtering Groups with HAVINGAfter Write correlated subqueries which return
Describe batches and how they are handled completing this module, students will be scalar or multi-valued results.
by SQL Server. able to: Use the EXISTS predicate to efficiently
Declare and assign variables and synonyms. Write queries which summarize data check for the existence of rows in a
Use IF and WHILE blocks to control using built-in aggregate functions. subquery.
program flow. Use the GROUP BY clause to arrange Using Common Table Expressions
Working with Error InformationAfter rows into groups. Using Views
completing this module, students will be able Use the HAVING clause to filter out Using Inline Table-Valued FunctionsAfter
to: groups based on a search condition. completing this module, students will be
Describe SQL Server's behavior when errors Writing Correlated Subqueries able to:
occur in T-SQL code. Using the EXISTS Predicate with Write queries which use derived tables.
Implement structured exception handling in SubqueriesAfter completing this module, Write queries which use common table
T-SQL. students will be able to: expressions.
Return information about errors from system Describe the uses of queries which are Create simple views and write queries
objects. nested within other queries. against them.
Raise user-defined errors and pass system Write self-contained subqueries which Create simple inline table-valued functions
errors in T-SQL code. return scalar or multi-valued results. and write queries against them.
Controlling TransactionsAfter completing Write correlated subqueries which return Using EXCEPT and INTERSECT
this module, students will be able to: scalar or multi-valued results. Using APPLYAfter completing this module,
Describe transactions and the differences Use the EXISTS predicate to efficiently students will be able to:
between batches and transactions. check for the existence of rows in a Write queries which combine data using
Describe batches and how they are handled subquery. the UNION operator
by SQL Server. Using Common Table Expressions Write queries which compare sets using
Create and manage transactions with Using Views the INTERSECT and EXCEPT operators
transaction control language statements. Using Inline Table-Valued FunctionsAfter Write queries which manipulate rows in a
Use SET XACT_ABORT to define SQL completing this module, students will be table by using APPLY with the results of a
Server's handling of transactions outside able to: derived table or function
TRY / CATCH blocks. Write queries which use derived tables. Exploring Window Functions
Displaying Query Performance DataAfter Write queries which use common table Restrict window functions to rows defined
completing this module, students will be able expressions. in an OVER clause, including partitions
to: Create simple views and write queries and frames.
Describe components of well-performing against them. Write queries which use window functions
queries. Create simple inline table-valued to operate on a window of rows and return
Describe the role of indexes and statistics in functions and write queries against them. ranking, aggregation and offset
SQL Server Using EXCEPT and INTERSECT comparison results.
Display and interpret basic query plans Using APPLYAfter completing this Working with Grouping SetsAfter
Display and interpret basic query module, students will be able to: completing this module, students will be
performance data Write queries which combine data using able to:
the UNION operator Write queries which pivot and unpivot
Write queries which compare sets using result sets
line the INTERSECT and EXCEPT operators Write queries which specify multiple
Getting Started with SQL Server Write queries which manipulate rows in a groupings with grouping sets
Management Studio table by using APPLY with the results of Executing System Stored Procedures
Work with SQL Server Management Studio. a derived table or function Querying Dynamic Management
Working with SQL AzureAfter completing Exploring Window Functions ObjectsAfter completing this module,

this module, students will be able to: Restrict window functions to rows defined students will be able to:
Describe the basic features of SQL Azure. in an OVER clause, including partitions Write queries that retrieve system
Provision a SQL Azure server and configure and frames. metadata using system views and
its security. Write queries which use window functions.
Understanding Sets functions to operate on a window of rows Execute system stored procedures to
Understanding Predicate Logic and return ranking, aggregation and return system information.
Understanding the Logical Order of offset comparison results. Write queries that retrieve system
Operations in SELECT statementsAfter Working with Grouping SetsAfter metadata and state information using
completing this module, students will be able completing this module, students will be system dynamic management views and
to: able to: functions.
Describe the elements of T-SQL and their Write queries which pivot and unpivot Passing Parameters to Stored Procedures
role in writing queries result sets Creating Simple Stored Procedures
Describe the use of sets in SQL Server Write queries which specify multiple Working with Dynamic SQLAfter
Describe the use of predicate logic in SQL groupings with grouping sets completing this module, students will be
Server Executing System Stored Procedures able to:
Describe the logical order of operations in Querying Dynamic Management Return results by executing stored
SELECT statements ObjectsAfter completing this module, procedures.
Eliminating Duplicates with DISTINCT students will be able to: Pass parameters to procedures.
Using Column and Table Aliases Write queries that retrieve system Create simple stored procedures which
Writing Simple CASE Expressions metadata using system views and encapsulate a SELECT statement.
Eliminate duplicates using the DISTINCT functions. Construct and execute dynamic SQL with
clause. Execute system stored procedures to EXEC and sp_executesql.
Use column and table aliases. return system information. Controlling Program FlowAfter completing
Write simple CASE expressions. Write queries that retrieve system this module, students will be able to:
Querying with Inner Joins metadata and state information using Describe the language elements of T-SQL
Querying with Outer Joins system dynamic management views and used for simple programming tasks.
Querying with Cross Joins and Self functions. Describe batches and how they are
JoinsAfter completing this module, students Passing Parameters to Stored handled by SQL Server.
will be able to: Procedures Declare and assign variables and
Describe how multiple tables may be Creating Simple Stored Procedures synonyms.
queried in a SELECT statement using joins. Working with Dynamic SQLAfter Use IF and WHILE blocks to control
Write queries that use inner joins. completing this module, students will be program flow.
Write queries that use outer joins. able to: Working with Error InformationAfter
Write queries that use self-joins and cross Return results by executing stored completing this module, students will be
joins. procedures. able to:
Filtering Data with a WHERE Clause Pass parameters to procedures. Describe SQL Server's behavior when
Filtering with the TOP and OFFSET-FETCH Create simple stored procedures which errors occur in T-SQL code.
Options encapsulate a SELECT statement. Implement structured exception handling in
Working with Unknown and Missing Construct and execute dynamic SQL with T-SQL.
ValuesAfter completing this module, EXEC and sp_executesql. Return information about errors from
students will be able to: Controlling Program FlowAfter system objects.
Filter data with predicates in the WHERE completing this module, students will be Raise user-defined errors and pass system
clause. able to: errors in T-SQL code.
Sort data using ORDER BY. Describe the language elements of Controlling TransactionsAfter completing
Filter data in the SELECT clause with TOP. T-SQL used for simple programming this module, students will be able to:
Filter data with OFFSET and FETCH. tasks. Describe transactions and the differences
Working with Character Data Describe batches and how they are between batches and transactions.
Working with Date and Time DataAfter handled by SQL Server. Describe batches and how they are
completing this module, students will be able Declare and assign variables and handled by SQL Server.
to: synonyms. Create and manage transactions with
Describe numeric data types, type Use IF and WHILE blocks to control transaction control language statements.
precedence and type conversions. program flow. Use SET XACT_ABORT to define SQL
Write queries using character data types. Working with Error InformationAfter Server's handling of transactions outside
Write queries using date and time data completing this module, students will be TRY / CATCH blocks.
types. able to: Displaying Query Performance DataAfter
Using Conversion Functions Describe SQL Server's behavior when completing this module, students will be
Using Logical Functions errors occur in T-SQL code. able to:
Using Functions to Work with NULLAfter Implement structured exception handling Describe components of well-performing
completing this module, students will be able in T-SQL. queries.
to: Return information about errors from Describe the role of indexes and statistics
Write queries with built-in scalar functions. system objects. in SQL Server
Use conversion functions. Raise user-defined errors and pass Display and interpret basic query plans
Use logical functions. system errors in T-SQL code. Display and interpret basic query
Use functions that work with NULL. Controlling TransactionsAfter completing performance data
Using the GROUP BY Clause this module, students will be able to:
Filtering Groups with HAVINGAfter Describe transactions and the differences

completing this module, students will be able between batches and transactions. line
to: Describe batches and how they are Getting Started with SQL Server
Write queries which summarize data using handled by SQL Server. Management Studio
built-in aggregate functions. Create and manage transactions with Work with SQL Server Management
Use the GROUP BY clause to arrange rows transaction control language statements. Studio.
into groups. Use SET XACT_ABORT to define SQL Working with SQL AzureAfter completing
Use the HAVING clause to filter out groups Server's handling of transactions outside this module, students will be able to:
based on a search condition. TRY / CATCH blocks. Describe the basic features of SQL Azure.
Writing Correlated Subqueries Displaying Query Performance DataAfter Provision a SQL Azure server and
Using the EXISTS Predicate with completing this module, students will be configure its security.
SubqueriesAfter completing this module, able to: Understanding Sets
students will be able to: Describe components of well-performing Understanding Predicate Logic
Describe the uses of queries which are queries. Understanding the Logical Order of
nested within other queries. Describe the role of indexes and statistics Operations in SELECT statementsAfter
Write self-contained subqueries which return in SQL Server completing this module, students will be
scalar or multi-valued results. Display and interpret basic query plans able to:
Write correlated subqueries which return Display and interpret basic query Describe the elements of T-SQL and their
scalar or multi-valued results. performance data role in writing queries
Use the EXISTS predicate to efficiently Describe the use of sets in SQL Server
check for the existence of rows in a Describe the use of predicate logic in SQL
subquery. line Server
Using Common Table Expressions Getting Started with SQL Server Describe the logical order of operations in
Using Views Management Studio SELECT statements
Using Inline Table-Valued FunctionsAfter Work with SQL Server Management Eliminating Duplicates with DISTINCT
completing this module, students will be able Studio. Using Column and Table Aliases
to: Working with SQL AzureAfter completing Writing Simple CASE Expressions
Write queries which use derived tables. this module, students will be able to: Eliminate duplicates using the DISTINCT
Write queries which use common table Describe the basic features of SQL clause.
expressions. Azure. Use column and table aliases.
Create simple views and write queries Provision a SQL Azure server and Write simple CASE expressions.
against them. configure its security. Querying with Inner Joins
Create simple inline table-valued functions Understanding Sets Querying with Outer Joins
and write queries against them. Understanding Predicate Logic Querying with Cross Joins and Self
Using EXCEPT and INTERSECT Understanding the Logical Order of JoinsAfter completing this module,
Using APPLYAfter completing this module, Operations in SELECT statementsAfter students will be able to:
students will be able to: completing this module, students will be Describe how multiple tables may be
Write queries which combine data using the able to: queried in a SELECT statement using
UNION operator Describe the elements of T-SQL and their joins.
Write queries which compare sets using the role in writing queries Write queries that use inner joins.
INTERSECT and EXCEPT operators Describe the use of sets in SQL Server Write queries that use outer joins.
Write queries which manipulate rows in a Describe the use of predicate logic in Write queries that use self-joins and cross
table by using APPLY with the results of a SQL Server joins.
derived table or function Describe the logical order of operations in Filtering Data with a WHERE Clause
Exploring Window Functions SELECT statements Filtering with the TOP and
Restrict window functions to rows defined in Eliminating Duplicates with DISTINCT OFFSET-FETCH Options
an OVER clause, including partitions and Using Column and Table Aliases Working with Unknown and Missing
frames. Writing Simple CASE Expressions ValuesAfter completing this module,
Write queries which use window functions to Eliminate duplicates using the DISTINCT students will be able to:
operate on a window of rows and return clause. Filter data with predicates in the WHERE
ranking, aggregation and offset comparison Use column and table aliases. clause.
results. Write simple CASE expressions. Sort data using ORDER BY.
Working with Grouping SetsAfter completing Querying with Inner Joins Filter data in the SELECT clause with
this module, students will be able to: Querying with Outer Joins TOP.
Write queries which pivot and unpivot result Querying with Cross Joins and Self Filter data with OFFSET and FETCH.
sets JoinsAfter completing this module, Working with Character Data
Write queries which specify multiple students will be able to: Working with Date and Time DataAfter
groupings with grouping sets Describe how multiple tables may be completing this module, students will be
Executing System Stored Procedures queried in a SELECT statement using able to:
Querying Dynamic Management joins. Describe numeric data types, type
ObjectsAfter completing this module, Write queries that use inner joins. precedence and type conversions.
students will be able to: Write queries that use outer joins. Write queries using character data types.
Write queries that retrieve system metadata Write queries that use self-joins and Write queries using date and time data
using system views and functions. cross joins. types.
Execute system stored procedures to return Filtering Data with a WHERE Clause Using Conversion Functions
system information. Filtering with the TOP and Using Logical Functions
Write queries that retrieve system metadata OFFSET-FETCH Options Using Functions to Work with NULLAfter

and state information using system dynamic Working with Unknown and Missing completing this module, students will be
management views and functions. ValuesAfter completing this module, able to:
Passing Parameters to Stored Procedures students will be able to: Write queries with built-in scalar functions.
Creating Simple Stored Procedures Filter data with predicates in the WHERE Use conversion functions.
Working with Dynamic SQLAfter completing clause. Use logical functions.
this module, students will be able to: Sort data using ORDER BY. Use functions that work with NULL.
Return results by executing stored Filter data in the SELECT clause with Using the GROUP BY Clause
procedures. TOP. Filtering Groups with HAVINGAfter
Pass parameters to procedures. Filter data with OFFSET and FETCH. completing this module, students will be
Create simple stored procedures which Working with Character Data able to:
encapsulate a SELECT statement. Working with Date and Time DataAfter Write queries which summarize data using
Construct and execute dynamic SQL with completing this module, students will be built-in aggregate functions.
EXEC and sp_executesql. able to: Use the GROUP BY clause to arrange
Controlling Program FlowAfter completing Describe numeric data types, type rows into groups.
this module, students will be able to: precedence and type conversions. Use the HAVING clause to filter out groups
Describe the language elements of T-SQL Write queries using character data types. based on a search condition.
used for simple programming tasks. Write queries using date and time data Writing Correlated Subqueries
Describe batches and how they are handled types. Using the EXISTS Predicate with
by SQL Server. Using Conversion Functions SubqueriesAfter completing this module,
Declare and assign variables and synonyms. Using Logical Functions students will be able to:
Use IF and WHILE blocks to control Using Functions to Work with NULLAfter Describe the uses of queries which are
program flow. completing this module, students will be nested within other queries.
Working with Error InformationAfter able to: Write self-contained subqueries which
completing this module, students will be able Write queries with built-in scalar return scalar or multi-valued results.
to: functions. Write correlated subqueries which return
Describe SQL Server's behavior when errors Use conversion functions. scalar or multi-valued results.
occur in T-SQL code. Use logical functions. Use the EXISTS predicate to efficiently
Implement structured exception handling in Use functions that work with NULL. check for the existence of rows in a
T-SQL. Using the GROUP BY Clause subquery.
Return information about errors from system Filtering Groups with HAVINGAfter Using Common Table Expressions
objects. completing this module, students will be Using Views
Raise user-defined errors and pass system able to: Using Inline Table-Valued FunctionsAfter
errors in T-SQL code. Write queries which summarize data completing this module, students will be
Controlling TransactionsAfter completing using built-in aggregate functions. able to:
this module, students will be able to: Use the GROUP BY clause to arrange Write queries which use derived tables.
Describe transactions and the differences rows into groups. Write queries which use common table
between batches and transactions. Use the HAVING clause to filter out expressions.
Describe batches and how they are handled groups based on a search condition. Create simple views and write queries
by SQL Server. Writing Correlated Subqueries against them.
Create and manage transactions with Using the EXISTS Predicate with Create simple inline table-valued functions
transaction control language statements. SubqueriesAfter completing this module, and write queries against them.
Use SET XACT_ABORT to define SQL students will be able to: Using EXCEPT and INTERSECT
Server's handling of transactions outside Describe the uses of queries which are Using APPLYAfter completing this module,
TRY / CATCH blocks. nested within other queries. students will be able to:
Displaying Query Performance DataAfter Write self-contained subqueries which Write queries which combine data using
completing this module, students will be able return scalar or multi-valued results. the UNION operator
to: Write correlated subqueries which return Write queries which compare sets using
Describe components of well-performing scalar or multi-valued results. the INTERSECT and EXCEPT operators
queries. Use the EXISTS predicate to efficiently Write queries which manipulate rows in a
Describe the role of indexes and statistics in check for the existence of rows in a table by using APPLY with the results of a
SQL Server subquery. derived table or function
Display and interpret basic query plans Using Common Table Expressions Exploring Window Functions
Display and interpret basic query Using Views Restrict window functions to rows defined
performance data Using Inline Table-Valued FunctionsAfter in an OVER clause, including partitions
completing this module, students will be and frames.
Module 4: Writing SELECT Queries able to: Write queries which use window functions
line Write queries which use derived tables. to operate on a window of rows and return
Write queries which use common table ranking, aggregation and offset
This module introduces the fundamentals of the expressions. comparison results.
SELECT statement, focusing on queries Create simple views and write queries Working with Grouping SetsAfter
against a single table. against them. completing this module, students will be
line Create simple inline table-valued able to:
Writing Simple SELECT Statements functions and write queries against them. Write queries which pivot and unpivot
Using EXCEPT and INTERSECT result sets
Using APPLYAfter completing this Write queries which specify multiple
line module, students will be able to: groupings with grouping sets

Getting Started with SQL Server Write queries which combine data using Executing System Stored Procedures
Management Studio the UNION operator Querying Dynamic Management
Work with SQL Server Management Studio. Write queries which compare sets using ObjectsAfter completing this module,
Working with SQL AzureAfter completing the INTERSECT and EXCEPT operators students will be able to:
this module, students will be able to: Write queries which manipulate rows in a Write queries that retrieve system
Describe the basic features of SQL Azure. table by using APPLY with the results of metadata using system views and
Provision a SQL Azure server and configure a derived table or function functions.
its security. Exploring Window Functions Execute system stored procedures to
Understanding Sets Restrict window functions to rows defined return system information.
Understanding Predicate Logic in an OVER clause, including partitions Write queries that retrieve system
Understanding the Logical Order of and frames. metadata and state information using
Operations in SELECT statementsAfter Write queries which use window system dynamic management views and
completing this module, students will be able functions to operate on a window of rows functions.
to: and return ranking, aggregation and Passing Parameters to Stored Procedures
Describe the elements of T-SQL and their offset comparison results. Creating Simple Stored Procedures
role in writing queries Working with Grouping SetsAfter Working with Dynamic SQLAfter
Describe the use of sets in SQL Server completing this module, students will be completing this module, students will be
Describe the use of predicate logic in SQL able to: able to:
Server Write queries which pivot and unpivot Return results by executing stored
Describe the logical order of operations in result sets procedures.
SELECT statements Write queries which specify multiple Pass parameters to procedures.
Eliminating Duplicates with DISTINCT groupings with grouping sets Create simple stored procedures which
Using Column and Table Aliases Executing System Stored Procedures encapsulate a SELECT statement.
Writing Simple CASE Expressions Querying Dynamic Management Construct and execute dynamic SQL with
Eliminate duplicates using the DISTINCT ObjectsAfter completing this module, EXEC and sp_executesql.
clause. students will be able to: Controlling Program FlowAfter completing
Use column and table aliases. Write queries that retrieve system this module, students will be able to:
Write simple CASE expressions. metadata using system views and Describe the language elements of T-SQL
Querying with Inner Joins functions. used for simple programming tasks.
Querying with Outer Joins Execute system stored procedures to Describe batches and how they are
Querying with Cross Joins and Self return system information. handled by SQL Server.
JoinsAfter completing this module, students Write queries that retrieve system Declare and assign variables and
will be able to: metadata and state information using synonyms.
Describe how multiple tables may be system dynamic management views and Use IF and WHILE blocks to control
queried in a SELECT statement using joins. functions. program flow.
Write queries that use inner joins. Passing Parameters to Stored Working with Error InformationAfter
Write queries that use outer joins. Procedures completing this module, students will be
Write queries that use self-joins and cross Creating Simple Stored Procedures able to:
joins. Working with Dynamic SQLAfter Describe SQL Server's behavior when
Filtering Data with a WHERE Clause completing this module, students will be errors occur in T-SQL code.
Filtering with the TOP and OFFSET-FETCH able to: Implement structured exception handling in
Options Return results by executing stored T-SQL.
Working with Unknown and Missing procedures. Return information about errors from
ValuesAfter completing this module, Pass parameters to procedures. system objects.
students will be able to: Create simple stored procedures which Raise user-defined errors and pass system
Filter data with predicates in the WHERE encapsulate a SELECT statement. errors in T-SQL code.
clause. Construct and execute dynamic SQL with Controlling TransactionsAfter completing
Sort data using ORDER BY. EXEC and sp_executesql. this module, students will be able to:
Filter data in the SELECT clause with TOP. Controlling Program FlowAfter Describe transactions and the differences
Filter data with OFFSET and FETCH. completing this module, students will be between batches and transactions.
Working with Character Data able to: Describe batches and how they are
Working with Date and Time DataAfter Describe the language elements of handled by SQL Server.
completing this module, students will be able T-SQL used for simple programming Create and manage transactions with
to: tasks. transaction control language statements.
Describe numeric data types, type Describe batches and how they are Use SET XACT_ABORT to define SQL
precedence and type conversions. handled by SQL Server. Server's handling of transactions outside
Write queries using character data types. Declare and assign variables and TRY / CATCH blocks.
Write queries using date and time data synonyms. Displaying Query Performance DataAfter
types. Use IF and WHILE blocks to control completing this module, students will be
Using Conversion Functions program flow. able to:
Using Logical Functions Working with Error InformationAfter Describe components of well-performing
Using Functions to Work with NULLAfter completing this module, students will be queries.
completing this module, students will be able able to: Describe the role of indexes and statistics
to: Describe SQL Server's behavior when in SQL Server
Write queries with built-in scalar functions. errors occur in T-SQL code. Display and interpret basic query plans
Use conversion functions. Implement structured exception handling Display and interpret basic query

Use logical functions. in T-SQL. performance data
Use functions that work with NULL. Return information about errors from
Using the GROUP BY Clause system objects.
Filtering Groups with HAVINGAfter Raise user-defined errors and pass line
completing this module, students will be able system errors in T-SQL code. Getting Started with SQL Server
to: Controlling TransactionsAfter completing Management Studio
Write queries which summarize data using this module, students will be able to: Work with SQL Server Management
built-in aggregate functions. Describe transactions and the differences Studio.
Use the GROUP BY clause to arrange rows between batches and transactions. Working with SQL AzureAfter completing
into groups. Describe batches and how they are this module, students will be able to:
Use the HAVING clause to filter out groups handled by SQL Server. Describe the basic features of SQL Azure.
based on a search condition. Create and manage transactions with Provision a SQL Azure server and
Writing Correlated Subqueries transaction control language statements. configure its security.
Using the EXISTS Predicate with Use SET XACT_ABORT to define SQL Understanding Sets
SubqueriesAfter completing this module, Server's handling of transactions outside Understanding Predicate Logic
students will be able to: TRY / CATCH blocks. Understanding the Logical Order of
Describe the uses of queries which are Displaying Query Performance DataAfter Operations in SELECT statementsAfter
nested within other queries. completing this module, students will be completing this module, students will be
Write self-contained subqueries which return able to: able to:
scalar or multi-valued results. Describe components of well-performing Describe the elements of T-SQL and their
Write correlated subqueries which return queries. role in writing queries
scalar or multi-valued results. Describe the role of indexes and statistics Describe the use of sets in SQL Server
Use the EXISTS predicate to efficiently in SQL Server Describe the use of predicate logic in SQL
check for the existence of rows in a Display and interpret basic query plans Server
subquery. Display and interpret basic query Describe the logical order of operations in
Using Common Table Expressions performance data SELECT statements
Using Views Eliminating Duplicates with DISTINCT
Using Inline Table-Valued FunctionsAfter Module 9: Grouping and Aggregating Data Using Column and Table Aliases
completing this module, students will be able line Writing Simple CASE Expressions
to: Eliminate duplicates using the DISTINCT
Write queries which use derived tables. This module introduces methods for grouping clause.
Write queries which use common table data within a query, aggregating the grouped Use column and table aliases.
expressions. data and filtering groups with HAVING. The Write simple CASE expressions.
Create simple views and write queries module is designed to help the student grasp Querying with Inner Joins
against them. why a SELECT clause has restrictions placed Querying with Outer Joins
Create simple inline table-valued functions upon column naming in the GROUP BY Querying with Cross Joins and Self
and write queries against them. clause as well as which columns may be JoinsAfter completing this module,
Using EXCEPT and INTERSECT listed in the SELECT clause. students will be able to:
Using APPLYAfter completing this module, line Describe how multiple tables may be
students will be able to: Using Aggregate Functions queried in a SELECT statement using
Write queries which combine data using the joins.
UNION operator Write queries that use inner joins.
Write queries which compare sets using the line Write queries that use outer joins.
INTERSECT and EXCEPT operators Getting Started with SQL Server Write queries that use self-joins and cross
Write queries which manipulate rows in a Management Studio joins.
table by using APPLY with the results of a Work with SQL Server Management Filtering Data with a WHERE Clause
derived table or function Studio. Filtering with the TOP and
Exploring Window Functions Working with SQL AzureAfter completing OFFSET-FETCH Options
Restrict window functions to rows defined in this module, students will be able to: Working with Unknown and Missing
an OVER clause, including partitions and Describe the basic features of SQL ValuesAfter completing this module,
frames. Azure. students will be able to:
Write queries which use window functions to Provision a SQL Azure server and Filter data with predicates in the WHERE
operate on a window of rows and return configure its security. clause.
ranking, aggregation and offset comparison Understanding Sets Sort data using ORDER BY.
results. Understanding Predicate Logic Filter data in the SELECT clause with
Working with Grouping SetsAfter completing Understanding the Logical Order of TOP.
this module, students will be able to: Operations in SELECT statementsAfter Filter data with OFFSET and FETCH.
Write queries which pivot and unpivot result completing this module, students will be Working with Character Data
sets able to: Working with Date and Time DataAfter
Write queries which specify multiple Describe the elements of T-SQL and their completing this module, students will be
groupings with grouping sets role in writing queries able to:
Executing System Stored Procedures Describe the use of sets in SQL Server Describe numeric data types, type
Querying Dynamic Management Describe the use of predicate logic in precedence and type conversions.
ObjectsAfter completing this module, SQL Server Write queries using character data types.
students will be able to: Describe the logical order of operations in Write queries using date and time data
Write queries that retrieve system metadata SELECT statements types.

using system views and functions. Eliminating Duplicates with DISTINCT Using Conversion Functions
Execute system stored procedures to return Using Column and Table Aliases Using Logical Functions
system information. Writing Simple CASE Expressions Using Functions to Work with NULLAfter
Write queries that retrieve system metadata Eliminate duplicates using the DISTINCT completing this module, students will be
and state information using system dynamic clause. able to:
management views and functions. Use column and table aliases. Write queries with built-in scalar functions.
Passing Parameters to Stored Procedures Write simple CASE expressions. Use conversion functions.
Creating Simple Stored Procedures Querying with Inner Joins Use logical functions.
Working with Dynamic SQLAfter completing Querying with Outer Joins Use functions that work with NULL.
this module, students will be able to: Querying with Cross Joins and Self Using the GROUP BY Clause
Return results by executing stored JoinsAfter completing this module, Filtering Groups with HAVINGAfter
procedures. students will be able to: completing this module, students will be
Pass parameters to procedures. Describe how multiple tables may be able to:
Create simple stored procedures which queried in a SELECT statement using Write queries which summarize data using
encapsulate a SELECT statement. joins. built-in aggregate functions.
Construct and execute dynamic SQL with Write queries that use inner joins. Use the GROUP BY clause to arrange
EXEC and sp_executesql. Write queries that use outer joins. rows into groups.
Controlling Program FlowAfter completing Write queries that use self-joins and Use the HAVING clause to filter out groups
this module, students will be able to: cross joins. based on a search condition.
Describe the language elements of T-SQL Filtering Data with a WHERE Clause Writing Correlated Subqueries
used for simple programming tasks. Filtering with the TOP and Using the EXISTS Predicate with
Describe batches and how they are handled OFFSET-FETCH Options SubqueriesAfter completing this module,
by SQL Server. Working with Unknown and Missing students will be able to:
Declare and assign variables and synonyms. ValuesAfter completing this module, Describe the uses of queries which are
Use IF and WHILE blocks to control students will be able to: nested within other queries.
program flow. Filter data with predicates in the WHERE Write self-contained subqueries which
Working with Error InformationAfter clause. return scalar or multi-valued results.
completing this module, students will be able Sort data using ORDER BY. Write correlated subqueries which return
to: Filter data in the SELECT clause with scalar or multi-valued results.
Describe SQL Server's behavior when errors TOP. Use the EXISTS predicate to efficiently
occur in T-SQL code. Filter data with OFFSET and FETCH. check for the existence of rows in a
Implement structured exception handling in Working with Character Data subquery.
T-SQL. Working with Date and Time DataAfter Using Common Table Expressions
Return information about errors from system completing this module, students will be Using Views
objects. able to: Using Inline Table-Valued FunctionsAfter
Raise user-defined errors and pass system Describe numeric data types, type completing this module, students will be
errors in T-SQL code. precedence and type conversions. able to:
Controlling TransactionsAfter completing Write queries using character data types. Write queries which use derived tables.
this module, students will be able to: Write queries using date and time data Write queries which use common table
Describe transactions and the differences types. expressions.
between batches and transactions. Using Conversion Functions Create simple views and write queries
Describe batches and how they are handled Using Logical Functions against them.
by SQL Server. Using Functions to Work with NULLAfter Create simple inline table-valued functions
Create and manage transactions with completing this module, students will be and write queries against them.
transaction control language statements. able to: Using EXCEPT and INTERSECT
Use SET XACT_ABORT to define SQL Write queries with built-in scalar Using APPLYAfter completing this module,
Server's handling of transactions outside functions. students will be able to:
TRY / CATCH blocks. Use conversion functions. Write queries which combine data using
Displaying Query Performance DataAfter Use logical functions. the UNION operator
completing this module, students will be able Use functions that work with NULL. Write queries which compare sets using
to: Using the GROUP BY Clause the INTERSECT and EXCEPT operators
Describe components of well-performing Filtering Groups with HAVINGAfter Write queries which manipulate rows in a
queries. completing this module, students will be table by using APPLY with the results of a
Describe the role of indexes and statistics in able to: derived table or function
SQL Server Write queries which summarize data Exploring Window Functions
Display and interpret basic query plans using built-in aggregate functions. Restrict window functions to rows defined
Display and interpret basic query Use the GROUP BY clause to arrange in an OVER clause, including partitions
performance data rows into groups. and frames.
Use the HAVING clause to filter out Write queries which use window functions
groups based on a search condition. to operate on a window of rows and return
line Writing Correlated Subqueries ranking, aggregation and offset
Getting Started with SQL Server Using the EXISTS Predicate with comparison results.
Management Studio SubqueriesAfter completing this module, Working with Grouping SetsAfter
Work with SQL Server Management Studio. students will be able to: completing this module, students will be
Working with SQL AzureAfter completing Describe the uses of queries which are able to:
this module, students will be able to: nested within other queries. Write queries which pivot and unpivot

Describe the basic features of SQL Azure. Write self-contained subqueries which result sets
Provision a SQL Azure server and configure return scalar or multi-valued results. Write queries which specify multiple
its security. Write correlated subqueries which return groupings with grouping sets
Understanding Sets scalar or multi-valued results. Executing System Stored Procedures
Understanding Predicate Logic Use the EXISTS predicate to efficiently Querying Dynamic Management
Understanding the Logical Order of check for the existence of rows in a ObjectsAfter completing this module,
Operations in SELECT statementsAfter subquery. students will be able to:
completing this module, students will be able Using Common Table Expressions Write queries that retrieve system
to: Using Views metadata using system views and
Describe the elements of T-SQL and their Using Inline Table-Valued FunctionsAfter functions.
role in writing queries completing this module, students will be Execute system stored procedures to
Describe the use of sets in SQL Server able to: return system information.
Describe the use of predicate logic in SQL Write queries which use derived tables. Write queries that retrieve system
Server Write queries which use common table metadata and state information using
Describe the logical order of operations in expressions. system dynamic management views and
SELECT statements Create simple views and write queries functions.
Eliminating Duplicates with DISTINCT against them. Passing Parameters to Stored Procedures
Using Column and Table Aliases Create simple inline table-valued Creating Simple Stored Procedures
Writing Simple CASE Expressions functions and write queries against them. Working with Dynamic SQLAfter
Eliminate duplicates using the DISTINCT Using EXCEPT and INTERSECT completing this module, students will be
clause. Using APPLYAfter completing this able to:
Use column and table aliases. module, students will be able to: Return results by executing stored
Write simple CASE expressions. Write queries which combine data using procedures.
Querying with Inner Joins the UNION operator Pass parameters to procedures.
Querying with Outer Joins Write queries which compare sets using Create simple stored procedures which
Querying with Cross Joins and Self the INTERSECT and EXCEPT operators encapsulate a SELECT statement.
JoinsAfter completing this module, students Write queries which manipulate rows in a Construct and execute dynamic SQL with
will be able to: table by using APPLY with the results of EXEC and sp_executesql.
Describe how multiple tables may be a derived table or function Controlling Program FlowAfter completing
queried in a SELECT statement using joins. Exploring Window Functions this module, students will be able to:
Write queries that use inner joins. Restrict window functions to rows defined Describe the language elements of T-SQL
Write queries that use outer joins. in an OVER clause, including partitions used for simple programming tasks.
Write queries that use self-joins and cross and frames. Describe batches and how they are
joins. Write queries which use window handled by SQL Server.
Filtering Data with a WHERE Clause functions to operate on a window of rows Declare and assign variables and
Filtering with the TOP and OFFSET-FETCH and return ranking, aggregation and synonyms.
Options offset comparison results. Use IF and WHILE blocks to control
Working with Unknown and Missing Working with Grouping SetsAfter program flow.
ValuesAfter completing this module, completing this module, students will be Working with Error InformationAfter
students will be able to: able to: completing this module, students will be
Filter data with predicates in the WHERE Write queries which pivot and unpivot able to:
clause. result sets Describe SQL Server's behavior when
Sort data using ORDER BY. Write queries which specify multiple errors occur in T-SQL code.
Filter data in the SELECT clause with TOP. groupings with grouping sets Implement structured exception handling in
Filter data with OFFSET and FETCH. Executing System Stored Procedures T-SQL.
Working with Character Data Querying Dynamic Management Return information about errors from
Working with Date and Time DataAfter ObjectsAfter completing this module, system objects.
completing this module, students will be able students will be able to: Raise user-defined errors and pass system
to: Write queries that retrieve system errors in T-SQL code.
Describe numeric data types, type metadata using system views and Controlling TransactionsAfter completing
precedence and type conversions. functions. this module, students will be able to:
Write queries using character data types. Execute system stored procedures to Describe transactions and the differences
Write queries using date and time data return system information. between batches and transactions.
types. Write queries that retrieve system Describe batches and how they are
Using Conversion Functions metadata and state information using handled by SQL Server.
Using Logical Functions system dynamic management views and Create and manage transactions with
Using Functions to Work with NULLAfter functions. transaction control language statements.
completing this module, students will be able Passing Parameters to Stored Use SET XACT_ABORT to define SQL
to: Procedures Server's handling of transactions outside
Write queries with built-in scalar functions. Creating Simple Stored Procedures TRY / CATCH blocks.
Use conversion functions. Working with Dynamic SQLAfter Displaying Query Performance DataAfter
Use logical functions. completing this module, students will be completing this module, students will be
Use functions that work with NULL. able to: able to:
Using the GROUP BY Clause Return results by executing stored Describe components of well-performing
Filtering Groups with HAVINGAfter procedures. queries.
completing this module, students will be able Pass parameters to procedures. Describe the role of indexes and statistics

to: Create simple stored procedures which in SQL Server
Write queries which summarize data using encapsulate a SELECT statement. Display and interpret basic query plans
built-in aggregate functions. Construct and execute dynamic SQL with Display and interpret basic query
Use the GROUP BY clause to arrange rows EXEC and sp_executesql. performance data
into groups. Controlling Program FlowAfter
Use the HAVING clause to filter out groups completing this module, students will be
based on a search condition. able to: line
Writing Correlated Subqueries Describe the language elements of Getting Started with SQL Server
Using the EXISTS Predicate with T-SQL used for simple programming Management Studio
SubqueriesAfter completing this module, tasks. Work with SQL Server Management
students will be able to: Describe batches and how they are Studio.
Describe the uses of queries which are handled by SQL Server. Working with SQL AzureAfter completing
nested within other queries. Declare and assign variables and this module, students will be able to:
Write self-contained subqueries which return synonyms. Describe the basic features of SQL Azure.
scalar or multi-valued results. Use IF and WHILE blocks to control Provision a SQL Azure server and
Write correlated subqueries which return program flow. configure its security.
scalar or multi-valued results. Working with Error InformationAfter Understanding Sets
Use the EXISTS predicate to efficiently completing this module, students will be Understanding Predicate Logic
check for the existence of rows in a able to: Understanding the Logical Order of
subquery. Describe SQL Server's behavior when Operations in SELECT statementsAfter
Using Common Table Expressions errors occur in T-SQL code. completing this module, students will be
Using Views Implement structured exception handling able to:
Using Inline Table-Valued FunctionsAfter in T-SQL. Describe the elements of T-SQL and their
completing this module, students will be able Return information about errors from role in writing queries
to: system objects. Describe the use of sets in SQL Server
Write queries which use derived tables. Raise user-defined errors and pass Describe the use of predicate logic in SQL
Write queries which use common table system errors in T-SQL code. Server
expressions. Controlling TransactionsAfter completing Describe the logical order of operations in
Create simple views and write queries this module, students will be able to: SELECT statements
against them. Describe transactions and the differences Eliminating Duplicates with DISTINCT
Create simple inline table-valued functions between batches and transactions. Using Column and Table Aliases
and write queries against them. Describe batches and how they are Writing Simple CASE Expressions
Using EXCEPT and INTERSECT handled by SQL Server. Eliminate duplicates using the DISTINCT
Using APPLYAfter completing this module, Create and manage transactions with clause.
students will be able to: transaction control language statements. Use column and table aliases.
Write queries which combine data using the Use SET XACT_ABORT to define SQL Write simple CASE expressions.
UNION operator Server's handling of transactions outside Querying with Inner Joins
Write queries which compare sets using the TRY / CATCH blocks. Querying with Outer Joins
INTERSECT and EXCEPT operators Displaying Query Performance DataAfter Querying with Cross Joins and Self
Write queries which manipulate rows in a completing this module, students will be JoinsAfter completing this module,
table by using APPLY with the results of a able to: students will be able to:
derived table or function Describe components of well-performing Describe how multiple tables may be
Exploring Window Functions queries. queried in a SELECT statement using
Restrict window functions to rows defined in Describe the role of indexes and statistics joins.
an OVER clause, including partitions and in SQL Server Write queries that use inner joins.
frames. Display and interpret basic query plans Write queries that use outer joins.
Write queries which use window functions to Display and interpret basic query Write queries that use self-joins and cross
operate on a window of rows and return performance data joins.
ranking, aggregation and offset comparison Filtering Data with a WHERE Clause
results. Filtering with the TOP and
Working with Grouping SetsAfter completing line OFFSET-FETCH Options
this module, students will be able to: Getting Started with SQL Server Working with Unknown and Missing
Write queries which pivot and unpivot result Management Studio ValuesAfter completing this module,
sets Work with SQL Server Management students will be able to:
Write queries which specify multiple Studio. Filter data with predicates in the WHERE
groupings with grouping sets Working with SQL AzureAfter completing clause.
Executing System Stored Procedures this module, students will be able to: Sort data using ORDER BY.
Querying Dynamic Management Describe the basic features of SQL Filter data in the SELECT clause with
ObjectsAfter completing this module, Azure. TOP.
students will be able to: Provision a SQL Azure server and Filter data with OFFSET and FETCH.
Write queries that retrieve system metadata configure its security. Working with Character Data
using system views and functions. Understanding Sets Working with Date and Time DataAfter
Execute system stored procedures to return Understanding Predicate Logic completing this module, students will be
system information. Understanding the Logical Order of able to:
Write queries that retrieve system metadata Operations in SELECT statementsAfter Describe numeric data types, type
and state information using system dynamic completing this module, students will be precedence and type conversions.

management views and functions. able to: Write queries using character data types.
Passing Parameters to Stored Procedures Describe the elements of T-SQL and their Write queries using date and time data
Creating Simple Stored Procedures role in writing queries types.
Working with Dynamic SQLAfter completing Describe the use of sets in SQL Server Using Conversion Functions
this module, students will be able to: Describe the use of predicate logic in Using Logical Functions
Return results by executing stored SQL Server Using Functions to Work with NULLAfter
procedures. Describe the logical order of operations in completing this module, students will be
Pass parameters to procedures. SELECT statements able to:
Create simple stored procedures which Eliminating Duplicates with DISTINCT Write queries with built-in scalar functions.
encapsulate a SELECT statement. Using Column and Table Aliases Use conversion functions.
Construct and execute dynamic SQL with Writing Simple CASE Expressions Use logical functions.
EXEC and sp_executesql. Eliminate duplicates using the DISTINCT Use functions that work with NULL.
Controlling Program FlowAfter completing clause. Using the GROUP BY Clause
this module, students will be able to: Use column and table aliases. Filtering Groups with HAVINGAfter
Describe the language elements of T-SQL Write simple CASE expressions. completing this module, students will be
used for simple programming tasks. Querying with Inner Joins able to:
Describe batches and how they are handled Querying with Outer Joins Write queries which summarize data using
by SQL Server. Querying with Cross Joins and Self built-in aggregate functions.
Declare and assign variables and synonyms. JoinsAfter completing this module, Use the GROUP BY clause to arrange
Use IF and WHILE blocks to control students will be able to: rows into groups.
program flow. Describe how multiple tables may be Use the HAVING clause to filter out groups
Working with Error InformationAfter queried in a SELECT statement using based on a search condition.
completing this module, students will be able joins. Writing Correlated Subqueries
to: Write queries that use inner joins. Using the EXISTS Predicate with
Describe SQL Server's behavior when errors Write queries that use outer joins. SubqueriesAfter completing this module,
occur in T-SQL code. Write queries that use self-joins and students will be able to:
Implement structured exception handling in cross joins. Describe the uses of queries which are
T-SQL. Filtering Data with a WHERE Clause nested within other queries.
Return information about errors from system Filtering with the TOP and Write self-contained subqueries which
objects. OFFSET-FETCH Options return scalar or multi-valued results.
Raise user-defined errors and pass system Working with Unknown and Missing Write correlated subqueries which return
errors in T-SQL code. ValuesAfter completing this module, scalar or multi-valued results.
Controlling TransactionsAfter completing students will be able to: Use the EXISTS predicate to efficiently
this module, students will be able to: Filter data with predicates in the WHERE check for the existence of rows in a
Describe transactions and the differences clause. subquery.
between batches and transactions. Sort data using ORDER BY. Using Common Table Expressions
Describe batches and how they are handled Filter data in the SELECT clause with Using Views
by SQL Server. TOP. Using Inline Table-Valued FunctionsAfter
Create and manage transactions with Filter data with OFFSET and FETCH. completing this module, students will be
transaction control language statements. Working with Character Data able to:
Use SET XACT_ABORT to define SQL Working with Date and Time DataAfter Write queries which use derived tables.
Server's handling of transactions outside completing this module, students will be Write queries which use common table
TRY / CATCH blocks. able to: expressions.
Displaying Query Performance DataAfter Describe numeric data types, type Create simple views and write queries
completing this module, students will be able precedence and type conversions. against them.
to: Write queries using character data types. Create simple inline table-valued functions
Describe components of well-performing Write queries using date and time data and write queries against them.
queries. types. Using EXCEPT and INTERSECT
Describe the role of indexes and statistics in Using Conversion Functions Using APPLYAfter completing this module,
SQL Server Using Logical Functions students will be able to:
Display and interpret basic query plans Using Functions to Work with NULLAfter Write queries which combine data using
Display and interpret basic query completing this module, students will be the UNION operator
performance data able to: Write queries which compare sets using
Write queries with built-in scalar the INTERSECT and EXCEPT operators
functions. Write queries which manipulate rows in a
line Use conversion functions. table by using APPLY with the results of a
Getting Started with SQL Server Use logical functions. derived table or function
Management Studio Use functions that work with NULL. Exploring Window Functions
Work with SQL Server Management Studio. Using the GROUP BY Clause Restrict window functions to rows defined
Working with SQL AzureAfter completing Filtering Groups with HAVINGAfter in an OVER clause, including partitions
this module, students will be able to: completing this module, students will be and frames.
Describe the basic features of SQL Azure. able to: Write queries which use window functions
Provision a SQL Azure server and configure Write queries which summarize data to operate on a window of rows and return
its security. using built-in aggregate functions. ranking, aggregation and offset
Understanding Sets Use the GROUP BY clause to arrange comparison results.
Understanding Predicate Logic rows into groups. Working with Grouping SetsAfter

Understanding the Logical Order of Use the HAVING clause to filter out completing this module, students will be
Operations in SELECT statementsAfter groups based on a search condition. able to:
completing this module, students will be able Writing Correlated Subqueries Write queries which pivot and unpivot
to: Using the EXISTS Predicate with result sets
Describe the elements of T-SQL and their SubqueriesAfter completing this module, Write queries which specify multiple
role in writing queries students will be able to: groupings with grouping sets
Describe the use of sets in SQL Server Describe the uses of queries which are Executing System Stored Procedures
Describe the use of predicate logic in SQL nested within other queries. Querying Dynamic Management
Server Write self-contained subqueries which ObjectsAfter completing this module,
Describe the logical order of operations in return scalar or multi-valued results. students will be able to:
SELECT statements Write correlated subqueries which return Write queries that retrieve system
Eliminating Duplicates with DISTINCT scalar or multi-valued results. metadata using system views and
Using Column and Table Aliases Use the EXISTS predicate to efficiently functions.
Writing Simple CASE Expressions check for the existence of rows in a Execute system stored procedures to
Eliminate duplicates using the DISTINCT subquery. return system information.
clause. Using Common Table Expressions Write queries that retrieve system
Use column and table aliases. Using Views metadata and state information using
Write simple CASE expressions. Using Inline Table-Valued FunctionsAfter system dynamic management views and
Querying with Inner Joins completing this module, students will be functions.
Querying with Outer Joins able to: Passing Parameters to Stored Procedures
Querying with Cross Joins and Self Write queries which use derived tables. Creating Simple Stored Procedures
JoinsAfter completing this module, students Write queries which use common table Working with Dynamic SQLAfter
will be able to: expressions. completing this module, students will be
Describe how multiple tables may be Create simple views and write queries able to:
queried in a SELECT statement using joins. against them. Return results by executing stored
Write queries that use inner joins. Create simple inline table-valued procedures.
Write queries that use outer joins. functions and write queries against them. Pass parameters to procedures.
Write queries that use self-joins and cross Using EXCEPT and INTERSECT Create simple stored procedures which
joins. Using APPLYAfter completing this encapsulate a SELECT statement.
Filtering Data with a WHERE Clause module, students will be able to: Construct and execute dynamic SQL with
Filtering with the TOP and OFFSET-FETCH Write queries which combine data using EXEC and sp_executesql.
Options the UNION operator Controlling Program FlowAfter completing
Working with Unknown and Missing Write queries which compare sets using this module, students will be able to:
ValuesAfter completing this module, the INTERSECT and EXCEPT operators Describe the language elements of T-SQL
students will be able to: Write queries which manipulate rows in a used for simple programming tasks.
Filter data with predicates in the WHERE table by using APPLY with the results of Describe batches and how they are
clause. a derived table or function handled by SQL Server.
Sort data using ORDER BY. Exploring Window Functions Declare and assign variables and
Filter data in the SELECT clause with TOP. Restrict window functions to rows defined synonyms.
Filter data with OFFSET and FETCH. in an OVER clause, including partitions Use IF and WHILE blocks to control
Working with Character Data and frames. program flow.
Working with Date and Time DataAfter Write queries which use window Working with Error InformationAfter
completing this module, students will be able functions to operate on a window of rows completing this module, students will be
to: and return ranking, aggregation and able to:
Describe numeric data types, type offset comparison results. Describe SQL Server's behavior when
precedence and type conversions. Working with Grouping SetsAfter errors occur in T-SQL code.
Write queries using character data types. completing this module, students will be Implement structured exception handling in
Write queries using date and time data able to: T-SQL.
types. Write queries which pivot and unpivot Return information about errors from
Using Conversion Functions result sets system objects.
Using Logical Functions Write queries which specify multiple Raise user-defined errors and pass system
Using Functions to Work with NULLAfter groupings with grouping sets errors in T-SQL code.
completing this module, students will be able Executing System Stored Procedures Controlling TransactionsAfter completing
to: Querying Dynamic Management this module, students will be able to:
Write queries with built-in scalar functions. ObjectsAfter completing this module, Describe transactions and the differences
Use conversion functions. students will be able to: between batches and transactions.
Use logical functions. Write queries that retrieve system Describe batches and how they are
Use functions that work with NULL. metadata using system views and handled by SQL Server.
Using the GROUP BY Clause functions. Create and manage transactions with
Filtering Groups with HAVINGAfter Execute system stored procedures to transaction control language statements.
completing this module, students will be able return system information. Use SET XACT_ABORT to define SQL
to: Write queries that retrieve system Server's handling of transactions outside
Write queries which summarize data using metadata and state information using TRY / CATCH blocks.
built-in aggregate functions. system dynamic management views and Displaying Query Performance DataAfter
Use the GROUP BY clause to arrange rows functions. completing this module, students will be
into groups. Passing Parameters to Stored able to:

Use the HAVING clause to filter out groups Procedures Describe components of well-performing
based on a search condition. Creating Simple Stored Procedures queries.
Writing Correlated Subqueries Working with Dynamic SQLAfter Describe the role of indexes and statistics
Using the EXISTS Predicate with completing this module, students will be in SQL Server
SubqueriesAfter completing this module, able to: Display and interpret basic query plans
students will be able to: Return results by executing stored Display and interpret basic query
Describe the uses of queries which are procedures. performance data
nested within other queries. Pass parameters to procedures.
Write self-contained subqueries which return Create simple stored procedures which
scalar or multi-valued results. encapsulate a SELECT statement. line
Write correlated subqueries which return Construct and execute dynamic SQL with Getting Started with SQL Server
scalar or multi-valued results. EXEC and sp_executesql. Management Studio
Use the EXISTS predicate to efficiently Controlling Program FlowAfter Work with SQL Server Management
check for the existence of rows in a completing this module, students will be Studio.
subquery. able to: Working with SQL AzureAfter completing
Using Common Table Expressions Describe the language elements of this module, students will be able to:
Using Views T-SQL used for simple programming Describe the basic features of SQL Azure.
Using Inline Table-Valued FunctionsAfter tasks. Provision a SQL Azure server and
completing this module, students will be able Describe batches and how they are configure its security.
to: handled by SQL Server. Understanding Sets
Write queries which use derived tables. Declare and assign variables and Understanding Predicate Logic
Write queries which use common table synonyms. Understanding the Logical Order of
expressions. Use IF and WHILE blocks to control Operations in SELECT statementsAfter
Create simple views and write queries program flow. completing this module, students will be
against them. Working with Error InformationAfter able to:
Create simple inline table-valued functions completing this module, students will be Describe the elements of T-SQL and their
and write queries against them. able to: role in writing queries
Using EXCEPT and INTERSECT Describe SQL Server's behavior when Describe the use of sets in SQL Server
Using APPLYAfter completing this module, errors occur in T-SQL code. Describe the use of predicate logic in SQL
students will be able to: Implement structured exception handling Server
Write queries which combine data using the in T-SQL. Describe the logical order of operations in
UNION operator Return information about errors from SELECT statements
Write queries which compare sets using the system objects. Eliminating Duplicates with DISTINCT
INTERSECT and EXCEPT operators Raise user-defined errors and pass Using Column and Table Aliases
Write queries which manipulate rows in a system errors in T-SQL code. Writing Simple CASE Expressions
table by using APPLY with the results of a Controlling TransactionsAfter completing Eliminate duplicates using the DISTINCT
derived table or function this module, students will be able to: clause.
Exploring Window Functions Describe transactions and the differences Use column and table aliases.
Restrict window functions to rows defined in between batches and transactions. Write simple CASE expressions.
an OVER clause, including partitions and Describe batches and how they are Querying with Inner Joins
frames. handled by SQL Server. Querying with Outer Joins
Write queries which use window functions to Create and manage transactions with Querying with Cross Joins and Self
operate on a window of rows and return transaction control language statements. JoinsAfter completing this module,
ranking, aggregation and offset comparison Use SET XACT_ABORT to define SQL students will be able to:
results. Server's handling of transactions outside Describe how multiple tables may be
Working with Grouping SetsAfter completing TRY / CATCH blocks. queried in a SELECT statement using
this module, students will be able to: Displaying Query Performance DataAfter joins.
Write queries which pivot and unpivot result completing this module, students will be Write queries that use inner joins.
sets able to: Write queries that use outer joins.
Write queries which specify multiple Describe components of well-performing Write queries that use self-joins and cross
groupings with grouping sets queries. joins.
Executing System Stored Procedures Describe the role of indexes and statistics Filtering Data with a WHERE Clause
Querying Dynamic Management in SQL Server Filtering with the TOP and
ObjectsAfter completing this module, Display and interpret basic query plans OFFSET-FETCH Options
students will be able to: Display and interpret basic query Working with Unknown and Missing
Write queries that retrieve system metadata performance data ValuesAfter completing this module,
using system views and functions. students will be able to:
Execute system stored procedures to return Filter data with predicates in the WHERE
system information. line clause.
Write queries that retrieve system metadata Getting Started with SQL Server Sort data using ORDER BY.
and state information using system dynamic Management Studio Filter data in the SELECT clause with
management views and functions. Work with SQL Server Management TOP.
Passing Parameters to Stored Procedures Studio. Filter data with OFFSET and FETCH.
Creating Simple Stored Procedures Working with SQL AzureAfter completing Working with Character Data
Working with Dynamic SQLAfter completing this module, students will be able to: Working with Date and Time DataAfter
this module, students will be able to: Describe the basic features of SQL completing this module, students will be

Return results by executing stored Azure. able to:
procedures. Provision a SQL Azure server and Describe numeric data types, type
Pass parameters to procedures. configure its security. precedence and type conversions.
Create simple stored procedures which Understanding Sets Write queries using character data types.
encapsulate a SELECT statement. Understanding Predicate Logic Write queries using date and time data
Construct and execute dynamic SQL with Understanding the Logical Order of types.
EXEC and sp_executesql. Operations in SELECT statementsAfter Using Conversion Functions
Controlling Program FlowAfter completing completing this module, students will be Using Logical Functions
this module, students will be able to: able to: Using Functions to Work with NULLAfter
Describe the language elements of T-SQL Describe the elements of T-SQL and their completing this module, students will be
used for simple programming tasks. role in writing queries able to:
Describe batches and how they are handled Describe the use of sets in SQL Server Write queries with built-in scalar functions.
by SQL Server. Describe the use of predicate logic in Use conversion functions.
Declare and assign variables and synonyms. SQL Server Use logical functions.
Use IF and WHILE blocks to control Describe the logical order of operations in Use functions that work with NULL.
program flow. SELECT statements Using the GROUP BY Clause
Working with Error InformationAfter Eliminating Duplicates with DISTINCT Filtering Groups with HAVINGAfter
completing this module, students will be able Using Column and Table Aliases completing this module, students will be
to: Writing Simple CASE Expressions able to:
Describe SQL Server's behavior when errors Eliminate duplicates using the DISTINCT Write queries which summarize data using
occur in T-SQL code. clause. built-in aggregate functions.
Implement structured exception handling in Use column and table aliases. Use the GROUP BY clause to arrange
T-SQL. Write simple CASE expressions. rows into groups.
Return information about errors from system Querying with Inner Joins Use the HAVING clause to filter out groups
objects. Querying with Outer Joins based on a search condition.
Raise user-defined errors and pass system Querying with Cross Joins and Self Writing Correlated Subqueries
errors in T-SQL code. JoinsAfter completing this module, Using the EXISTS Predicate with
Controlling TransactionsAfter completing students will be able to: SubqueriesAfter completing this module,
this module, students will be able to: Describe how multiple tables may be students will be able to:
Describe transactions and the differences queried in a SELECT statement using Describe the uses of queries which are
between batches and transactions. joins. nested within other queries.
Describe batches and how they are handled Write queries that use inner joins. Write self-contained subqueries which
by SQL Server. Write queries that use outer joins. return scalar or multi-valued results.
Create and manage transactions with Write queries that use self-joins and Write correlated subqueries which return
transaction control language statements. cross joins. scalar or multi-valued results.
Use SET XACT_ABORT to define SQL Filtering Data with a WHERE Clause Use the EXISTS predicate to efficiently
Server's handling of transactions outside Filtering with the TOP and check for the existence of rows in a
TRY / CATCH blocks. OFFSET-FETCH Options subquery.
Displaying Query Performance DataAfter Working with Unknown and Missing Using Common Table Expressions
completing this module, students will be able ValuesAfter completing this module, Using Views
to: students will be able to: Using Inline Table-Valued FunctionsAfter
Describe components of well-performing Filter data with predicates in the WHERE completing this module, students will be
queries. clause. able to:
Describe the role of indexes and statistics in Sort data using ORDER BY. Write queries which use derived tables.
SQL Server Filter data in the SELECT clause with Write queries which use common table
Display and interpret basic query plans TOP. expressions.
Display and interpret basic query Filter data with OFFSET and FETCH. Create simple views and write queries
performance data Working with Character Data against them.
Working with Date and Time DataAfter Create simple inline table-valued functions
After completing this module, students will be completing this module, students will be and write queries against them.
able to: able to: Using EXCEPT and INTERSECT
line Describe numeric data types, type Using APPLYAfter completing this module,
Write simple SELECT statements. precedence and type conversions. students will be able to:
Write queries using character data types. Write queries which combine data using
Write queries using date and time data the UNION operator
line types. Write queries which compare sets using
Getting Started with SQL Server Using Conversion Functions the INTERSECT and EXCEPT operators
Management Studio Using Logical Functions Write queries which manipulate rows in a
Work with SQL Server Management Studio. Using Functions to Work with NULLAfter table by using APPLY with the results of a
Working with SQL AzureAfter completing completing this module, students will be derived table or function
this module, students will be able to: able to: Exploring Window Functions
Describe the basic features of SQL Azure. Write queries with built-in scalar Restrict window functions to rows defined
Provision a SQL Azure server and configure functions. in an OVER clause, including partitions
its security. Use conversion functions. and frames.
Understanding Sets Use logical functions. Write queries which use window functions
Understanding Predicate Logic Use functions that work with NULL. to operate on a window of rows and return

Understanding the Logical Order of Using the GROUP BY Clause ranking, aggregation and offset
Operations in SELECT statementsAfter Filtering Groups with HAVINGAfter comparison results.
completing this module, students will be able completing this module, students will be Working with Grouping SetsAfter
to: able to: completing this module, students will be
Describe the elements of T-SQL and their Write queries which summarize data able to:
role in writing queries using built-in aggregate functions. Write queries which pivot and unpivot
Describe the use of sets in SQL Server Use the GROUP BY clause to arrange result sets
Describe the use of predicate logic in SQL rows into groups. Write queries which specify multiple
Server Use the HAVING clause to filter out groupings with grouping sets
Describe the logical order of operations in groups based on a search condition. Executing System Stored Procedures
SELECT statements Writing Correlated Subqueries Querying Dynamic Management
Eliminating Duplicates with DISTINCT Using the EXISTS Predicate with ObjectsAfter completing this module,
Using Column and Table Aliases SubqueriesAfter completing this module, students will be able to:
Writing Simple CASE Expressions students will be able to: Write queries that retrieve system
Eliminate duplicates using the DISTINCT Describe the uses of queries which are metadata using system views and
clause. nested within other queries. functions.
Use column and table aliases. Write self-contained subqueries which Execute system stored procedures to
Write simple CASE expressions. return scalar or multi-valued results. return system information.
Querying with Inner Joins Write correlated subqueries which return Write queries that retrieve system
Querying with Outer Joins scalar or multi-valued results. metadata and state information using
Querying with Cross Joins and Self Use the EXISTS predicate to efficiently system dynamic management views and
JoinsAfter completing this module, students check for the existence of rows in a functions.
will be able to: subquery. Passing Parameters to Stored Procedures
Describe how multiple tables may be Using Common Table Expressions Creating Simple Stored Procedures
queried in a SELECT statement using joins. Using Views Working with Dynamic SQLAfter
Write queries that use inner joins. Using Inline Table-Valued FunctionsAfter completing this module, students will be
Write queries that use outer joins. completing this module, students will be able to:
Write queries that use self-joins and cross able to: Return results by executing stored
joins. Write queries which use derived tables. procedures.
Filtering Data with a WHERE Clause Write queries which use common table Pass parameters to procedures.
Filtering with the TOP and OFFSET-FETCH expressions. Create simple stored procedures which
Options Create simple views and write queries encapsulate a SELECT statement.
Working with Unknown and Missing against them. Construct and execute dynamic SQL with
ValuesAfter completing this module, Create simple inline table-valued EXEC and sp_executesql.
students will be able to: functions and write queries against them. Controlling Program FlowAfter completing
Filter data with predicates in the WHERE Using EXCEPT and INTERSECT this module, students will be able to:
clause. Using APPLYAfter completing this Describe the language elements of T-SQL
Sort data using ORDER BY. module, students will be able to: used for simple programming tasks.
Filter data in the SELECT clause with TOP. Write queries which combine data using Describe batches and how they are
Filter data with OFFSET and FETCH. the UNION operator handled by SQL Server.
Working with Character Data Write queries which compare sets using Declare and assign variables and
Working with Date and Time DataAfter the INTERSECT and EXCEPT operators synonyms.
completing this module, students will be able Write queries which manipulate rows in a Use IF and WHILE blocks to control
to: table by using APPLY with the results of program flow.
Describe numeric data types, type a derived table or function Working with Error InformationAfter
precedence and type conversions. Exploring Window Functions completing this module, students will be
Write queries using character data types. Restrict window functions to rows defined able to:
Write queries using date and time data in an OVER clause, including partitions Describe SQL Server's behavior when
types. and frames. errors occur in T-SQL code.
Using Conversion Functions Write queries which use window Implement structured exception handling in
Using Logical Functions functions to operate on a window of rows T-SQL.
Using Functions to Work with NULLAfter and return ranking, aggregation and Return information about errors from
completing this module, students will be able offset comparison results. system objects.
to: Working with Grouping SetsAfter Raise user-defined errors and pass system
Write queries with built-in scalar functions. completing this module, students will be errors in T-SQL code.
Use conversion functions. able to: Controlling TransactionsAfter completing
Use logical functions. Write queries which pivot and unpivot this module, students will be able to:
Use functions that work with NULL. result sets Describe transactions and the differences
Using the GROUP BY Clause Write queries which specify multiple between batches and transactions.
Filtering Groups with HAVINGAfter groupings with grouping sets Describe batches and how they are
completing this module, students will be able Executing System Stored Procedures handled by SQL Server.
to: Querying Dynamic Management Create and manage transactions with
Write queries which summarize data using ObjectsAfter completing this module, transaction control language statements.
built-in aggregate functions. students will be able to: Use SET XACT_ABORT to define SQL
Use the GROUP BY clause to arrange rows Write queries that retrieve system Server's handling of transactions outside
into groups. metadata using system views and TRY / CATCH blocks.

Use the HAVING clause to filter out groups functions. Displaying Query Performance DataAfter
based on a search condition. Execute system stored procedures to completing this module, students will be
Writing Correlated Subqueries return system information. able to:
Using the EXISTS Predicate with Write queries that retrieve system Describe components of well-performing
SubqueriesAfter completing this module, metadata and state information using queries.
students will be able to: system dynamic management views and Describe the role of indexes and statistics
Describe the uses of queries which are functions. in SQL Server
nested within other queries. Passing Parameters to Stored Display and interpret basic query plans
Write self-contained subqueries which return Procedures Display and interpret basic query
scalar or multi-valued results. Creating Simple Stored Procedures performance data
Write correlated subqueries which return Working with Dynamic SQLAfter
scalar or multi-valued results. completing this module, students will be Module 17: Programming with T-SQL
Use the EXISTS predicate to efficiently able to: line
check for the existence of rows in a Return results by executing stored
subquery. procedures. This module provides a basic introduction to
Using Common Table Expressions Pass parameters to procedures. T-SQL programming concepts and objects. It
Using Views Create simple stored procedures which discusses batches, variables, control of flow
Using Inline Table-Valued FunctionsAfter encapsulate a SELECT statement. elements such as loops and conditionals, how
completing this module, students will be able Construct and execute dynamic SQL with to create and execute dynamic SQL
to: EXEC and sp_executesql. statements, and how to use synonyms.
Write queries which use derived tables. Controlling Program FlowAfter line
Write queries which use common table completing this module, students will be T-SQL Programming Elements
expressions. able to:
Create simple views and write queries Describe the language elements of
against them. T-SQL used for simple programming line
Create simple inline table-valued functions tasks. Getting Started with SQL Server
and write queries against them. Describe batches and how they are Management Studio
Using EXCEPT and INTERSECT handled by SQL Server. Work with SQL Server Management
Using APPLYAfter completing this module, Declare and assign variables and Studio.
students will be able to: synonyms. Working with SQL AzureAfter completing
Write queries which combine data using the Use IF and WHILE blocks to control this module, students will be able to:
UNION operator program flow. Describe the basic features of SQL Azure.
Write queries which compare sets using the Working with Error InformationAfter Provision a SQL Azure server and
INTERSECT and EXCEPT operators completing this module, students will be configure its security.
Write queries which manipulate rows in a able to: Understanding Sets
table by using APPLY with the results of a Describe SQL Server's behavior when Understanding Predicate Logic
derived table or function errors occur in T-SQL code. Understanding the Logical Order of
Exploring Window Functions Implement structured exception handling Operations in SELECT statementsAfter
Restrict window functions to rows defined in in T-SQL. completing this module, students will be
an OVER clause, including partitions and Return information about errors from able to:
frames. system objects. Describe the elements of T-SQL and their
Write queries which use window functions to Raise user-defined errors and pass role in writing queries
operate on a window of rows and return system errors in T-SQL code. Describe the use of sets in SQL Server
ranking, aggregation and offset comparison Controlling TransactionsAfter completing Describe the use of predicate logic in SQL
results. this module, students will be able to: Server
Working with Grouping SetsAfter completing Describe transactions and the differences Describe the logical order of operations in
this module, students will be able to: between batches and transactions. SELECT statements
Write queries which pivot and unpivot result Describe batches and how they are Eliminating Duplicates with DISTINCT
sets handled by SQL Server. Using Column and Table Aliases
Write queries which specify multiple Create and manage transactions with Writing Simple CASE Expressions
groupings with grouping sets transaction control language statements. Eliminate duplicates using the DISTINCT
Executing System Stored Procedures Use SET XACT_ABORT to define SQL clause.
Querying Dynamic Management Server's handling of transactions outside Use column and table aliases.
ObjectsAfter completing this module, TRY / CATCH blocks. Write simple CASE expressions.
students will be able to: Displaying Query Performance DataAfter Querying with Inner Joins
Write queries that retrieve system metadata completing this module, students will be Querying with Outer Joins
using system views and functions. able to: Querying with Cross Joins and Self
Execute system stored procedures to return Describe components of well-performing JoinsAfter completing this module,
system information. queries. students will be able to:
Write queries that retrieve system metadata Describe the role of indexes and statistics Describe how multiple tables may be
and state information using system dynamic in SQL Server queried in a SELECT statement using
management views and functions. Display and interpret basic query plans joins.
Passing Parameters to Stored Procedures Display and interpret basic query Write queries that use inner joins.
Creating Simple Stored Procedures performance data Write queries that use outer joins.
Working with Dynamic SQLAfter completing Write queries that use self-joins and cross
this module, students will be able to: joins.

Return results by executing stored line Filtering Data with a WHERE Clause
procedures. Getting Started with SQL Server Filtering with the TOP and
Pass parameters to procedures. Management Studio OFFSET-FETCH Options
Create simple stored procedures which Work with SQL Server Management Working with Unknown and Missing
encapsulate a SELECT statement. Studio. ValuesAfter completing this module,
Construct and execute dynamic SQL with Working with SQL AzureAfter completing students will be able to:
EXEC and sp_executesql. this module, students will be able to: Filter data with predicates in the WHERE
Controlling Program FlowAfter completing Describe the basic features of SQL clause.
this module, students will be able to: Azure. Sort data using ORDER BY.
Describe the language elements of T-SQL Provision a SQL Azure server and Filter data in the SELECT clause with
used for simple programming tasks. configure its security. TOP.
Describe batches and how they are handled Understanding Sets Filter data with OFFSET and FETCH.
by SQL Server. Understanding Predicate Logic Working with Character Data
Declare and assign variables and synonyms. Understanding the Logical Order of Working with Date and Time DataAfter
Use IF and WHILE blocks to control Operations in SELECT statementsAfter completing this module, students will be
program flow. completing this module, students will be able to:
Working with Error InformationAfter able to: Describe numeric data types, type
completing this module, students will be able Describe the elements of T-SQL and their precedence and type conversions.
to: role in writing queries Write queries using character data types.
Describe SQL Server's behavior when errors Describe the use of sets in SQL Server Write queries using date and time data
occur in T-SQL code. Describe the use of predicate logic in types.
Implement structured exception handling in SQL Server Using Conversion Functions
T-SQL. Describe the logical order of operations in Using Logical Functions
Return information about errors from system SELECT statements Using Functions to Work with NULLAfter
objects. Eliminating Duplicates with DISTINCT completing this module, students will be
Raise user-defined errors and pass system Using Column and Table Aliases able to:
errors in T-SQL code. Writing Simple CASE Expressions Write queries with built-in scalar functions.
Controlling TransactionsAfter completing Eliminate duplicates using the DISTINCT Use conversion functions.
this module, students will be able to: clause. Use logical functions.
Describe transactions and the differences Use column and table aliases. Use functions that work with NULL.
between batches and transactions. Write simple CASE expressions. Using the GROUP BY Clause
Describe batches and how they are handled Querying with Inner Joins Filtering Groups with HAVINGAfter
by SQL Server. Querying with Outer Joins completing this module, students will be
Create and manage transactions with Querying with Cross Joins and Self able to:
transaction control language statements. JoinsAfter completing this module, Write queries which summarize data using
Use SET XACT_ABORT to define SQL students will be able to: built-in aggregate functions.
Server's handling of transactions outside Describe how multiple tables may be Use the GROUP BY clause to arrange
TRY / CATCH blocks. queried in a SELECT statement using rows into groups.
Displaying Query Performance DataAfter joins. Use the HAVING clause to filter out groups
completing this module, students will be able Write queries that use inner joins. based on a search condition.
to: Write queries that use outer joins. Writing Correlated Subqueries
Describe components of well-performing Write queries that use self-joins and Using the EXISTS Predicate with
queries. cross joins. SubqueriesAfter completing this module,
Describe the role of indexes and statistics in Filtering Data with a WHERE Clause students will be able to:
SQL Server Filtering with the TOP and Describe the uses of queries which are
Display and interpret basic query plans OFFSET-FETCH Options nested within other queries.
Display and interpret basic query Working with Unknown and Missing Write self-contained subqueries which
performance data ValuesAfter completing this module, return scalar or multi-valued results.
students will be able to: Write correlated subqueries which return
Filter data with predicates in the WHERE scalar or multi-valued results.
line clause. Use the EXISTS predicate to efficiently
Getting Started with SQL Server Sort data using ORDER BY. check for the existence of rows in a
Management Studio Filter data in the SELECT clause with subquery.
Work with SQL Server Management Studio. TOP. Using Common Table Expressions
Working with SQL AzureAfter completing Filter data with OFFSET and FETCH. Using Views
this module, students will be able to: Working with Character Data Using Inline Table-Valued FunctionsAfter
Describe the basic features of SQL Azure. Working with Date and Time DataAfter completing this module, students will be
Provision a SQL Azure server and configure completing this module, students will be able to:
its security. able to: Write queries which use derived tables.
Understanding Sets Describe numeric data types, type Write queries which use common table
Understanding Predicate Logic precedence and type conversions. expressions.
Understanding the Logical Order of Write queries using character data types. Create simple views and write queries
Operations in SELECT statementsAfter Write queries using date and time data against them.
completing this module, students will be able types. Create simple inline table-valued functions
to: Using Conversion Functions and write queries against them.
Describe the elements of T-SQL and their Using Logical Functions Using EXCEPT and INTERSECT

role in writing queries Using Functions to Work with NULLAfter Using APPLYAfter completing this module,
Describe the use of sets in SQL Server completing this module, students will be students will be able to:
Describe the use of predicate logic in SQL able to: Write queries which combine data using
Server Write queries with built-in scalar the UNION operator
Describe the logical order of operations in functions. Write queries which compare sets using
SELECT statements Use conversion functions. the INTERSECT and EXCEPT operators
Eliminating Duplicates with DISTINCT Use logical functions. Write queries which manipulate rows in a
Using Column and Table Aliases Use functions that work with NULL. table by using APPLY with the results of a
Writing Simple CASE Expressions Using the GROUP BY Clause derived table or function
Eliminate duplicates using the DISTINCT Filtering Groups with HAVINGAfter Exploring Window Functions
clause. completing this module, students will be Restrict window functions to rows defined
Use column and table aliases. able to: in an OVER clause, including partitions
Write simple CASE expressions. Write queries which summarize data and frames.
Querying with Inner Joins using built-in aggregate functions. Write queries which use window functions
Querying with Outer Joins Use the GROUP BY clause to arrange to operate on a window of rows and return
Querying with Cross Joins and Self rows into groups. ranking, aggregation and offset
JoinsAfter completing this module, students Use the HAVING clause to filter out comparison results.
will be able to: groups based on a search condition. Working with Grouping SetsAfter
Describe how multiple tables may be Writing Correlated Subqueries completing this module, students will be
queried in a SELECT statement using joins. Using the EXISTS Predicate with able to:
Write queries that use inner joins. SubqueriesAfter completing this module, Write queries which pivot and unpivot
Write queries that use outer joins. students will be able to: result sets
Write queries that use self-joins and cross Describe the uses of queries which are Write queries which specify multiple
joins. nested within other queries. groupings with grouping sets
Filtering Data with a WHERE Clause Write self-contained subqueries which Executing System Stored Procedures
Filtering with the TOP and OFFSET-FETCH return scalar or multi-valued results. Querying Dynamic Management
Options Write correlated subqueries which return ObjectsAfter completing this module,
Working with Unknown and Missing scalar or multi-valued results. students will be able to:
ValuesAfter completing this module, Use the EXISTS predicate to efficiently Write queries that retrieve system
students will be able to: check for the existence of rows in a metadata using system views and
Filter data with predicates in the WHERE subquery. functions.
clause. Using Common Table Expressions Execute system stored procedures to
Sort data using ORDER BY. Using Views return system information.
Filter data in the SELECT clause with TOP. Using Inline Table-Valued FunctionsAfter Write queries that retrieve system
Filter data with OFFSET and FETCH. completing this module, students will be metadata and state information using
Working with Character Data able to: system dynamic management views and
Working with Date and Time DataAfter Write queries which use derived tables. functions.
completing this module, students will be able Write queries which use common table Passing Parameters to Stored Procedures
to: expressions. Creating Simple Stored Procedures
Describe numeric data types, type Create simple views and write queries Working with Dynamic SQLAfter
precedence and type conversions. against them. completing this module, students will be
Write queries using character data types. Create simple inline table-valued able to:
Write queries using date and time data functions and write queries against them. Return results by executing stored
types. Using EXCEPT and INTERSECT procedures.
Using Conversion Functions Using APPLYAfter completing this Pass parameters to procedures.
Using Logical Functions module, students will be able to: Create simple stored procedures which
Using Functions to Work with NULLAfter Write queries which combine data using encapsulate a SELECT statement.
completing this module, students will be able the UNION operator Construct and execute dynamic SQL with
to: Write queries which compare sets using EXEC and sp_executesql.
Write queries with built-in scalar functions. the INTERSECT and EXCEPT operators Controlling Program FlowAfter completing
Use conversion functions. Write queries which manipulate rows in a this module, students will be able to:
Use logical functions. table by using APPLY with the results of Describe the language elements of T-SQL
Use functions that work with NULL. a derived table or function used for simple programming tasks.
Using the GROUP BY Clause Exploring Window Functions Describe batches and how they are
Filtering Groups with HAVINGAfter Restrict window functions to rows defined handled by SQL Server.
completing this module, students will be able in an OVER clause, including partitions Declare and assign variables and
to: and frames. synonyms.
Write queries which summarize data using Write queries which use window Use IF and WHILE blocks to control
built-in aggregate functions. functions to operate on a window of rows program flow.
Use the GROUP BY clause to arrange rows and return ranking, aggregation and Working with Error InformationAfter
into groups. offset comparison results. completing this module, students will be
Use the HAVING clause to filter out groups Working with Grouping SetsAfter able to:
based on a search condition. completing this module, students will be Describe SQL Server's behavior when
Writing Correlated Subqueries able to: errors occur in T-SQL code.
Using the EXISTS Predicate with Write queries which pivot and unpivot Implement structured exception handling in
SubqueriesAfter completing this module, result sets T-SQL.

students will be able to: Write queries which specify multiple Return information about errors from
Describe the uses of queries which are groupings with grouping sets system objects.
nested within other queries. Executing System Stored Procedures Raise user-defined errors and pass system
Write self-contained subqueries which return Querying Dynamic Management errors in T-SQL code.
scalar or multi-valued results. ObjectsAfter completing this module, Controlling TransactionsAfter completing
Write correlated subqueries which return students will be able to: this module, students will be able to:
scalar or multi-valued results. Write queries that retrieve system Describe transactions and the differences
Use the EXISTS predicate to efficiently metadata using system views and between batches and transactions.
check for the existence of rows in a functions. Describe batches and how they are
subquery. Execute system stored procedures to handled by SQL Server.
Using Common Table Expressions return system information. Create and manage transactions with
Using Views Write queries that retrieve system transaction control language statements.
Using Inline Table-Valued FunctionsAfter metadata and state information using Use SET XACT_ABORT to define SQL
completing this module, students will be able system dynamic management views and Server's handling of transactions outside
to: functions. TRY / CATCH blocks.
Write queries which use derived tables. Passing Parameters to Stored Displaying Query Performance DataAfter
Write queries which use common table Procedures completing this module, students will be
expressions. Creating Simple Stored Procedures able to:
Create simple views and write queries Working with Dynamic SQLAfter Describe components of well-performing
against them. completing this module, students will be queries.
Create simple inline table-valued functions able to: Describe the role of indexes and statistics
and write queries against them. Return results by executing stored in SQL Server
Using EXCEPT and INTERSECT procedures. Display and interpret basic query plans
Using APPLYAfter completing this module, Pass parameters to procedures. Display and interpret basic query
students will be able to: Create simple stored procedures which performance data
Write queries which combine data using the encapsulate a SELECT statement.
UNION operator Construct and execute dynamic SQL with
Write queries which compare sets using the EXEC and sp_executesql. line
INTERSECT and EXCEPT operators Controlling Program FlowAfter Getting Started with SQL Server
Write queries which manipulate rows in a completing this module, students will be Management Studio
table by using APPLY with the results of a able to: Work with SQL Server Management
derived table or function Describe the language elements of Studio.
Exploring Window Functions T-SQL used for simple programming Working with SQL AzureAfter completing
Restrict window functions to rows defined in tasks. this module, students will be able to:
an OVER clause, including partitions and Describe batches and how they are Describe the basic features of SQL Azure.
frames. handled by SQL Server. Provision a SQL Azure server and
Write queries which use window functions to Declare and assign variables and configure its security.
operate on a window of rows and return synonyms. Understanding Sets
ranking, aggregation and offset comparison Use IF and WHILE blocks to control Understanding Predicate Logic
results. program flow. Understanding the Logical Order of
Working with Grouping SetsAfter completing Working with Error InformationAfter Operations in SELECT statementsAfter
this module, students will be able to: completing this module, students will be completing this module, students will be
Write queries which pivot and unpivot result able to: able to:
sets Describe SQL Server's behavior when Describe the elements of T-SQL and their
Write queries which specify multiple errors occur in T-SQL code. role in writing queries
groupings with grouping sets Implement structured exception handling Describe the use of sets in SQL Server
Executing System Stored Procedures in T-SQL. Describe the use of predicate logic in SQL
Querying Dynamic Management Return information about errors from Server
ObjectsAfter completing this module, system objects. Describe the logical order of operations in
students will be able to: Raise user-defined errors and pass SELECT statements
Write queries that retrieve system metadata system errors in T-SQL code. Eliminating Duplicates with DISTINCT
using system views and functions. Controlling TransactionsAfter completing Using Column and Table Aliases
Execute system stored procedures to return this module, students will be able to: Writing Simple CASE Expressions
system information. Describe transactions and the differences Eliminate duplicates using the DISTINCT
Write queries that retrieve system metadata between batches and transactions. clause.
and state information using system dynamic Describe batches and how they are Use column and table aliases.
management views and functions. handled by SQL Server. Write simple CASE expressions.
Passing Parameters to Stored Procedures Create and manage transactions with Querying with Inner Joins
Creating Simple Stored Procedures transaction control language statements. Querying with Outer Joins
Working with Dynamic SQLAfter completing Use SET XACT_ABORT to define SQL Querying with Cross Joins and Self
this module, students will be able to: Server's handling of transactions outside JoinsAfter completing this module,
Return results by executing stored TRY / CATCH blocks. students will be able to:
procedures. Displaying Query Performance DataAfter Describe how multiple tables may be
Pass parameters to procedures. completing this module, students will be queried in a SELECT statement using
Create simple stored procedures which able to: joins.
encapsulate a SELECT statement. Describe components of well-performing Write queries that use inner joins.

Construct and execute dynamic SQL with queries. Write queries that use outer joins.
EXEC and sp_executesql. Describe the role of indexes and statistics Write queries that use self-joins and cross
Controlling Program FlowAfter completing in SQL Server joins.
this module, students will be able to: Display and interpret basic query plans Filtering Data with a WHERE Clause
Describe the language elements of T-SQL Display and interpret basic query Filtering with the TOP and
used for simple programming tasks. performance data OFFSET-FETCH Options
Describe batches and how they are handled Working with Unknown and Missing
by SQL Server. Module 10: Using Subqueries ValuesAfter completing this module,
Declare and assign variables and synonyms. line students will be able to:
Use IF and WHILE blocks to control Filter data with predicates in the WHERE
program flow. This module will introduce the use of clause.
Working with Error InformationAfter subqueries in various parts of a SELECT Sort data using ORDER BY.
completing this module, students will be able statement. It will include the use of scalar and Filter data in the SELECT clause with
to: multi-result subqueries, and the use of the IN TOP.
Describe SQL Server's behavior when errors and EXISTS operators. Filter data with OFFSET and FETCH.
occur in T-SQL code. line Working with Character Data
Implement structured exception handling in Writing Self-Contained Subqueries Working with Date and Time DataAfter
T-SQL. completing this module, students will be
Return information about errors from system able to:
objects. line Describe numeric data types, type
Raise user-defined errors and pass system Getting Started with SQL Server precedence and type conversions.
errors in T-SQL code. Management Studio Write queries using character data types.
Controlling TransactionsAfter completing Work with SQL Server Management Write queries using date and time data
this module, students will be able to: Studio. types.
Describe transactions and the differences Working with SQL AzureAfter completing Using Conversion Functions
between batches and transactions. this module, students will be able to: Using Logical Functions
Describe batches and how they are handled Describe the basic features of SQL Using Functions to Work with NULLAfter
by SQL Server. Azure. completing this module, students will be
Create and manage transactions with Provision a SQL Azure server and able to:
transaction control language statements. configure its security. Write queries with built-in scalar functions.
Use SET XACT_ABORT to define SQL Understanding Sets Use conversion functions.
Server's handling of transactions outside Understanding Predicate Logic Use logical functions.
TRY / CATCH blocks. Understanding the Logical Order of Use functions that work with NULL.
Displaying Query Performance DataAfter Operations in SELECT statementsAfter Using the GROUP BY Clause
completing this module, students will be able completing this module, students will be Filtering Groups with HAVINGAfter
to: able to: completing this module, students will be
Describe components of well-performing Describe the elements of T-SQL and their able to:
queries. role in writing queries Write queries which summarize data using
Describe the role of indexes and statistics in Describe the use of sets in SQL Server built-in aggregate functions.
SQL Server Describe the use of predicate logic in Use the GROUP BY clause to arrange
Display and interpret basic query plans SQL Server rows into groups.
Display and interpret basic query Describe the logical order of operations in Use the HAVING clause to filter out groups
performance data SELECT statements based on a search condition.
Eliminating Duplicates with DISTINCT Writing Correlated Subqueries
Using Column and Table Aliases Using the EXISTS Predicate with
line Writing Simple CASE Expressions SubqueriesAfter completing this module,
Getting Started with SQL Server Eliminate duplicates using the DISTINCT students will be able to:
Management Studio clause. Describe the uses of queries which are
Work with SQL Server Management Studio. Use column and table aliases. nested within other queries.
Working with SQL AzureAfter completing Write simple CASE expressions. Write self-contained subqueries which
this module, students will be able to: Querying with Inner Joins return scalar or multi-valued results.
Describe the basic features of SQL Azure. Querying with Outer Joins Write correlated subqueries which return
Provision a SQL Azure server and configure Querying with Cross Joins and Self scalar or multi-valued results.
its security. JoinsAfter completing this module, Use the EXISTS predicate to efficiently
Understanding Sets students will be able to: check for the existence of rows in a
Understanding Predicate Logic Describe how multiple tables may be subquery.
Understanding the Logical Order of queried in a SELECT statement using Using Common Table Expressions
Operations in SELECT statementsAfter joins. Using Views
completing this module, students will be able Write queries that use inner joins. Using Inline Table-Valued FunctionsAfter
to: Write queries that use outer joins. completing this module, students will be
Describe the elements of T-SQL and their Write queries that use self-joins and able to:
role in writing queries cross joins. Write queries which use derived tables.
Describe the use of sets in SQL Server Filtering Data with a WHERE Clause Write queries which use common table
Describe the use of predicate logic in SQL Filtering with the TOP and expressions.
Server OFFSET-FETCH Options Create simple views and write queries
Describe the logical order of operations in Working with Unknown and Missing against them.

SELECT statements ValuesAfter completing this module, Create simple inline table-valued functions
Eliminating Duplicates with DISTINCT students will be able to: and write queries against them.
Using Column and Table Aliases Filter data with predicates in the WHERE Using EXCEPT and INTERSECT
Writing Simple CASE Expressions clause. Using APPLYAfter completing this module,
Eliminate duplicates using the DISTINCT Sort data using ORDER BY. students will be able to:
clause. Filter data in the SELECT clause with Write queries which combine data using
Use column and table aliases. TOP. the UNION operator
Write simple CASE expressions. Filter data with OFFSET and FETCH. Write queries which compare sets using
Querying with Inner Joins Working with Character Data the INTERSECT and EXCEPT operators
Querying with Outer Joins Working with Date and Time DataAfter Write queries which manipulate rows in a
Querying with Cross Joins and Self completing this module, students will be table by using APPLY with the results of a
JoinsAfter completing this module, students able to: derived table or function
will be able to: Describe numeric data types, type Exploring Window Functions
Describe how multiple tables may be precedence and type conversions. Restrict window functions to rows defined
queried in a SELECT statement using joins. Write queries using character data types. in an OVER clause, including partitions
Write queries that use inner joins. Write queries using date and time data and frames.
Write queries that use outer joins. types. Write queries which use window functions
Write queries that use self-joins and cross Using Conversion Functions to operate on a window of rows and return
joins. Using Logical Functions ranking, aggregation and offset
Filtering Data with a WHERE Clause Using Functions to Work with NULLAfter comparison results.
Filtering with the TOP and OFFSET-FETCH completing this module, students will be Working with Grouping SetsAfter
Options able to: completing this module, students will be
Working with Unknown and Missing Write queries with built-in scalar able to:
ValuesAfter completing this module, functions. Write queries which pivot and unpivot
students will be able to: Use conversion functions. result sets
Filter data with predicates in the WHERE Use logical functions. Write queries which specify multiple
clause. Use functions that work with NULL. groupings with grouping sets
Sort data using ORDER BY. Using the GROUP BY Clause Executing System Stored Procedures
Filter data in the SELECT clause with TOP. Filtering Groups with HAVINGAfter Querying Dynamic Management
Filter data with OFFSET and FETCH. completing this module, students will be ObjectsAfter completing this module,
Working with Character Data able to: students will be able to:
Working with Date and Time DataAfter Write queries which summarize data Write queries that retrieve system
completing this module, students will be able using built-in aggregate functions. metadata using system views and
to: Use the GROUP BY clause to arrange functions.
Describe numeric data types, type rows into groups. Execute system stored procedures to
precedence and type conversions. Use the HAVING clause to filter out return system information.
Write queries using character data types. groups based on a search condition. Write queries that retrieve system
Write queries using date and time data Writing Correlated Subqueries metadata and state information using
types. Using the EXISTS Predicate with system dynamic management views and
Using Conversion Functions SubqueriesAfter completing this module, functions.
Using Logical Functions students will be able to: Passing Parameters to Stored Procedures
Using Functions to Work with NULLAfter Describe the uses of queries which are Creating Simple Stored Procedures
completing this module, students will be able nested within other queries. Working with Dynamic SQLAfter
to: Write self-contained subqueries which completing this module, students will be
Write queries with built-in scalar functions. return scalar or multi-valued results. able to:
Use conversion functions. Write correlated subqueries which return Return results by executing stored
Use logical functions. scalar or multi-valued results. procedures.
Use functions that work with NULL. Use the EXISTS predicate to efficiently Pass parameters to procedures.
Using the GROUP BY Clause check for the existence of rows in a Create simple stored procedures which
Filtering Groups with HAVINGAfter subquery. encapsulate a SELECT statement.
completing this module, students will be able Using Common Table Expressions Construct and execute dynamic SQL with
to: Using Views EXEC and sp_executesql.
Write queries which summarize data using Using Inline Table-Valued FunctionsAfter Controlling Program FlowAfter completing
built-in aggregate functions. completing this module, students will be this module, students will be able to:
Use the GROUP BY clause to arrange rows able to: Describe the language elements of T-SQL
into groups. Write queries which use derived tables. used for simple programming tasks.
Use the HAVING clause to filter out groups Write queries which use common table Describe batches and how they are
based on a search condition. expressions. handled by SQL Server.
Writing Correlated Subqueries Create simple views and write queries Declare and assign variables and
Using the EXISTS Predicate with against them. synonyms.
SubqueriesAfter completing this module, Create simple inline table-valued Use IF and WHILE blocks to control
students will be able to: functions and write queries against them. program flow.
Describe the uses of queries which are Using EXCEPT and INTERSECT Working with Error InformationAfter
nested within other queries. Using APPLYAfter completing this completing this module, students will be
Write self-contained subqueries which return module, students will be able to: able to:
scalar or multi-valued results. Write queries which combine data using Describe SQL Server's behavior when

Write correlated subqueries which return the UNION operator errors occur in T-SQL code.
scalar or multi-valued results. Write queries which compare sets using Implement structured exception handling in
Use the EXISTS predicate to efficiently the INTERSECT and EXCEPT operators T-SQL.
check for the existence of rows in a Write queries which manipulate rows in a Return information about errors from
subquery. table by using APPLY with the results of system objects.
Using Common Table Expressions a derived table or function Raise user-defined errors and pass system
Using Views Exploring Window Functions errors in T-SQL code.
Using Inline Table-Valued FunctionsAfter Restrict window functions to rows defined Controlling TransactionsAfter completing
completing this module, students will be able in an OVER clause, including partitions this module, students will be able to:
to: and frames. Describe transactions and the differences
Write queries which use derived tables. Write queries which use window between batches and transactions.
Write queries which use common table functions to operate on a window of rows Describe batches and how they are
expressions. and return ranking, aggregation and handled by SQL Server.
Create simple views and write queries offset comparison results. Create and manage transactions with
against them. Working with Grouping SetsAfter transaction control language statements.
Create simple inline table-valued functions completing this module, students will be Use SET XACT_ABORT to define SQL
and write queries against them. able to: Server's handling of transactions outside
Using EXCEPT and INTERSECT Write queries which pivot and unpivot TRY / CATCH blocks.
Using APPLYAfter completing this module, result sets Displaying Query Performance DataAfter
students will be able to: Write queries which specify multiple completing this module, students will be
Write queries which combine data using the groupings with grouping sets able to:
UNION operator Executing System Stored Procedures Describe components of well-performing
Write queries which compare sets using the Querying Dynamic Management queries.
INTERSECT and EXCEPT operators ObjectsAfter completing this module, Describe the role of indexes and statistics
Write queries which manipulate rows in a students will be able to: in SQL Server
table by using APPLY with the results of a Write queries that retrieve system Display and interpret basic query plans
derived table or function metadata using system views and Display and interpret basic query
Exploring Window Functions functions. performance data
Restrict window functions to rows defined in Execute system stored procedures to
an OVER clause, including partitions and return system information.
frames. Write queries that retrieve system line
Write queries which use window functions to metadata and state information using Getting Started with SQL Server
operate on a window of rows and return system dynamic management views and Management Studio
ranking, aggregation and offset comparison functions. Work with SQL Server Management
results. Passing Parameters to Stored Studio.
Working with Grouping SetsAfter completing Procedures Working with SQL AzureAfter completing
this module, students will be able to: Creating Simple Stored Procedures this module, students will be able to:
Write queries which pivot and unpivot result Working with Dynamic SQLAfter Describe the basic features of SQL Azure.
sets completing this module, students will be Provision a SQL Azure server and
Write queries which specify multiple able to: configure its security.
groupings with grouping sets Return results by executing stored Understanding Sets
Executing System Stored Procedures procedures. Understanding Predicate Logic
Querying Dynamic Management Pass parameters to procedures. Understanding the Logical Order of
ObjectsAfter completing this module, Create simple stored procedures which Operations in SELECT statementsAfter
students will be able to: encapsulate a SELECT statement. completing this module, students will be
Write queries that retrieve system metadata Construct and execute dynamic SQL with able to:
using system views and functions. EXEC and sp_executesql. Describe the elements of T-SQL and their
Execute system stored procedures to return Controlling Program FlowAfter role in writing queries
system information. completing this module, students will be Describe the use of sets in SQL Server
Write queries that retrieve system metadata able to: Describe the use of predicate logic in SQL
and state information using system dynamic Describe the language elements of Server
management views and functions. T-SQL used for simple programming Describe the logical order of operations in
Passing Parameters to Stored Procedures tasks. SELECT statements
Creating Simple Stored Procedures Describe batches and how they are Eliminating Duplicates with DISTINCT
Working with Dynamic SQLAfter completing handled by SQL Server. Using Column and Table Aliases
this module, students will be able to: Declare and assign variables and Writing Simple CASE Expressions
Return results by executing stored synonyms. Eliminate duplicates using the DISTINCT
procedures. Use IF and WHILE blocks to control clause.
Pass parameters to procedures. program flow. Use column and table aliases.
Create simple stored procedures which Working with Error InformationAfter Write simple CASE expressions.
encapsulate a SELECT statement. completing this module, students will be Querying with Inner Joins
Construct and execute dynamic SQL with able to: Querying with Outer Joins
EXEC and sp_executesql. Describe SQL Server's behavior when Querying with Cross Joins and Self
Controlling Program FlowAfter completing errors occur in T-SQL code. JoinsAfter completing this module,
this module, students will be able to: Implement structured exception handling students will be able to:
Describe the language elements of T-SQL in T-SQL. Describe how multiple tables may be

used for simple programming tasks. Return information about errors from queried in a SELECT statement using
Describe batches and how they are handled system objects. joins.
by SQL Server. Raise user-defined errors and pass Write queries that use inner joins.
Declare and assign variables and synonyms. system errors in T-SQL code. Write queries that use outer joins.
Use IF and WHILE blocks to control Controlling TransactionsAfter completing Write queries that use self-joins and cross
program flow. this module, students will be able to: joins.
Working with Error InformationAfter Describe transactions and the differences Filtering Data with a WHERE Clause
completing this module, students will be able between batches and transactions. Filtering with the TOP and
to: Describe batches and how they are OFFSET-FETCH Options
Describe SQL Server's behavior when errors handled by SQL Server. Working with Unknown and Missing
occur in T-SQL code. Create and manage transactions with ValuesAfter completing this module,
Implement structured exception handling in transaction control language statements. students will be able to:
T-SQL. Use SET XACT_ABORT to define SQL Filter data with predicates in the WHERE
Return information about errors from system Server's handling of transactions outside clause.
objects. TRY / CATCH blocks. Sort data using ORDER BY.
Raise user-defined errors and pass system Displaying Query Performance DataAfter Filter data in the SELECT clause with
errors in T-SQL code. completing this module, students will be TOP.
Controlling TransactionsAfter completing able to: Filter data with OFFSET and FETCH.
this module, students will be able to: Describe components of well-performing Working with Character Data
Describe transactions and the differences queries. Working with Date and Time DataAfter
between batches and transactions. Describe the role of indexes and statistics completing this module, students will be
Describe batches and how they are handled in SQL Server able to:
by SQL Server. Display and interpret basic query plans Describe numeric data types, type
Create and manage transactions with Display and interpret basic query precedence and type conversions.
transaction control language statements. performance data Write queries using character data types.
Use SET XACT_ABORT to define SQL Write queries using date and time data
Server's handling of transactions outside types.
TRY / CATCH blocks. line Using Conversion Functions
Displaying Query Performance DataAfter Getting Started with SQL Server Using Logical Functions
completing this module, students will be able Management Studio Using Functions to Work with NULLAfter
to: Work with SQL Server Management completing this module, students will be
Describe components of well-performing Studio. able to:
queries. Working with SQL AzureAfter completing Write queries with built-in scalar functions.
Describe the role of indexes and statistics in this module, students will be able to: Use conversion functions.
SQL Server Describe the basic features of SQL Use logical functions.
Display and interpret basic query plans Azure. Use functions that work with NULL.
Display and interpret basic query Provision a SQL Azure server and Using the GROUP BY Clause
performance data configure its security. Filtering Groups with HAVINGAfter
Understanding Sets completing this module, students will be
Module 5: Querying Multiple Tables Understanding Predicate Logic able to:
line Understanding the Logical Order of Write queries which summarize data using
Operations in SELECT statementsAfter built-in aggregate functions.
This module explains how to write queries completing this module, students will be Use the GROUP BY clause to arrange
which combine data from multiple sources in able to: rows into groups.
SQL Server. The module introduces the use of Describe the elements of T-SQL and their Use the HAVING clause to filter out groups
JOINs in T-SQL queries as a mechanism for role in writing queries based on a search condition.
retrieving data from multiple tables. Describe the use of sets in SQL Server Writing Correlated Subqueries
line Describe the use of predicate logic in Using the EXISTS Predicate with
Understanding Joins SQL Server SubqueriesAfter completing this module,
Describe the logical order of operations in students will be able to:
SELECT statements Describe the uses of queries which are
line Eliminating Duplicates with DISTINCT nested within other queries.
Getting Started with SQL Server Using Column and Table Aliases Write self-contained subqueries which
Management Studio Writing Simple CASE Expressions return scalar or multi-valued results.
Work with SQL Server Management Studio. Eliminate duplicates using the DISTINCT Write correlated subqueries which return
Working with SQL AzureAfter completing clause. scalar or multi-valued results.
this module, students will be able to: Use column and table aliases. Use the EXISTS predicate to efficiently
Describe the basic features of SQL Azure. Write simple CASE expressions. check for the existence of rows in a
Provision a SQL Azure server and configure Querying with Inner Joins subquery.
its security. Querying with Outer Joins Using Common Table Expressions
Understanding Sets Querying with Cross Joins and Self Using Views
Understanding Predicate Logic JoinsAfter completing this module, Using Inline Table-Valued FunctionsAfter
Understanding the Logical Order of students will be able to: completing this module, students will be
Operations in SELECT statementsAfter Describe how multiple tables may be able to:
completing this module, students will be able queried in a SELECT statement using Write queries which use derived tables.
to: joins. Write queries which use common table

Describe the elements of T-SQL and their Write queries that use inner joins. expressions.
role in writing queries Write queries that use outer joins. Create simple views and write queries
Describe the use of sets in SQL Server Write queries that use self-joins and against them.
Describe the use of predicate logic in SQL cross joins. Create simple inline table-valued functions
Server Filtering Data with a WHERE Clause and write queries against them.
Describe the logical order of operations in Filtering with the TOP and Using EXCEPT and INTERSECT
SELECT statements OFFSET-FETCH Options Using APPLYAfter completing this module,
Eliminating Duplicates with DISTINCT Working with Unknown and Missing students will be able to:
Using Column and Table Aliases ValuesAfter completing this module, Write queries which combine data using
Writing Simple CASE Expressions students will be able to: the UNION operator
Eliminate duplicates using the DISTINCT Filter data with predicates in the WHERE Write queries which compare sets using
clause. clause. the INTERSECT and EXCEPT operators
Use column and table aliases. Sort data using ORDER BY. Write queries which manipulate rows in a
Write simple CASE expressions. Filter data in the SELECT clause with table by using APPLY with the results of a
Querying with Inner Joins TOP. derived table or function
Querying with Outer Joins Filter data with OFFSET and FETCH. Exploring Window Functions
Querying with Cross Joins and Self Working with Character Data Restrict window functions to rows defined
JoinsAfter completing this module, students Working with Date and Time DataAfter in an OVER clause, including partitions
will be able to: completing this module, students will be and frames.
Describe how multiple tables may be able to: Write queries which use window functions
queried in a SELECT statement using joins. Describe numeric data types, type to operate on a window of rows and return
Write queries that use inner joins. precedence and type conversions. ranking, aggregation and offset
Write queries that use outer joins. Write queries using character data types. comparison results.
Write queries that use self-joins and cross Write queries using date and time data Working with Grouping SetsAfter
joins. types. completing this module, students will be
Filtering Data with a WHERE Clause Using Conversion Functions able to:
Filtering with the TOP and OFFSET-FETCH Using Logical Functions Write queries which pivot and unpivot
Options Using Functions to Work with NULLAfter result sets
Working with Unknown and Missing completing this module, students will be Write queries which specify multiple
ValuesAfter completing this module, able to: groupings with grouping sets
students will be able to: Write queries with built-in scalar Executing System Stored Procedures
Filter data with predicates in the WHERE functions. Querying Dynamic Management
clause. Use conversion functions. ObjectsAfter completing this module,
Sort data using ORDER BY. Use logical functions. students will be able to:
Filter data in the SELECT clause with TOP. Use functions that work with NULL. Write queries that retrieve system
Filter data with OFFSET and FETCH. Using the GROUP BY Clause metadata using system views and
Working with Character Data Filtering Groups with HAVINGAfter functions.
Working with Date and Time DataAfter completing this module, students will be Execute system stored procedures to
completing this module, students will be able able to: return system information.
to: Write queries which summarize data Write queries that retrieve system
Describe numeric data types, type using built-in aggregate functions. metadata and state information using
precedence and type conversions. Use the GROUP BY clause to arrange system dynamic management views and
Write queries using character data types. rows into groups. functions.
Write queries using date and time data Use the HAVING clause to filter out Passing Parameters to Stored Procedures
types. groups based on a search condition. Creating Simple Stored Procedures
Using Conversion Functions Writing Correlated Subqueries Working with Dynamic SQLAfter
Using Logical Functions Using the EXISTS Predicate with completing this module, students will be
Using Functions to Work with NULLAfter SubqueriesAfter completing this module, able to:
completing this module, students will be able students will be able to: Return results by executing stored
to: Describe the uses of queries which are procedures.
Write queries with built-in scalar functions. nested within other queries. Pass parameters to procedures.
Use conversion functions. Write self-contained subqueries which Create simple stored procedures which
Use logical functions. return scalar or multi-valued results. encapsulate a SELECT statement.
Use functions that work with NULL. Write correlated subqueries which return Construct and execute dynamic SQL with
Using the GROUP BY Clause scalar or multi-valued results. EXEC and sp_executesql.
Filtering Groups with HAVINGAfter Use the EXISTS predicate to efficiently Controlling Program FlowAfter completing
completing this module, students will be able check for the existence of rows in a this module, students will be able to:
to: subquery. Describe the language elements of T-SQL
Write queries which summarize data using Using Common Table Expressions used for simple programming tasks.
built-in aggregate functions. Using Views Describe batches and how they are
Use the GROUP BY clause to arrange rows Using Inline Table-Valued FunctionsAfter handled by SQL Server.
into groups. completing this module, students will be Declare and assign variables and
Use the HAVING clause to filter out groups able to: synonyms.
based on a search condition. Write queries which use derived tables. Use IF and WHILE blocks to control
Writing Correlated Subqueries Write queries which use common table program flow.
Using the EXISTS Predicate with expressions. Working with Error InformationAfter

SubqueriesAfter completing this module, Create simple views and write queries completing this module, students will be
students will be able to: against them. able to:
Describe the uses of queries which are Create simple inline table-valued Describe SQL Server's behavior when
nested within other queries. functions and write queries against them. errors occur in T-SQL code.
Write self-contained subqueries which return Using EXCEPT and INTERSECT Implement structured exception handling in
scalar or multi-valued results. Using APPLYAfter completing this T-SQL.
Write correlated subqueries which return module, students will be able to: Return information about errors from
scalar or multi-valued results. Write queries which combine data using system objects.
Use the EXISTS predicate to efficiently the UNION operator Raise user-defined errors and pass system
check for the existence of rows in a Write queries which compare sets using errors in T-SQL code.
subquery. the INTERSECT and EXCEPT operators Controlling TransactionsAfter completing
Using Common Table Expressions Write queries which manipulate rows in a this module, students will be able to:
Using Views table by using APPLY with the results of Describe transactions and the differences
Using Inline Table-Valued FunctionsAfter a derived table or function between batches and transactions.
completing this module, students will be able Exploring Window Functions Describe batches and how they are
to: Restrict window functions to rows defined handled by SQL Server.
Write queries which use derived tables. in an OVER clause, including partitions Create and manage transactions with
Write queries which use common table and frames. transaction control language statements.
expressions. Write queries which use window Use SET XACT_ABORT to define SQL
Create simple views and write queries functions to operate on a window of rows Server's handling of transactions outside
against them. and return ranking, aggregation and TRY / CATCH blocks.
Create simple inline table-valued functions offset comparison results. Displaying Query Performance DataAfter
and write queries against them. Working with Grouping SetsAfter completing this module, students will be
Using EXCEPT and INTERSECT completing this module, students will be able to:
Using APPLYAfter completing this module, able to: Describe components of well-performing
students will be able to: Write queries which pivot and unpivot queries.
Write queries which combine data using the result sets Describe the role of indexes and statistics
UNION operator Write queries which specify multiple in SQL Server
Write queries which compare sets using the groupings with grouping sets Display and interpret basic query plans
INTERSECT and EXCEPT operators Executing System Stored Procedures Display and interpret basic query
Write queries which manipulate rows in a Querying Dynamic Management performance data
table by using APPLY with the results of a ObjectsAfter completing this module,
derived table or function students will be able to:
Exploring Window Functions Write queries that retrieve system line
Restrict window functions to rows defined in metadata using system views and Getting Started with SQL Server
an OVER clause, including partitions and functions. Management Studio
frames. Execute system stored procedures to Work with SQL Server Management
Write queries which use window functions to return system information. Studio.
operate on a window of rows and return Write queries that retrieve system Working with SQL AzureAfter completing
ranking, aggregation and offset comparison metadata and state information using this module, students will be able to:
results. system dynamic management views and Describe the basic features of SQL Azure.
Working with Grouping SetsAfter completing functions. Provision a SQL Azure server and
this module, students will be able to: Passing Parameters to Stored configure its security.
Write queries which pivot and unpivot result Procedures Understanding Sets
sets Creating Simple Stored Procedures Understanding Predicate Logic
Write queries which specify multiple Working with Dynamic SQLAfter Understanding the Logical Order of
groupings with grouping sets completing this module, students will be Operations in SELECT statementsAfter
Executing System Stored Procedures able to: completing this module, students will be
Querying Dynamic Management Return results by executing stored able to:
ObjectsAfter completing this module, procedures. Describe the elements of T-SQL and their
students will be able to: Pass parameters to procedures. role in writing queries
Write queries that retrieve system metadata Create simple stored procedures which Describe the use of sets in SQL Server
using system views and functions. encapsulate a SELECT statement. Describe the use of predicate logic in SQL
Execute system stored procedures to return Construct and execute dynamic SQL with Server
system information. EXEC and sp_executesql. Describe the logical order of operations in
Write queries that retrieve system metadata Controlling Program FlowAfter SELECT statements
and state information using system dynamic completing this module, students will be Eliminating Duplicates with DISTINCT
management views and functions. able to: Using Column and Table Aliases
Passing Parameters to Stored Procedures Describe the language elements of Writing Simple CASE Expressions
Creating Simple Stored Procedures T-SQL used for simple programming Eliminate duplicates using the DISTINCT
Working with Dynamic SQLAfter completing tasks. clause.
this module, students will be able to: Describe batches and how they are Use column and table aliases.
Return results by executing stored handled by SQL Server. Write simple CASE expressions.
procedures. Declare and assign variables and Querying with Inner Joins
Pass parameters to procedures. synonyms. Querying with Outer Joins
Create simple stored procedures which Use IF and WHILE blocks to control Querying with Cross Joins and Self

encapsulate a SELECT statement. program flow. JoinsAfter completing this module,
Construct and execute dynamic SQL with Working with Error InformationAfter students will be able to:
EXEC and sp_executesql. completing this module, students will be Describe how multiple tables may be
Controlling Program FlowAfter completing able to: queried in a SELECT statement using
this module, students will be able to: Describe SQL Server's behavior when joins.
Describe the language elements of T-SQL errors occur in T-SQL code. Write queries that use inner joins.
used for simple programming tasks. Implement structured exception handling Write queries that use outer joins.
Describe batches and how they are handled in T-SQL. Write queries that use self-joins and cross
by SQL Server. Return information about errors from joins.
Declare and assign variables and synonyms. system objects. Filtering Data with a WHERE Clause
Use IF and WHILE blocks to control Raise user-defined errors and pass Filtering with the TOP and
program flow. system errors in T-SQL code. OFFSET-FETCH Options
Working with Error InformationAfter Controlling TransactionsAfter completing Working with Unknown and Missing
completing this module, students will be able this module, students will be able to: ValuesAfter completing this module,
to: Describe transactions and the differences students will be able to:
Describe SQL Server's behavior when errors between batches and transactions. Filter data with predicates in the WHERE
occur in T-SQL code. Describe batches and how they are clause.
Implement structured exception handling in handled by SQL Server. Sort data using ORDER BY.
T-SQL. Create and manage transactions with Filter data in the SELECT clause with
Return information about errors from system transaction control language statements. TOP.
objects. Use SET XACT_ABORT to define SQL Filter data with OFFSET and FETCH.
Raise user-defined errors and pass system Server's handling of transactions outside Working with Character Data
errors in T-SQL code. TRY / CATCH blocks. Working with Date and Time DataAfter
Controlling TransactionsAfter completing Displaying Query Performance DataAfter completing this module, students will be
this module, students will be able to: completing this module, students will be able to:
Describe transactions and the differences able to: Describe numeric data types, type
between batches and transactions. Describe components of well-performing precedence and type conversions.
Describe batches and how they are handled queries. Write queries using character data types.
by SQL Server. Describe the role of indexes and statistics Write queries using date and time data
Create and manage transactions with in SQL Server types.
transaction control language statements. Display and interpret basic query plans Using Conversion Functions
Use SET XACT_ABORT to define SQL Display and interpret basic query Using Logical Functions
Server's handling of transactions outside performance data Using Functions to Work with NULLAfter
TRY / CATCH blocks. completing this module, students will be
Displaying Query Performance DataAfter able to:
completing this module, students will be able line Write queries with built-in scalar functions.
to: Getting Started with SQL Server Use conversion functions.
Describe components of well-performing Management Studio Use logical functions.
queries. Work with SQL Server Management Use functions that work with NULL.
Describe the role of indexes and statistics in Studio. Using the GROUP BY Clause
SQL Server Working with SQL AzureAfter completing Filtering Groups with HAVINGAfter
Display and interpret basic query plans this module, students will be able to: completing this module, students will be
Display and interpret basic query Describe the basic features of SQL able to:
performance data Azure. Write queries which summarize data using
Provision a SQL Azure server and built-in aggregate functions.
configure its security. Use the GROUP BY clause to arrange
line Understanding Sets rows into groups.
Getting Started with SQL Server Understanding Predicate Logic Use the HAVING clause to filter out groups
Management Studio Understanding the Logical Order of based on a search condition.
Work with SQL Server Management Studio. Operations in SELECT statementsAfter Writing Correlated Subqueries
Working with SQL AzureAfter completing completing this module, students will be Using the EXISTS Predicate with
this module, students will be able to: able to: SubqueriesAfter completing this module,
Describe the basic features of SQL Azure. Describe the elements of T-SQL and their students will be able to:
Provision a SQL Azure server and configure role in writing queries Describe the uses of queries which are
its security. Describe the use of sets in SQL Server nested within other queries.
Understanding Sets Describe the use of predicate logic in Write self-contained subqueries which
Understanding Predicate Logic SQL Server return scalar or multi-valued results.
Understanding the Logical Order of Describe the logical order of operations in Write correlated subqueries which return
Operations in SELECT statementsAfter SELECT statements scalar or multi-valued results.
completing this module, students will be able Eliminating Duplicates with DISTINCT Use the EXISTS predicate to efficiently
to: Using Column and Table Aliases check for the existence of rows in a
Describe the elements of T-SQL and their Writing Simple CASE Expressions subquery.
role in writing queries Eliminate duplicates using the DISTINCT Using Common Table Expressions
Describe the use of sets in SQL Server clause. Using Views
Describe the use of predicate logic in SQL Use column and table aliases. Using Inline Table-Valued FunctionsAfter
Server Write simple CASE expressions. completing this module, students will be

Describe the logical order of operations in Querying with Inner Joins able to:
SELECT statements Querying with Outer Joins Write queries which use derived tables.
Eliminating Duplicates with DISTINCT Querying with Cross Joins and Self Write queries which use common table
Using Column and Table Aliases JoinsAfter completing this module, expressions.
Writing Simple CASE Expressions students will be able to: Create simple views and write queries
Eliminate duplicates using the DISTINCT Describe how multiple tables may be against them.
clause. queried in a SELECT statement using Create simple inline table-valued functions
Use column and table aliases. joins. and write queries against them.
Write simple CASE expressions. Write queries that use inner joins. Using EXCEPT and INTERSECT
Querying with Inner Joins Write queries that use outer joins. Using APPLYAfter completing this module,
Querying with Outer Joins Write queries that use self-joins and students will be able to:
Querying with Cross Joins and Self cross joins. Write queries which combine data using
JoinsAfter completing this module, students Filtering Data with a WHERE Clause the UNION operator
will be able to: Filtering with the TOP and Write queries which compare sets using
Describe how multiple tables may be OFFSET-FETCH Options the INTERSECT and EXCEPT operators
queried in a SELECT statement using joins. Working with Unknown and Missing Write queries which manipulate rows in a
Write queries that use inner joins. ValuesAfter completing this module, table by using APPLY with the results of a
Write queries that use outer joins. students will be able to: derived table or function
Write queries that use self-joins and cross Filter data with predicates in the WHERE Exploring Window Functions
joins. clause. Restrict window functions to rows defined
Filtering Data with a WHERE Clause Sort data using ORDER BY. in an OVER clause, including partitions
Filtering with the TOP and OFFSET-FETCH Filter data in the SELECT clause with and frames.
Options TOP. Write queries which use window functions
Working with Unknown and Missing Filter data with OFFSET and FETCH. to operate on a window of rows and return
ValuesAfter completing this module, Working with Character Data ranking, aggregation and offset
students will be able to: Working with Date and Time DataAfter comparison results.
Filter data with predicates in the WHERE completing this module, students will be Working with Grouping SetsAfter
clause. able to: completing this module, students will be
Sort data using ORDER BY. Describe numeric data types, type able to:
Filter data in the SELECT clause with TOP. precedence and type conversions. Write queries which pivot and unpivot
Filter data with OFFSET and FETCH. Write queries using character data types. result sets
Working with Character Data Write queries using date and time data Write queries which specify multiple
Working with Date and Time DataAfter types. groupings with grouping sets
completing this module, students will be able Using Conversion Functions Executing System Stored Procedures
to: Using Logical Functions Querying Dynamic Management
Describe numeric data types, type Using Functions to Work with NULLAfter ObjectsAfter completing this module,
precedence and type conversions. completing this module, students will be students will be able to:
Write queries using character data types. able to: Write queries that retrieve system
Write queries using date and time data Write queries with built-in scalar metadata using system views and
types. functions. functions.
Using Conversion Functions Use conversion functions. Execute system stored procedures to
Using Logical Functions Use logical functions. return system information.
Using Functions to Work with NULLAfter Use functions that work with NULL. Write queries that retrieve system
completing this module, students will be able Using the GROUP BY Clause metadata and state information using
to: Filtering Groups with HAVINGAfter system dynamic management views and
Write queries with built-in scalar functions. completing this module, students will be functions.
Use conversion functions. able to: Passing Parameters to Stored Procedures
Use logical functions. Write queries which summarize data Creating Simple Stored Procedures
Use functions that work with NULL. using built-in aggregate functions. Working with Dynamic SQLAfter
Using the GROUP BY Clause Use the GROUP BY clause to arrange completing this module, students will be
Filtering Groups with HAVINGAfter rows into groups. able to:
completing this module, students will be able Use the HAVING clause to filter out Return results by executing stored
to: groups based on a search condition. procedures.
Write queries which summarize data using Writing Correlated Subqueries Pass parameters to procedures.
built-in aggregate functions. Using the EXISTS Predicate with Create simple stored procedures which
Use the GROUP BY clause to arrange rows SubqueriesAfter completing this module, encapsulate a SELECT statement.
into groups. students will be able to: Construct and execute dynamic SQL with
Use the HAVING clause to filter out groups Describe the uses of queries which are EXEC and sp_executesql.
based on a search condition. nested within other queries. Controlling Program FlowAfter completing
Writing Correlated Subqueries Write self-contained subqueries which this module, students will be able to:
Using the EXISTS Predicate with return scalar or multi-valued results. Describe the language elements of T-SQL
SubqueriesAfter completing this module, Write correlated subqueries which return used for simple programming tasks.
students will be able to: scalar or multi-valued results. Describe batches and how they are
Describe the uses of queries which are Use the EXISTS predicate to efficiently handled by SQL Server.
nested within other queries. check for the existence of rows in a Declare and assign variables and
Write self-contained subqueries which return subquery. synonyms.

scalar or multi-valued results. Using Common Table Expressions Use IF and WHILE blocks to control
Write correlated subqueries which return Using Views program flow.
scalar or multi-valued results. Using Inline Table-Valued FunctionsAfter Working with Error InformationAfter
Use the EXISTS predicate to efficiently completing this module, students will be completing this module, students will be
check for the existence of rows in a able to: able to:
subquery. Write queries which use derived tables. Describe SQL Server's behavior when
Using Common Table Expressions Write queries which use common table errors occur in T-SQL code.
Using Views expressions. Implement structured exception handling in
Using Inline Table-Valued FunctionsAfter Create simple views and write queries T-SQL.
completing this module, students will be able against them. Return information about errors from
to: Create simple inline table-valued system objects.
Write queries which use derived tables. functions and write queries against them. Raise user-defined errors and pass system
Write queries which use common table Using EXCEPT and INTERSECT errors in T-SQL code.
expressions. Using APPLYAfter completing this Controlling TransactionsAfter completing
Create simple views and write queries module, students will be able to: this module, students will be able to:
against them. Write queries which combine data using Describe transactions and the differences
Create simple inline table-valued functions the UNION operator between batches and transactions.
and write queries against them. Write queries which compare sets using Describe batches and how they are
Using EXCEPT and INTERSECT the INTERSECT and EXCEPT operators handled by SQL Server.
Using APPLYAfter completing this module, Write queries which manipulate rows in a Create and manage transactions with
students will be able to: table by using APPLY with the results of transaction control language statements.
Write queries which combine data using the a derived table or function Use SET XACT_ABORT to define SQL
UNION operator Exploring Window Functions Server's handling of transactions outside
Write queries which compare sets using the Restrict window functions to rows defined TRY / CATCH blocks.
INTERSECT and EXCEPT operators in an OVER clause, including partitions Displaying Query Performance DataAfter
Write queries which manipulate rows in a and frames. completing this module, students will be
table by using APPLY with the results of a Write queries which use window able to:
derived table or function functions to operate on a window of rows Describe components of well-performing
Exploring Window Functions and return ranking, aggregation and queries.
Restrict window functions to rows defined in offset comparison results. Describe the role of indexes and statistics
an OVER clause, including partitions and Working with Grouping SetsAfter in SQL Server
frames. completing this module, students will be Display and interpret basic query plans
Write queries which use window functions to able to: Display and interpret basic query
operate on a window of rows and return Write queries which pivot and unpivot performance data
ranking, aggregation and offset comparison result sets
results. Write queries which specify multiple Module 18: Implementing Error Handling
Working with Grouping SetsAfter completing groupings with grouping sets line
this module, students will be able to: Executing System Stored Procedures
Write queries which pivot and unpivot result Querying Dynamic Management This module introduces the use of error
sets ObjectsAfter completing this module, handlers in T-SQL code. It will introduce the
Write queries which specify multiple students will be able to: difference between compile errors and
groupings with grouping sets Write queries that retrieve system run-time errors, and will cover how errors
Executing System Stored Procedures metadata using system views and affect batches. The module will also cover
Querying Dynamic Management functions. how to control error handling using
ObjectsAfter completing this module, Execute system stored procedures to TRY/CATCH blocks, the use of the ERROR
students will be able to: return system information. class of functions, and the use of the new
Write queries that retrieve system metadata Write queries that retrieve system THROW statement.
using system views and functions. metadata and state information using line
Execute system stored procedures to return system dynamic management views and Using TRY / CATCH Blocks
system information. functions.
Write queries that retrieve system metadata Passing Parameters to Stored
and state information using system dynamic Procedures line
management views and functions. Creating Simple Stored Procedures Getting Started with SQL Server
Passing Parameters to Stored Procedures Working with Dynamic SQLAfter Management Studio
Creating Simple Stored Procedures completing this module, students will be Work with SQL Server Management
Working with Dynamic SQLAfter completing able to: Studio.
this module, students will be able to: Return results by executing stored Working with SQL AzureAfter completing
Return results by executing stored procedures. this module, students will be able to:
procedures. Pass parameters to procedures. Describe the basic features of SQL Azure.
Pass parameters to procedures. Create simple stored procedures which Provision a SQL Azure server and
Create simple stored procedures which encapsulate a SELECT statement. configure its security.
encapsulate a SELECT statement. Construct and execute dynamic SQL with Understanding Sets
Construct and execute dynamic SQL with EXEC and sp_executesql. Understanding Predicate Logic
EXEC and sp_executesql. Controlling Program FlowAfter Understanding the Logical Order of
Controlling Program FlowAfter completing completing this module, students will be Operations in SELECT statementsAfter
this module, students will be able to: able to: completing this module, students will be

Describe the language elements of T-SQL Describe the language elements of able to:
used for simple programming tasks. T-SQL used for simple programming Describe the elements of T-SQL and their
Describe batches and how they are handled tasks. role in writing queries
by SQL Server. Describe batches and how they are Describe the use of sets in SQL Server
Declare and assign variables and synonyms. handled by SQL Server. Describe the use of predicate logic in SQL
Use IF and WHILE blocks to control Declare and assign variables and Server
program flow. synonyms. Describe the logical order of operations in
Working with Error InformationAfter Use IF and WHILE blocks to control SELECT statements
completing this module, students will be able program flow. Eliminating Duplicates with DISTINCT
to: Working with Error InformationAfter Using Column and Table Aliases
Describe SQL Server's behavior when errors completing this module, students will be Writing Simple CASE Expressions
occur in T-SQL code. able to: Eliminate duplicates using the DISTINCT
Implement structured exception handling in Describe SQL Server's behavior when clause.
T-SQL. errors occur in T-SQL code. Use column and table aliases.
Return information about errors from system Implement structured exception handling Write simple CASE expressions.
objects. in T-SQL. Querying with Inner Joins
Raise user-defined errors and pass system Return information about errors from Querying with Outer Joins
errors in T-SQL code. system objects. Querying with Cross Joins and Self
Controlling TransactionsAfter completing Raise user-defined errors and pass JoinsAfter completing this module,
this module, students will be able to: system errors in T-SQL code. students will be able to:
Describe transactions and the differences Controlling TransactionsAfter completing Describe how multiple tables may be
between batches and transactions. this module, students will be able to: queried in a SELECT statement using
Describe batches and how they are handled Describe transactions and the differences joins.
by SQL Server. between batches and transactions. Write queries that use inner joins.
Create and manage transactions with Describe batches and how they are Write queries that use outer joins.
transaction control language statements. handled by SQL Server. Write queries that use self-joins and cross
Use SET XACT_ABORT to define SQL Create and manage transactions with joins.
Server's handling of transactions outside transaction control language statements. Filtering Data with a WHERE Clause
TRY / CATCH blocks. Use SET XACT_ABORT to define SQL Filtering with the TOP and
Displaying Query Performance DataAfter Server's handling of transactions outside OFFSET-FETCH Options
completing this module, students will be able TRY / CATCH blocks. Working with Unknown and Missing
to: Displaying Query Performance DataAfter ValuesAfter completing this module,
Describe components of well-performing completing this module, students will be students will be able to:
queries. able to: Filter data with predicates in the WHERE
Describe the role of indexes and statistics in Describe components of well-performing clause.
SQL Server queries. Sort data using ORDER BY.
Display and interpret basic query plans Describe the role of indexes and statistics Filter data in the SELECT clause with
Display and interpret basic query in SQL Server TOP.
performance data Display and interpret basic query plans Filter data with OFFSET and FETCH.
Display and interpret basic query Working with Character Data
performance data Working with Date and Time DataAfter
line completing this module, students will be
Getting Started with SQL Server able to:
Management Studio line Describe numeric data types, type
Work with SQL Server Management Studio. Getting Started with SQL Server precedence and type conversions.
Working with SQL AzureAfter completing Management Studio Write queries using character data types.
this module, students will be able to: Work with SQL Server Management Write queries using date and time data
Describe the basic features of SQL Azure. Studio. types.
Provision a SQL Azure server and configure Working with SQL AzureAfter completing Using Conversion Functions
its security. this module, students will be able to: Using Logical Functions
Understanding Sets Describe the basic features of SQL Using Functions to Work with NULLAfter
Understanding Predicate Logic Azure. completing this module, students will be
Understanding the Logical Order of Provision a SQL Azure server and able to:
Operations in SELECT statementsAfter configure its security. Write queries with built-in scalar functions.
completing this module, students will be able Understanding Sets Use conversion functions.
to: Understanding Predicate Logic Use logical functions.
Describe the elements of T-SQL and their Understanding the Logical Order of Use functions that work with NULL.
role in writing queries Operations in SELECT statementsAfter Using the GROUP BY Clause
Describe the use of sets in SQL Server completing this module, students will be Filtering Groups with HAVINGAfter
Describe the use of predicate logic in SQL able to: completing this module, students will be
Server Describe the elements of T-SQL and their able to:
Describe the logical order of operations in role in writing queries Write queries which summarize data using
SELECT statements Describe the use of sets in SQL Server built-in aggregate functions.
Eliminating Duplicates with DISTINCT Describe the use of predicate logic in Use the GROUP BY clause to arrange
Using Column and Table Aliases SQL Server rows into groups.
Writing Simple CASE Expressions Describe the logical order of operations in Use the HAVING clause to filter out groups

Eliminate duplicates using the DISTINCT SELECT statements based on a search condition.
clause. Eliminating Duplicates with DISTINCT Writing Correlated Subqueries
Use column and table aliases. Using Column and Table Aliases Using the EXISTS Predicate with
Write simple CASE expressions. Writing Simple CASE Expressions SubqueriesAfter completing this module,
Querying with Inner Joins Eliminate duplicates using the DISTINCT students will be able to:
Querying with Outer Joins clause. Describe the uses of queries which are
Querying with Cross Joins and Self Use column and table aliases. nested within other queries.
JoinsAfter completing this module, students Write simple CASE expressions. Write self-contained subqueries which
will be able to: Querying with Inner Joins return scalar or multi-valued results.
Describe how multiple tables may be Querying with Outer Joins Write correlated subqueries which return
queried in a SELECT statement using joins. Querying with Cross Joins and Self scalar or multi-valued results.
Write queries that use inner joins. JoinsAfter completing this module, Use the EXISTS predicate to efficiently
Write queries that use outer joins. students will be able to: check for the existence of rows in a
Write queries that use self-joins and cross Describe how multiple tables may be subquery.
joins. queried in a SELECT statement using Using Common Table Expressions
Filtering Data with a WHERE Clause joins. Using Views
Filtering with the TOP and OFFSET-FETCH Write queries that use inner joins. Using Inline Table-Valued FunctionsAfter
Options Write queries that use outer joins. completing this module, students will be
Working with Unknown and Missing Write queries that use self-joins and able to:
ValuesAfter completing this module, cross joins. Write queries which use derived tables.
students will be able to: Filtering Data with a WHERE Clause Write queries which use common table
Filter data with predicates in the WHERE Filtering with the TOP and expressions.
clause. OFFSET-FETCH Options Create simple views and write queries
Sort data using ORDER BY. Working with Unknown and Missing against them.
Filter data in the SELECT clause with TOP. ValuesAfter completing this module, Create simple inline table-valued functions
Filter data with OFFSET and FETCH. students will be able to: and write queries against them.
Working with Character Data Filter data with predicates in the WHERE Using EXCEPT and INTERSECT
Working with Date and Time DataAfter clause. Using APPLYAfter completing this module,
completing this module, students will be able Sort data using ORDER BY. students will be able to:
to: Filter data in the SELECT clause with Write queries which combine data using
Describe numeric data types, type TOP. the UNION operator
precedence and type conversions. Filter data with OFFSET and FETCH. Write queries which compare sets using
Write queries using character data types. Working with Character Data the INTERSECT and EXCEPT operators
Write queries using date and time data Working with Date and Time DataAfter Write queries which manipulate rows in a
types. completing this module, students will be table by using APPLY with the results of a
Using Conversion Functions able to: derived table or function
Using Logical Functions Describe numeric data types, type Exploring Window Functions
Using Functions to Work with NULLAfter precedence and type conversions. Restrict window functions to rows defined
completing this module, students will be able Write queries using character data types. in an OVER clause, including partitions
to: Write queries using date and time data and frames.
Write queries with built-in scalar functions. types. Write queries which use window functions
Use conversion functions. Using Conversion Functions to operate on a window of rows and return
Use logical functions. Using Logical Functions ranking, aggregation and offset
Use functions that work with NULL. Using Functions to Work with NULLAfter comparison results.
Using the GROUP BY Clause completing this module, students will be Working with Grouping SetsAfter
Filtering Groups with HAVINGAfter able to: completing this module, students will be
completing this module, students will be able Write queries with built-in scalar able to:
to: functions. Write queries which pivot and unpivot
Write queries which summarize data using Use conversion functions. result sets
built-in aggregate functions. Use logical functions. Write queries which specify multiple
Use the GROUP BY clause to arrange rows Use functions that work with NULL. groupings with grouping sets
into groups. Using the GROUP BY Clause Executing System Stored Procedures
Use the HAVING clause to filter out groups Filtering Groups with HAVINGAfter Querying Dynamic Management
based on a search condition. completing this module, students will be ObjectsAfter completing this module,
Writing Correlated Subqueries able to: students will be able to:
Using the EXISTS Predicate with Write queries which summarize data Write queries that retrieve system
SubqueriesAfter completing this module, using built-in aggregate functions. metadata using system views and
students will be able to: Use the GROUP BY clause to arrange functions.
Describe the uses of queries which are rows into groups. Execute system stored procedures to
nested within other queries. Use the HAVING clause to filter out return system information.
Write self-contained subqueries which return groups based on a search condition. Write queries that retrieve system
scalar or multi-valued results. Writing Correlated Subqueries metadata and state information using
Write correlated subqueries which return Using the EXISTS Predicate with system dynamic management views and
scalar or multi-valued results. SubqueriesAfter completing this module, functions.
Use the EXISTS predicate to efficiently students will be able to: Passing Parameters to Stored Procedures
check for the existence of rows in a Describe the uses of queries which are Creating Simple Stored Procedures

subquery. nested within other queries. Working with Dynamic SQLAfter
Using Common Table Expressions Write self-contained subqueries which completing this module, students will be
Using Views return scalar or multi-valued results. able to:
Using Inline Table-Valued FunctionsAfter Write correlated subqueries which return Return results by executing stored
completing this module, students will be able scalar or multi-valued results. procedures.
to: Use the EXISTS predicate to efficiently Pass parameters to procedures.
Write queries which use derived tables. check for the existence of rows in a Create simple stored procedures which
Write queries which use common table subquery. encapsulate a SELECT statement.
expressions. Using Common Table Expressions Construct and execute dynamic SQL with
Create simple views and write queries Using Views EXEC and sp_executesql.
against them. Using Inline Table-Valued FunctionsAfter Controlling Program FlowAfter completing
Create simple inline table-valued functions completing this module, students will be this module, students will be able to:
and write queries against them. able to: Describe the language elements of T-SQL
Using EXCEPT and INTERSECT Write queries which use derived tables. used for simple programming tasks.
Using APPLYAfter completing this module, Write queries which use common table Describe batches and how they are
students will be able to: expressions. handled by SQL Server.
Write queries which combine data using the Create simple views and write queries Declare and assign variables and
UNION operator against them. synonyms.
Write queries which compare sets using the Create simple inline table-valued Use IF and WHILE blocks to control
INTERSECT and EXCEPT operators functions and write queries against them. program flow.
Write queries which manipulate rows in a Using EXCEPT and INTERSECT Working with Error InformationAfter
table by using APPLY with the results of a Using APPLYAfter completing this completing this module, students will be
derived table or function module, students will be able to: able to:
Exploring Window Functions Write queries which combine data using Describe SQL Server's behavior when
Restrict window functions to rows defined in the UNION operator errors occur in T-SQL code.
an OVER clause, including partitions and Write queries which compare sets using Implement structured exception handling in
frames. the INTERSECT and EXCEPT operators T-SQL.
Write queries which use window functions to Write queries which manipulate rows in a Return information about errors from
operate on a window of rows and return table by using APPLY with the results of system objects.
ranking, aggregation and offset comparison a derived table or function Raise user-defined errors and pass system
results. Exploring Window Functions errors in T-SQL code.
Working with Grouping SetsAfter completing Restrict window functions to rows defined Controlling TransactionsAfter completing
this module, students will be able to: in an OVER clause, including partitions this module, students will be able to:
Write queries which pivot and unpivot result and frames. Describe transactions and the differences
sets Write queries which use window between batches and transactions.
Write queries which specify multiple functions to operate on a window of rows Describe batches and how they are
groupings with grouping sets and return ranking, aggregation and handled by SQL Server.
Executing System Stored Procedures offset comparison results. Create and manage transactions with
Querying Dynamic Management Working with Grouping SetsAfter transaction control language statements.
ObjectsAfter completing this module, completing this module, students will be Use SET XACT_ABORT to define SQL
students will be able to: able to: Server's handling of transactions outside
Write queries that retrieve system metadata Write queries which pivot and unpivot TRY / CATCH blocks.
using system views and functions. result sets Displaying Query Performance DataAfter
Execute system stored procedures to return Write queries which specify multiple completing this module, students will be
system information. groupings with grouping sets able to:
Write queries that retrieve system metadata Executing System Stored Procedures Describe components of well-performing
and state information using system dynamic Querying Dynamic Management queries.
management views and functions. ObjectsAfter completing this module, Describe the role of indexes and statistics
Passing Parameters to Stored Procedures students will be able to: in SQL Server
Creating Simple Stored Procedures Write queries that retrieve system Display and interpret basic query plans
Working with Dynamic SQLAfter completing metadata using system views and Display and interpret basic query
this module, students will be able to: functions. performance data
Return results by executing stored Execute system stored procedures to
procedures. return system information.
Pass parameters to procedures. Write queries that retrieve system line
Create simple stored procedures which metadata and state information using Getting Started with SQL Server
encapsulate a SELECT statement. system dynamic management views and Management Studio
Construct and execute dynamic SQL with functions. Work with SQL Server Management
EXEC and sp_executesql. Passing Parameters to Stored Studio.
Controlling Program FlowAfter completing Procedures Working with SQL AzureAfter completing
this module, students will be able to: Creating Simple Stored Procedures this module, students will be able to:
Describe the language elements of T-SQL Working with Dynamic SQLAfter Describe the basic features of SQL Azure.
used for simple programming tasks. completing this module, students will be Provision a SQL Azure server and
Describe batches and how they are handled able to: configure its security.
by SQL Server. Return results by executing stored Understanding Sets
Declare and assign variables and synonyms. procedures. Understanding Predicate Logic

Use IF and WHILE blocks to control Pass parameters to procedures. Understanding the Logical Order of
program flow. Create simple stored procedures which Operations in SELECT statementsAfter
Working with Error InformationAfter encapsulate a SELECT statement. completing this module, students will be
completing this module, students will be able Construct and execute dynamic SQL with able to:
to: EXEC and sp_executesql. Describe the elements of T-SQL and their
Describe SQL Server's behavior when errors Controlling Program FlowAfter role in writing queries
occur in T-SQL code. completing this module, students will be Describe the use of sets in SQL Server
Implement structured exception handling in able to: Describe the use of predicate logic in SQL
T-SQL. Describe the language elements of Server
Return information about errors from system T-SQL used for simple programming Describe the logical order of operations in
objects. tasks. SELECT statements
Raise user-defined errors and pass system Describe batches and how they are Eliminating Duplicates with DISTINCT
errors in T-SQL code. handled by SQL Server. Using Column and Table Aliases
Controlling TransactionsAfter completing Declare and assign variables and Writing Simple CASE Expressions
this module, students will be able to: synonyms. Eliminate duplicates using the DISTINCT
Describe transactions and the differences Use IF and WHILE blocks to control clause.
between batches and transactions. program flow. Use column and table aliases.
Describe batches and how they are handled Working with Error InformationAfter Write simple CASE expressions.
by SQL Server. completing this module, students will be Querying with Inner Joins
Create and manage transactions with able to: Querying with Outer Joins
transaction control language statements. Describe SQL Server's behavior when Querying with Cross Joins and Self
Use SET XACT_ABORT to define SQL errors occur in T-SQL code. JoinsAfter completing this module,
Server's handling of transactions outside Implement structured exception handling students will be able to:
TRY / CATCH blocks. in T-SQL. Describe how multiple tables may be
Displaying Query Performance DataAfter Return information about errors from queried in a SELECT statement using
completing this module, students will be able system objects. joins.
to: Raise user-defined errors and pass Write queries that use inner joins.
Describe components of well-performing system errors in T-SQL code. Write queries that use outer joins.
queries. Controlling TransactionsAfter completing Write queries that use self-joins and cross
Describe the role of indexes and statistics in this module, students will be able to: joins.
SQL Server Describe transactions and the differences Filtering Data with a WHERE Clause
Display and interpret basic query plans between batches and transactions. Filtering with the TOP and
Display and interpret basic query Describe batches and how they are OFFSET-FETCH Options
performance data handled by SQL Server. Working with Unknown and Missing
Create and manage transactions with ValuesAfter completing this module,
transaction control language statements. students will be able to:
line Use SET XACT_ABORT to define SQL Filter data with predicates in the WHERE
Getting Started with SQL Server Server's handling of transactions outside clause.
Management Studio TRY / CATCH blocks. Sort data using ORDER BY.
Work with SQL Server Management Studio. Displaying Query Performance DataAfter Filter data in the SELECT clause with
Working with SQL AzureAfter completing completing this module, students will be TOP.
this module, students will be able to: able to: Filter data with OFFSET and FETCH.
Describe the basic features of SQL Azure. Describe components of well-performing Working with Character Data
Provision a SQL Azure server and configure queries. Working with Date and Time DataAfter
its security. Describe the role of indexes and statistics completing this module, students will be
Understanding Sets in SQL Server able to:
Understanding Predicate Logic Display and interpret basic query plans Describe numeric data types, type
Understanding the Logical Order of Display and interpret basic query precedence and type conversions.
Operations in SELECT statementsAfter performance data Write queries using character data types.
completing this module, students will be able Write queries using date and time data
to: types.
Describe the elements of T-SQL and their line Using Conversion Functions
role in writing queries Getting Started with SQL Server Using Logical Functions
Describe the use of sets in SQL Server Management Studio Using Functions to Work with NULLAfter
Describe the use of predicate logic in SQL Work with SQL Server Management completing this module, students will be
Server Studio. able to:
Describe the logical order of operations in Working with SQL AzureAfter completing Write queries with built-in scalar functions.
SELECT statements this module, students will be able to: Use conversion functions.
Eliminating Duplicates with DISTINCT Describe the basic features of SQL Use logical functions.
Using Column and Table Aliases Azure. Use functions that work with NULL.
Writing Simple CASE Expressions Provision a SQL Azure server and Using the GROUP BY Clause
Eliminate duplicates using the DISTINCT configure its security. Filtering Groups with HAVINGAfter
clause. Understanding Sets completing this module, students will be
Use column and table aliases. Understanding Predicate Logic able to:
Write simple CASE expressions. Understanding the Logical Order of Write queries which summarize data using
Querying with Inner Joins Operations in SELECT statementsAfter built-in aggregate functions.

Querying with Outer Joins completing this module, students will be Use the GROUP BY clause to arrange
Querying with Cross Joins and Self able to: rows into groups.
JoinsAfter completing this module, students Describe the elements of T-SQL and their Use the HAVING clause to filter out groups
will be able to: role in writing queries based on a search condition.
Describe how multiple tables may be Describe the use of sets in SQL Server Writing Correlated Subqueries
queried in a SELECT statement using joins. Describe the use of predicate logic in Using the EXISTS Predicate with
Write queries that use inner joins. SQL Server SubqueriesAfter completing this module,
Write queries that use outer joins. Describe the logical order of operations in students will be able to:
Write queries that use self-joins and cross SELECT statements Describe the uses of queries which are
joins. Eliminating Duplicates with DISTINCT nested within other queries.
Filtering Data with a WHERE Clause Using Column and Table Aliases Write self-contained subqueries which
Filtering with the TOP and OFFSET-FETCH Writing Simple CASE Expressions return scalar or multi-valued results.
Options Eliminate duplicates using the DISTINCT Write correlated subqueries which return
Working with Unknown and Missing clause. scalar or multi-valued results.
ValuesAfter completing this module, Use column and table aliases. Use the EXISTS predicate to efficiently
students will be able to: Write simple CASE expressions. check for the existence of rows in a
Filter data with predicates in the WHERE Querying with Inner Joins subquery.
clause. Querying with Outer Joins Using Common Table Expressions
Sort data using ORDER BY. Querying with Cross Joins and Self Using Views
Filter data in the SELECT clause with TOP. JoinsAfter completing this module, Using Inline Table-Valued FunctionsAfter
Filter data with OFFSET and FETCH. students will be able to: completing this module, students will be
Working with Character Data Describe how multiple tables may be able to:
Working with Date and Time DataAfter queried in a SELECT statement using Write queries which use derived tables.
completing this module, students will be able joins. Write queries which use common table
to: Write queries that use inner joins. expressions.
Describe numeric data types, type Write queries that use outer joins. Create simple views and write queries
precedence and type conversions. Write queries that use self-joins and against them.
Write queries using character data types. cross joins. Create simple inline table-valued functions
Write queries using date and time data Filtering Data with a WHERE Clause and write queries against them.
types. Filtering with the TOP and Using EXCEPT and INTERSECT
Using Conversion Functions OFFSET-FETCH Options Using APPLYAfter completing this module,
Using Logical Functions Working with Unknown and Missing students will be able to:
Using Functions to Work with NULLAfter ValuesAfter completing this module, Write queries which combine data using
completing this module, students will be able students will be able to: the UNION operator
to: Filter data with predicates in the WHERE Write queries which compare sets using
Write queries with built-in scalar functions. clause. the INTERSECT and EXCEPT operators
Use conversion functions. Sort data using ORDER BY. Write queries which manipulate rows in a
Use logical functions. Filter data in the SELECT clause with table by using APPLY with the results of a
Use functions that work with NULL. TOP. derived table or function
Using the GROUP BY Clause Filter data with OFFSET and FETCH. Exploring Window Functions
Filtering Groups with HAVINGAfter Working with Character Data Restrict window functions to rows defined
completing this module, students will be able Working with Date and Time DataAfter in an OVER clause, including partitions
to: completing this module, students will be and frames.
Write queries which summarize data using able to: Write queries which use window functions
built-in aggregate functions. Describe numeric data types, type to operate on a window of rows and return
Use the GROUP BY clause to arrange rows precedence and type conversions. ranking, aggregation and offset
into groups. Write queries using character data types. comparison results.
Use the HAVING clause to filter out groups Write queries using date and time data Working with Grouping SetsAfter
based on a search condition. types. completing this module, students will be
Writing Correlated Subqueries Using Conversion Functions able to:
Using the EXISTS Predicate with Using Logical Functions Write queries which pivot and unpivot
SubqueriesAfter completing this module, Using Functions to Work with NULLAfter result sets
students will be able to: completing this module, students will be Write queries which specify multiple
Describe the uses of queries which are able to: groupings with grouping sets
nested within other queries. Write queries with built-in scalar Executing System Stored Procedures
Write self-contained subqueries which return functions. Querying Dynamic Management
scalar or multi-valued results. Use conversion functions. ObjectsAfter completing this module,
Write correlated subqueries which return Use logical functions. students will be able to:
scalar or multi-valued results. Use functions that work with NULL. Write queries that retrieve system
Use the EXISTS predicate to efficiently Using the GROUP BY Clause metadata using system views and
check for the existence of rows in a Filtering Groups with HAVINGAfter functions.
subquery. completing this module, students will be Execute system stored procedures to
Using Common Table Expressions able to: return system information.
Using Views Write queries which summarize data Write queries that retrieve system
Using Inline Table-Valued FunctionsAfter using built-in aggregate functions. metadata and state information using
completing this module, students will be able Use the GROUP BY clause to arrange system dynamic management views and

to: rows into groups. functions.
Write queries which use derived tables. Use the HAVING clause to filter out Passing Parameters to Stored Procedures
Write queries which use common table groups based on a search condition. Creating Simple Stored Procedures
expressions. Writing Correlated Subqueries Working with Dynamic SQLAfter
Create simple views and write queries Using the EXISTS Predicate with completing this module, students will be
against them. SubqueriesAfter completing this module, able to:
Create simple inline table-valued functions students will be able to: Return results by executing stored
and write queries against them. Describe the uses of queries which are procedures.
Using EXCEPT and INTERSECT nested within other queries. Pass parameters to procedures.
Using APPLYAfter completing this module, Write self-contained subqueries which Create simple stored procedures which
students will be able to: return scalar or multi-valued results. encapsulate a SELECT statement.
Write queries which combine data using the Write correlated subqueries which return Construct and execute dynamic SQL with
UNION operator scalar or multi-valued results. EXEC and sp_executesql.
Write queries which compare sets using the Use the EXISTS predicate to efficiently Controlling Program FlowAfter completing
INTERSECT and EXCEPT operators check for the existence of rows in a this module, students will be able to:
Write queries which manipulate rows in a subquery. Describe the language elements of T-SQL
table by using APPLY with the results of a Using Common Table Expressions used for simple programming tasks.
derived table or function Using Views Describe batches and how they are
Exploring Window Functions Using Inline Table-Valued FunctionsAfter handled by SQL Server.
Restrict window functions to rows defined in completing this module, students will be Declare and assign variables and
an OVER clause, including partitions and able to: synonyms.
frames. Write queries which use derived tables. Use IF and WHILE blocks to control
Write queries which use window functions to Write queries which use common table program flow.
operate on a window of rows and return expressions. Working with Error InformationAfter
ranking, aggregation and offset comparison Create simple views and write queries completing this module, students will be
results. against them. able to:
Working with Grouping SetsAfter completing Create simple inline table-valued Describe SQL Server's behavior when
this module, students will be able to: functions and write queries against them. errors occur in T-SQL code.
Write queries which pivot and unpivot result Using EXCEPT and INTERSECT Implement structured exception handling in
sets Using APPLYAfter completing this T-SQL.
Write queries which specify multiple module, students will be able to: Return information about errors from
groupings with grouping sets Write queries which combine data using system objects.
Executing System Stored Procedures the UNION operator Raise user-defined errors and pass system
Querying Dynamic Management Write queries which compare sets using errors in T-SQL code.
ObjectsAfter completing this module, the INTERSECT and EXCEPT operators Controlling TransactionsAfter completing
students will be able to: Write queries which manipulate rows in a this module, students will be able to:
Write queries that retrieve system metadata table by using APPLY with the results of Describe transactions and the differences
using system views and functions. a derived table or function between batches and transactions.
Execute system stored procedures to return Exploring Window Functions Describe batches and how they are
system information. Restrict window functions to rows defined handled by SQL Server.
Write queries that retrieve system metadata in an OVER clause, including partitions Create and manage transactions with
and state information using system dynamic and frames. transaction control language statements.
management views and functions. Write queries which use window Use SET XACT_ABORT to define SQL
Passing Parameters to Stored Procedures functions to operate on a window of rows Server's handling of transactions outside
Creating Simple Stored Procedures and return ranking, aggregation and TRY / CATCH blocks.
Working with Dynamic SQLAfter completing offset comparison results. Displaying Query Performance DataAfter
this module, students will be able to: Working with Grouping SetsAfter completing this module, students will be
Return results by executing stored completing this module, students will be able to:
procedures. able to: Describe components of well-performing
Pass parameters to procedures. Write queries which pivot and unpivot queries.
Create simple stored procedures which result sets Describe the role of indexes and statistics
encapsulate a SELECT statement. Write queries which specify multiple in SQL Server
Construct and execute dynamic SQL with groupings with grouping sets Display and interpret basic query plans
EXEC and sp_executesql. Executing System Stored Procedures Display and interpret basic query
Controlling Program FlowAfter completing Querying Dynamic Management performance data
this module, students will be able to: ObjectsAfter completing this module,
Describe the language elements of T-SQL students will be able to:
used for simple programming tasks. Write queries that retrieve system line
Describe batches and how they are handled metadata using system views and Getting Started with SQL Server
by SQL Server. functions. Management Studio
Declare and assign variables and synonyms. Execute system stored procedures to Work with SQL Server Management
Use IF and WHILE blocks to control return system information. Studio.
program flow. Write queries that retrieve system Working with SQL AzureAfter completing
Working with Error InformationAfter metadata and state information using this module, students will be able to:
completing this module, students will be able system dynamic management views and Describe the basic features of SQL Azure.
to: functions. Provision a SQL Azure server and

Describe SQL Server's behavior when errors Passing Parameters to Stored configure its security.
occur in T-SQL code. Procedures Understanding Sets
Implement structured exception handling in Creating Simple Stored Procedures Understanding Predicate Logic
T-SQL. Working with Dynamic SQLAfter Understanding the Logical Order of
Return information about errors from system completing this module, students will be Operations in SELECT statementsAfter
objects. able to: completing this module, students will be
Raise user-defined errors and pass system Return results by executing stored able to:
errors in T-SQL code. procedures. Describe the elements of T-SQL and their
Controlling TransactionsAfter completing Pass parameters to procedures. role in writing queries
this module, students will be able to: Create simple stored procedures which Describe the use of sets in SQL Server
Describe transactions and the differences encapsulate a SELECT statement. Describe the use of predicate logic in SQL
between batches and transactions. Construct and execute dynamic SQL with Server
Describe batches and how they are handled EXEC and sp_executesql. Describe the logical order of operations in
by SQL Server. Controlling Program FlowAfter SELECT statements
Create and manage transactions with completing this module, students will be Eliminating Duplicates with DISTINCT
transaction control language statements. able to: Using Column and Table Aliases
Use SET XACT_ABORT to define SQL Describe the language elements of Writing Simple CASE Expressions
Server's handling of transactions outside T-SQL used for simple programming Eliminate duplicates using the DISTINCT
TRY / CATCH blocks. tasks. clause.
Displaying Query Performance DataAfter Describe batches and how they are Use column and table aliases.
completing this module, students will be able handled by SQL Server. Write simple CASE expressions.
to: Declare and assign variables and Querying with Inner Joins
Describe components of well-performing synonyms. Querying with Outer Joins
queries. Use IF and WHILE blocks to control Querying with Cross Joins and Self
Describe the role of indexes and statistics in program flow. JoinsAfter completing this module,
SQL Server Working with Error InformationAfter students will be able to:
Display and interpret basic query plans completing this module, students will be Describe how multiple tables may be
Display and interpret basic query able to: queried in a SELECT statement using
performance data Describe SQL Server's behavior when joins.
errors occur in T-SQL code. Write queries that use inner joins.
Implement structured exception handling Write queries that use outer joins.
line in T-SQL. Write queries that use self-joins and cross
Getting Started with SQL Server Return information about errors from joins.
Management Studio system objects. Filtering Data with a WHERE Clause
Work with SQL Server Management Studio. Raise user-defined errors and pass Filtering with the TOP and
Working with SQL AzureAfter completing system errors in T-SQL code. OFFSET-FETCH Options
this module, students will be able to: Controlling TransactionsAfter completing Working with Unknown and Missing
Describe the basic features of SQL Azure. this module, students will be able to: ValuesAfter completing this module,
Provision a SQL Azure server and configure Describe transactions and the differences students will be able to:
its security. between batches and transactions. Filter data with predicates in the WHERE
Understanding Sets Describe batches and how they are clause.
Understanding Predicate Logic handled by SQL Server. Sort data using ORDER BY.
Understanding the Logical Order of Create and manage transactions with Filter data in the SELECT clause with
Operations in SELECT statementsAfter transaction control language statements. TOP.
completing this module, students will be able Use SET XACT_ABORT to define SQL Filter data with OFFSET and FETCH.
to: Server's handling of transactions outside Working with Character Data
Describe the elements of T-SQL and their TRY / CATCH blocks. Working with Date and Time DataAfter
role in writing queries Displaying Query Performance DataAfter completing this module, students will be
Describe the use of sets in SQL Server completing this module, students will be able to:
Describe the use of predicate logic in SQL able to: Describe numeric data types, type
Server Describe components of well-performing precedence and type conversions.
Describe the logical order of operations in queries. Write queries using character data types.
SELECT statements Describe the role of indexes and statistics Write queries using date and time data
Eliminating Duplicates with DISTINCT in SQL Server types.
Using Column and Table Aliases Display and interpret basic query plans Using Conversion Functions
Writing Simple CASE Expressions Display and interpret basic query Using Logical Functions
Eliminate duplicates using the DISTINCT performance data Using Functions to Work with NULLAfter
clause. completing this module, students will be
Use column and table aliases. Module 11: Using Table Expressions able to:
Write simple CASE expressions. line Write queries with built-in scalar functions.
Querying with Inner Joins Use conversion functions.
Querying with Outer Joins This module introduces T-SQL expressions Use logical functions.
Querying with Cross Joins and Self which return a valid relational table, typically Use functions that work with NULL.
JoinsAfter completing this module, students for further use in the query. The module Using the GROUP BY Clause
will be able to: discusses views, derived tables, common Filtering Groups with HAVINGAfter
Describe how multiple tables may be table expressions and inline table-valued completing this module, students will be

queried in a SELECT statement using joins. functions. able to:
Write queries that use inner joins. line Write queries which summarize data using
Write queries that use outer joins. Using Derived Tables built-in aggregate functions.
Write queries that use self-joins and cross Use the GROUP BY clause to arrange
joins. rows into groups.
Filtering Data with a WHERE Clause line Use the HAVING clause to filter out groups
Filtering with the TOP and OFFSET-FETCH Getting Started with SQL Server based on a search condition.
Options Management Studio Writing Correlated Subqueries
Working with Unknown and Missing Work with SQL Server Management Using the EXISTS Predicate with
ValuesAfter completing this module, Studio. SubqueriesAfter completing this module,
students will be able to: Working with SQL AzureAfter completing students will be able to:
Filter data with predicates in the WHERE this module, students will be able to: Describe the uses of queries which are
clause. Describe the basic features of SQL nested within other queries.
Sort data using ORDER BY. Azure. Write self-contained subqueries which
Filter data in the SELECT clause with TOP. Provision a SQL Azure server and return scalar or multi-valued results.
Filter data with OFFSET and FETCH. configure its security. Write correlated subqueries which return
Working with Character Data Understanding Sets scalar or multi-valued results.
Working with Date and Time DataAfter Understanding Predicate Logic Use the EXISTS predicate to efficiently
completing this module, students will be able Understanding the Logical Order of check for the existence of rows in a
to: Operations in SELECT statementsAfter subquery.
Describe numeric data types, type completing this module, students will be Using Common Table Expressions
precedence and type conversions. able to: Using Views
Write queries using character data types. Describe the elements of T-SQL and their Using Inline Table-Valued FunctionsAfter
Write queries using date and time data role in writing queries completing this module, students will be
types. Describe the use of sets in SQL Server able to:
Using Conversion Functions Describe the use of predicate logic in Write queries which use derived tables.
Using Logical Functions SQL Server Write queries which use common table
Using Functions to Work with NULLAfter Describe the logical order of operations in expressions.
completing this module, students will be able SELECT statements Create simple views and write queries
to: Eliminating Duplicates with DISTINCT against them.
Write queries with built-in scalar functions. Using Column and Table Aliases Create simple inline table-valued functions
Use conversion functions. Writing Simple CASE Expressions and write queries against them.
Use logical functions. Eliminate duplicates using the DISTINCT Using EXCEPT and INTERSECT
Use functions that work with NULL. clause. Using APPLYAfter completing this module,
Using the GROUP BY Clause Use column and table aliases. students will be able to:
Filtering Groups with HAVINGAfter Write simple CASE expressions. Write queries which combine data using
completing this module, students will be able Querying with Inner Joins the UNION operator
to: Querying with Outer Joins Write queries which compare sets using
Write queries which summarize data using Querying with Cross Joins and Self the INTERSECT and EXCEPT operators
built-in aggregate functions. JoinsAfter completing this module, Write queries which manipulate rows in a
Use the GROUP BY clause to arrange rows students will be able to: table by using APPLY with the results of a
into groups. Describe how multiple tables may be derived table or function
Use the HAVING clause to filter out groups queried in a SELECT statement using Exploring Window Functions
based on a search condition. joins. Restrict window functions to rows defined
Writing Correlated Subqueries Write queries that use inner joins. in an OVER clause, including partitions
Using the EXISTS Predicate with Write queries that use outer joins. and frames.
SubqueriesAfter completing this module, Write queries that use self-joins and Write queries which use window functions
students will be able to: cross joins. to operate on a window of rows and return
Describe the uses of queries which are Filtering Data with a WHERE Clause ranking, aggregation and offset
nested within other queries. Filtering with the TOP and comparison results.
Write self-contained subqueries which return OFFSET-FETCH Options Working with Grouping SetsAfter
scalar or multi-valued results. Working with Unknown and Missing completing this module, students will be
Write correlated subqueries which return ValuesAfter completing this module, able to:
scalar or multi-valued results. students will be able to: Write queries which pivot and unpivot
Use the EXISTS predicate to efficiently Filter data with predicates in the WHERE result sets
check for the existence of rows in a clause. Write queries which specify multiple
subquery. Sort data using ORDER BY. groupings with grouping sets
Using Common Table Expressions Filter data in the SELECT clause with Executing System Stored Procedures
Using Views TOP. Querying Dynamic Management
Using Inline Table-Valued FunctionsAfter Filter data with OFFSET and FETCH. ObjectsAfter completing this module,
completing this module, students will be able Working with Character Data students will be able to:
to: Working with Date and Time DataAfter Write queries that retrieve system
Write queries which use derived tables. completing this module, students will be metadata using system views and
Write queries which use common table able to: functions.
expressions. Describe numeric data types, type Execute system stored procedures to
Create simple views and write queries precedence and type conversions. return system information.

against them. Write queries using character data types. Write queries that retrieve system
Create simple inline table-valued functions Write queries using date and time data metadata and state information using
and write queries against them. types. system dynamic management views and
Using EXCEPT and INTERSECT Using Conversion Functions functions.
Using APPLYAfter completing this module, Using Logical Functions Passing Parameters to Stored Procedures
students will be able to: Using Functions to Work with NULLAfter Creating Simple Stored Procedures
Write queries which combine data using the completing this module, students will be Working with Dynamic SQLAfter
UNION operator able to: completing this module, students will be
Write queries which compare sets using the Write queries with built-in scalar able to:
INTERSECT and EXCEPT operators functions. Return results by executing stored
Write queries which manipulate rows in a Use conversion functions. procedures.
table by using APPLY with the results of a Use logical functions. Pass parameters to procedures.
derived table or function Use functions that work with NULL. Create simple stored procedures which
Exploring Window Functions Using the GROUP BY Clause encapsulate a SELECT statement.
Restrict window functions to rows defined in Filtering Groups with HAVINGAfter Construct and execute dynamic SQL with
an OVER clause, including partitions and completing this module, students will be EXEC and sp_executesql.
frames. able to: Controlling Program FlowAfter completing
Write queries which use window functions to Write queries which summarize data this module, students will be able to:
operate on a window of rows and return using built-in aggregate functions. Describe the language elements of T-SQL
ranking, aggregation and offset comparison Use the GROUP BY clause to arrange used for simple programming tasks.
results. rows into groups. Describe batches and how they are
Working with Grouping SetsAfter completing Use the HAVING clause to filter out handled by SQL Server.
this module, students will be able to: groups based on a search condition. Declare and assign variables and
Write queries which pivot and unpivot result Writing Correlated Subqueries synonyms.
sets Using the EXISTS Predicate with Use IF and WHILE blocks to control
Write queries which specify multiple SubqueriesAfter completing this module, program flow.
groupings with grouping sets students will be able to: Working with Error InformationAfter
Executing System Stored Procedures Describe the uses of queries which are completing this module, students will be
Querying Dynamic Management nested within other queries. able to:
ObjectsAfter completing this module, Write self-contained subqueries which Describe SQL Server's behavior when
students will be able to: return scalar or multi-valued results. errors occur in T-SQL code.
Write queries that retrieve system metadata Write correlated subqueries which return Implement structured exception handling in
using system views and functions. scalar or multi-valued results. T-SQL.
Execute system stored procedures to return Use the EXISTS predicate to efficiently Return information about errors from
system information. check for the existence of rows in a system objects.
Write queries that retrieve system metadata subquery. Raise user-defined errors and pass system
and state information using system dynamic Using Common Table Expressions errors in T-SQL code.
management views and functions. Using Views Controlling TransactionsAfter completing
Passing Parameters to Stored Procedures Using Inline Table-Valued FunctionsAfter this module, students will be able to:
Creating Simple Stored Procedures completing this module, students will be Describe transactions and the differences
Working with Dynamic SQLAfter completing able to: between batches and transactions.
this module, students will be able to: Write queries which use derived tables. Describe batches and how they are
Return results by executing stored Write queries which use common table handled by SQL Server.
procedures. expressions. Create and manage transactions with
Pass parameters to procedures. Create simple views and write queries transaction control language statements.
Create simple stored procedures which against them. Use SET XACT_ABORT to define SQL
encapsulate a SELECT statement. Create simple inline table-valued Server's handling of transactions outside
Construct and execute dynamic SQL with functions and write queries against them. TRY / CATCH blocks.
EXEC and sp_executesql. Using EXCEPT and INTERSECT Displaying Query Performance DataAfter
Controlling Program FlowAfter completing Using APPLYAfter completing this completing this module, students will be
this module, students will be able to: module, students will be able to: able to:
Describe the language elements of T-SQL Write queries which combine data using Describe components of well-performing
used for simple programming tasks. the UNION operator queries.
Describe batches and how they are handled Write queries which compare sets using Describe the role of indexes and statistics
by SQL Server. the INTERSECT and EXCEPT operators in SQL Server
Declare and assign variables and synonyms. Write queries which manipulate rows in a Display and interpret basic query plans
Use IF and WHILE blocks to control table by using APPLY with the results of Display and interpret basic query
program flow. a derived table or function performance data
Working with Error InformationAfter Exploring Window Functions
completing this module, students will be able Restrict window functions to rows defined
to: in an OVER clause, including partitions line
Describe SQL Server's behavior when errors and frames. Getting Started with SQL Server
occur in T-SQL code. Write queries which use window Management Studio
Implement structured exception handling in functions to operate on a window of rows Work with SQL Server Management
T-SQL. and return ranking, aggregation and Studio.
Return information about errors from system offset comparison results. Working with SQL AzureAfter completing

objects. Working with Grouping SetsAfter this module, students will be able to:
Raise user-defined errors and pass system completing this module, students will be Describe the basic features of SQL Azure.
errors in T-SQL code. able to: Provision a SQL Azure server and
Controlling TransactionsAfter completing Write queries which pivot and unpivot configure its security.
this module, students will be able to: result sets Understanding Sets
Describe transactions and the differences Write queries which specify multiple Understanding Predicate Logic
between batches and transactions. groupings with grouping sets Understanding the Logical Order of
Describe batches and how they are handled Executing System Stored Procedures Operations in SELECT statementsAfter
by SQL Server. Querying Dynamic Management completing this module, students will be
Create and manage transactions with ObjectsAfter completing this module, able to:
transaction control language statements. students will be able to: Describe the elements of T-SQL and their
Use SET XACT_ABORT to define SQL Write queries that retrieve system role in writing queries
Server's handling of transactions outside metadata using system views and Describe the use of sets in SQL Server
TRY / CATCH blocks. functions. Describe the use of predicate logic in SQL
Displaying Query Performance DataAfter Execute system stored procedures to Server
completing this module, students will be able return system information. Describe the logical order of operations in
to: Write queries that retrieve system SELECT statements
Describe components of well-performing metadata and state information using Eliminating Duplicates with DISTINCT
queries. system dynamic management views and Using Column and Table Aliases
Describe the role of indexes and statistics in functions. Writing Simple CASE Expressions
SQL Server Passing Parameters to Stored Eliminate duplicates using the DISTINCT
Display and interpret basic query plans Procedures clause.
Display and interpret basic query Creating Simple Stored Procedures Use column and table aliases.
performance data Working with Dynamic SQLAfter Write simple CASE expressions.
completing this module, students will be Querying with Inner Joins
able to: Querying with Outer Joins
line Return results by executing stored Querying with Cross Joins and Self
Getting Started with SQL Server procedures. JoinsAfter completing this module,
Management Studio Pass parameters to procedures. students will be able to:
Work with SQL Server Management Studio. Create simple stored procedures which Describe how multiple tables may be
Working with SQL AzureAfter completing encapsulate a SELECT statement. queried in a SELECT statement using
this module, students will be able to: Construct and execute dynamic SQL with joins.
Describe the basic features of SQL Azure. EXEC and sp_executesql. Write queries that use inner joins.
Provision a SQL Azure server and configure Controlling Program FlowAfter Write queries that use outer joins.
its security. completing this module, students will be Write queries that use self-joins and cross
Understanding Sets able to: joins.
Understanding Predicate Logic Describe the language elements of Filtering Data with a WHERE Clause
Understanding the Logical Order of T-SQL used for simple programming Filtering with the TOP and
Operations in SELECT statementsAfter tasks. OFFSET-FETCH Options
completing this module, students will be able Describe batches and how they are Working with Unknown and Missing
to: handled by SQL Server. ValuesAfter completing this module,
Describe the elements of T-SQL and their Declare and assign variables and students will be able to:
role in writing queries synonyms. Filter data with predicates in the WHERE
Describe the use of sets in SQL Server Use IF and WHILE blocks to control clause.
Describe the use of predicate logic in SQL program flow. Sort data using ORDER BY.
Server Working with Error InformationAfter Filter data in the SELECT clause with
Describe the logical order of operations in completing this module, students will be TOP.
SELECT statements able to: Filter data with OFFSET and FETCH.
Eliminating Duplicates with DISTINCT Describe SQL Server's behavior when Working with Character Data
Using Column and Table Aliases errors occur in T-SQL code. Working with Date and Time DataAfter
Writing Simple CASE Expressions Implement structured exception handling completing this module, students will be
Eliminate duplicates using the DISTINCT in T-SQL. able to:
clause. Return information about errors from Describe numeric data types, type
Use column and table aliases. system objects. precedence and type conversions.
Write simple CASE expressions. Raise user-defined errors and pass Write queries using character data types.
Querying with Inner Joins system errors in T-SQL code. Write queries using date and time data
Querying with Outer Joins Controlling TransactionsAfter completing types.
Querying with Cross Joins and Self this module, students will be able to: Using Conversion Functions
JoinsAfter completing this module, students Describe transactions and the differences Using Logical Functions
will be able to: between batches and transactions. Using Functions to Work with NULLAfter
Describe how multiple tables may be Describe batches and how they are completing this module, students will be
queried in a SELECT statement using joins. handled by SQL Server. able to:
Write queries that use inner joins. Create and manage transactions with Write queries with built-in scalar functions.
Write queries that use outer joins. transaction control language statements. Use conversion functions.
Write queries that use self-joins and cross Use SET XACT_ABORT to define SQL Use logical functions.
joins. Server's handling of transactions outside Use functions that work with NULL.

Filtering Data with a WHERE Clause TRY / CATCH blocks. Using the GROUP BY Clause
Filtering with the TOP and OFFSET-FETCH Displaying Query Performance DataAfter Filtering Groups with HAVINGAfter
Options completing this module, students will be completing this module, students will be
Working with Unknown and Missing able to: able to:
ValuesAfter completing this module, Describe components of well-performing Write queries which summarize data using
students will be able to: queries. built-in aggregate functions.
Filter data with predicates in the WHERE Describe the role of indexes and statistics Use the GROUP BY clause to arrange
clause. in SQL Server rows into groups.
Sort data using ORDER BY. Display and interpret basic query plans Use the HAVING clause to filter out groups
Filter data in the SELECT clause with TOP. Display and interpret basic query based on a search condition.
Filter data with OFFSET and FETCH. performance data Writing Correlated Subqueries
Working with Character Data Using the EXISTS Predicate with
Working with Date and Time DataAfter SubqueriesAfter completing this module,
completing this module, students will be able line students will be able to:
to: Getting Started with SQL Server Describe the uses of queries which are
Describe numeric data types, type Management Studio nested within other queries.
precedence and type conversions. Work with SQL Server Management Write self-contained subqueries which
Write queries using character data types. Studio. return scalar or multi-valued results.
Write queries using date and time data Working with SQL AzureAfter completing Write correlated subqueries which return
types. this module, students will be able to: scalar or multi-valued results.
Using Conversion Functions Describe the basic features of SQL Use the EXISTS predicate to efficiently
Using Logical Functions Azure. check for the existence of rows in a
Using Functions to Work with NULLAfter Provision a SQL Azure server and subquery.
completing this module, students will be able configure its security. Using Common Table Expressions
to: Understanding Sets Using Views
Write queries with built-in scalar functions. Understanding Predicate Logic Using Inline Table-Valued FunctionsAfter
Use conversion functions. Understanding the Logical Order of completing this module, students will be
Use logical functions. Operations in SELECT statementsAfter able to:
Use functions that work with NULL. completing this module, students will be Write queries which use derived tables.
Using the GROUP BY Clause able to: Write queries which use common table
Filtering Groups with HAVINGAfter Describe the elements of T-SQL and their expressions.
completing this module, students will be able role in writing queries Create simple views and write queries
to: Describe the use of sets in SQL Server against them.
Write queries which summarize data using Describe the use of predicate logic in Create simple inline table-valued functions
built-in aggregate functions. SQL Server and write queries against them.
Use the GROUP BY clause to arrange rows Describe the logical order of operations in Using EXCEPT and INTERSECT
into groups. SELECT statements Using APPLYAfter completing this module,
Use the HAVING clause to filter out groups Eliminating Duplicates with DISTINCT students will be able to:
based on a search condition. Using Column and Table Aliases Write queries which combine data using
Writing Correlated Subqueries Writing Simple CASE Expressions the UNION operator
Using the EXISTS Predicate with Eliminate duplicates using the DISTINCT Write queries which compare sets using
SubqueriesAfter completing this module, clause. the INTERSECT and EXCEPT operators
students will be able to: Use column and table aliases. Write queries which manipulate rows in a
Describe the uses of queries which are Write simple CASE expressions. table by using APPLY with the results of a
nested within other queries. Querying with Inner Joins derived table or function
Write self-contained subqueries which return Querying with Outer Joins Exploring Window Functions
scalar or multi-valued results. Querying with Cross Joins and Self Restrict window functions to rows defined
Write correlated subqueries which return JoinsAfter completing this module, in an OVER clause, including partitions
scalar or multi-valued results. students will be able to: and frames.
Use the EXISTS predicate to efficiently Describe how multiple tables may be Write queries which use window functions
check for the existence of rows in a queried in a SELECT statement using to operate on a window of rows and return
subquery. joins. ranking, aggregation and offset
Using Common Table Expressions Write queries that use inner joins. comparison results.
Using Views Write queries that use outer joins. Working with Grouping SetsAfter
Using Inline Table-Valued FunctionsAfter Write queries that use self-joins and completing this module, students will be
completing this module, students will be able cross joins. able to:
to: Filtering Data with a WHERE Clause Write queries which pivot and unpivot
Write queries which use derived tables. Filtering with the TOP and result sets
Write queries which use common table OFFSET-FETCH Options Write queries which specify multiple
expressions. Working with Unknown and Missing groupings with grouping sets
Create simple views and write queries ValuesAfter completing this module, Executing System Stored Procedures
against them. students will be able to: Querying Dynamic Management
Create simple inline table-valued functions Filter data with predicates in the WHERE ObjectsAfter completing this module,
and write queries against them. clause. students will be able to:
Using EXCEPT and INTERSECT Sort data using ORDER BY. Write queries that retrieve system
Using APPLYAfter completing this module, Filter data in the SELECT clause with metadata using system views and

students will be able to: TOP. functions.
Write queries which combine data using the Filter data with OFFSET and FETCH. Execute system stored procedures to
UNION operator Working with Character Data return system information.
Write queries which compare sets using the Working with Date and Time DataAfter Write queries that retrieve system
INTERSECT and EXCEPT operators completing this module, students will be metadata and state information using
Write queries which manipulate rows in a able to: system dynamic management views and
table by using APPLY with the results of a Describe numeric data types, type functions.
derived table or function precedence and type conversions. Passing Parameters to Stored Procedures
Exploring Window Functions Write queries using character data types. Creating Simple Stored Procedures
Restrict window functions to rows defined in Write queries using date and time data Working with Dynamic SQLAfter
an OVER clause, including partitions and types. completing this module, students will be
frames. Using Conversion Functions able to:
Write queries which use window functions to Using Logical Functions Return results by executing stored
operate on a window of rows and return Using Functions to Work with NULLAfter procedures.
ranking, aggregation and offset comparison completing this module, students will be Pass parameters to procedures.
results. able to: Create simple stored procedures which
Working with Grouping SetsAfter completing Write queries with built-in scalar encapsulate a SELECT statement.
this module, students will be able to: functions. Construct and execute dynamic SQL with
Write queries which pivot and unpivot result Use conversion functions. EXEC and sp_executesql.
sets Use logical functions. Controlling Program FlowAfter completing
Write queries which specify multiple Use functions that work with NULL. this module, students will be able to:
groupings with grouping sets Using the GROUP BY Clause Describe the language elements of T-SQL
Executing System Stored Procedures Filtering Groups with HAVINGAfter used for simple programming tasks.
Querying Dynamic Management completing this module, students will be Describe batches and how they are
ObjectsAfter completing this module, able to: handled by SQL Server.
students will be able to: Write queries which summarize data Declare and assign variables and
Write queries that retrieve system metadata using built-in aggregate functions. synonyms.
using system views and functions. Use the GROUP BY clause to arrange Use IF and WHILE blocks to control
Execute system stored procedures to return rows into groups. program flow.
system information. Use the HAVING clause to filter out Working with Error InformationAfter
Write queries that retrieve system metadata groups based on a search condition. completing this module, students will be
and state information using system dynamic Writing Correlated Subqueries able to:
management views and functions. Using the EXISTS Predicate with Describe SQL Server's behavior when
Passing Parameters to Stored Procedures SubqueriesAfter completing this module, errors occur in T-SQL code.
Creating Simple Stored Procedures students will be able to: Implement structured exception handling in
Working with Dynamic SQLAfter completing Describe the uses of queries which are T-SQL.
this module, students will be able to: nested within other queries. Return information about errors from
Return results by executing stored Write self-contained subqueries which system objects.
procedures. return scalar or multi-valued results. Raise user-defined errors and pass system
Pass parameters to procedures. Write correlated subqueries which return errors in T-SQL code.
Create simple stored procedures which scalar or multi-valued results. Controlling TransactionsAfter completing
encapsulate a SELECT statement. Use the EXISTS predicate to efficiently this module, students will be able to:
Construct and execute dynamic SQL with check for the existence of rows in a Describe transactions and the differences
EXEC and sp_executesql. subquery. between batches and transactions.
Controlling Program FlowAfter completing Using Common Table Expressions Describe batches and how they are
this module, students will be able to: Using Views handled by SQL Server.
Describe the language elements of T-SQL Using Inline Table-Valued FunctionsAfter Create and manage transactions with
used for simple programming tasks. completing this module, students will be transaction control language statements.
Describe batches and how they are handled able to: Use SET XACT_ABORT to define SQL
by SQL Server. Write queries which use derived tables. Server's handling of transactions outside
Declare and assign variables and synonyms. Write queries which use common table TRY / CATCH blocks.
Use IF and WHILE blocks to control expressions. Displaying Query Performance DataAfter
program flow. Create simple views and write queries completing this module, students will be
Working with Error InformationAfter against them. able to:
completing this module, students will be able Create simple inline table-valued Describe components of well-performing
to: functions and write queries against them. queries.
Describe SQL Server's behavior when errors Using EXCEPT and INTERSECT Describe the role of indexes and statistics
occur in T-SQL code. Using APPLYAfter completing this in SQL Server
Implement structured exception handling in module, students will be able to: Display and interpret basic query plans
T-SQL. Write queries which combine data using Display and interpret basic query
Return information about errors from system the UNION operator performance data
objects. Write queries which compare sets using
Raise user-defined errors and pass system the INTERSECT and EXCEPT operators Module 19: Implementing Transactions
errors in T-SQL code. Write queries which manipulate rows in a line
Controlling TransactionsAfter completing table by using APPLY with the results of
this module, students will be able to: a derived table or function This module introduces the concepts of

Describe transactions and the differences Exploring Window Functions transaction management in SQL Server. It will
between batches and transactions. Restrict window functions to rows defined provide a high-level overview of transaction
Describe batches and how they are handled in an OVER clause, including partitions properties, cover the basics of marking
by SQL Server. and frames. transactions with BEGIN, COMMIT and
Create and manage transactions with Write queries which use window ROLLBACK.
transaction control language statements. functions to operate on a window of rows line
Use SET XACT_ABORT to define SQL and return ranking, aggregation and Transactions and the Database Engine
Server's handling of transactions outside offset comparison results.
TRY / CATCH blocks. Working with Grouping SetsAfter
Displaying Query Performance DataAfter completing this module, students will be line
completing this module, students will be able able to: Getting Started with SQL Server
to: Write queries which pivot and unpivot Management Studio
Describe components of well-performing result sets Work with SQL Server Management
queries. Write queries which specify multiple Studio.
Describe the role of indexes and statistics in groupings with grouping sets Working with SQL AzureAfter completing
SQL Server Executing System Stored Procedures this module, students will be able to:
Display and interpret basic query plans Querying Dynamic Management Describe the basic features of SQL Azure.
Display and interpret basic query ObjectsAfter completing this module, Provision a SQL Azure server and
performance data students will be able to: configure its security.
Write queries that retrieve system Understanding Sets
Module 6: Sorting and Filtering Data metadata using system views and Understanding Predicate Logic
line functions. Understanding the Logical Order of
Execute system stored procedures to Operations in SELECT statementsAfter
This module explains how to enhance queries return system information. completing this module, students will be
to limit the rows they return, and to control the Write queries that retrieve system able to:
order in which the rows are displayed. The metadata and state information using Describe the elements of T-SQL and their
module also discusses how to resolve missing system dynamic management views and role in writing queries
and unknown results. functions. Describe the use of sets in SQL Server
line Passing Parameters to Stored Describe the use of predicate logic in SQL
Sorting Data Procedures Server
Creating Simple Stored Procedures Describe the logical order of operations in
Working with Dynamic SQLAfter SELECT statements
line completing this module, students will be Eliminating Duplicates with DISTINCT
Getting Started with SQL Server able to: Using Column and Table Aliases
Management Studio Return results by executing stored Writing Simple CASE Expressions
Work with SQL Server Management Studio. procedures. Eliminate duplicates using the DISTINCT
Working with SQL AzureAfter completing Pass parameters to procedures. clause.
this module, students will be able to: Create simple stored procedures which Use column and table aliases.
Describe the basic features of SQL Azure. encapsulate a SELECT statement. Write simple CASE expressions.
Provision a SQL Azure server and configure Construct and execute dynamic SQL with Querying with Inner Joins
its security. EXEC and sp_executesql. Querying with Outer Joins
Understanding Sets Controlling Program FlowAfter Querying with Cross Joins and Self
Understanding Predicate Logic completing this module, students will be JoinsAfter completing this module,
Understanding the Logical Order of able to: students will be able to:
Operations in SELECT statementsAfter Describe the language elements of Describe how multiple tables may be
completing this module, students will be able T-SQL used for simple programming queried in a SELECT statement using
to: tasks. joins.
Describe the elements of T-SQL and their Describe batches and how they are Write queries that use inner joins.
role in writing queries handled by SQL Server. Write queries that use outer joins.
Describe the use of sets in SQL Server Declare and assign variables and Write queries that use self-joins and cross
Describe the use of predicate logic in SQL synonyms. joins.
Server Use IF and WHILE blocks to control Filtering Data with a WHERE Clause
Describe the logical order of operations in program flow. Filtering with the TOP and
SELECT statements Working with Error InformationAfter OFFSET-FETCH Options
Eliminating Duplicates with DISTINCT completing this module, students will be Working with Unknown and Missing
Using Column and Table Aliases able to: ValuesAfter completing this module,
Writing Simple CASE Expressions Describe SQL Server's behavior when students will be able to:
Eliminate duplicates using the DISTINCT errors occur in T-SQL code. Filter data with predicates in the WHERE
clause. Implement structured exception handling clause.
Use column and table aliases. in T-SQL. Sort data using ORDER BY.
Write simple CASE expressions. Return information about errors from Filter data in the SELECT clause with
Querying with Inner Joins system objects. TOP.
Querying with Outer Joins Raise user-defined errors and pass Filter data with OFFSET and FETCH.
Querying with Cross Joins and Self system errors in T-SQL code. Working with Character Data
JoinsAfter completing this module, students Controlling TransactionsAfter completing Working with Date and Time DataAfter
will be able to: this module, students will be able to: completing this module, students will be

Describe how multiple tables may be Describe transactions and the differences able to:
queried in a SELECT statement using joins. between batches and transactions. Describe numeric data types, type
Write queries that use inner joins. Describe batches and how they are precedence and type conversions.
Write queries that use outer joins. handled by SQL Server. Write queries using character data types.
Write queries that use self-joins and cross Create and manage transactions with Write queries using date and time data
joins. transaction control language statements. types.
Filtering Data with a WHERE Clause Use SET XACT_ABORT to define SQL Using Conversion Functions
Filtering with the TOP and OFFSET-FETCH Server's handling of transactions outside Using Logical Functions
Options TRY / CATCH blocks. Using Functions to Work with NULLAfter
Working with Unknown and Missing Displaying Query Performance DataAfter completing this module, students will be
ValuesAfter completing this module, completing this module, students will be able to:
students will be able to: able to: Write queries with built-in scalar functions.
Filter data with predicates in the WHERE Describe components of well-performing Use conversion functions.
clause. queries. Use logical functions.
Sort data using ORDER BY. Describe the role of indexes and statistics Use functions that work with NULL.
Filter data in the SELECT clause with TOP. in SQL Server Using the GROUP BY Clause
Filter data with OFFSET and FETCH. Display and interpret basic query plans Filtering Groups with HAVINGAfter
Working with Character Data Display and interpret basic query completing this module, students will be
Working with Date and Time DataAfter performance data able to:
completing this module, students will be able Write queries which summarize data using
to: built-in aggregate functions.
Describe numeric data types, type line Use the GROUP BY clause to arrange
precedence and type conversions. Getting Started with SQL Server rows into groups.
Write queries using character data types. Management Studio Use the HAVING clause to filter out groups
Write queries using date and time data Work with SQL Server Management based on a search condition.
types. Studio. Writing Correlated Subqueries
Using Conversion Functions Working with SQL AzureAfter completing Using the EXISTS Predicate with
Using Logical Functions this module, students will be able to: SubqueriesAfter completing this module,
Using Functions to Work with NULLAfter Describe the basic features of SQL students will be able to:
completing this module, students will be able Azure. Describe the uses of queries which are
to: Provision a SQL Azure server and nested within other queries.
Write queries with built-in scalar functions. configure its security. Write self-contained subqueries which
Use conversion functions. Understanding Sets return scalar or multi-valued results.
Use logical functions. Understanding Predicate Logic Write correlated subqueries which return
Use functions that work with NULL. Understanding the Logical Order of scalar or multi-valued results.
Using the GROUP BY Clause Operations in SELECT statementsAfter Use the EXISTS predicate to efficiently
Filtering Groups with HAVINGAfter completing this module, students will be check for the existence of rows in a
completing this module, students will be able able to: subquery.
to: Describe the elements of T-SQL and their Using Common Table Expressions
Write queries which summarize data using role in writing queries Using Views
built-in aggregate functions. Describe the use of sets in SQL Server Using Inline Table-Valued FunctionsAfter
Use the GROUP BY clause to arrange rows Describe the use of predicate logic in completing this module, students will be
into groups. SQL Server able to:
Use the HAVING clause to filter out groups Describe the logical order of operations in Write queries which use derived tables.
based on a search condition. SELECT statements Write queries which use common table
Writing Correlated Subqueries Eliminating Duplicates with DISTINCT expressions.
Using the EXISTS Predicate with Using Column and Table Aliases Create simple views and write queries
SubqueriesAfter completing this module, Writing Simple CASE Expressions against them.
students will be able to: Eliminate duplicates using the DISTINCT Create simple inline table-valued functions
Describe the uses of queries which are clause. and write queries against them.
nested within other queries. Use column and table aliases. Using EXCEPT and INTERSECT
Write self-contained subqueries which return Write simple CASE expressions. Using APPLYAfter completing this module,
scalar or multi-valued results. Querying with Inner Joins students will be able to:
Write correlated subqueries which return Querying with Outer Joins Write queries which combine data using
scalar or multi-valued results. Querying with Cross Joins and Self the UNION operator
Use the EXISTS predicate to efficiently JoinsAfter completing this module, Write queries which compare sets using
check for the existence of rows in a students will be able to: the INTERSECT and EXCEPT operators
subquery. Describe how multiple tables may be Write queries which manipulate rows in a
Using Common Table Expressions queried in a SELECT statement using table by using APPLY with the results of a
Using Views joins. derived table or function
Using Inline Table-Valued FunctionsAfter Write queries that use inner joins. Exploring Window Functions
completing this module, students will be able Write queries that use outer joins. Restrict window functions to rows defined
to: Write queries that use self-joins and in an OVER clause, including partitions
Write queries which use derived tables. cross joins. and frames.
Write queries which use common table Filtering Data with a WHERE Clause Write queries which use window functions
expressions. Filtering with the TOP and to operate on a window of rows and return

Create simple views and write queries OFFSET-FETCH Options ranking, aggregation and offset
against them. Working with Unknown and Missing comparison results.
Create simple inline table-valued functions ValuesAfter completing this module, Working with Grouping SetsAfter
and write queries against them. students will be able to: completing this module, students will be
Using EXCEPT and INTERSECT Filter data with predicates in the WHERE able to:
Using APPLYAfter completing this module, clause. Write queries which pivot and unpivot
students will be able to: Sort data using ORDER BY. result sets
Write queries which combine data using the Filter data in the SELECT clause with Write queries which specify multiple
UNION operator TOP. groupings with grouping sets
Write queries which compare sets using the Filter data with OFFSET and FETCH. Executing System Stored Procedures
INTERSECT and EXCEPT operators Working with Character Data Querying Dynamic Management
Write queries which manipulate rows in a Working with Date and Time DataAfter ObjectsAfter completing this module,
table by using APPLY with the results of a completing this module, students will be students will be able to:
derived table or function able to: Write queries that retrieve system
Exploring Window Functions Describe numeric data types, type metadata using system views and
Restrict window functions to rows defined in precedence and type conversions. functions.
an OVER clause, including partitions and Write queries using character data types. Execute system stored procedures to
frames. Write queries using date and time data return system information.
Write queries which use window functions to types. Write queries that retrieve system
operate on a window of rows and return Using Conversion Functions metadata and state information using
ranking, aggregation and offset comparison Using Logical Functions system dynamic management views and
results. Using Functions to Work with NULLAfter functions.
Working with Grouping SetsAfter completing completing this module, students will be Passing Parameters to Stored Procedures
this module, students will be able to: able to: Creating Simple Stored Procedures
Write queries which pivot and unpivot result Write queries with built-in scalar Working with Dynamic SQLAfter
sets functions. completing this module, students will be
Write queries which specify multiple Use conversion functions. able to:
groupings with grouping sets Use logical functions. Return results by executing stored
Executing System Stored Procedures Use functions that work with NULL. procedures.
Querying Dynamic Management Using the GROUP BY Clause Pass parameters to procedures.
ObjectsAfter completing this module, Filtering Groups with HAVINGAfter Create simple stored procedures which
students will be able to: completing this module, students will be encapsulate a SELECT statement.
Write queries that retrieve system metadata able to: Construct and execute dynamic SQL with
using system views and functions. Write queries which summarize data EXEC and sp_executesql.
Execute system stored procedures to return using built-in aggregate functions. Controlling Program FlowAfter completing
system information. Use the GROUP BY clause to arrange this module, students will be able to:
Write queries that retrieve system metadata rows into groups. Describe the language elements of T-SQL
and state information using system dynamic Use the HAVING clause to filter out used for simple programming tasks.
management views and functions. groups based on a search condition. Describe batches and how they are
Passing Parameters to Stored Procedures Writing Correlated Subqueries handled by SQL Server.
Creating Simple Stored Procedures Using the EXISTS Predicate with Declare and assign variables and
Working with Dynamic SQLAfter completing SubqueriesAfter completing this module, synonyms.
this module, students will be able to: students will be able to: Use IF and WHILE blocks to control
Return results by executing stored Describe the uses of queries which are program flow.
procedures. nested within other queries. Working with Error InformationAfter
Pass parameters to procedures. Write self-contained subqueries which completing this module, students will be
Create simple stored procedures which return scalar or multi-valued results. able to:
encapsulate a SELECT statement. Write correlated subqueries which return Describe SQL Server's behavior when
Construct and execute dynamic SQL with scalar or multi-valued results. errors occur in T-SQL code.
EXEC and sp_executesql. Use the EXISTS predicate to efficiently Implement structured exception handling in
Controlling Program FlowAfter completing check for the existence of rows in a T-SQL.
this module, students will be able to: subquery. Return information about errors from
Describe the language elements of T-SQL Using Common Table Expressions system objects.
used for simple programming tasks. Using Views Raise user-defined errors and pass system
Describe batches and how they are handled Using Inline Table-Valued FunctionsAfter errors in T-SQL code.
by SQL Server. completing this module, students will be Controlling TransactionsAfter completing
Declare and assign variables and synonyms. able to: this module, students will be able to:
Use IF and WHILE blocks to control Write queries which use derived tables. Describe transactions and the differences
program flow. Write queries which use common table between batches and transactions.
Working with Error InformationAfter expressions. Describe batches and how they are
completing this module, students will be able Create simple views and write queries handled by SQL Server.
to: against them. Create and manage transactions with
Describe SQL Server's behavior when errors Create simple inline table-valued transaction control language statements.
occur in T-SQL code. functions and write queries against them. Use SET XACT_ABORT to define SQL
Implement structured exception handling in Using EXCEPT and INTERSECT Server's handling of transactions outside
T-SQL. Using APPLYAfter completing this TRY / CATCH blocks.

Return information about errors from system module, students will be able to: Displaying Query Performance DataAfter
objects. Write queries which combine data using completing this module, students will be
Raise user-defined errors and pass system the UNION operator able to:
errors in T-SQL code. Write queries which compare sets using Describe components of well-performing
Controlling TransactionsAfter completing the INTERSECT and EXCEPT operators queries.
this module, students will be able to: Write queries which manipulate rows in a Describe the role of indexes and statistics
Describe transactions and the differences table by using APPLY with the results of in SQL Server
between batches and transactions. a derived table or function Display and interpret basic query plans
Describe batches and how they are handled Exploring Window Functions Display and interpret basic query
by SQL Server. Restrict window functions to rows defined performance data
Create and manage transactions with in an OVER clause, including partitions
transaction control language statements. and frames.
Use SET XACT_ABORT to define SQL Write queries which use window line
Server's handling of transactions outside functions to operate on a window of rows Getting Started with SQL Server
TRY / CATCH blocks. and return ranking, aggregation and Management Studio
Displaying Query Performance DataAfter offset comparison results. Work with SQL Server Management
completing this module, students will be able Working with Grouping SetsAfter Studio.
to: completing this module, students will be Working with SQL AzureAfter completing
Describe components of well-performing able to: this module, students will be able to:
queries. Write queries which pivot and unpivot Describe the basic features of SQL Azure.
Describe the role of indexes and statistics in result sets Provision a SQL Azure server and
SQL Server Write queries which specify multiple configure its security.
Display and interpret basic query plans groupings with grouping sets Understanding Sets
Display and interpret basic query Executing System Stored Procedures Understanding Predicate Logic
performance data Querying Dynamic Management Understanding the Logical Order of
ObjectsAfter completing this module, Operations in SELECT statementsAfter
students will be able to: completing this module, students will be
line Write queries that retrieve system able to:
Getting Started with SQL Server metadata using system views and Describe the elements of T-SQL and their
Management Studio functions. role in writing queries
Work with SQL Server Management Studio. Execute system stored procedures to Describe the use of sets in SQL Server
Working with SQL AzureAfter completing return system information. Describe the use of predicate logic in SQL
this module, students will be able to: Write queries that retrieve system Server
Describe the basic features of SQL Azure. metadata and state information using Describe the logical order of operations in
Provision a SQL Azure server and configure system dynamic management views and SELECT statements
its security. functions. Eliminating Duplicates with DISTINCT
Understanding Sets Passing Parameters to Stored Using Column and Table Aliases
Understanding Predicate Logic Procedures Writing Simple CASE Expressions
Understanding the Logical Order of Creating Simple Stored Procedures Eliminate duplicates using the DISTINCT
Operations in SELECT statementsAfter Working with Dynamic SQLAfter clause.
completing this module, students will be able completing this module, students will be Use column and table aliases.
to: able to: Write simple CASE expressions.
Describe the elements of T-SQL and their Return results by executing stored Querying with Inner Joins
role in writing queries procedures. Querying with Outer Joins
Describe the use of sets in SQL Server Pass parameters to procedures. Querying with Cross Joins and Self
Describe the use of predicate logic in SQL Create simple stored procedures which JoinsAfter completing this module,
Server encapsulate a SELECT statement. students will be able to:
Describe the logical order of operations in Construct and execute dynamic SQL with Describe how multiple tables may be
SELECT statements EXEC and sp_executesql. queried in a SELECT statement using
Eliminating Duplicates with DISTINCT Controlling Program FlowAfter joins.
Using Column and Table Aliases completing this module, students will be Write queries that use inner joins.
Writing Simple CASE Expressions able to: Write queries that use outer joins.
Eliminate duplicates using the DISTINCT Describe the language elements of Write queries that use self-joins and cross
clause. T-SQL used for simple programming joins.
Use column and table aliases. tasks. Filtering Data with a WHERE Clause
Write simple CASE expressions. Describe batches and how they are Filtering with the TOP and
Querying with Inner Joins handled by SQL Server. OFFSET-FETCH Options
Querying with Outer Joins Declare and assign variables and Working with Unknown and Missing
Querying with Cross Joins and Self synonyms. ValuesAfter completing this module,
JoinsAfter completing this module, students Use IF and WHILE blocks to control students will be able to:
will be able to: program flow. Filter data with predicates in the WHERE
Describe how multiple tables may be Working with Error InformationAfter clause.
queried in a SELECT statement using joins. completing this module, students will be Sort data using ORDER BY.
Write queries that use inner joins. able to: Filter data in the SELECT clause with
Write queries that use outer joins. Describe SQL Server's behavior when TOP.
Write queries that use self-joins and cross errors occur in T-SQL code. Filter data with OFFSET and FETCH.

joins. Implement structured exception handling Working with Character Data
Filtering Data with a WHERE Clause in T-SQL. Working with Date and Time DataAfter
Filtering with the TOP and OFFSET-FETCH Return information about errors from completing this module, students will be
Options system objects. able to:
Working with Unknown and Missing Raise user-defined errors and pass Describe numeric data types, type
ValuesAfter completing this module, system errors in T-SQL code. precedence and type conversions.
students will be able to: Controlling TransactionsAfter completing Write queries using character data types.
Filter data with predicates in the WHERE this module, students will be able to: Write queries using date and time data
clause. Describe transactions and the differences types.
Sort data using ORDER BY. between batches and transactions. Using Conversion Functions
Filter data in the SELECT clause with TOP. Describe batches and how they are Using Logical Functions
Filter data with OFFSET and FETCH. handled by SQL Server. Using Functions to Work with NULLAfter
Working with Character Data Create and manage transactions with completing this module, students will be
Working with Date and Time DataAfter transaction control language statements. able to:
completing this module, students will be able Use SET XACT_ABORT to define SQL Write queries with built-in scalar functions.
to: Server's handling of transactions outside Use conversion functions.
Describe numeric data types, type TRY / CATCH blocks. Use logical functions.
precedence and type conversions. Displaying Query Performance DataAfter Use functions that work with NULL.
Write queries using character data types. completing this module, students will be Using the GROUP BY Clause
Write queries using date and time data able to: Filtering Groups with HAVINGAfter
types. Describe components of well-performing completing this module, students will be
Using Conversion Functions queries. able to:
Using Logical Functions Describe the role of indexes and statistics Write queries which summarize data using
Using Functions to Work with NULLAfter in SQL Server built-in aggregate functions.
completing this module, students will be able Display and interpret basic query plans Use the GROUP BY clause to arrange
to: Display and interpret basic query rows into groups.
Write queries with built-in scalar functions. performance data Use the HAVING clause to filter out groups
Use conversion functions. based on a search condition.
Use logical functions. Writing Correlated Subqueries
Use functions that work with NULL. line Using the EXISTS Predicate with
Using the GROUP BY Clause Getting Started with SQL Server SubqueriesAfter completing this module,
Filtering Groups with HAVINGAfter Management Studio students will be able to:
completing this module, students will be able Work with SQL Server Management Describe the uses of queries which are
to: Studio. nested within other queries.
Write queries which summarize data using Working with SQL AzureAfter completing Write self-contained subqueries which
built-in aggregate functions. this module, students will be able to: return scalar or multi-valued results.
Use the GROUP BY clause to arrange rows Describe the basic features of SQL Write correlated subqueries which return
into groups. Azure. scalar or multi-valued results.
Use the HAVING clause to filter out groups Provision a SQL Azure server and Use the EXISTS predicate to efficiently
based on a search condition. configure its security. check for the existence of rows in a
Writing Correlated Subqueries Understanding Sets subquery.
Using the EXISTS Predicate with Understanding Predicate Logic Using Common Table Expressions
SubqueriesAfter completing this module, Understanding the Logical Order of Using Views
students will be able to: Operations in SELECT statementsAfter Using Inline Table-Valued FunctionsAfter
Describe the uses of queries which are completing this module, students will be completing this module, students will be
nested within other queries. able to: able to:
Write self-contained subqueries which return Describe the elements of T-SQL and their Write queries which use derived tables.
scalar or multi-valued results. role in writing queries Write queries which use common table
Write correlated subqueries which return Describe the use of sets in SQL Server expressions.
scalar or multi-valued results. Describe the use of predicate logic in Create simple views and write queries
Use the EXISTS predicate to efficiently SQL Server against them.
check for the existence of rows in a Describe the logical order of operations in Create simple inline table-valued functions
subquery. SELECT statements and write queries against them.
Using Common Table Expressions Eliminating Duplicates with DISTINCT Using EXCEPT and INTERSECT
Using Views Using Column and Table Aliases Using APPLYAfter completing this module,
Using Inline Table-Valued FunctionsAfter Writing Simple CASE Expressions students will be able to:
completing this module, students will be able Eliminate duplicates using the DISTINCT Write queries which combine data using
to: clause. the UNION operator
Write queries which use derived tables. Use column and table aliases. Write queries which compare sets using
Write queries which use common table Write simple CASE expressions. the INTERSECT and EXCEPT operators
expressions. Querying with Inner Joins Write queries which manipulate rows in a
Create simple views and write queries Querying with Outer Joins table by using APPLY with the results of a
against them. Querying with Cross Joins and Self derived table or function
Create simple inline table-valued functions JoinsAfter completing this module, Exploring Window Functions
and write queries against them. students will be able to: Restrict window functions to rows defined
Using EXCEPT and INTERSECT Describe how multiple tables may be in an OVER clause, including partitions

Using APPLYAfter completing this module, queried in a SELECT statement using and frames.
students will be able to: joins. Write queries which use window functions
Write queries which combine data using the Write queries that use inner joins. to operate on a window of rows and return
UNION operator Write queries that use outer joins. ranking, aggregation and offset
Write queries which compare sets using the Write queries that use self-joins and comparison results.
INTERSECT and EXCEPT operators cross joins. Working with Grouping SetsAfter
Write queries which manipulate rows in a Filtering Data with a WHERE Clause completing this module, students will be
table by using APPLY with the results of a Filtering with the TOP and able to:
derived table or function OFFSET-FETCH Options Write queries which pivot and unpivot
Exploring Window Functions Working with Unknown and Missing result sets
Restrict window functions to rows defined in ValuesAfter completing this module, Write queries which specify multiple
an OVER clause, including partitions and students will be able to: groupings with grouping sets
frames. Filter data with predicates in the WHERE Executing System Stored Procedures
Write queries which use window functions to clause. Querying Dynamic Management
operate on a window of rows and return Sort data using ORDER BY. ObjectsAfter completing this module,
ranking, aggregation and offset comparison Filter data in the SELECT clause with students will be able to:
results. TOP. Write queries that retrieve system
Working with Grouping SetsAfter completing Filter data with OFFSET and FETCH. metadata using system views and
this module, students will be able to: Working with Character Data functions.
Write queries which pivot and unpivot result Working with Date and Time DataAfter Execute system stored procedures to
sets completing this module, students will be return system information.
Write queries which specify multiple able to: Write queries that retrieve system
groupings with grouping sets Describe numeric data types, type metadata and state information using
Executing System Stored Procedures precedence and type conversions. system dynamic management views and
Querying Dynamic Management Write queries using character data types. functions.
ObjectsAfter completing this module, Write queries using date and time data Passing Parameters to Stored Procedures
students will be able to: types. Creating Simple Stored Procedures
Write queries that retrieve system metadata Using Conversion Functions Working with Dynamic SQLAfter
using system views and functions. Using Logical Functions completing this module, students will be
Execute system stored procedures to return Using Functions to Work with NULLAfter able to:
system information. completing this module, students will be Return results by executing stored
Write queries that retrieve system metadata able to: procedures.
and state information using system dynamic Write queries with built-in scalar Pass parameters to procedures.
management views and functions. functions. Create simple stored procedures which
Passing Parameters to Stored Procedures Use conversion functions. encapsulate a SELECT statement.
Creating Simple Stored Procedures Use logical functions. Construct and execute dynamic SQL with
Working with Dynamic SQLAfter completing Use functions that work with NULL. EXEC and sp_executesql.
this module, students will be able to: Using the GROUP BY Clause Controlling Program FlowAfter completing
Return results by executing stored Filtering Groups with HAVINGAfter this module, students will be able to:
procedures. completing this module, students will be Describe the language elements of T-SQL
Pass parameters to procedures. able to: used for simple programming tasks.
Create simple stored procedures which Write queries which summarize data Describe batches and how they are
encapsulate a SELECT statement. using built-in aggregate functions. handled by SQL Server.
Construct and execute dynamic SQL with Use the GROUP BY clause to arrange Declare and assign variables and
EXEC and sp_executesql. rows into groups. synonyms.
Controlling Program FlowAfter completing Use the HAVING clause to filter out Use IF and WHILE blocks to control
this module, students will be able to: groups based on a search condition. program flow.
Describe the language elements of T-SQL Writing Correlated Subqueries Working with Error InformationAfter
used for simple programming tasks. Using the EXISTS Predicate with completing this module, students will be
Describe batches and how they are handled SubqueriesAfter completing this module, able to:
by SQL Server. students will be able to: Describe SQL Server's behavior when
Declare and assign variables and synonyms. Describe the uses of queries which are errors occur in T-SQL code.
Use IF and WHILE blocks to control nested within other queries. Implement structured exception handling in
program flow. Write self-contained subqueries which T-SQL.
Working with Error InformationAfter return scalar or multi-valued results. Return information about errors from
completing this module, students will be able Write correlated subqueries which return system objects.
to: scalar or multi-valued results. Raise user-defined errors and pass system
Describe SQL Server's behavior when errors Use the EXISTS predicate to efficiently errors in T-SQL code.
occur in T-SQL code. check for the existence of rows in a Controlling TransactionsAfter completing
Implement structured exception handling in subquery. this module, students will be able to:
T-SQL. Using Common Table Expressions Describe transactions and the differences
Return information about errors from system Using Views between batches and transactions.
objects. Using Inline Table-Valued FunctionsAfter Describe batches and how they are
Raise user-defined errors and pass system completing this module, students will be handled by SQL Server.
errors in T-SQL code. able to: Create and manage transactions with
Controlling TransactionsAfter completing Write queries which use derived tables. transaction control language statements.

this module, students will be able to: Write queries which use common table Use SET XACT_ABORT to define SQL
Describe transactions and the differences expressions. Server's handling of transactions outside
between batches and transactions. Create simple views and write queries TRY / CATCH blocks.
Describe batches and how they are handled against them. Displaying Query Performance DataAfter
by SQL Server. Create simple inline table-valued completing this module, students will be
Create and manage transactions with functions and write queries against them. able to:
transaction control language statements. Using EXCEPT and INTERSECT Describe components of well-performing
Use SET XACT_ABORT to define SQL Using APPLYAfter completing this queries.
Server's handling of transactions outside module, students will be able to: Describe the role of indexes and statistics
TRY / CATCH blocks. Write queries which combine data using in SQL Server
Displaying Query Performance DataAfter the UNION operator Display and interpret basic query plans
completing this module, students will be able Write queries which compare sets using Display and interpret basic query
to: the INTERSECT and EXCEPT operators performance data
Describe components of well-performing Write queries which manipulate rows in a
queries. table by using APPLY with the results of
Describe the role of indexes and statistics in a derived table or function line
SQL Server Exploring Window Functions Getting Started with SQL Server
Display and interpret basic query plans Restrict window functions to rows defined Management Studio
Display and interpret basic query in an OVER clause, including partitions Work with SQL Server Management
performance data and frames. Studio.
Write queries which use window Working with SQL AzureAfter completing
functions to operate on a window of rows this module, students will be able to:
line and return ranking, aggregation and Describe the basic features of SQL Azure.
Getting Started with SQL Server offset comparison results. Provision a SQL Azure server and
Management Studio Working with Grouping SetsAfter configure its security.
Work with SQL Server Management Studio. completing this module, students will be Understanding Sets
Working with SQL AzureAfter completing able to: Understanding Predicate Logic
this module, students will be able to: Write queries which pivot and unpivot Understanding the Logical Order of
Describe the basic features of SQL Azure. result sets Operations in SELECT statementsAfter
Provision a SQL Azure server and configure Write queries which specify multiple completing this module, students will be
its security. groupings with grouping sets able to:
Understanding Sets Executing System Stored Procedures Describe the elements of T-SQL and their
Understanding Predicate Logic Querying Dynamic Management role in writing queries
Understanding the Logical Order of ObjectsAfter completing this module, Describe the use of sets in SQL Server
Operations in SELECT statementsAfter students will be able to: Describe the use of predicate logic in SQL
completing this module, students will be able Write queries that retrieve system Server
to: metadata using system views and Describe the logical order of operations in
Describe the elements of T-SQL and their functions. SELECT statements
role in writing queries Execute system stored procedures to Eliminating Duplicates with DISTINCT
Describe the use of sets in SQL Server return system information. Using Column and Table Aliases
Describe the use of predicate logic in SQL Write queries that retrieve system Writing Simple CASE Expressions
Server metadata and state information using Eliminate duplicates using the DISTINCT
Describe the logical order of operations in system dynamic management views and clause.
SELECT statements functions. Use column and table aliases.
Eliminating Duplicates with DISTINCT Passing Parameters to Stored Write simple CASE expressions.
Using Column and Table Aliases Procedures Querying with Inner Joins
Writing Simple CASE Expressions Creating Simple Stored Procedures Querying with Outer Joins
Eliminate duplicates using the DISTINCT Working with Dynamic SQLAfter Querying with Cross Joins and Self
clause. completing this module, students will be JoinsAfter completing this module,
Use column and table aliases. able to: students will be able to:
Write simple CASE expressions. Return results by executing stored Describe how multiple tables may be
Querying with Inner Joins procedures. queried in a SELECT statement using
Querying with Outer Joins Pass parameters to procedures. joins.
Querying with Cross Joins and Self Create simple stored procedures which Write queries that use inner joins.
JoinsAfter completing this module, students encapsulate a SELECT statement. Write queries that use outer joins.
will be able to: Construct and execute dynamic SQL with Write queries that use self-joins and cross
Describe how multiple tables may be EXEC and sp_executesql. joins.
queried in a SELECT statement using joins. Controlling Program FlowAfter Filtering Data with a WHERE Clause
Write queries that use inner joins. completing this module, students will be Filtering with the TOP and
Write queries that use outer joins. able to: OFFSET-FETCH Options
Write queries that use self-joins and cross Describe the language elements of Working with Unknown and Missing
joins. T-SQL used for simple programming ValuesAfter completing this module,
Filtering Data with a WHERE Clause tasks. students will be able to:
Filtering with the TOP and OFFSET-FETCH Describe batches and how they are Filter data with predicates in the WHERE
Options handled by SQL Server. clause.
Working with Unknown and Missing Declare and assign variables and Sort data using ORDER BY.

ValuesAfter completing this module, synonyms. Filter data in the SELECT clause with
students will be able to: Use IF and WHILE blocks to control TOP.
Filter data with predicates in the WHERE program flow. Filter data with OFFSET and FETCH.
clause. Working with Error InformationAfter Working with Character Data
Sort data using ORDER BY. completing this module, students will be Working with Date and Time DataAfter
Filter data in the SELECT clause with TOP. able to: completing this module, students will be
Filter data with OFFSET and FETCH. Describe SQL Server's behavior when able to:
Working with Character Data errors occur in T-SQL code. Describe numeric data types, type
Working with Date and Time DataAfter Implement structured exception handling precedence and type conversions.
completing this module, students will be able in T-SQL. Write queries using character data types.
to: Return information about errors from Write queries using date and time data
Describe numeric data types, type system objects. types.
precedence and type conversions. Raise user-defined errors and pass Using Conversion Functions
Write queries using character data types. system errors in T-SQL code. Using Logical Functions
Write queries using date and time data Controlling TransactionsAfter completing Using Functions to Work with NULLAfter
types. this module, students will be able to: completing this module, students will be
Using Conversion Functions Describe transactions and the differences able to:
Using Logical Functions between batches and transactions. Write queries with built-in scalar functions.
Using Functions to Work with NULLAfter Describe batches and how they are Use conversion functions.
completing this module, students will be able handled by SQL Server. Use logical functions.
to: Create and manage transactions with Use functions that work with NULL.
Write queries with built-in scalar functions. transaction control language statements. Using the GROUP BY Clause
Use conversion functions. Use SET XACT_ABORT to define SQL Filtering Groups with HAVINGAfter
Use logical functions. Server's handling of transactions outside completing this module, students will be
Use functions that work with NULL. TRY / CATCH blocks. able to:
Using the GROUP BY Clause Displaying Query Performance DataAfter Write queries which summarize data using
Filtering Groups with HAVINGAfter completing this module, students will be built-in aggregate functions.
completing this module, students will be able able to: Use the GROUP BY clause to arrange
to: Describe components of well-performing rows into groups.
Write queries which summarize data using queries. Use the HAVING clause to filter out groups
built-in aggregate functions. Describe the role of indexes and statistics based on a search condition.
Use the GROUP BY clause to arrange rows in SQL Server Writing Correlated Subqueries
into groups. Display and interpret basic query plans Using the EXISTS Predicate with
Use the HAVING clause to filter out groups Display and interpret basic query SubqueriesAfter completing this module,
based on a search condition. performance data students will be able to:
Writing Correlated Subqueries Describe the uses of queries which are
Using the EXISTS Predicate with nested within other queries.
SubqueriesAfter completing this module, line Write self-contained subqueries which
students will be able to: Getting Started with SQL Server return scalar or multi-valued results.
Describe the uses of queries which are Management Studio Write correlated subqueries which return
nested within other queries. Work with SQL Server Management scalar or multi-valued results.
Write self-contained subqueries which return Studio. Use the EXISTS predicate to efficiently
scalar or multi-valued results. Working with SQL AzureAfter completing check for the existence of rows in a
Write correlated subqueries which return this module, students will be able to: subquery.
scalar or multi-valued results. Describe the basic features of SQL Using Common Table Expressions
Use the EXISTS predicate to efficiently Azure. Using Views
check for the existence of rows in a Provision a SQL Azure server and Using Inline Table-Valued FunctionsAfter
subquery. configure its security. completing this module, students will be
Using Common Table Expressions Understanding Sets able to:
Using Views Understanding Predicate Logic Write queries which use derived tables.
Using Inline Table-Valued FunctionsAfter Understanding the Logical Order of Write queries which use common table
completing this module, students will be able Operations in SELECT statementsAfter expressions.
to: completing this module, students will be Create simple views and write queries
Write queries which use derived tables. able to: against them.
Write queries which use common table Describe the elements of T-SQL and their Create simple inline table-valued functions
expressions. role in writing queries and write queries against them.
Create simple views and write queries Describe the use of sets in SQL Server Using EXCEPT and INTERSECT
against them. Describe the use of predicate logic in Using APPLYAfter completing this module,
Create simple inline table-valued functions SQL Server students will be able to:
and write queries against them. Describe the logical order of operations in Write queries which combine data using
Using EXCEPT and INTERSECT SELECT statements the UNION operator
Using APPLYAfter completing this module, Eliminating Duplicates with DISTINCT Write queries which compare sets using
students will be able to: Using Column and Table Aliases the INTERSECT and EXCEPT operators
Write queries which combine data using the Writing Simple CASE Expressions Write queries which manipulate rows in a
UNION operator Eliminate duplicates using the DISTINCT table by using APPLY with the results of a
Write queries which compare sets using the clause. derived table or function

INTERSECT and EXCEPT operators Use column and table aliases. Exploring Window Functions
Write queries which manipulate rows in a Write simple CASE expressions. Restrict window functions to rows defined
table by using APPLY with the results of a Querying with Inner Joins in an OVER clause, including partitions
derived table or function Querying with Outer Joins and frames.
Exploring Window Functions Querying with Cross Joins and Self Write queries which use window functions
Restrict window functions to rows defined in JoinsAfter completing this module, to operate on a window of rows and return
an OVER clause, including partitions and students will be able to: ranking, aggregation and offset
frames. Describe how multiple tables may be comparison results.
Write queries which use window functions to queried in a SELECT statement using Working with Grouping SetsAfter
operate on a window of rows and return joins. completing this module, students will be
ranking, aggregation and offset comparison Write queries that use inner joins. able to:
results. Write queries that use outer joins. Write queries which pivot and unpivot
Working with Grouping SetsAfter completing Write queries that use self-joins and result sets
this module, students will be able to: cross joins. Write queries which specify multiple
Write queries which pivot and unpivot result Filtering Data with a WHERE Clause groupings with grouping sets
sets Filtering with the TOP and Executing System Stored Procedures
Write queries which specify multiple OFFSET-FETCH Options Querying Dynamic Management
groupings with grouping sets Working with Unknown and Missing ObjectsAfter completing this module,
Executing System Stored Procedures ValuesAfter completing this module, students will be able to:
Querying Dynamic Management students will be able to: Write queries that retrieve system
ObjectsAfter completing this module, Filter data with predicates in the WHERE metadata using system views and
students will be able to: clause. functions.
Write queries that retrieve system metadata Sort data using ORDER BY. Execute system stored procedures to
using system views and functions. Filter data in the SELECT clause with return system information.
Execute system stored procedures to return TOP. Write queries that retrieve system
system information. Filter data with OFFSET and FETCH. metadata and state information using
Write queries that retrieve system metadata Working with Character Data system dynamic management views and
and state information using system dynamic Working with Date and Time DataAfter functions.
management views and functions. completing this module, students will be Passing Parameters to Stored Procedures
Passing Parameters to Stored Procedures able to: Creating Simple Stored Procedures
Creating Simple Stored Procedures Describe numeric data types, type Working with Dynamic SQLAfter
Working with Dynamic SQLAfter completing precedence and type conversions. completing this module, students will be
this module, students will be able to: Write queries using character data types. able to:
Return results by executing stored Write queries using date and time data Return results by executing stored
procedures. types. procedures.
Pass parameters to procedures. Using Conversion Functions Pass parameters to procedures.
Create simple stored procedures which Using Logical Functions Create simple stored procedures which
encapsulate a SELECT statement. Using Functions to Work with NULLAfter encapsulate a SELECT statement.
Construct and execute dynamic SQL with completing this module, students will be Construct and execute dynamic SQL with
EXEC and sp_executesql. able to: EXEC and sp_executesql.
Controlling Program FlowAfter completing Write queries with built-in scalar Controlling Program FlowAfter completing
this module, students will be able to: functions. this module, students will be able to:
Describe the language elements of T-SQL Use conversion functions. Describe the language elements of T-SQL
used for simple programming tasks. Use logical functions. used for simple programming tasks.
Describe batches and how they are handled Use functions that work with NULL. Describe batches and how they are
by SQL Server. Using the GROUP BY Clause handled by SQL Server.
Declare and assign variables and synonyms. Filtering Groups with HAVINGAfter Declare and assign variables and
Use IF and WHILE blocks to control completing this module, students will be synonyms.
program flow. able to: Use IF and WHILE blocks to control
Working with Error InformationAfter Write queries which summarize data program flow.
completing this module, students will be able using built-in aggregate functions. Working with Error InformationAfter
to: Use the GROUP BY clause to arrange completing this module, students will be
Describe SQL Server's behavior when errors rows into groups. able to:
occur in T-SQL code. Use the HAVING clause to filter out Describe SQL Server's behavior when
Implement structured exception handling in groups based on a search condition. errors occur in T-SQL code.
T-SQL. Writing Correlated Subqueries Implement structured exception handling in
Return information about errors from system Using the EXISTS Predicate with T-SQL.
objects. SubqueriesAfter completing this module, Return information about errors from
Raise user-defined errors and pass system students will be able to: system objects.
errors in T-SQL code. Describe the uses of queries which are Raise user-defined errors and pass system
Controlling TransactionsAfter completing nested within other queries. errors in T-SQL code.
this module, students will be able to: Write self-contained subqueries which Controlling TransactionsAfter completing
Describe transactions and the differences return scalar or multi-valued results. this module, students will be able to:
between batches and transactions. Write correlated subqueries which return Describe transactions and the differences
Describe batches and how they are handled scalar or multi-valued results. between batches and transactions.
by SQL Server. Use the EXISTS predicate to efficiently Describe batches and how they are

Create and manage transactions with check for the existence of rows in a handled by SQL Server.
transaction control language statements. subquery. Create and manage transactions with
Use SET XACT_ABORT to define SQL Using Common Table Expressions transaction control language statements.
Server's handling of transactions outside Using Views Use SET XACT_ABORT to define SQL
TRY / CATCH blocks. Using Inline Table-Valued FunctionsAfter Server's handling of transactions outside
Displaying Query Performance DataAfter completing this module, students will be TRY / CATCH blocks.
completing this module, students will be able able to: Displaying Query Performance DataAfter
to: Write queries which use derived tables. completing this module, students will be
Describe components of well-performing Write queries which use common table able to:
queries. expressions. Describe components of well-performing
Describe the role of indexes and statistics in Create simple views and write queries queries.
SQL Server against them. Describe the role of indexes and statistics
Display and interpret basic query plans Create simple inline table-valued in SQL Server
Display and interpret basic query functions and write queries against them. Display and interpret basic query plans
performance data Using EXCEPT and INTERSECT Display and interpret basic query
Using APPLYAfter completing this performance data
module, students will be able to:
line Write queries which combine data using
Getting Started with SQL Server the UNION operator line
Management Studio Write queries which compare sets using Getting Started with SQL Server
Work with SQL Server Management Studio. the INTERSECT and EXCEPT operators Management Studio
Working with SQL AzureAfter completing Write queries which manipulate rows in a Work with SQL Server Management
this module, students will be able to: table by using APPLY with the results of Studio.
Describe the basic features of SQL Azure. a derived table or function Working with SQL AzureAfter completing
Provision a SQL Azure server and configure Exploring Window Functions this module, students will be able to:
its security. Restrict window functions to rows defined Describe the basic features of SQL Azure.
Understanding Sets in an OVER clause, including partitions Provision a SQL Azure server and
Understanding Predicate Logic and frames. configure its security.
Understanding the Logical Order of Write queries which use window Understanding Sets
Operations in SELECT statementsAfter functions to operate on a window of rows Understanding Predicate Logic
completing this module, students will be able and return ranking, aggregation and Understanding the Logical Order of
to: offset comparison results. Operations in SELECT statementsAfter
Describe the elements of T-SQL and their Working with Grouping SetsAfter completing this module, students will be
role in writing queries completing this module, students will be able to:
Describe the use of sets in SQL Server able to: Describe the elements of T-SQL and their
Describe the use of predicate logic in SQL Write queries which pivot and unpivot role in writing queries
Server result sets Describe the use of sets in SQL Server
Describe the logical order of operations in Write queries which specify multiple Describe the use of predicate logic in SQL
SELECT statements groupings with grouping sets Server
Eliminating Duplicates with DISTINCT Executing System Stored Procedures Describe the logical order of operations in
Using Column and Table Aliases Querying Dynamic Management SELECT statements
Writing Simple CASE Expressions ObjectsAfter completing this module, Eliminating Duplicates with DISTINCT
Eliminate duplicates using the DISTINCT students will be able to: Using Column and Table Aliases
clause. Write queries that retrieve system Writing Simple CASE Expressions
Use column and table aliases. metadata using system views and Eliminate duplicates using the DISTINCT
Write simple CASE expressions. functions. clause.
Querying with Inner Joins Execute system stored procedures to Use column and table aliases.
Querying with Outer Joins return system information. Write simple CASE expressions.
Querying with Cross Joins and Self Write queries that retrieve system Querying with Inner Joins
JoinsAfter completing this module, students metadata and state information using Querying with Outer Joins
will be able to: system dynamic management views and Querying with Cross Joins and Self
Describe how multiple tables may be functions. JoinsAfter completing this module,
queried in a SELECT statement using joins. Passing Parameters to Stored students will be able to:
Write queries that use inner joins. Procedures Describe how multiple tables may be
Write queries that use outer joins. Creating Simple Stored Procedures queried in a SELECT statement using
Write queries that use self-joins and cross Working with Dynamic SQLAfter joins.
joins. completing this module, students will be Write queries that use inner joins.
Filtering Data with a WHERE Clause able to: Write queries that use outer joins.
Filtering with the TOP and OFFSET-FETCH Return results by executing stored Write queries that use self-joins and cross
Options procedures. joins.
Working with Unknown and Missing Pass parameters to procedures. Filtering Data with a WHERE Clause
ValuesAfter completing this module, Create simple stored procedures which Filtering with the TOP and
students will be able to: encapsulate a SELECT statement. OFFSET-FETCH Options
Filter data with predicates in the WHERE Construct and execute dynamic SQL with Working with Unknown and Missing
clause. EXEC and sp_executesql. ValuesAfter completing this module,
Sort data using ORDER BY. Controlling Program FlowAfter students will be able to:

Filter data in the SELECT clause with TOP. completing this module, students will be Filter data with predicates in the WHERE
Filter data with OFFSET and FETCH. able to: clause.
Working with Character Data Describe the language elements of Sort data using ORDER BY.
Working with Date and Time DataAfter T-SQL used for simple programming Filter data in the SELECT clause with
completing this module, students will be able tasks. TOP.
to: Describe batches and how they are Filter data with OFFSET and FETCH.
Describe numeric data types, type handled by SQL Server. Working with Character Data
precedence and type conversions. Declare and assign variables and Working with Date and Time DataAfter
Write queries using character data types. synonyms. completing this module, students will be
Write queries using date and time data Use IF and WHILE blocks to control able to:
types. program flow. Describe numeric data types, type
Using Conversion Functions Working with Error InformationAfter precedence and type conversions.
Using Logical Functions completing this module, students will be Write queries using character data types.
Using Functions to Work with NULLAfter able to: Write queries using date and time data
completing this module, students will be able Describe SQL Server's behavior when types.
to: errors occur in T-SQL code. Using Conversion Functions
Write queries with built-in scalar functions. Implement structured exception handling Using Logical Functions
Use conversion functions. in T-SQL. Using Functions to Work with NULLAfter
Use logical functions. Return information about errors from completing this module, students will be
Use functions that work with NULL. system objects. able to:
Using the GROUP BY Clause Raise user-defined errors and pass Write queries with built-in scalar functions.
Filtering Groups with HAVINGAfter system errors in T-SQL code. Use conversion functions.
completing this module, students will be able Controlling TransactionsAfter completing Use logical functions.
to: this module, students will be able to: Use functions that work with NULL.
Write queries which summarize data using Describe transactions and the differences Using the GROUP BY Clause
built-in aggregate functions. between batches and transactions. Filtering Groups with HAVINGAfter
Use the GROUP BY clause to arrange rows Describe batches and how they are completing this module, students will be
into groups. handled by SQL Server. able to:
Use the HAVING clause to filter out groups Create and manage transactions with Write queries which summarize data using
based on a search condition. transaction control language statements. built-in aggregate functions.
Writing Correlated Subqueries Use SET XACT_ABORT to define SQL Use the GROUP BY clause to arrange
Using the EXISTS Predicate with Server's handling of transactions outside rows into groups.
SubqueriesAfter completing this module, TRY / CATCH blocks. Use the HAVING clause to filter out groups
students will be able to: Displaying Query Performance DataAfter based on a search condition.
Describe the uses of queries which are completing this module, students will be Writing Correlated Subqueries
nested within other queries. able to: Using the EXISTS Predicate with
Write self-contained subqueries which return Describe components of well-performing SubqueriesAfter completing this module,
scalar or multi-valued results. queries. students will be able to:
Write correlated subqueries which return Describe the role of indexes and statistics Describe the uses of queries which are
scalar or multi-valued results. in SQL Server nested within other queries.
Use the EXISTS predicate to efficiently Display and interpret basic query plans Write self-contained subqueries which
check for the existence of rows in a Display and interpret basic query return scalar or multi-valued results.
subquery. performance data Write correlated subqueries which return
Using Common Table Expressions scalar or multi-valued results.
Using Views Use the EXISTS predicate to efficiently
Using Inline Table-Valued FunctionsAfter line check for the existence of rows in a
completing this module, students will be able Getting Started with SQL Server subquery.
to: Management Studio Using Common Table Expressions
Write queries which use derived tables. Work with SQL Server Management Using Views
Write queries which use common table Studio. Using Inline Table-Valued FunctionsAfter
expressions. Working with SQL AzureAfter completing completing this module, students will be
Create simple views and write queries this module, students will be able to: able to:
against them. Describe the basic features of SQL Write queries which use derived tables.
Create simple inline table-valued functions Azure. Write queries which use common table
and write queries against them. Provision a SQL Azure server and expressions.
Using EXCEPT and INTERSECT configure its security. Create simple views and write queries
Using APPLYAfter completing this module, Understanding Sets against them.
students will be able to: Understanding Predicate Logic Create simple inline table-valued functions
Write queries which combine data using the Understanding the Logical Order of and write queries against them.
UNION operator Operations in SELECT statementsAfter Using EXCEPT and INTERSECT
Write queries which compare sets using the completing this module, students will be Using APPLYAfter completing this module,
INTERSECT and EXCEPT operators able to: students will be able to:
Write queries which manipulate rows in a Describe the elements of T-SQL and their Write queries which combine data using
table by using APPLY with the results of a role in writing queries the UNION operator
derived table or function Describe the use of sets in SQL Server Write queries which compare sets using
Exploring Window Functions Describe the use of predicate logic in the INTERSECT and EXCEPT operators

Restrict window functions to rows defined in SQL Server Write queries which manipulate rows in a
an OVER clause, including partitions and Describe the logical order of operations in table by using APPLY with the results of a
frames. SELECT statements derived table or function
Write queries which use window functions to Eliminating Duplicates with DISTINCT Exploring Window Functions
operate on a window of rows and return Using Column and Table Aliases Restrict window functions to rows defined
ranking, aggregation and offset comparison Writing Simple CASE Expressions in an OVER clause, including partitions
results. Eliminate duplicates using the DISTINCT and frames.
Working with Grouping SetsAfter completing clause. Write queries which use window functions
this module, students will be able to: Use column and table aliases. to operate on a window of rows and return
Write queries which pivot and unpivot result Write simple CASE expressions. ranking, aggregation and offset
sets Querying with Inner Joins comparison results.
Write queries which specify multiple Querying with Outer Joins Working with Grouping SetsAfter
groupings with grouping sets Querying with Cross Joins and Self completing this module, students will be
Executing System Stored Procedures JoinsAfter completing this module, able to:
Querying Dynamic Management students will be able to: Write queries which pivot and unpivot
ObjectsAfter completing this module, Describe how multiple tables may be result sets
students will be able to: queried in a SELECT statement using Write queries which specify multiple
Write queries that retrieve system metadata joins. groupings with grouping sets
using system views and functions. Write queries that use inner joins. Executing System Stored Procedures
Execute system stored procedures to return Write queries that use outer joins. Querying Dynamic Management
system information. Write queries that use self-joins and ObjectsAfter completing this module,
Write queries that retrieve system metadata cross joins. students will be able to:
and state information using system dynamic Filtering Data with a WHERE Clause Write queries that retrieve system
management views and functions. Filtering with the TOP and metadata using system views and
Passing Parameters to Stored Procedures OFFSET-FETCH Options functions.
Creating Simple Stored Procedures Working with Unknown and Missing Execute system stored procedures to
Working with Dynamic SQLAfter completing ValuesAfter completing this module, return system information.
this module, students will be able to: students will be able to: Write queries that retrieve system
Return results by executing stored Filter data with predicates in the WHERE metadata and state information using
procedures. clause. system dynamic management views and
Pass parameters to procedures. Sort data using ORDER BY. functions.
Create simple stored procedures which Filter data in the SELECT clause with Passing Parameters to Stored Procedures
encapsulate a SELECT statement. TOP. Creating Simple Stored Procedures
Construct and execute dynamic SQL with Filter data with OFFSET and FETCH. Working with Dynamic SQLAfter
EXEC and sp_executesql. Working with Character Data completing this module, students will be
Controlling Program FlowAfter completing Working with Date and Time DataAfter able to:
this module, students will be able to: completing this module, students will be Return results by executing stored
Describe the language elements of T-SQL able to: procedures.
used for simple programming tasks. Describe numeric data types, type Pass parameters to procedures.
Describe batches and how they are handled precedence and type conversions. Create simple stored procedures which
by SQL Server. Write queries using character data types. encapsulate a SELECT statement.
Declare and assign variables and synonyms. Write queries using date and time data Construct and execute dynamic SQL with
Use IF and WHILE blocks to control types. EXEC and sp_executesql.
program flow. Using Conversion Functions Controlling Program FlowAfter completing
Working with Error InformationAfter Using Logical Functions this module, students will be able to:
completing this module, students will be able Using Functions to Work with NULLAfter Describe the language elements of T-SQL
to: completing this module, students will be used for simple programming tasks.
Describe SQL Server's behavior when errors able to: Describe batches and how they are
occur in T-SQL code. Write queries with built-in scalar handled by SQL Server.
Implement structured exception handling in functions. Declare and assign variables and
T-SQL. Use conversion functions. synonyms.
Return information about errors from system Use logical functions. Use IF and WHILE blocks to control
objects. Use functions that work with NULL. program flow.
Raise user-defined errors and pass system Using the GROUP BY Clause Working with Error InformationAfter
errors in T-SQL code. Filtering Groups with HAVINGAfter completing this module, students will be
Controlling TransactionsAfter completing completing this module, students will be able to:
this module, students will be able to: able to: Describe SQL Server's behavior when
Describe transactions and the differences Write queries which summarize data errors occur in T-SQL code.
between batches and transactions. using built-in aggregate functions. Implement structured exception handling in
Describe batches and how they are handled Use the GROUP BY clause to arrange T-SQL.
by SQL Server. rows into groups. Return information about errors from
Create and manage transactions with Use the HAVING clause to filter out system objects.
transaction control language statements. groups based on a search condition. Raise user-defined errors and pass system
Use SET XACT_ABORT to define SQL Writing Correlated Subqueries errors in T-SQL code.
Server's handling of transactions outside Using the EXISTS Predicate with Controlling TransactionsAfter completing
TRY / CATCH blocks. SubqueriesAfter completing this module, this module, students will be able to:

Displaying Query Performance DataAfter students will be able to: Describe transactions and the differences
completing this module, students will be able Describe the uses of queries which are between batches and transactions.
to: nested within other queries. Describe batches and how they are
Describe components of well-performing Write self-contained subqueries which handled by SQL Server.
queries. return scalar or multi-valued results. Create and manage transactions with
Describe the role of indexes and statistics in Write correlated subqueries which return transaction control language statements.
SQL Server scalar or multi-valued results. Use SET XACT_ABORT to define SQL
Display and interpret basic query plans Use the EXISTS predicate to efficiently Server's handling of transactions outside
Display and interpret basic query check for the existence of rows in a TRY / CATCH blocks.
performance data subquery. Displaying Query Performance DataAfter
Using Common Table Expressions completing this module, students will be
Using Views able to:
line Using Inline Table-Valued FunctionsAfter Describe components of well-performing
Getting Started with SQL Server completing this module, students will be queries.
Management Studio able to: Describe the role of indexes and statistics
Work with SQL Server Management Studio. Write queries which use derived tables. in SQL Server
Working with SQL AzureAfter completing Write queries which use common table Display and interpret basic query plans
this module, students will be able to: expressions. Display and interpret basic query
Describe the basic features of SQL Azure. Create simple views and write queries performance data
Provision a SQL Azure server and configure against them.
its security. Create simple inline table-valued Module 20: Improving Query Performance
Understanding Sets functions and write queries against them. line
Understanding Predicate Logic Using EXCEPT and INTERSECT
Understanding the Logical Order of Using APPLYAfter completing this This module introduces the concepts of
Operations in SELECT statementsAfter module, students will be able to: system resource usage and the performance
completing this module, students will be able Write queries which combine data using impact of querying SQL Server 2012. It will
to: the UNION operator cover, at a high level, the use of indexes in
Describe the elements of T-SQL and their Write queries which compare sets using SQL Server, the use of execution plans in
role in writing queries the INTERSECT and EXCEPT operators SQL Server Management Studio, and the use
Describe the use of sets in SQL Server Write queries which manipulate rows in a of SET options to view system resource
Describe the use of predicate logic in SQL table by using APPLY with the results of usage when executing queries. It will also
Server a derived table or function compare set-based operations with
Describe the logical order of operations in Exploring Window Functions cursor-based operations.
SELECT statements Restrict window functions to rows defined line
Eliminating Duplicates with DISTINCT in an OVER clause, including partitions Factors in Query Performance
Using Column and Table Aliases and frames.
Writing Simple CASE Expressions Write queries which use window
Eliminate duplicates using the DISTINCT functions to operate on a window of rows line
clause. and return ranking, aggregation and Getting Started with SQL Server
Use column and table aliases. offset comparison results. Management Studio
Write simple CASE expressions. Working with Grouping SetsAfter Work with SQL Server Management
Querying with Inner Joins completing this module, students will be Studio.
Querying with Outer Joins able to: Working with SQL AzureAfter completing
Querying with Cross Joins and Self Write queries which pivot and unpivot this module, students will be able to:
JoinsAfter completing this module, students result sets Describe the basic features of SQL Azure.
will be able to: Write queries which specify multiple Provision a SQL Azure server and
Describe how multiple tables may be groupings with grouping sets configure its security.
queried in a SELECT statement using joins. Executing System Stored Procedures Understanding Sets
Write queries that use inner joins. Querying Dynamic Management Understanding Predicate Logic
Write queries that use outer joins. ObjectsAfter completing this module, Understanding the Logical Order of
Write queries that use self-joins and cross students will be able to: Operations in SELECT statementsAfter
joins. Write queries that retrieve system completing this module, students will be
Filtering Data with a WHERE Clause metadata using system views and able to:
Filtering with the TOP and OFFSET-FETCH functions. Describe the elements of T-SQL and their
Options Execute system stored procedures to role in writing queries
Working with Unknown and Missing return system information. Describe the use of sets in SQL Server
ValuesAfter completing this module, Write queries that retrieve system Describe the use of predicate logic in SQL
students will be able to: metadata and state information using Server
Filter data with predicates in the WHERE system dynamic management views and Describe the logical order of operations in
clause. functions. SELECT statements
Sort data using ORDER BY. Passing Parameters to Stored Eliminating Duplicates with DISTINCT
Filter data in the SELECT clause with TOP. Procedures Using Column and Table Aliases
Filter data with OFFSET and FETCH. Creating Simple Stored Procedures Writing Simple CASE Expressions
Working with Character Data Working with Dynamic SQLAfter Eliminate duplicates using the DISTINCT
Working with Date and Time DataAfter completing this module, students will be clause.
completing this module, students will be able able to: Use column and table aliases.

to: Return results by executing stored Write simple CASE expressions.
Describe numeric data types, type procedures. Querying with Inner Joins
precedence and type conversions. Pass parameters to procedures. Querying with Outer Joins
Write queries using character data types. Create simple stored procedures which Querying with Cross Joins and Self
Write queries using date and time data encapsulate a SELECT statement. JoinsAfter completing this module,
types. Construct and execute dynamic SQL with students will be able to:
Using Conversion Functions EXEC and sp_executesql. Describe how multiple tables may be
Using Logical Functions Controlling Program FlowAfter queried in a SELECT statement using
Using Functions to Work with NULLAfter completing this module, students will be joins.
completing this module, students will be able able to: Write queries that use inner joins.
to: Describe the language elements of Write queries that use outer joins.
Write queries with built-in scalar functions. T-SQL used for simple programming Write queries that use self-joins and cross
Use conversion functions. tasks. joins.
Use logical functions. Describe batches and how they are Filtering Data with a WHERE Clause
Use functions that work with NULL. handled by SQL Server. Filtering with the TOP and
Using the GROUP BY Clause Declare and assign variables and OFFSET-FETCH Options
Filtering Groups with HAVINGAfter synonyms. Working with Unknown and Missing
completing this module, students will be able Use IF and WHILE blocks to control ValuesAfter completing this module,
to: program flow. students will be able to:
Write queries which summarize data using Working with Error InformationAfter Filter data with predicates in the WHERE
built-in aggregate functions. completing this module, students will be clause.
Use the GROUP BY clause to arrange rows able to: Sort data using ORDER BY.
into groups. Describe SQL Server's behavior when Filter data in the SELECT clause with
Use the HAVING clause to filter out groups errors occur in T-SQL code. TOP.
based on a search condition. Implement structured exception handling Filter data with OFFSET and FETCH.
Writing Correlated Subqueries in T-SQL. Working with Character Data
Using the EXISTS Predicate with Return information about errors from Working with Date and Time DataAfter
SubqueriesAfter completing this module, system objects. completing this module, students will be
students will be able to: Raise user-defined errors and pass able to:
Describe the uses of queries which are system errors in T-SQL code. Describe numeric data types, type
nested within other queries. Controlling TransactionsAfter completing precedence and type conversions.
Write self-contained subqueries which return this module, students will be able to: Write queries using character data types.
scalar or multi-valued results. Describe transactions and the differences Write queries using date and time data
Write correlated subqueries which return between batches and transactions. types.
scalar or multi-valued results. Describe batches and how they are Using Conversion Functions
Use the EXISTS predicate to efficiently handled by SQL Server. Using Logical Functions
check for the existence of rows in a Create and manage transactions with Using Functions to Work with NULLAfter
subquery. transaction control language statements. completing this module, students will be
Using Common Table Expressions Use SET XACT_ABORT to define SQL able to:
Using Views Server's handling of transactions outside Write queries with built-in scalar functions.
Using Inline Table-Valued FunctionsAfter TRY / CATCH blocks. Use conversion functions.
completing this module, students will be able Displaying Query Performance DataAfter Use logical functions.
to: completing this module, students will be Use functions that work with NULL.
Write queries which use derived tables. able to: Using the GROUP BY Clause
Write queries which use common table Describe components of well-performing Filtering Groups with HAVINGAfter
expressions. queries. completing this module, students will be
Create simple views and write queries Describe the role of indexes and statistics able to:
against them. in SQL Server Write queries which summarize data using
Create simple inline table-valued functions Display and interpret basic query plans built-in aggregate functions.
and write queries against them. Display and interpret basic query Use the GROUP BY clause to arrange
Using EXCEPT and INTERSECT performance data rows into groups.
Using APPLYAfter completing this module, Use the HAVING clause to filter out groups
students will be able to: Module 12: Using Set Operators based on a search condition.
Write queries which combine data using the line Writing Correlated Subqueries
UNION operator Using the EXISTS Predicate with
Write queries which compare sets using the This module introduces operations involving SubqueriesAfter completing this module,
INTERSECT and EXCEPT operators multiple sets of data. It will cover the use of students will be able to:
Write queries which manipulate rows in a the UNION, UNION ALL, APPLY, CROSS Describe the uses of queries which are
table by using APPLY with the results of a APPLY, OUTER APPLY operators as well as nested within other queries.
derived table or function the EXCEPT and INTERSECTS operators. Write self-contained subqueries which
Exploring Window Functions line return scalar or multi-valued results.
Restrict window functions to rows defined in Writing Queries with the UNION Operator Write correlated subqueries which return
an OVER clause, including partitions and scalar or multi-valued results.
frames. Use the EXISTS predicate to efficiently
Write queries which use window functions to line check for the existence of rows in a
operate on a window of rows and return Getting Started with SQL Server subquery.

ranking, aggregation and offset comparison Management Studio Using Common Table Expressions
results. Work with SQL Server Management Using Views
Working with Grouping SetsAfter completing Studio. Using Inline Table-Valued FunctionsAfter
this module, students will be able to: Working with SQL AzureAfter completing completing this module, students will be
Write queries which pivot and unpivot result this module, students will be able to: able to:
sets Describe the basic features of SQL Write queries which use derived tables.
Write queries which specify multiple Azure. Write queries which use common table
groupings with grouping sets Provision a SQL Azure server and expressions.
Executing System Stored Procedures configure its security. Create simple views and write queries
Querying Dynamic Management Understanding Sets against them.
ObjectsAfter completing this module, Understanding Predicate Logic Create simple inline table-valued functions
students will be able to: Understanding the Logical Order of and write queries against them.
Write queries that retrieve system metadata Operations in SELECT statementsAfter Using EXCEPT and INTERSECT
using system views and functions. completing this module, students will be Using APPLYAfter completing this module,
Execute system stored procedures to return able to: students will be able to:
system information. Describe the elements of T-SQL and their Write queries which combine data using
Write queries that retrieve system metadata role in writing queries the UNION operator
and state information using system dynamic Describe the use of sets in SQL Server Write queries which compare sets using
management views and functions. Describe the use of predicate logic in the INTERSECT and EXCEPT operators
Passing Parameters to Stored Procedures SQL Server Write queries which manipulate rows in a
Creating Simple Stored Procedures Describe the logical order of operations in table by using APPLY with the results of a
Working with Dynamic SQLAfter completing SELECT statements derived table or function
this module, students will be able to: Eliminating Duplicates with DISTINCT Exploring Window Functions
Return results by executing stored Using Column and Table Aliases Restrict window functions to rows defined
procedures. Writing Simple CASE Expressions in an OVER clause, including partitions
Pass parameters to procedures. Eliminate duplicates using the DISTINCT and frames.
Create simple stored procedures which clause. Write queries which use window functions
encapsulate a SELECT statement. Use column and table aliases. to operate on a window of rows and return
Construct and execute dynamic SQL with Write simple CASE expressions. ranking, aggregation and offset
EXEC and sp_executesql. Querying with Inner Joins comparison results.
Controlling Program FlowAfter completing Querying with Outer Joins Working with Grouping SetsAfter
this module, students will be able to: Querying with Cross Joins and Self completing this module, students will be
Describe the language elements of T-SQL JoinsAfter completing this module, able to:
used for simple programming tasks. students will be able to: Write queries which pivot and unpivot
Describe batches and how they are handled Describe how multiple tables may be result sets
by SQL Server. queried in a SELECT statement using Write queries which specify multiple
Declare and assign variables and synonyms. joins. groupings with grouping sets
Use IF and WHILE blocks to control Write queries that use inner joins. Executing System Stored Procedures
program flow. Write queries that use outer joins. Querying Dynamic Management
Working with Error InformationAfter Write queries that use self-joins and ObjectsAfter completing this module,
completing this module, students will be able cross joins. students will be able to:
to: Filtering Data with a WHERE Clause Write queries that retrieve system
Describe SQL Server's behavior when errors Filtering with the TOP and metadata using system views and
occur in T-SQL code. OFFSET-FETCH Options functions.
Implement structured exception handling in Working with Unknown and Missing Execute system stored procedures to
T-SQL. ValuesAfter completing this module, return system information.
Return information about errors from system students will be able to: Write queries that retrieve system
objects. Filter data with predicates in the WHERE metadata and state information using
Raise user-defined errors and pass system clause. system dynamic management views and
errors in T-SQL code. Sort data using ORDER BY. functions.
Controlling TransactionsAfter completing Filter data in the SELECT clause with Passing Parameters to Stored Procedures
this module, students will be able to: TOP. Creating Simple Stored Procedures
Describe transactions and the differences Filter data with OFFSET and FETCH. Working with Dynamic SQLAfter
between batches and transactions. Working with Character Data completing this module, students will be
Describe batches and how they are handled Working with Date and Time DataAfter able to:
by SQL Server. completing this module, students will be Return results by executing stored
Create and manage transactions with able to: procedures.
transaction control language statements. Describe numeric data types, type Pass parameters to procedures.
Use SET XACT_ABORT to define SQL precedence and type conversions. Create simple stored procedures which
Server's handling of transactions outside Write queries using character data types. encapsulate a SELECT statement.
TRY / CATCH blocks. Write queries using date and time data Construct and execute dynamic SQL with
Displaying Query Performance DataAfter types. EXEC and sp_executesql.
completing this module, students will be able Using Conversion Functions Controlling Program FlowAfter completing
to: Using Logical Functions this module, students will be able to:
Describe components of well-performing Using Functions to Work with NULLAfter Describe the language elements of T-SQL
queries. completing this module, students will be used for simple programming tasks.

Describe the role of indexes and statistics in able to: Describe batches and how they are
SQL Server Write queries with built-in scalar handled by SQL Server.
Display and interpret basic query plans functions. Declare and assign variables and
Display and interpret basic query Use conversion functions. synonyms.
performance data Use logical functions. Use IF and WHILE blocks to control
Use functions that work with NULL. program flow.
Using the GROUP BY Clause Working with Error InformationAfter
line Filtering Groups with HAVINGAfter completing this module, students will be
Getting Started with SQL Server completing this module, students will be able to:
Management Studio able to: Describe SQL Server's behavior when
Work with SQL Server Management Studio. Write queries which summarize data errors occur in T-SQL code.
Working with SQL AzureAfter completing using built-in aggregate functions. Implement structured exception handling in
this module, students will be able to: Use the GROUP BY clause to arrange T-SQL.
Describe the basic features of SQL Azure. rows into groups. Return information about errors from
Provision a SQL Azure server and configure Use the HAVING clause to filter out system objects.
its security. groups based on a search condition. Raise user-defined errors and pass system
Understanding Sets Writing Correlated Subqueries errors in T-SQL code.
Understanding Predicate Logic Using the EXISTS Predicate with Controlling TransactionsAfter completing
Understanding the Logical Order of SubqueriesAfter completing this module, this module, students will be able to:
Operations in SELECT statementsAfter students will be able to: Describe transactions and the differences
completing this module, students will be able Describe the uses of queries which are between batches and transactions.
to: nested within other queries. Describe batches and how they are
Describe the elements of T-SQL and their Write self-contained subqueries which handled by SQL Server.
role in writing queries return scalar or multi-valued results. Create and manage transactions with
Describe the use of sets in SQL Server Write correlated subqueries which return transaction control language statements.
Describe the use of predicate logic in SQL scalar or multi-valued results. Use SET XACT_ABORT to define SQL
Server Use the EXISTS predicate to efficiently Server's handling of transactions outside
Describe the logical order of operations in check for the existence of rows in a TRY / CATCH blocks.
SELECT statements subquery. Displaying Query Performance DataAfter
Eliminating Duplicates with DISTINCT Using Common Table Expressions completing this module, students will be
Using Column and Table Aliases Using Views able to:
Writing Simple CASE Expressions Using Inline Table-Valued FunctionsAfter Describe components of well-performing
Eliminate duplicates using the DISTINCT completing this module, students will be queries.
clause. able to: Describe the role of indexes and statistics
Use column and table aliases. Write queries which use derived tables. in SQL Server
Write simple CASE expressions. Write queries which use common table Display and interpret basic query plans
Querying with Inner Joins expressions. Display and interpret basic query
Querying with Outer Joins Create simple views and write queries performance data
Querying with Cross Joins and Self against them.
JoinsAfter completing this module, students Create simple inline table-valued
will be able to: functions and write queries against them. line
Describe how multiple tables may be Using EXCEPT and INTERSECT Getting Started with SQL Server
queried in a SELECT statement using joins. Using APPLYAfter completing this Management Studio
Write queries that use inner joins. module, students will be able to: Work with SQL Server Management
Write queries that use outer joins. Write queries which combine data using Studio.
Write queries that use self-joins and cross the UNION operator Working with SQL AzureAfter completing
joins. Write queries which compare sets using this module, students will be able to:
Filtering Data with a WHERE Clause the INTERSECT and EXCEPT operators Describe the basic features of SQL Azure.
Filtering with the TOP and OFFSET-FETCH Write queries which manipulate rows in a Provision a SQL Azure server and
Options table by using APPLY with the results of configure its security.
Working with Unknown and Missing a derived table or function Understanding Sets
ValuesAfter completing this module, Exploring Window Functions Understanding Predicate Logic
students will be able to: Restrict window functions to rows defined Understanding the Logical Order of
Filter data with predicates in the WHERE in an OVER clause, including partitions Operations in SELECT statementsAfter
clause. and frames. completing this module, students will be
Sort data using ORDER BY. Write queries which use window able to:
Filter data in the SELECT clause with TOP. functions to operate on a window of rows Describe the elements of T-SQL and their
Filter data with OFFSET and FETCH. and return ranking, aggregation and role in writing queries
Working with Character Data offset comparison results. Describe the use of sets in SQL Server
Working with Date and Time DataAfter Working with Grouping SetsAfter Describe the use of predicate logic in SQL
completing this module, students will be able completing this module, students will be Server
to: able to: Describe the logical order of operations in
Describe numeric data types, type Write queries which pivot and unpivot SELECT statements
precedence and type conversions. result sets Eliminating Duplicates with DISTINCT
Write queries using character data types. Write queries which specify multiple Using Column and Table Aliases
Write queries using date and time data groupings with grouping sets Writing Simple CASE Expressions

types. Executing System Stored Procedures Eliminate duplicates using the DISTINCT
Using Conversion Functions Querying Dynamic Management clause.
Using Logical Functions ObjectsAfter completing this module, Use column and table aliases.
Using Functions to Work with NULLAfter students will be able to: Write simple CASE expressions.
completing this module, students will be able Write queries that retrieve system Querying with Inner Joins
to: metadata using system views and Querying with Outer Joins
Write queries with built-in scalar functions. functions. Querying with Cross Joins and Self
Use conversion functions. Execute system stored procedures to JoinsAfter completing this module,
Use logical functions. return system information. students will be able to:
Use functions that work with NULL. Write queries that retrieve system Describe how multiple tables may be
Using the GROUP BY Clause metadata and state information using queried in a SELECT statement using
Filtering Groups with HAVINGAfter system dynamic management views and joins.
completing this module, students will be able functions. Write queries that use inner joins.
to: Passing Parameters to Stored Write queries that use outer joins.
Write queries which summarize data using Procedures Write queries that use self-joins and cross
built-in aggregate functions. Creating Simple Stored Procedures joins.
Use the GROUP BY clause to arrange rows Working with Dynamic SQLAfter Filtering Data with a WHERE Clause
into groups. completing this module, students will be Filtering with the TOP and
Use the HAVING clause to filter out groups able to: OFFSET-FETCH Options
based on a search condition. Return results by executing stored Working with Unknown and Missing
Writing Correlated Subqueries procedures. ValuesAfter completing this module,
Using the EXISTS Predicate with Pass parameters to procedures. students will be able to:
SubqueriesAfter completing this module, Create simple stored procedures which Filter data with predicates in the WHERE
students will be able to: encapsulate a SELECT statement. clause.
Describe the uses of queries which are Construct and execute dynamic SQL with Sort data using ORDER BY.
nested within other queries. EXEC and sp_executesql. Filter data in the SELECT clause with
Write self-contained subqueries which return Controlling Program FlowAfter TOP.
scalar or multi-valued results. completing this module, students will be Filter data with OFFSET and FETCH.
Write correlated subqueries which return able to: Working with Character Data
scalar or multi-valued results. Describe the language elements of Working with Date and Time DataAfter
Use the EXISTS predicate to efficiently T-SQL used for simple programming completing this module, students will be
check for the existence of rows in a tasks. able to:
subquery. Describe batches and how they are Describe numeric data types, type
Using Common Table Expressions handled by SQL Server. precedence and type conversions.
Using Views Declare and assign variables and Write queries using character data types.
Using Inline Table-Valued FunctionsAfter synonyms. Write queries using date and time data
completing this module, students will be able Use IF and WHILE blocks to control types.
to: program flow. Using Conversion Functions
Write queries which use derived tables. Working with Error InformationAfter Using Logical Functions
Write queries which use common table completing this module, students will be Using Functions to Work with NULLAfter
expressions. able to: completing this module, students will be
Create simple views and write queries Describe SQL Server's behavior when able to:
against them. errors occur in T-SQL code. Write queries with built-in scalar functions.
Create simple inline table-valued functions Implement structured exception handling Use conversion functions.
and write queries against them. in T-SQL. Use logical functions.
Using EXCEPT and INTERSECT Return information about errors from Use functions that work with NULL.
Using APPLYAfter completing this module, system objects. Using the GROUP BY Clause
students will be able to: Raise user-defined errors and pass Filtering Groups with HAVINGAfter
Write queries which combine data using the system errors in T-SQL code. completing this module, students will be
UNION operator Controlling TransactionsAfter completing able to:
Write queries which compare sets using the this module, students will be able to: Write queries which summarize data using
INTERSECT and EXCEPT operators Describe transactions and the differences built-in aggregate functions.
Write queries which manipulate rows in a between batches and transactions. Use the GROUP BY clause to arrange
table by using APPLY with the results of a Describe batches and how they are rows into groups.
derived table or function handled by SQL Server. Use the HAVING clause to filter out groups
Exploring Window Functions Create and manage transactions with based on a search condition.
Restrict window functions to rows defined in transaction control language statements. Writing Correlated Subqueries
an OVER clause, including partitions and Use SET XACT_ABORT to define SQL Using the EXISTS Predicate with
frames. Server's handling of transactions outside SubqueriesAfter completing this module,
Write queries which use window functions to TRY / CATCH blocks. students will be able to:
operate on a window of rows and return Displaying Query Performance DataAfter Describe the uses of queries which are
ranking, aggregation and offset comparison completing this module, students will be nested within other queries.
results. able to: Write self-contained subqueries which
Working with Grouping SetsAfter completing Describe components of well-performing return scalar or multi-valued results.
this module, students will be able to: queries. Write correlated subqueries which return
Write queries which pivot and unpivot result Describe the role of indexes and statistics scalar or multi-valued results.

sets in SQL Server Use the EXISTS predicate to efficiently
Write queries which specify multiple Display and interpret basic query plans check for the existence of rows in a
groupings with grouping sets Display and interpret basic query subquery.
Executing System Stored Procedures performance data Using Common Table Expressions
Querying Dynamic Management Using Views
ObjectsAfter completing this module, Using Inline Table-Valued FunctionsAfter
students will be able to: line completing this module, students will be
Write queries that retrieve system metadata Getting Started with SQL Server able to:
using system views and functions. Management Studio Write queries which use derived tables.
Execute system stored procedures to return Work with SQL Server Management Write queries which use common table
system information. Studio. expressions.
Write queries that retrieve system metadata Working with SQL AzureAfter completing Create simple views and write queries
and state information using system dynamic this module, students will be able to: against them.
management views and functions. Describe the basic features of SQL Create simple inline table-valued functions
Passing Parameters to Stored Procedures Azure. and write queries against them.
Creating Simple Stored Procedures Provision a SQL Azure server and Using EXCEPT and INTERSECT
Working with Dynamic SQLAfter completing configure its security. Using APPLYAfter completing this module,
this module, students will be able to: Understanding Sets students will be able to:
Return results by executing stored Understanding Predicate Logic Write queries which combine data using
procedures. Understanding the Logical Order of the UNION operator
Pass parameters to procedures. Operations in SELECT statementsAfter Write queries which compare sets using
Create simple stored procedures which completing this module, students will be the INTERSECT and EXCEPT operators
encapsulate a SELECT statement. able to: Write queries which manipulate rows in a
Construct and execute dynamic SQL with Describe the elements of T-SQL and their table by using APPLY with the results of a
EXEC and sp_executesql. role in writing queries derived table or function
Controlling Program FlowAfter completing Describe the use of sets in SQL Server Exploring Window Functions
this module, students will be able to: Describe the use of predicate logic in Restrict window functions to rows defined
Describe the language elements of T-SQL SQL Server in an OVER clause, including partitions
used for simple programming tasks. Describe the logical order of operations in and frames.
Describe batches and how they are handled SELECT statements Write queries which use window functions
by SQL Server. Eliminating Duplicates with DISTINCT to operate on a window of rows and return
Declare and assign variables and synonyms. Using Column and Table Aliases ranking, aggregation and offset
Use IF and WHILE blocks to control Writing Simple CASE Expressions comparison results.
program flow. Eliminate duplicates using the DISTINCT Working with Grouping SetsAfter
Working with Error InformationAfter clause. completing this module, students will be
completing this module, students will be able Use column and table aliases. able to:
to: Write simple CASE expressions. Write queries which pivot and unpivot
Describe SQL Server's behavior when errors Querying with Inner Joins result sets
occur in T-SQL code. Querying with Outer Joins Write queries which specify multiple
Implement structured exception handling in Querying with Cross Joins and Self groupings with grouping sets
T-SQL. JoinsAfter completing this module, Executing System Stored Procedures
Return information about errors from system students will be able to: Querying Dynamic Management
objects. Describe how multiple tables may be ObjectsAfter completing this module,
Raise user-defined errors and pass system queried in a SELECT statement using students will be able to:
errors in T-SQL code. joins. Write queries that retrieve system
Controlling TransactionsAfter completing Write queries that use inner joins. metadata using system views and
this module, students will be able to: Write queries that use outer joins. functions.
Describe transactions and the differences Write queries that use self-joins and Execute system stored procedures to
between batches and transactions. cross joins. return system information.
Describe batches and how they are handled Filtering Data with a WHERE Clause Write queries that retrieve system
by SQL Server. Filtering with the TOP and metadata and state information using
Create and manage transactions with OFFSET-FETCH Options system dynamic management views and
transaction control language statements. Working with Unknown and Missing functions.
Use SET XACT_ABORT to define SQL ValuesAfter completing this module, Passing Parameters to Stored Procedures
Server's handling of transactions outside students will be able to: Creating Simple Stored Procedures
TRY / CATCH blocks. Filter data with predicates in the WHERE Working with Dynamic SQLAfter
Displaying Query Performance DataAfter clause. completing this module, students will be
completing this module, students will be able Sort data using ORDER BY. able to:
to: Filter data in the SELECT clause with Return results by executing stored
Describe components of well-performing TOP. procedures.
queries. Filter data with OFFSET and FETCH. Pass parameters to procedures.
Describe the role of indexes and statistics in Working with Character Data Create simple stored procedures which
SQL Server Working with Date and Time DataAfter encapsulate a SELECT statement.
Display and interpret basic query plans completing this module, students will be Construct and execute dynamic SQL with
Display and interpret basic query able to: EXEC and sp_executesql.
performance data Describe numeric data types, type Controlling Program FlowAfter completing

precedence and type conversions. this module, students will be able to:
Module 7: Working with SQL Server 2012 Data Write queries using character data types. Describe the language elements of T-SQL
Types Write queries using date and time data used for simple programming tasks.
line types. Describe batches and how they are
Using Conversion Functions handled by SQL Server.
This module explains the data types SQL Using Logical Functions Declare and assign variables and
Server uses to store data. It introduces the Using Functions to Work with NULLAfter synonyms.
many types of numeric and special-use data completing this module, students will be Use IF and WHILE blocks to control
types. It also explains conversions between able to: program flow.
data types, and the importance of type Write queries with built-in scalar Working with Error InformationAfter
precedence. functions. completing this module, students will be
line Use conversion functions. able to:
Introducing SQL Server 2012 Data Types Use logical functions. Describe SQL Server's behavior when
Use functions that work with NULL. errors occur in T-SQL code.
Using the GROUP BY Clause Implement structured exception handling in
Filtering Groups with HAVINGAfter T-SQL.
completing this module, students will be Return information about errors from
able to: system objects.
Write queries which summarize data Raise user-defined errors and pass system
using built-in aggregate functions. errors in T-SQL code.
Use the GROUP BY clause to arrange Controlling TransactionsAfter completing
rows into groups. this module, students will be able to:
Use the HAVING clause to filter out Describe transactions and the differences
groups based on a search condition. between batches and transactions.
Writing Correlated Subqueries Describe batches and how they are
Using the EXISTS Predicate with handled by SQL Server.
SubqueriesAfter completing this module, Create and manage transactions with
students will be able to: transaction control language statements.
Describe the uses of queries which are Use SET XACT_ABORT to define SQL
nested within other queries. Server's handling of transactions outside
Write self-contained subqueries which TRY / CATCH blocks.
return scalar or multi-valued results. Displaying Query Performance DataAfter
Write correlated subqueries which return completing this module, students will be
scalar or multi-valued results. able to:
Use the EXISTS predicate to efficiently Describe components of well-performing
check for the existence of rows in a queries.
subquery. Describe the role of indexes and statistics
Using Common Table Expressions in SQL Server
Using Views Display and interpret basic query plans
Using Inline Table-Valued FunctionsAfter Display and interpret basic query
completing this module, students will be performance data
able to:
Write queries which use derived tables.
Write queries which use common table line
expressions. Getting Started with SQL Server
Create simple views and write queries Management Studio
against them. Work with SQL Server Management
Create simple inline table-valued Studio.
functions and write queries against them. Working with SQL AzureAfter completing
Using EXCEPT and INTERSECT this module, students will be able to:
Using APPLYAfter completing this Describe the basic features of SQL Azure.
module, students will be able to: Provision a SQL Azure server and
Write queries which combine data using configure its security.
the UNION operator Understanding Sets
Write queries which compare sets using Understanding Predicate Logic
the INTERSECT and EXCEPT operators Understanding the Logical Order of
Write queries which manipulate rows in a Operations in SELECT statementsAfter
table by using APPLY with the results of completing this module, students will be
a derived table or function able to:
Exploring Window Functions Describe the elements of T-SQL and their
Restrict window functions to rows defined role in writing queries
in an OVER clause, including partitions Describe the use of sets in SQL Server
and frames. Describe the use of predicate logic in SQL
Write queries which use window Server
functions to operate on a window of rows Describe the logical order of operations in
and return ranking, aggregation and SELECT statements

offset comparison results. Eliminating Duplicates with DISTINCT
Working with Grouping SetsAfter Using Column and Table Aliases
completing this module, students will be Writing Simple CASE Expressions
able to: Eliminate duplicates using the DISTINCT
Write queries which pivot and unpivot clause.
result sets Use column and table aliases.
Write queries which specify multiple Write simple CASE expressions.
groupings with grouping sets Querying with Inner Joins
Executing System Stored Procedures Querying with Outer Joins
Querying Dynamic Management Querying with Cross Joins and Self
ObjectsAfter completing this module, JoinsAfter completing this module,
students will be able to: students will be able to:
Write queries that retrieve system Describe how multiple tables may be
metadata using system views and queried in a SELECT statement using
functions. joins.
Execute system stored procedures to Write queries that use inner joins.
return system information. Write queries that use outer joins.
Write queries that retrieve system Write queries that use self-joins and cross
metadata and state information using joins.
system dynamic management views and Filtering Data with a WHERE Clause
functions. Filtering with the TOP and
Passing Parameters to Stored OFFSET-FETCH Options
Procedures Working with Unknown and Missing
Creating Simple Stored Procedures ValuesAfter completing this module,
Working with Dynamic SQLAfter students will be able to:
completing this module, students will be Filter data with predicates in the WHERE
able to: clause.
Return results by executing stored Sort data using ORDER BY.
procedures. Filter data in the SELECT clause with
Pass parameters to procedures. TOP.
Create simple stored procedures which Filter data with OFFSET and FETCH.
encapsulate a SELECT statement. Working with Character Data
Construct and execute dynamic SQL with Working with Date and Time DataAfter
EXEC and sp_executesql. completing this module, students will be
Controlling Program FlowAfter able to:
completing this module, students will be Describe numeric data types, type
able to: precedence and type conversions.
Describe the language elements of Write queries using character data types.
T-SQL used for simple programming Write queries using date and time data
tasks. types.
Describe batches and how they are Using Conversion Functions
handled by SQL Server. Using Logical Functions
Declare and assign variables and Using Functions to Work with NULLAfter
synonyms. completing this module, students will be
Use IF and WHILE blocks to control able to:
program flow. Write queries with built-in scalar functions.
Working with Error InformationAfter Use conversion functions.
completing this module, students will be Use logical functions.
able to: Use functions that work with NULL.
Describe SQL Server's behavior when Using the GROUP BY Clause
errors occur in T-SQL code. Filtering Groups with HAVINGAfter
Implement structured exception handling completing this module, students will be
in T-SQL. able to:
Return information about errors from Write queries which summarize data using
system objects. built-in aggregate functions.
Raise user-defined errors and pass Use the GROUP BY clause to arrange
system errors in T-SQL code. rows into groups.
Controlling TransactionsAfter completing Use the HAVING clause to filter out groups
this module, students will be able to: based on a search condition.
Describe transactions and the differences Writing Correlated Subqueries
between batches and transactions. Using the EXISTS Predicate with
Describe batches and how they are SubqueriesAfter completing this module,
handled by SQL Server. students will be able to:
Create and manage transactions with Describe the uses of queries which are
transaction control language statements. nested within other queries.
Use SET XACT_ABORT to define SQL Write self-contained subqueries which

Server's handling of transactions outside return scalar or multi-valued results.
TRY / CATCH blocks. Write correlated subqueries which return
Displaying Query Performance DataAfter scalar or multi-valued results.
completing this module, students will be Use the EXISTS predicate to efficiently
able to: check for the existence of rows in a
Describe components of well-performing subquery.
queries. Using Common Table Expressions
Describe the role of indexes and statistics Using Views
in SQL Server Using Inline Table-Valued FunctionsAfter
Display and interpret basic query plans completing this module, students will be
Display and interpret basic query able to:
performance data Write queries which use derived tables.
Write queries which use common table
expressions.
line Create simple views and write queries
Getting Started with SQL Server against them.
Management Studio Create simple inline table-valued functions
Work with SQL Server Management and write queries against them.
Studio. Using EXCEPT and INTERSECT
Working with SQL AzureAfter completing Using APPLYAfter completing this module,
this module, students will be able to: students will be able to:
Describe the basic features of SQL Write queries which combine data using
Azure. the UNION operator
Provision a SQL Azure server and Write queries which compare sets using
configure its security. the INTERSECT and EXCEPT operators
Understanding Sets Write queries which manipulate rows in a
Understanding Predicate Logic table by using APPLY with the results of a
Understanding the Logical Order of derived table or function
Operations in SELECT statementsAfter Exploring Window Functions
completing this module, students will be Restrict window functions to rows defined
able to: in an OVER clause, including partitions
Describe the elements of T-SQL and their and frames.
role in writing queries Write queries which use window functions
Describe the use of sets in SQL Server to operate on a window of rows and return
Describe the use of predicate logic in ranking, aggregation and offset
SQL Server comparison results.
Describe the logical order of operations in Working with Grouping SetsAfter
SELECT statements completing this module, students will be
Eliminating Duplicates with DISTINCT able to:
Using Column and Table Aliases Write queries which pivot and unpivot
Writing Simple CASE Expressions result sets
Eliminate duplicates using the DISTINCT Write queries which specify multiple
clause. groupings with grouping sets
Use column and table aliases. Executing System Stored Procedures
Write simple CASE expressions. Querying Dynamic Management
Querying with Inner Joins ObjectsAfter completing this module,
Querying with Outer Joins students will be able to:
Querying with Cross Joins and Self Write queries that retrieve system
JoinsAfter completing this module, metadata using system views and
students will be able to: functions.
Describe how multiple tables may be Execute system stored procedures to
queried in a SELECT statement using return system information.
joins. Write queries that retrieve system
Write queries that use inner joins. metadata and state information using
Write queries that use outer joins. system dynamic management views and
Write queries that use self-joins and functions.
cross joins. Passing Parameters to Stored Procedures
Filtering Data with a WHERE Clause Creating Simple Stored Procedures
Filtering with the TOP and Working with Dynamic SQLAfter
OFFSET-FETCH Options completing this module, students will be
Working with Unknown and Missing able to:
ValuesAfter completing this module, Return results by executing stored
students will be able to: procedures.
Filter data with predicates in the WHERE Pass parameters to procedures.
clause. Create simple stored procedures which
Sort data using ORDER BY. encapsulate a SELECT statement.

Filter data in the SELECT clause with Construct and execute dynamic SQL with
TOP. EXEC and sp_executesql.
Filter data with OFFSET and FETCH. Controlling Program FlowAfter completing
Working with Character Data this module, students will be able to:
Working with Date and Time DataAfter Describe the language elements of T-SQL
completing this module, students will be used for simple programming tasks.
able to: Describe batches and how they are
Describe numeric data types, type handled by SQL Server.
precedence and type conversions. Declare and assign variables and
Write queries using character data types. synonyms.
Write queries using date and time data Use IF and WHILE blocks to control
types. program flow.
Using Conversion Functions Working with Error InformationAfter
Using Logical Functions completing this module, students will be
Using Functions to Work with NULLAfter able to:
completing this module, students will be Describe SQL Server's behavior when
able to: errors occur in T-SQL code.
Write queries with built-in scalar Implement structured exception handling in
functions. T-SQL.
Use conversion functions. Return information about errors from
Use logical functions. system objects.
Use functions that work with NULL. Raise user-defined errors and pass system
Using the GROUP BY Clause errors in T-SQL code.
Filtering Groups with HAVINGAfter Controlling TransactionsAfter completing
completing this module, students will be this module, students will be able to:
able to: Describe transactions and the differences
Write queries which summarize data between batches and transactions.
using built-in aggregate functions. Describe batches and how they are
Use the GROUP BY clause to arrange handled by SQL Server.
rows into groups. Create and manage transactions with
Use the HAVING clause to filter out transaction control language statements.
groups based on a search condition. Use SET XACT_ABORT to define SQL
Writing Correlated Subqueries Server's handling of transactions outside
Using the EXISTS Predicate with TRY / CATCH blocks.
SubqueriesAfter completing this module, Displaying Query Performance DataAfter
students will be able to: completing this module, students will be
Describe the uses of queries which are able to:
nested within other queries. Describe components of well-performing
Write self-contained subqueries which queries.
return scalar or multi-valued results. Describe the role of indexes and statistics
Write correlated subqueries which return in SQL Server
scalar or multi-valued results. Display and interpret basic query plans
Use the EXISTS predicate to efficiently Display and interpret basic query
check for the existence of rows in a performance data
subquery.
Using Common Table Expressions
Using Views line
Using Inline Table-Valued FunctionsAfter Getting Started with SQL Server
completing this module, students will be Management Studio
able to: Work with SQL Server Management
Write queries which use derived tables. Studio.
Write queries which use common table Working with SQL AzureAfter completing
expressions. this module, students will be able to:
Create simple views and write queries Describe the basic features of SQL Azure.
against them. Provision a SQL Azure server and
Create simple inline table-valued configure its security.
functions and write queries against them. Understanding Sets
Using EXCEPT and INTERSECT Understanding Predicate Logic
Using APPLYAfter completing this Understanding the Logical Order of
module, students will be able to: Operations in SELECT statementsAfter
Write queries which combine data using completing this module, students will be
the UNION operator able to:
Write queries which compare sets using Describe the elements of T-SQL and their
the INTERSECT and EXCEPT operators role in writing queries
Write queries which manipulate rows in a Describe the use of sets in SQL Server
table by using APPLY with the results of Describe the use of predicate logic in SQL

a derived table or function Server
Exploring Window Functions Describe the logical order of operations in
Restrict window functions to rows defined SELECT statements
in an OVER clause, including partitions Eliminating Duplicates with DISTINCT
and frames. Using Column and Table Aliases
Write queries which use window Writing Simple CASE Expressions
functions to operate on a window of rows Eliminate duplicates using the DISTINCT
and return ranking, aggregation and clause.
offset comparison results. Use column and table aliases.
Working with Grouping SetsAfter Write simple CASE expressions.
completing this module, students will be Querying with Inner Joins
able to: Querying with Outer Joins
Write queries which pivot and unpivot Querying with Cross Joins and Self
result sets JoinsAfter completing this module,
Write queries which specify multiple students will be able to:
groupings with grouping sets Describe how multiple tables may be
Executing System Stored Procedures queried in a SELECT statement using
Querying Dynamic Management joins.
ObjectsAfter completing this module, Write queries that use inner joins.
students will be able to: Write queries that use outer joins.
Write queries that retrieve system Write queries that use self-joins and cross
metadata using system views and joins.
functions. Filtering Data with a WHERE Clause
Execute system stored procedures to Filtering with the TOP and
return system information. OFFSET-FETCH Options
Write queries that retrieve system Working with Unknown and Missing
metadata and state information using ValuesAfter completing this module,
system dynamic management views and students will be able to:
functions. Filter data with predicates in the WHERE
Passing Parameters to Stored clause.
Procedures Sort data using ORDER BY.
Creating Simple Stored Procedures Filter data in the SELECT clause with
Working with Dynamic SQLAfter TOP.
completing this module, students will be Filter data with OFFSET and FETCH.
able to: Working with Character Data
Return results by executing stored Working with Date and Time DataAfter
procedures. completing this module, students will be
Pass parameters to procedures. able to:
Create simple stored procedures which Describe numeric data types, type
encapsulate a SELECT statement. precedence and type conversions.
Construct and execute dynamic SQL with Write queries using character data types.
EXEC and sp_executesql. Write queries using date and time data
Controlling Program FlowAfter types.
completing this module, students will be Using Conversion Functions
able to: Using Logical Functions
Describe the language elements of Using Functions to Work with NULLAfter
T-SQL used for simple programming completing this module, students will be
tasks. able to:
Describe batches and how they are Write queries with built-in scalar functions.
handled by SQL Server. Use conversion functions.
Declare and assign variables and Use logical functions.
synonyms. Use functions that work with NULL.
Use IF and WHILE blocks to control Using the GROUP BY Clause
program flow. Filtering Groups with HAVINGAfter
Working with Error InformationAfter completing this module, students will be
completing this module, students will be able to:
able to: Write queries which summarize data using
Describe SQL Server's behavior when built-in aggregate functions.
errors occur in T-SQL code. Use the GROUP BY clause to arrange
Implement structured exception handling rows into groups.
in T-SQL. Use the HAVING clause to filter out groups
Return information about errors from based on a search condition.
system objects. Writing Correlated Subqueries
Raise user-defined errors and pass Using the EXISTS Predicate with
system errors in T-SQL code. SubqueriesAfter completing this module,
Controlling TransactionsAfter completing students will be able to:

this module, students will be able to: Describe the uses of queries which are
Describe transactions and the differences nested within other queries.
between batches and transactions. Write self-contained subqueries which
Describe batches and how they are return scalar or multi-valued results.
handled by SQL Server. Write correlated subqueries which return
Create and manage transactions with scalar or multi-valued results.
transaction control language statements. Use the EXISTS predicate to efficiently
Use SET XACT_ABORT to define SQL check for the existence of rows in a
Server's handling of transactions outside subquery.
TRY / CATCH blocks. Using Common Table Expressions
Displaying Query Performance DataAfter Using Views
completing this module, students will be Using Inline Table-Valued FunctionsAfter
able to: completing this module, students will be
Describe components of well-performing able to:
queries. Write queries which use derived tables.
Describe the role of indexes and statistics Write queries which use common table
in SQL Server expressions.
Display and interpret basic query plans Create simple views and write queries
Display and interpret basic query against them.
performance data Create simple inline table-valued functions
and write queries against them.
Using EXCEPT and INTERSECT
line Using APPLYAfter completing this module,
Getting Started with SQL Server students will be able to:
Management Studio Write queries which combine data using
Work with SQL Server Management the UNION operator
Studio. Write queries which compare sets using
Working with SQL AzureAfter completing the INTERSECT and EXCEPT operators
this module, students will be able to: Write queries which manipulate rows in a
Describe the basic features of SQL table by using APPLY with the results of a
Azure. derived table or function
Provision a SQL Azure server and Exploring Window Functions
configure its security. Restrict window functions to rows defined
Understanding Sets in an OVER clause, including partitions
Understanding Predicate Logic and frames.
Understanding the Logical Order of Write queries which use window functions
Operations in SELECT statementsAfter to operate on a window of rows and return
completing this module, students will be ranking, aggregation and offset
able to: comparison results.
Describe the elements of T-SQL and their Working with Grouping SetsAfter
role in writing queries completing this module, students will be
Describe the use of sets in SQL Server able to:
Describe the use of predicate logic in Write queries which pivot and unpivot
SQL Server result sets
Describe the logical order of operations in Write queries which specify multiple
SELECT statements groupings with grouping sets
Eliminating Duplicates with DISTINCT Executing System Stored Procedures
Using Column and Table Aliases Querying Dynamic Management
Writing Simple CASE Expressions ObjectsAfter completing this module,
Eliminate duplicates using the DISTINCT students will be able to:
clause. Write queries that retrieve system
Use column and table aliases. metadata using system views and
Write simple CASE expressions. functions.
Querying with Inner Joins Execute system stored procedures to
Querying with Outer Joins return system information.
Querying with Cross Joins and Self Write queries that retrieve system
JoinsAfter completing this module, metadata and state information using
students will be able to: system dynamic management views and
Describe how multiple tables may be functions.
queried in a SELECT statement using Passing Parameters to Stored Procedures
joins. Creating Simple Stored Procedures
Write queries that use inner joins. Working with Dynamic SQLAfter
Write queries that use outer joins. completing this module, students will be
Write queries that use self-joins and able to:
cross joins. Return results by executing stored
Filtering Data with a WHERE Clause procedures.

Filtering with the TOP and Pass parameters to procedures.
OFFSET-FETCH Options Create simple stored procedures which
Working with Unknown and Missing encapsulate a SELECT statement.
ValuesAfter completing this module, Construct and execute dynamic SQL with
students will be able to: EXEC and sp_executesql.
Filter data with predicates in the WHERE Controlling Program FlowAfter completing
clause. this module, students will be able to:
Sort data using ORDER BY. Describe the language elements of T-SQL
Filter data in the SELECT clause with used for simple programming tasks.
TOP. Describe batches and how they are
Filter data with OFFSET and FETCH. handled by SQL Server.
Working with Character Data Declare and assign variables and
Working with Date and Time DataAfter synonyms.
completing this module, students will be Use IF and WHILE blocks to control
able to: program flow.
Describe numeric data types, type Working with Error InformationAfter
precedence and type conversions. completing this module, students will be
Write queries using character data types. able to:
Write queries using date and time data Describe SQL Server's behavior when
types. errors occur in T-SQL code.
Using Conversion Functions Implement structured exception handling in
Using Logical Functions T-SQL.
Using Functions to Work with NULLAfter Return information about errors from
completing this module, students will be system objects.
able to: Raise user-defined errors and pass system
Write queries with built-in scalar errors in T-SQL code.
functions. Controlling TransactionsAfter completing
Use conversion functions. this module, students will be able to:
Use logical functions. Describe transactions and the differences
Use functions that work with NULL. between batches and transactions.
Using the GROUP BY Clause Describe batches and how they are
Filtering Groups with HAVINGAfter handled by SQL Server.
completing this module, students will be Create and manage transactions with
able to: transaction control language statements.
Write queries which summarize data Use SET XACT_ABORT to define SQL
using built-in aggregate functions. Server's handling of transactions outside
Use the GROUP BY clause to arrange TRY / CATCH blocks.
rows into groups. Displaying Query Performance DataAfter
Use the HAVING clause to filter out completing this module, students will be
groups based on a search condition. able to:
Writing Correlated Subqueries Describe components of well-performing
Using the EXISTS Predicate with queries.
SubqueriesAfter completing this module, Describe the role of indexes and statistics
students will be able to: in SQL Server
Describe the uses of queries which are Display and interpret basic query plans
nested within other queries. Display and interpret basic query
Write self-contained subqueries which performance data
return scalar or multi-valued results.
Write correlated subqueries which return
scalar or multi-valued results.
Use the EXISTS predicate to efficiently
check for the existence of rows in a
subquery.
Using Views
Using Inline Table-Valued FunctionsAfter
completing this module, students will be
able to:
expressions.
Create simple views and write queries
against them.
Create simple inline table-valued
functions and write queries against them.

Using APPLYAfter completing this
Write queries which combine data using
the UNION operator
Write queries which compare sets using
the INTERSECT and EXCEPT operators
Write queries which manipulate rows in a
table by using APPLY with the results of
a derived table or function
Exploring Window Functions
Restrict window functions to rows defined
in an OVER clause, including partitions
and frames.
Write queries which use window
functions to operate on a window of rows
and return ranking, aggregation and
offset comparison results.
Working with Grouping SetsAfter
able to:
Write queries which pivot and unpivot
result sets
Write queries which specify multiple
groupings with grouping sets
Executing System Stored Procedures
Querying Dynamic Management
ObjectsAfter completing this module,
students will be able to:
Write queries that retrieve system
metadata using system views and
functions.
Execute system stored procedures to
return system information.
metadata and state information using
system dynamic management views and
functions.
Passing Parameters to Stored
Procedures
Creating Simple Stored Procedures
Working with Dynamic SQLAfter
able to:
Return results by executing stored
procedures.
Pass parameters to procedures.
Create simple stored procedures which
encapsulate a SELECT statement.
Construct and execute dynamic SQL with
EXEC and sp_executesql.
Controlling Program FlowAfter
able to:
Describe the language elements of
T-SQL used for simple programming
tasks.
Describe batches and how they are
handled by SQL Server.
Declare and assign variables and
synonyms.
Use IF and WHILE blocks to control
program flow.
Working with Error InformationAfter
able to:
Describe SQL Server's behavior when

errors occur in T-SQL code.
Implement structured exception handling
in T-SQL.
Return information about errors from
system objects.
Raise user-defined errors and pass
system errors in T-SQL code.
Controlling TransactionsAfter completing
this module, students will be able to:
Describe transactions and the differences
between batches and transactions.
Create and manage transactions with
transaction control language statements.
Use SET XACT_ABORT to define SQL
Server's handling of transactions outside
TRY / CATCH blocks.
Displaying Query Performance DataAfter
able to:
Describe components of well-performing
queries.
Describe the role of indexes and statistics
in SQL Server
Display and interpret basic query plans
performance data
Module 13: Using Window Ranking, Offset

and Aggregate Functions
line
This module introduces window functions

including ranking, aggregate and offset
functions. Much of this functionality is new to
SQL Server 2012. It will cover the use of
T-SQL functions such as ROW_NUMBER,
RANK, DENSE_RANK, NTILE, LAG, LEAD,
FIRST_VALUE and LAST_VALUE to perform
calculations against a set, or window, of rows.
line
Creating Windows with OVER
line
Getting Started with SQL Server
Management Studio
Work with SQL Server Management
Studio.
Describe the basic features of SQL
Azure.
Provision a SQL Azure server and
configure its security.
Understanding Sets
Understanding Predicate Logic
Understanding the Logical Order of
able to:
Describe the elements of T-SQL and their
role in writing queries
Describe the use of sets in SQL Server
Describe the use of predicate logic in

SQL Server
Describe the logical order of operations in
SELECT statements
Eliminating Duplicates with DISTINCT
Using Column and Table Aliases
Writing Simple CASE Expressions
Eliminate duplicates using the DISTINCT
clause.
Use column and table aliases.
Write simple CASE expressions.
Querying with Inner Joins
Querying with Outer Joins
Querying with Cross Joins and Self
JoinsAfter completing this module,
Describe how multiple tables may be
queried in a SELECT statement using
joins.
Write queries that use inner joins.
Write queries that use outer joins.
Write queries that use self-joins and
cross joins.
Filtering Data with a WHERE Clause
Filtering with the TOP and
OFFSET-FETCH Options
Working with Unknown and Missing
ValuesAfter completing this module,
Filter data with predicates in the WHERE
clause.
Sort data using ORDER BY.
Filter data in the SELECT clause with
TOP.
Filter data with OFFSET and FETCH.
Working with Character Data
Working with Date and Time DataAfter
able to:
Describe numeric data types, type
precedence and type conversions.
Write queries using character data types.
Write queries using date and time data
types.
Using Conversion Functions
Using Logical Functions
Using Functions to Work with NULLAfter
able to:
Write queries with built-in scalar
functions.
Use conversion functions.
Use logical functions.
Use functions that work with NULL.
Using the GROUP BY Clause
Filtering Groups with HAVINGAfter
able to:
Write queries which summarize data
using built-in aggregate functions.
Use the GROUP BY clause to arrange
rows into groups.
Use the HAVING clause to filter out
groups based on a search condition.
Writing Correlated Subqueries
Using the EXISTS Predicate with
SubqueriesAfter completing this module,

Describe the uses of queries which are
nested within other queries.
Write self-contained subqueries which
subquery.
Using Views
able to:
expressions.
against them.
the UNION operator
and frames.
able to:
result sets
functions.
functions.
Procedures
able to:

procedures.
able to:
tasks.
synonyms.
program flow.
able to:
in T-SQL.
system objects.
TRY / CATCH blocks.
able to:
queries.
in SQL Server
performance data
After completing this module, students will be

able to:
line
Describe the architecture and editions of
SQL Server 2012.
Describe the benefits to using window
functions.
line
Getting Started with SQL Server
Management Studio
Work with SQL Server Management
Studio.

Describe the basic features of SQL
Azure.
Provision a SQL Azure server and
configure its security.
Understanding Sets
Understanding Predicate Logic
Understanding the Logical Order of
able to:
Describe the elements of T-SQL and their
role in writing queries
Describe the use of sets in SQL Server
Describe the use of predicate logic in
SQL Server
Describe the logical order of operations in
SELECT statements
Eliminating Duplicates with DISTINCT
Using Column and Table Aliases
Writing Simple CASE Expressions
Eliminate duplicates using the DISTINCT
clause.
Use column and table aliases.
Write simple CASE expressions.
Querying with Inner Joins
Querying with Outer Joins
Querying with Cross Joins and Self
JoinsAfter completing this module,
Describe how multiple tables may be
queried in a SELECT statement using
joins.
Write queries that use inner joins.
Write queries that use outer joins.
Write queries that use self-joins and
cross joins.
Filtering Data with a WHERE Clause
Filtering with the TOP and
OFFSET-FETCH Options
Working with Unknown and Missing
ValuesAfter completing this module,
Filter data with predicates in the WHERE
clause.
Sort data using ORDER BY.
Filter data in the SELECT clause with
TOP.
Filter data with OFFSET and FETCH.
Working with Character Data
Working with Date and Time DataAfter
able to:
Describe numeric data types, type
precedence and type conversions.
Write queries using character data types.
Write queries using date and time data
types.
Using Conversion Functions
Using Logical Functions
Using Functions to Work with NULLAfter
able to:
Write queries with built-in scalar
functions.

Use conversion functions.
Use logical functions.
Use functions that work with NULL.
Using the GROUP BY Clause
Filtering Groups with HAVINGAfter
able to:
Write queries which summarize data
using built-in aggregate functions.
Use the GROUP BY clause to arrange
rows into groups.
Use the HAVING clause to filter out
groups based on a search condition.
Writing Correlated Subqueries
Using the EXISTS Predicate with
SubqueriesAfter completing this module,
Describe the uses of queries which are
nested within other queries.
Write self-contained subqueries which
subquery.
Using Views
able to:
expressions.
against them.
the UNION operator
and frames.
able to:
result sets

functions.
functions.
Procedures
able to:
procedures.
able to:
tasks.
synonyms.
program flow.
able to:
in T-SQL.
system objects.
TRY / CATCH blocks.
able to:
queries.
in SQL Server

performance data
Extra informatie:
This course will be delivered with digital courseware. In order to have the best learning experience you are asked to bring your own second
screen to view the courseware. A second screen includes: tablets and laptops.
Nadere informatie:
Neem voor nadere informatie of boekingen contact op met onze Customer Service Desk 030 - 60 89 444
info@globalknowledge.nl
www.globalknowledge.nl
Iepenhoeve 5, 3438 MR Nieuwegein

Querying Microsoft SQL Server 2012

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Querying Microsoft SQL Server 2012

Uploaded by

Copyright:

Available Formats

Querying Microsoft SQL Server 2012

Cursusduur: 5 Dagen Cursuscode: M10774

After completing this course, students will be able to:

Write SELECT Queries Implementing Transactions

Query Multiple Tables Use Table Expressions

Use Built-In Functions Sort and Filter Data

Use Subqueries Use Window Ranking, Offset and Aggregate Functions

Execute Stored Procedures Query SQL Server Metadata

Use Set Operators Program with T-SQL

Implement Error Handling Improve Query Performance

Vereiste kennis en vaardigheden: Examens en certificering

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444

M10774 www.globalknowledge.nl info@globalknowledge.nl 030 - 60 89 444