Exemplos de SELECT (Transact-SQL)SELECT Examples (Transact-SQL)

APLICA-SE A: simSQL Server simBanco de Dados SQL do Azure nãoAzure Synapse Analytics (SQL DW) nãoParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database noAzure Synapse Analytics (SQL DW) noParallel Data Warehouse

Este tópico fornece exemplos de uso da instrução SELECT.This topic provides examples of using the SELECT statement.

A.A. Usando SELECT para recuperar linhas e colunasUsing SELECT to retrieve rows and columns

O exemplo a seguir mostra três exemplos de código.The following example shows three code examples. Este primeiro retorna todas as linhas (nenhuma cláusula WHERE foi especificada) e todas as colunas (usando o *) da tabela Product do banco de dados AdventureWorks2012AdventureWorks2012.This first code example returns all rows (no WHERE clause is specified) and all columns (using the *) from the Product table in the AdventureWorks2012AdventureWorks2012 database.

USE AdventureWorks2012;
GO
SELECT *
FROM Production.Product
ORDER BY Name ASC;
-- Alternate way.
USE AdventureWorks2012;
GO
SELECT p.*
FROM Production.Product AS p
ORDER BY Name ASC;
GO

Este exemplo retorna todas as linhas (nenhuma cláusula WHERE foi especificada) e somente um subconjunto das colunas (Name, ProductNumber, ListPrice) da tabela Product do banco de dados AdventureWorks2012AdventureWorks2012.This example returns all rows (no WHERE clause is specified), and only a subset of the columns (Name, ProductNumber, ListPrice) from the Product table in the AdventureWorks2012AdventureWorks2012 database. Além disso, um título de coluna é adicionado.Additionally, a column heading is added.

USE AdventureWorks2012;
GO
SELECT Name, ProductNumber, ListPrice AS Price
FROM Production.Product 
ORDER BY Name ASC;
GO

Este exemplo retorna somente as linhas de Product que têm uma linha de produto igual a R e que tenham dias para manufatura menores que 4.This example returns only the rows for Product that have a product line of R and that have days to manufacture that is less than 4.

USE AdventureWorks2012;
GO
SELECT Name, ProductNumber, ListPrice AS Price
FROM Production.Product 
WHERE ProductLine = 'R' 
AND DaysToManufacture < 4
ORDER BY Name ASC;
GO

B.B. Usando SELECT com títulos de coluna e cálculosUsing SELECT with column headings and calculations

Os exemplos a seguir retornam todas as linhas da tabela Product.The following examples return all rows from the Product table. O primeiro exemplo retorna o total de vendas e os descontos para cada produto.The first example returns total sales and the discounts for each product. No segundo exemplo, a receita total é calculada para cada produto.In the second example, the total revenue is calculated for each product.

USE AdventureWorks2012;
GO
SELECT p.Name AS ProductName, 
NonDiscountSales = (OrderQty * UnitPrice),
Discounts = ((OrderQty * UnitPrice) * UnitPriceDiscount)
FROM Production.Product AS p 
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID 
ORDER BY ProductName DESC;
GO

Esta é a consulta que calcula a receita para cada produto em cada ordem de vendas.This is the query that calculates the revenue for each product in each sales order.

USE AdventureWorks2012;
GO
SELECT 'Total income is', ((OrderQty * UnitPrice) * (1.0 - UnitPriceDiscount)), ' for ',
p.Name AS ProductName 
FROM Production.Product AS p 
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID 
ORDER BY ProductName ASC;
GO

C.C. Usando DISTINCT com SELECTUsing DISTINCT with SELECT

O exemplo a seguir usa DISTINCT para impedir a recuperação de títulos duplicados.The following example uses DISTINCT to prevent the retrieval of duplicate titles.

USE AdventureWorks2012;
GO
SELECT DISTINCT JobTitle
FROM HumanResources.Employee
ORDER BY JobTitle;
GO

D.D. Criando tabelas com SELECT INTOCreating tables with SELECT INTO

