Esempi di istruzioni SELECT (Transact-SQL)SELECT Examples (Transact-SQL)

SI APPLICA A: sìSQL Server sìDatabase SQL di Azure noAzure SQL Data Warehouse noParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Questo argomento include alcuni esempi relativi all'uso dell'istruzione SELECT.This topic provides examples of using the SELECT statement.

A.A. Utilizzo dell'istruzione SELECT per il recupero di righe e colonneUsing SELECT to retrieve rows and columns

Nell'esempio seguente vengono illustrati tre blocchi di codice.The following example shows three code examples. Nel primo esempio di codice vengono restituite tutte le righe (clausola WHERE omessa) e tutte le colonne (utilizzando *) della tabella Product del database 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

Nell'esempio seguente vengono restituite tutte le righe (clausola WHERE omessa) e solo un subset delle colonne (Name, ProductNumber, ListPrice) della tabella Product del database 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. Viene aggiunta, inoltre, un'intestazione di colonna.Additionally, a column heading is added.

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

Nell'esempio seguente vengono restituite solo le righe della tabella Product caratterizzate da una riga di prodotto R e da un numero di giorni per l'invio in produzione minore di 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. Utilizzo dell'istruzione SELECT con intestazioni e calcoli di colonnaUsing SELECT with column headings and calculations

Nell'esempio seguente vengono restituite tutte le righe della tabella Product.The following examples return all rows from the Product table. Nel primo esempio vengono restituite le vendite totali e gli sconti per ogni prodotto.The first example returns total sales and the discounts for each product. Nel secondo esempio vengono calcolati i ricavi totali per ogni prodotto.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

Questa è la query che calcola il ricavo per ogni prodotto di ogni ordine di vendita.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. Utilizzo della clausola DISTINCT con l'istruzione SELECTUsing DISTINCT with SELECT

Nell'esempio seguente viene utilizzata la clausola DISTINCT per evitare il recupero di titoli duplicati.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. Creazione di tabelle con l'istruzione SELECT INTOCreating tables with SELECT INTO

Nel primo esempio seguente viene creata una tabella temporanea denominata #Bicycles in 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

Nel secondo esempio viene creata la tabella 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. Utilizzo di sottoquery correlateUsing correlated subqueries

Nell'esempio seguente vengono illustrate query semanticamente equivalenti e viene evidenziata la differenza tra la parola chiave EXISTS e la parola chiave IN.The following example shows queries that are semantically equivalent and illustrates the difference between using the EXISTS keyword and the IN keyword. Entrambi sono esempi di sottoquery valide che recuperano un'istanza del nome di ogni prodotto del modello "Long-sleeve logo jersey" e con valori ProductModelID uguali nelle tabelle 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

Nell'esempio seguente viene utilizzata la parola chiave IN in una sottoquery correlata o ripetuta.The following example uses IN in a correlated, or repeating, subquery. È una query che dipende dalla query esterna.This is a query that depends on the outer query for its values. La query viene eseguita ripetutamente, una volta per ogni riga che può essere selezionata dalla query esterna.The query is executed repeatedly, one time for each row that may be selected by the outer query. Questa query recupera un'istanza del nome e del cognome di ogni dipendente il cui bonus nella tabella SalesPerson corrisponde a 5000.00 e con numero di identificazione uguale nelle tabelle 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

La sottoquery precedente non può essere valutata indipendentemente dalla query esterna.The previous subquery in this statement cannot be evaluated independently of the outer query. Richiede un valore per Employee.EmployeeID, ma questo valore cambia quando Motore di database di SQL ServerSQL Server Database Engine esamina righe diverse della tabella Employee.It requires a value for Employee.EmployeeID, but this value changes as the Motore di database di SQL ServerSQL Server Database Engine examines different rows in Employee.

È inoltre possibile inserire una sottoquery correlata nella clausola HAVING della query esterna.A correlated subquery can also be used in the HAVING clause of an outer query. Nell'esempio vengono trovati i modelli il cui prezzo massimo è più del doppio del prezzo medio per il modello.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)
     FROM Production.Product AS p2
     WHERE p1.ProductModelID = p2.ProductModelID);
GO

In questo esempio vengono utilizzate due sottoquery correlate per trovare i nomi dei dipendenti che hanno venduto un determinato prodotto.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. Utilizzo della clausola GROUP BYUsing GROUP BY

Nell'esempio seguente viene trovato il totale di ogni ordine di vendita nel database.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

La presenza della clausola GROUP BY comporta la restituzione di una sola riga contenente il totale di tutte le vendite per ogni ordine di vendita.Because of the GROUP BY clause, only one row containing the sum of all sales is returned for each sales order.

G.G. Utilizzo della clausola GROUP BY con più gruppiUsing GROUP BY with multiple groups

Nell'esempio seguente vengono individuati il prezzo medio e il totale delle vendite per l'anno in corso raggruppati per ID del prodotto e ID dell'offerta speciale.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. Utilizzo delle clausole GROUP BY e WHEREUsing GROUP BY and WHERE

Nell'esempio seguente i risultati vengono suddivisi in gruppi dopo che sono state recuperate le righe con prezzi maggiori di $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. Utilizzo della clausola GROUP BY con un'espressioneUsing GROUP BY with an expression

Nell'esempio seguente vengono creati gruppi in base a un'espressione.The following example groups by an expression. È possibile creare gruppi in base a un'espressione se tale espressione non include funzioni di aggregazione.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. Utilizzo della clausola GROUP BY con la clausola ORDER BYUsing GROUP BY with ORDER BY

Nell'esempio seguente viene individuato il prezzo medio di ogni tipo di prodotto e i risultati vengono ordinati in base al prezzo medio.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. Utilizzo della clausola HAVINGUsing the HAVING clause

