Click to edit

Master subtitle
style

02 | Advanced SELECT Statements

Brian Alderman | MCT, CEO / Founder of
MicroTechPoint
Tobias Ternstrom | Microsoft SQL Server Program
Manager

Course Topics
Querying Microsoft SQL Server 2012 Jump Start
01 | Introducing SQL Server 2012
SQL Server types of statements; other SQL statement elements; basic SELECT statements

02 | Advanced SELECT Statements

DISTINCT, Aliases, scalar functions and CASE, using JOIN and MERGE;
Filtering and sorting data, NULL values

03 | SQL Server Data Types

Introduce data types, data type usage, converting data types, understanding SQL Server function
types

04 | Grouping and Aggregating Data

Aggregate functions, GROUP BY and HAVING clauses, subqueries; self-contained, correlated, and
EXISTS; Views, inline-table valued functions, and derived tables

| Lunch Break
Eat, drink, and recharge for the afternoon session

Module Overview

Advanced SELECT clauses (DISTINCT, aliases,

CASE, and scalar functions)
Query multiple tables using JOIN statements
Filtering and sorting data

Advanced SELECT
Clauses

Understanding DISTINCT
Specifies that only unique rows can appear in the result
set
Removes duplicates based on column list results, not
source table
Provides uniqueness across set of selected columns
Removes rows already operated on by WHERE, HAVING,
and GROUP BY clauses
Some queries may improve performance by filtering out
duplicates prior to execution of SELECT clause

SELECT DISTINCT syntax

SELECT
SELECT DISTINCT
DISTINCT <column
<column list>
list>
FROM
FROM <table
<table or
or view>
view>
SELECT
SELECT DISTINCT
DISTINCT StoreID
StoreID
FROM
FROM Sales.Customer;
Sales.Customer;
StoreID
StoreID
------------1234
1234
570
570
902
902
1898
1898
710
710

Using aliases to refer to columns

Column aliases using AS

SELECT
SELECT SalesOrderID,
SalesOrderID, UnitPrice,
UnitPrice, OrderQty
OrderQty AS
AS Quantity
Quantity
FROM
FROM

Sales.SalesOrderDetail;
Sales.SalesOrderDetail;

Column aliases using =

SELECT SalesOrderID,
SalesOrderID, UnitPrice, Quantity
Quantity =
=
OrderQty
OrderQty
FROM
FROM

Sales.SalesOrderDetail;
Sales.SalesOrderDetail;

Accidental column aliases

SELECT
SELECT SalesOrderID,
SalesOrderID, UnitPrice
UnitPrice Quantity
Quantity
FROM
FROM

Sales.SalesOrderDetail;
Sales.SalesOrderDetail;

Using aliases to refer to tables

Create table aliases in the FROM clause using AS

SELECT
SELECT SalesOrderID,
SalesOrderID, ProductID
ProductID
FROM
FROM Sales.SalesOrderDetail
Sales.SalesOrderDetail AS
AS SalesOrders;
SalesOrders;
Table aliases without AS

SELECT
SELECT SalesOrderID,
SalesOrderID, ProductID
ProductID
FROM
FROM Sales.SalesOrderDetail
Sales.SalesOrderDetail SalesOrders;
SalesOrders;
Using table aliases in the SELECT clause

SELECT
SELECT SalesOrders.SalesOrderID,
SalesOrders.SalesOrderID,
SalesOrders.ProductID
SalesOrders.ProductID
FROM
FROM Sales.SalesOrderDetail
Sales.SalesOrderDetail AS
AS SalesOrders;
SalesOrders;

T-SQL CASE expressions

Simple CASE
Compares one value to a list of possible values and returns
first match
If no match, returns value found in optional ELSE clause
If no match and no ELSE, returns NULL
Searched CASE
Evaluates a set of predicates, or logical expressions
Returns value found in THEN clause matching first
expression that evaluates to TRUE
T-SQL CASE expressions return a single (scalar) value
CASE expressions may be used in:
SELECT column list (behaves as calculated column requiring
an alias)
WHERE or HAVING clauses
ORDER BY clause