O primeiro exemplo a seguir cria uma tabela temporária denominada #Bicycles em tempdb.The following first example creates a temporary table named #Bicycles in tempdb.

USE tempdb;
GO
IF OBJECT_ID (N'#Bicycles',N'U') IS NOT NULL
DROP TABLE #Bicycles;
GO
SELECT * 
INTO #Bicycles
FROM AdventureWorks2012.Production.Product
WHERE ProductNumber LIKE 'BK%';
GO

Este segundo exemplo cria a tabela permanente NewProducts.This second example creates the permanent table NewProducts.

USE AdventureWorks2012;
GO
IF OBJECT_ID('dbo.NewProducts', 'U') IS NOT NULL
    DROP TABLE dbo.NewProducts;
GO
ALTER DATABASE AdventureWorks2012 SET RECOVERY BULK_LOGGED;
GO

SELECT * INTO dbo.NewProducts
FROM Production.Product
WHERE ListPrice > $25 
AND ListPrice < $100;
GO
ALTER DATABASE AdventureWorks2012 SET RECOVERY FULL;
GO

E.E. Usando subconsultas correlacionadasUsing correlated subqueries

O exemplo a seguir mostra consultas semanticamente equivalentes e ilustra a diferença entre o uso da palavra-chave EXISTS e da palavra-chave IN.The following example shows queries that are semantically equivalent and illustrates the difference between using the EXISTS keyword and the IN keyword. Ambos são exemplos de uma subconsulta válida que recupera uma instância de cada nome de produto para o qual o modelo do produto é uma camisa de marca de manga longa e os números de ProductModelID são correspondentes entre as tabelas Product e ProductModel.Both are examples of a valid subquery that retrieves one instance of each product name for which the product model is a long sleeve logo jersey, and the ProductModelID numbers match between the Product and ProductModel tables.

USE AdventureWorks2012;
GO
SELECT DISTINCT Name
FROM Production.Product AS p 
WHERE EXISTS
    (SELECT *
     FROM Production.ProductModel AS pm 
     WHERE p.ProductModelID = pm.ProductModelID
           AND pm.Name LIKE 'Long-Sleeve Logo Jersey%');
GO

-- OR

USE AdventureWorks2012;
GO
SELECT DISTINCT Name
FROM Production.Product
WHERE ProductModelID IN
    (SELECT ProductModelID 
     FROM Production.ProductModel
     WHERE Name LIKE 'Long-Sleeve Logo Jersey%');
GO

O exemplo a seguir usa IN em uma subconsulta correlata ou repetitiva.The following example uses IN in a correlated, or repeating, subquery. Trata-se de uma consulta que depende da consulta externa para obter seus valores.This is a query that depends on the outer query for its values. A consulta é executada repetidamente, uma vez para cada linha que pode ser selecionada pela consulta externa.The query is executed repeatedly, one time for each row that may be selected by the outer query. Essa consulta recupera uma instância do nome e sobrenome de cada funcionário para os quais o bônus da tabela SalesPerson seja 5000.00 e para os quais existam números de identificação de funcionário correspondentes nas tabelas Employee e SalesPerson.This query retrieves one instance of the first and last name of each employee for which the bonus in the SalesPerson table is 5000.00 and for which the employee identification numbers match in the Employee and SalesPerson tables.

USE AdventureWorks2012;
GO
SELECT DISTINCT p.LastName, p.FirstName 
FROM Person.Person AS p 
JOIN HumanResources.Employee AS e
    ON e.BusinessEntityID = p.BusinessEntityID WHERE 5000.00 IN
    (SELECT Bonus
     FROM Sales.SalesPerson AS sp
     WHERE e.BusinessEntityID = sp.BusinessEntityID);
GO

A subconsulta anterior dessa instrução não pode ser avaliada independentemente da consulta externa.The previous subquery in this statement cannot be evaluated independently of the outer query. É necessário um valor de Employee.EmployeeID, mas esse valor é alterado à medida que o Mecanismo de Banco de Dados do SQL ServerSQL Server Database Engine examina diferentes linhas em Employee.It requires a value for Employee.EmployeeID, but this value changes as the Mecanismo de Banco de Dados do SQL ServerSQL Server Database Engine examines different rows in Employee.