Nel primo esempio viene illustrata la clausola HAVING con una funzione di aggregazione.The first example that follows shows a HAVING clause with an aggregate function. Le righe della tabella SalesOrderDetail vengono raggruppate per ID di prodotto e vengono eliminati i prodotti con ordini con quantitativo medio minore o uguale a cinque.It groups the rows in the SalesOrderDetail table by product ID and eliminates products whose average order quantities are five or less. Nel secondo esempio viene illustrata una clausola HAVING senza funzioni di aggregazione.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

Questa query utilizza la clausola LIKE all'interno della clausola 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. Utilizzo delle clausole HAVING e GROUP BYUsing HAVING and GROUP BY

Nell'esempio seguente viene illustrato l'utilizzo delle clausole GROUP BY, HAVING, WHERE e ORDER BY in un'istruzione SELECT.The following example shows using GROUP BY, HAVING, WHERE, and ORDER BY clauses in one SELECT statement. Vengono creati gruppi e valori di riepilogo, ma solo dopo l'eliminazione dei prodotti con prezzo maggiore di $25 e quantitativo medio minore di 5.It produces groups and summary values but does so after eliminating the products with prices over $25 and average order quantities under 5. I risultati vengono organizzati in base a 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. Utilizzo della clausola HAVING con le funzioni SUM e AVGUsing HAVING with SUM and AVG

Nell'esempio seguente il contenuto della tabella SalesOrderDetail viene raggruppato in base all'ID prodotto e vengono inclusi solo i gruppi di prodotti con ordini che ammontano a più di $1000000.00 e con quantitativo medio minore di 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

Per visualizzare i prodotti con vendite totali maggiori di $2000000.00, utilizzare la query seguente: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

Se si desidera che nei calcoli siano inclusi solo i prodotti per cui sono stati venduti almeno 1500 articoli, utilizzare la clausola HAVING COUNT(*) > 1500 per eliminare i prodotti per cui sono stati venduti meno di 1500 articoli.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. La query è la seguente: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. Utilizzo dell'hint di ottimizzazione INDEXUsing the INDEX optimizer hint

Nell'esempio seguente vengono illustrati due diversi utilizzi dell'hint di ottimizzazione INDEX.The following example shows two ways to use the INDEX optimizer hint. Nel primo esempio viene illustrato come forzare l'utilizzo di un indice non cluster per il recupero di righe da una tabella, mentre nel secondo viene forzata un'analisi di tabella in base all'indice 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. Utilizzo della clausola OPTION e degli hint GROUPUsing OPTION and the GROUP hints

Nell'esempio seguente viene illustrato l'utilizzo della clausola OPTION (GROUP) con una clausola 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. Utilizzo dell'hint per la query UNIONUsing the UNION query hint

Nell'esempio seguente viene utilizzato l'hint per la query 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. Utilizzo di un semplice operatore UNIONUsing a simple UNION

Nell'esempio seguente il set di risultati include il contenuto delle colonne ProductModelID e Name di entrambe le tabelle 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. Utilizzo di SELECT INTO con UNIONUsing SELECT INTO with UNION

Nell'esempio seguente la clausola INTO nella seconda istruzione SELECT specifica che la tabella ProductResults contiene il set di risultati finale ottenuto con l'unione delle colonne designate delle tabelle 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. Si noti che la tabella Gloves viene creata nella prima istruzione 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. Utilizzo dell'operatore UNION in due istruzioni SELECT con la clausola ORDER BYUsing UNION of two SELECT statements with ORDER BY

L'ordine di alcuni parametri utilizzati con la clausola UNION è importante.The order of certain parameters used with the UNION clause is important. Nell'esempio seguente vengono illustrati l'utilizzo errato e quello corretto di UNION in due istruzioni SELECT in cui una colonna deve essere rinominata nell'output.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. Utilizzo dell'operatore UNION in tre istruzioni SELECT per illustrare gli effetti dell'opzione ALL e delle parentesiUsing UNION of three SELECT statements to show the effects of ALL and parentheses

Negli esempi seguenti viene utilizzato l'operatore UNION per combinare i risultati di tre tabelle contenenti 5 righe di dati identiche.The following examples use UNION to combine the results of three tables that all have the same 5 rows of data. Nel primo esempio viene utilizzato UNION ALL per mostrare i record duplicati e vengono restituite tutte le 15 righe.The first example uses UNION ALL to show the duplicated records, and returns all 15 rows. Nel secondo esempio l'operatore UNION viene utilizzato senza l'opzione ALL per eliminare le righe duplicate dai risultati combinati delle tre istruzioni SELECT e vengono restituite 5 righe.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.

Nel terzo esempio viene utilizzata l'opzione ALL con il primo operatore UNION e il secondo operatore UNION, che non utilizza l'opzione ALL, viene racchiuso tra parentesi.The third example uses ALL with the first UNION and parentheses enclose the second UNION that is not using ALL. Il secondo operatore UNION viene elaborato per primo in quanto è racchiuso tra parentesi e restituisce 5 righe in quanto l'opzione ALL è stata omessa e i duplicati vengono rimossi.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. Queste 5 righe vengono combinate con i risultati della prima istruzione SELECT mediante le parole chiave UNION ALL.These 5 rows are combined with the results of the first SELECT by using the UNION ALL keywords. I duplicati tra i due set di 5 righe non vengono rimossi.This does not remove the duplicates between the two sets of 5 rows. Il risultato finale include 10 righe.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

Vedere ancheSee 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)
Espressioni (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)
Clausola INTO (Transact-SQL)INTO Clause (Transact-SQL)