Writing simple CASE expressions

Keyword

Expression component

SELECT

<select list>

CASE

<value to compare>

WHEN

<value to match>

THEN

<result>

END
FROM

N/A
<table source>

SELECT
SELECT ProductID,
ProductID, Name,
Name, ProductSubCategoryID,
ProductSubCategoryID,
CASE
CASE ProductSubCategoryID
ProductSubCategoryID
WHEN
WHEN 1
1 THEN
THEN 'Beverages'
'Beverages'
ELSE
ELSE 'Unknown
'Unknown Category'
Category'
END
END
FROM
FROM Production.Product
Production.Product

Demo
Using basic SELECT clauses

JOIN Statements

Overview of JOIN types

JOIN types in FROM clause specify the operations performed on the
virtual table:
Join Type

Description

Cross

Combines all rows in both tables (creates Cartesian product).

Inner

Starts with Cartesian product; applies filter to match rows

between tables based on predicate.

Outer

Starts with Cartesian product; all rows from designated table

preserved, matching rows from other table retrieved.
Additional NULLs inserted as placeholders.

Understanding INNER JOINS

Returns only rows where a match is found in both tables
Matches rows based on attributes supplied in predicate
ON clause in SQL-92 syntax
Why filter in ON clause?
Logical separation between filtering for purposes of JOIN
and filtering results in WHERE
Typically no difference to query optimizer
If JOIN predicate operator is =, also known as equi-join

INNER JOIN Syntax

List tables in FROM Clause separated by JOIN operator
Table order does not matter, and aliases are preferred
FROM
FROM t1
t1 JOIN
JOIN t2
t2
ON
ON t1.column
t1.column =
= t2.column
t2.column
SELECT
SELECT SOH.SalesOrderID,
SOH.SalesOrderID,
SOH.OrderDate,
SOH.OrderDate,
SOD.ProductID,
SOD.ProductID,
SOD.UnitPrice,
SOD.UnitPrice,
SOD.OrderQty
SOD.OrderQty
FROM
FROM Sales.SalesOrderHeader
Sales.SalesOrderHeader AS
AS SOH
SOH
JOIN
JOIN Sales.SalesOrderDetail
Sales.SalesOrderDetail AS
AS SOD
SOD
ON
ON SOH.SalesOrderID = SOD.SalesOrderID;
SOD.SalesOrderID;

Understanding OUTER JOINS

Returns all rows from one table and any matching rows from
second table
One tables rows are preserved
Designated with LEFT, RIGHT, FULL keyword
All rows from preserved table output to result set
Matches from other table retrieved
Additional rows added to results for non-matched rows
NULLs added in place where attributes do not match
Example: Return all customers and for those who have
placed orders, return order information. Customers without
matching orders will display NULL for order details.

OUTER JOIN examples

Customers that did not place orders:

SELECT
SELECT CUST.CustomerID,
CUST.CustomerID, CUST.StoreID,
CUST.StoreID,
ORD.SalesOrderID,
ORD.SalesOrderID, ORD.OrderDate
ORD.OrderDate
FROM
FROM Sales.Customer
Sales.Customer AS
AS CUST
LEFT
LEFT OUTER
OUTER JOIN
JOIN Sales.SalesOrderHeader
Sales.SalesOrderHeader AS
AS
ORD
ORD
ON
ON CUST.CustomerID
CUST.CustomerID =
= ORD.CustomerID
ORD.CustomerID
WHERE
WHERE ORD.SalesOrderID IS
IS NULL;
NULL;

Understanding CROSS JOINS

Combine each row from first table with each row from second
table
All possible combinations are displayed
Logical foundation for inner and outer joins
INNER JOIN starts with Cartesian product, adds filter
OUTER JOIN takes Cartesian output, filtered, adds back
non-matching rows (with NULL placeholders)
Due to Cartesian product output, not typically a desired form
of JOIN
Some useful exceptions:
Generating a table of numbers for testing

CROSS JOIN Example

Create test data by returning all combinations of two inputs:

SELECT
SELECT EMP1.BusinessEntityID,
EMP1.BusinessEntityID, EMP2.JobTitle
EMP2.JobTitle
FROM
FROM HumanResources.Employee AS
AS EMP1
EMP1
CROSS
CROSS JOIN
JOIN HumanResources.Employee
HumanResources.Employee AS
AS EMP2;
EMP2;

Understanding Self-Joins
Why use self-joins?
Compare rows in same table to each other
Create two instances of same table in FROM clause
At least one alias required
Example: Return all employees and
the name of the employees manager

Self-Join examples
Return all employees with ID of employees manager when a
manager exists (INNER JOIN):

SELECT

EMP.EmpID,
EMP.EmpID, EMP.LastName,
EMP.LastName,
EMP.JobTitle,
EMP.JobTitle, EMP.MgrID,
EMP.MgrID, MGR.LastName
MGR.LastName
FROM
HR.Employees
HR.Employees AS
AS EMP
EMP
INNER JOIN HR.Employees
HR.Employees AS
AS MGR
MGR
ON EMP.MgrID
EMP.MgrID =
= MGR.EmpID
MGR.EmpID ;
Return all employees with ID of manager (OUTER JOIN). This will
return NULL for the CEO:

SELECT
SELECT EMP.EmpID,
EMP.EmpID, EMP.LastName,
EMP.LastName,
EMP.Title,
EMP.Title, MGR.MgrID
MGR.MgrID
FROM
FROM HumanResources.Employee
HumanResources.Employee AS
AS EMP
EMP
LEFT
LEFT OUTER
OUTER JOIN
JOIN HumanResources.Employee
HumanResources.Employee AS
AS
MGR
MGR
ON
ON EMP.MgrID
EMP.MgrID =
= MGR.EmpID;

Demo
Using JOINS to view data from
multiple tables

Filtering and Sorting

Data

Using the ORDER BY clause

ORDER BY sorts rows in results for presentation purposes
Use of ORDER BY guarantees the sort order of the result
Last clause to be logically processed
Sorts all NULLs together
ORDER BY can refer to:
Columns by name, alias or ordinal position (not
recommended)
Columns not part of SELECT list unless DISTINCT clause
specified
Declare sort order with ASC or DESC

ORDER BY clause examples

ORDER BY with column names:

SELECT
SELECT SalesOrderID,
SalesOrderID, CustomerID,
CustomerID, OrderDate
OrderDate
FROM
FROM Sales.SalesOrderHeader
Sales.SalesOrderHeader
ORDER
ORDER BY
BY OrderDate;
OrderDate;
ORDER BY with column alias:

SELECT
SELECT SalesOrderID,
SalesOrderID, CustomerID,
CustomerID,
YEAR(OrderDate)
YEAR(OrderDate) AS
AS OrderYear
OrderYear
FROM
FROM Sales.SalesOrderHeader
Sales.SalesOrderHeader
ORDER
ORDER BY
BY OrderYear;
OrderYear;
ORDER BY with descending order:

SELECT
SELECT SalesOrderID,
SalesOrderID, CustomerID,
CustomerID, OrderDate
OrderDate
FROM
FROM Sales.SalesOrderHeader
Sales.SalesOrderHeader
ORDER
ORDER BY
BY OrderDate
OrderDate DESC;
DESC;

Filtering data in the WHERE clause

WHERE clauses use predicates
Must be expressed as logical conditions
Only rows for which predicate evaluates to TRUE are
accepted
Values of FALSE or UNKNOWN are filtered out
WHERE clause follows FROM, precedes other clauses
Cant see aliases declared in SELECT clause
Can be optimized by SQL Server to use indexes

WHERE clause syntax

Filter rows for customers in territory 6

SELECT
SELECT CustomerID,
CustomerID, TerritoryID
FROM
FROM Sales.Customer
Sales.Customer
WHERE
WHERE TerritoryID
TerritoryID =
= 6;
6;
Filter rows for orders in territories greater than or equal to 6