Uma subconsulta correlata também pode ser usada na cláusula HAVING de uma consulta externa.A correlated subquery can also be used in the HAVING clause of an outer query. Este exemplo localiza os modelos de produto cujo preço máximo de tabela é mais que o dobro da média para o modelo.This example finds the product models for which the maximum list price is more than twice the average for the model.

USE AdventureWorks2012;
GO
SELECT p1.ProductModelID
FROM Production.Product AS p1
GROUP BY p1.ProductModelID
HAVING MAX(p1.ListPrice) >= ALL
    (SELECT AVG(p2.ListPrice) * 2
     FROM Production.Product AS p2
     WHERE p1.ProductModelID = p2.ProductModelID);
GO

Este exemplo usa duas subconsultas correlatas para localizar os nomes de funcionários que venderam um produto específico.This example uses two correlated subqueries to find the names of employees who have sold a particular product.

USE AdventureWorks2012;
GO
SELECT DISTINCT pp.LastName, pp.FirstName 
FROM Person.Person pp JOIN HumanResources.Employee e
ON e.BusinessEntityID = pp.BusinessEntityID WHERE pp.BusinessEntityID IN 
(SELECT SalesPersonID 
FROM Sales.SalesOrderHeader
WHERE SalesOrderID IN 
(SELECT SalesOrderID 
FROM Sales.SalesOrderDetail
WHERE ProductID IN 
(SELECT ProductID 
FROM Production.Product p 
WHERE ProductNumber = 'BK-M68B-42')));
GO

F.F. Usando GROUP BYUsing GROUP BY

O exemplo a seguir localiza o total de cada ordem de vendas no banco de dados.The following example finds the total of each sales order in the database.

USE AdventureWorks2012;
GO
SELECT SalesOrderID, SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail
GROUP BY SalesOrderID
ORDER BY SalesOrderID;
GO

Devido à cláusula GROUP BY, somente uma linha que contenha a soma de todas as vendas será retornada para cada ordem de vendas.Because of the GROUP BY clause, only one row containing the sum of all sales is returned for each sales order.

G.G. Usando GROUP BY com vários gruposUsing GROUP BY with multiple groups

O exemplo a seguir localiza o preço médio e a soma das vendas do ano até a data atual, agrupadas por ID de produto e ID de oferta especial.The following example finds the average price and the sum of year-to-date sales, grouped by product ID and special offer ID.

USE AdventureWorks2012;
GO
SELECT ProductID, SpecialOfferID, AVG(UnitPrice) AS [Average Price], 
    SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail
GROUP BY ProductID, SpecialOfferID
ORDER BY ProductID;
GO

H.H. Usando GROUP BY e WHEREUsing GROUP BY and WHERE

O exemplo a seguir põe os resultados em grupos depois de recuperar apenas as linhas com preços de tabela maiores que $1000.The following example puts the results into groups after retrieving only the rows with list prices greater than $1000.

USE AdventureWorks2012;
GO
SELECT ProductModelID, AVG(ListPrice) AS [Average List Price]
FROM Production.Product
WHERE ListPrice > $1000
GROUP BY ProductModelID
ORDER BY ProductModelID;
GO

I.I. Usando GROUP BY com uma expressãoUsing GROUP BY with an expression

O exemplo a seguir agrupa por uma expressão.The following example groups by an expression. É possível agrupar por uma expressão se a mesma não contiver funções de agregação.You can group by an expression if the expression does not include aggregate functions.

USE AdventureWorks2012;
GO
SELECT AVG(OrderQty) AS [Average Quantity], 
NonDiscountSales = (OrderQty * UnitPrice)
FROM Sales.SalesOrderDetail
GROUP BY (OrderQty * UnitPrice)
ORDER BY (OrderQty * UnitPrice) DESC;
GO

J.J. Usando GROUP BY com ORDER BYUsing GROUP BY with ORDER BY