SELECT CustomerID,
CustomerID, TerritoryID
FROM Sales.Customer
Sales.Customer
WHERE
WHERE TerritoryID
TerritoryID >= 6;
Filter orders within a range of dates

SELECT CustomerID,
CustomerID, TerritoryID, StoreID
FROM Sales.Customer
Sales.Customer
WHERE
WHERE StoreID
StoreID >=
>= 1000
1000 AND
AND StoreID
StoreID <=
<= 1200;
1200;

Filtering data in the SELECT clause

TOP allows you to limit the number or percentage of rows
returned Works with ORDER BY clause to limit rows by sort
order
If ORDER BY list is not unique, results are not deterministic
(no single correct result set)
Modify ORDER BY list to ensure uniqueness, or use TOP
WITH TIES
Added to SELECT clause:
SELECT TOP (N) | TOP (N) Percent
With percent, number of rows rounded up
SELECT TOP (N) WITH TIES
Retrieve duplicates where applicable (nondeterministic)
TOP is proprietary to Microsoft SQL Server

Filtering using TOP

Filter rows for customers to display top 20 TotalDue items

SELECT TOP
TOP (20)
(20) SalesOrderID,
SalesOrderID, CustomerID,
CustomerID,
TotalDue
FROM
FROM Sales.SalesOrderHeader
ORDER
ORDER BY TotalDue
TotalDue DESC;
DESC;
Filter rows for customers to display top 20 TotalDue items with
ties

SELECT TOP
TOP (20)
(20) WITH
WITH TIES
TIES SalesOrderID,
SalesOrderID,
CustomerID, TotalDue
TotalDue
FROM
FROM Sales.SalesOrderHeader
ORDER
ORDER BY TotalDue
TotalDue DESC;
DESC;

Filter rows for customers to display top 1% of TotalDue items

SELECT
SELECT TOP
TOP (1)
(1) PERCENT
PERCENT SalesOrderID,
SalesOrderID, CustomerID,
CustomerID,
TotalDue
TotalDue
FROM
FROM Sales.SalesOrderHeader
ORDER
ORDER BY
BY TotalDue
TotalDue DESC;
DESC;

Handling NULL in queries

Different components of SQL Server handle NULL
differently
Query filters (ON, WHERE, HAVING) filter out
UNKNOWNs
CHECK constraints accept UNKNOWNS
ORDER BY, DISTINCT treat NULLs as equals
Testing for NULL
Use IS NULL or IS NOT NULL rather than = NULL or <>
SELECT CustomerID,
CustomerID, StoreID, TerritoryID
NULL
FROM
FROM Sales.Customer
Sales.Customer
WHERE
WHERE StoreID
StoreID IS
IS NULL
NULL
ORDER BY TerritoryID
TerritoryID

Demo
Sorting and filtering data

Summary
The SELECT statement requires columns specified (* all
columns) and the FROM clause to identify what view or
table the rows of data are being pulled from
Clauses like DISTINCT provide control over what items are
returned in the result set.
Aliases are used to define the names of columns or tables
being referenced in the SELECT statement
CASE statements are used for performing comparisons in a
list of values and returns first match

Summary
JOINS are used to display content from multiple tables in a
single result set. INNER, OUTER, CROSS, and SELF JOINS
can all be used to create the desire result set
ORDER BY is used to sort the rows returned in the result
set
WHERE is used to filter the rows returned in the result set
The TOP clause is used to define the number of rows
returned in the result set by specifying the number of rows
or a percentage of rows returned.

2013 Microsoft Corporation. All rights reserved. Microsoft, Windows, Office, Azure, System Center, Dynamics and other product names are
or may be registered trademarks and/or trademarks in the U.S. and/or other countries. The information herein is for informational purposes
only and represents the current view of Microsoft Corporation as of the date of this presentation. Because Microsoft must respond to
changing market conditions, it should not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the
accuracy of any information provided after the date of this presentation. MICROSOFT MAKES NO WARRANTIES, EXPRESS, IMPLIED OR
STATUTORY, AS TO THE INFORMATION IN THIS PRESENTATION.