O exemplo a seguir localiza o preço médio de cada tipo de produto e ordena os resultados por preço médio.The following example finds the average price of each type of product and orders the results by average price.

USE AdventureWorks2012;
GO
SELECT ProductID, AVG(UnitPrice) AS [Average Price]
FROM Sales.SalesOrderDetail
WHERE OrderQty > 10
GROUP BY ProductID
ORDER BY AVG(UnitPrice);
GO

K.K. Usando a cláusula HAVINGUsing the HAVING clause

O primeiro exemplo a seguir mostra uma cláusula HAVING com uma função de agregação.The first example that follows shows a HAVING clause with an aggregate function. Ela agrupa as linhas da tabela SalesOrderDetail por ID de produto e elimina os produtos cujas quantidades médias de pedido forem cinco ou menos.It groups the rows in the SalesOrderDetail table by product ID and eliminates products whose average order quantities are five or less. O segundo exemplo mostra uma cláusula HAVING sem funções de agregação.The second example shows a HAVING clause without aggregate functions.

USE AdventureWorks2012;
GO
SELECT ProductID 
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING AVG(OrderQty) > 5
ORDER BY ProductID;
GO

Esta consulta usa a cláusula LIKE na cláusula HAVING.This query uses the LIKE clause in the HAVING clause.

USE AdventureWorks2012 ;  
GO  
SELECT SalesOrderID, CarrierTrackingNumber   
FROM Sales.SalesOrderDetail  
GROUP BY SalesOrderID, CarrierTrackingNumber  
HAVING CarrierTrackingNumber LIKE '4BD%'  
ORDER BY SalesOrderID ;  
GO  

L.L. Usando HAVING e GROUP BYUsing HAVING and GROUP BY

O exemplo a seguir mostra o uso de cláusulas GROUP BY, HAVING, WHERE e ORDER BY em uma instrução SELECT.The following example shows using GROUP BY, HAVING, WHERE, and ORDER BY clauses in one SELECT statement. Ele produz grupos e valores resumidos, mas o faz depois de eliminar os produtos com preços acima de $25 e quantidades médias de pedido abaixo de 5.It produces groups and summary values but does so after eliminating the products with prices over $25 and average order quantities under 5. Também organiza os resultados por ProductID.It also organizes the results by ProductID.

USE AdventureWorks2012;
GO
SELECT ProductID 
FROM Sales.SalesOrderDetail
WHERE UnitPrice < 25.00
GROUP BY ProductID
HAVING AVG(OrderQty) > 5
ORDER BY ProductID;
GO

M.M. Usando HAVING com SUM e AVGUsing HAVING with SUM and AVG

O exemplo a seguir agrupa a tabela SalesOrderDetail por ID de produto e somente inclui os grupos de produtos que têm pedidos totalizando mais de $1000000.00 e cujas quantidades médias do pedido são inferiores a 3.The following example groups the SalesOrderDetail table by product ID and includes only those groups of products that have orders totaling more than $1000000.00 and whose average order quantities are less than 3.

USE AdventureWorks2012;
GO
SELECT ProductID, AVG(OrderQty) AS AverageQuantity, SUM(LineTotal) AS Total
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING SUM(LineTotal) > $1000000.00
AND AVG(OrderQty) < 3;
GO

Para consultar os produtos que tiveram vendas totais maiores que $2000000.00, use esta consulta:To see the products that have had total sales greater than $2000000.00, use this query:

USE AdventureWorks2012;
GO
SELECT ProductID, Total = SUM(LineTotal)
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING SUM(LineTotal) > $2000000.00;
GO

Para certificar-se de que existam pelo menos mil e quinhentos itens envolvidos nos cálculos para cada produto, use HAVING COUNT(*) > 1500 para eliminar os produtos que retornam totais para menos que 1500 itens vendidos.If you want to make sure there are at least one thousand five hundred items involved in the calculations for each product, use HAVING COUNT(*) > 1500 to eliminate the products that return totals for fewer than 1500 items sold. A consulta parece com:The query looks like this:

USE AdventureWorks2012;
GO
SELECT ProductID, SUM(LineTotal) AS Total
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING COUNT(*) > 1500;
GO

N.N. Usando a dica de otimização INDEXUsing the INDEX optimizer hint

O exemplo a seguir mostra dois modos de uso da dica de otimização INDEX.The following example shows two ways to use the INDEX optimizer hint. O primeiro exemplo mostra como forçar o otimizador a usar um índice não clusterizado para recuperar linhas de uma tabela e o segundo exemplo força uma verificação da tabela usando um índice 0.The first example shows how to force the optimizer to use a nonclustered index to retrieve rows from a table, and the second example forces a table scan by using an index of 0.

USE AdventureWorks2012;
GO
SELECT pp.FirstName, pp.LastName, e.NationalIDNumber
FROM HumanResources.Employee AS e WITH (INDEX(AK_Employee_NationalIDNumber))
JOIN Person.Person AS pp on e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO

-- Force a table scan by using INDEX = 0.
USE AdventureWorks2012;
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle
FROM HumanResources.Employee AS e WITH (INDEX = 0) JOIN Person.Person AS pp
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO

M.M. Usando OPTION e as dicas de GROUPUsing OPTION and the GROUP hints

O exemplo a seguir mostra como a cláusula OPTION (GROUP) é usada com uma cláusula GROUP BY.The following example shows how the OPTION (GROUP) clause is used with a GROUP BY clause.

USE AdventureWorks2012;
GO
SELECT ProductID, OrderQty, SUM(LineTotal) AS Total
FROM Sales.SalesOrderDetail
WHERE UnitPrice < $5.00
GROUP BY ProductID, OrderQty
ORDER BY ProductID, OrderQty
OPTION (HASH GROUP, FAST 10);
GO

O.O. Usando a dica de consulta UNIONUsing the UNION query hint

O exemplo a seguir usa a dica de consulta MERGE UNION.The following example uses the MERGE UNION query hint.

USE AdventureWorks2012;
GO
SELECT BusinessEntityID, JobTitle, HireDate, VacationHours, SickLeaveHours
FROM HumanResources.Employee AS e1
UNION
SELECT BusinessEntityID, JobTitle, HireDate, VacationHours, SickLeaveHours
FROM HumanResources.Employee AS e2
OPTION (MERGE UNION);
GO

P.P. Usando uma UNION simplesUsing a simple UNION

No exemplo a seguir, o conjunto de resultados inclui o conteúdo das colunas ProductModelID e Name das tabelas ProductModel e Gloves.In the following example, the result set includes the contents of the ProductModelID and Name columns of both the ProductModel and Gloves tables.

USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO

-- Here is the simple union.
USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves
ORDER BY Name;
GO

Q.Q. Usando SELECT INTO com UNIONUsing SELECT INTO with UNION

No exemplo a seguir, a cláusula INTO da segunda instrução SELECT especifica que a tabela denominada ProductResults contenha o conjunto de resultados final da união das colunas designadas das tabelas ProductModel e Gloves.In the following example, the INTO clause in the second SELECT statement specifies that the table named ProductResults holds the final result set of the union of the designated columns of the ProductModel and Gloves tables. Observe que a tabela Gloves é criada na primeira instrução SELECT.Note that the Gloves table is created in the first SELECT statement.

USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.ProductResults', 'U') IS NOT NULL
DROP TABLE dbo.ProductResults;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO

USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
INTO dbo.ProductResults
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves;
GO

SELECT ProductModelID, Name 
FROM dbo.ProductResults;

R.R. Usando UNION de duas instruções SELECT com ORDER BYUsing UNION of two SELECT statements with ORDER BY

A ordem de determinados parâmetros usados com a cláusula UNION é importante.The order of certain parameters used with the UNION clause is important. O exemplo a seguir mostra o uso incorreto e correto de UNION em duas instruções SELECT nas quais uma coluna deve ser renomeada na saída.The following example shows the incorrect and correct use of UNION in two SELECT statements in which a column is to be renamed in the output.

USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO

/* INCORRECT */
USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
ORDER BY Name
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves;
GO

/* CORRECT */
USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves
ORDER BY Name;
GO

S.S. Usando UNION de três instruções SELECT para mostrar os efeitos de ALL e parêntesesUsing UNION of three SELECT statements to show the effects of ALL and parentheses

Os exemplos a seguir usam UNION para combinar os resultados de três tabelas que têm as mesmas 5 linhas de dados.The following examples use UNION to combine the results of three tables that all have the same 5 rows of data. O primeiro exemplo usa UNION ALL para mostrar os registros duplicados e retorna todas as 15 linhas.The first example uses UNION ALL to show the duplicated records, and returns all 15 rows. O segundo exemplo usa UNION sem ALL para eliminar as linhas duplicadas dos resultados combinados das três instruções SELECT e retorna 5 linhas.The second example uses UNION without ALL to eliminate the duplicate rows from the combined results of the three SELECT statements, and returns 5 rows.

O terceiro exemplo usa ALL com a primeira UNION e parênteses cercam a segunda UNION que não está usando ALL.The third example uses ALL with the first UNION and parentheses enclose the second UNION that is not using ALL. A segunda UNION é processada em primeiro lugar porque está entre parênteses e retorna 5 linhas porque a opção ALL não é usada e as linhas duplicadas são removidas.The second UNION is processed first because it is in parentheses, and returns 5 rows because the ALL option is not used and the duplicates are removed. Essas 5 linhas são combinadas com os resultados do primeiro SELECT usando as palavras-chave UNION ALL.These 5 rows are combined with the results of the first SELECT by using the UNION ALL keywords. Isso não remove as duplicatas entre os dois conjuntos de cinco linhas.This does not remove the duplicates between the two sets of 5 rows. O resultado final tem 10 linhas.The final result has 10 rows.

USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.EmployeeOne', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeOne;
GO
IF OBJECT_ID ('dbo.EmployeeTwo', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeTwo;
GO
IF OBJECT_ID ('dbo.EmployeeThree', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeThree;
GO

SELECT pp.LastName, pp.FirstName, e.JobTitle 
INTO dbo.EmployeeOne
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle 
INTO dbo.EmployeeTwo
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle 
INTO dbo.EmployeeThree
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
-- Union ALL
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeOne
UNION ALL
SELECT LastName, FirstName ,JobTitle
FROM dbo.EmployeeTwo
UNION ALL
SELECT LastName, FirstName,JobTitle 
FROM dbo.EmployeeThree;
GO

SELECT LastName, FirstName,JobTitle
FROM dbo.EmployeeOne
UNION 
SELECT LastName, FirstName, JobTitle 
FROM dbo.EmployeeTwo
UNION 
SELECT LastName, FirstName, JobTitle 
FROM dbo.EmployeeThree;
GO

SELECT LastName, FirstName,JobTitle 
FROM dbo.EmployeeOne
UNION ALL
(
SELECT LastName, FirstName, JobTitle 
FROM dbo.EmployeeTwo
UNION
SELECT LastName, FirstName, JobTitle 
FROM dbo.EmployeeThree
);
GO

Consulte TambémSee Also

CREATE TRIGGER (Transact-SQL) CREATE TRIGGER (Transact-SQL)
CREATE VIEW (Transact-SQL) CREATE VIEW (Transact-SQL)
DELETE (Transact-SQL) DELETE (Transact-SQL)
EXECUTE (Transact-SQL) EXECUTE (Transact-SQL)
Expressões (Transact-SQL) Expressions (Transact-SQL)
INSERT (Transact-SQL) INSERT (Transact-SQL)
LIKE (Transact-SQL) LIKE (Transact-SQL)
UNION (Transact-SQL) UNION (Transact-SQL)
EXCEPT e INTERSECT (Transact-SQL) EXCEPT and INTERSECT (Transact-SQL)
UPDATE (Transact-SQL) UPDATE (Transact-SQL)
WHERE (Transact-SQL) WHERE (Transact-SQL)
PathName (Transact-SQL) PathName (Transact-SQL)
Cláusula INTO (Transact-SQL)INTO Clause (Transact-SQL)