FROM (Transact-SQL)

Specifica le tabelle, le viste, le tabelle derivate e le tabelle unite in join utilizzate nelle istruzioni DELETE, SELECT e UPDATE in SQL Server 2012. Nell'istruzione SELECT la clausola FROM è obbligatoria, tranne nel caso in cui l'elenco di selezione includa solo costanti, variabili ed espressioni aritmetiche (non nomi di colonna).

Convenzioni della sintassi Transact-SQL

Sintassi

[ FROM { <table_source> } [ ,...n ] ] 
<table_source> ::= 
{
    table_or_view_name [ [ AS ] table_alias ] [ <tablesample_clause> ] 
        [ WITH ( < table_hint > [ [ , ]...n ] ) ] 
    | rowset_function [ [ AS ] table_alias ] 
        [ ( bulk_column_alias [ ,...n ] ) ] 
    | user_defined_function [ [ AS ] table_alias ] ]
    | OPENXML <openxml_clause> 
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ] 
    | <joined_table> 
    | <pivoted_table> 
    | <unpivoted_table>
      | @variable [ [ AS ] table_alias ]
        | @variable.function_call ( expression [ ,...n ] ) [ [ AS ] table_alias ] [ (column_alias [ ,...n ] ) ]
}
<tablesample_clause> ::=
    TABLESAMPLE [SYSTEM] ( sample_number [ PERCENT | ROWS ] ) 
        [ REPEATABLE ( repeat_seed ) ] 

<joined_table> ::= 
{
    <table_source> <join_type> <table_source> ON <search_condition> 
    | <table_source> CROSS JOIN <table_source> 
    | left_table_source { CROSS | OUTER } APPLY right_table_source 
    | [ ( ] <joined_table> [ ) ] 
}
<join_type> ::= 
    [ { INNER | { { LEFT | RIGHT | FULL } [ OUTER ] } } [ <join_hint> ] ]
    JOIN

<pivoted_table> ::=
    table_source PIVOT <pivot_clause> [ AS ] table_alias

<pivot_clause> ::=
        ( aggregate_function ( value_column [ [ , ]...n ]) 
        FOR pivot_column 
        IN ( <column_list> ) 
    ) 

<unpivoted_table> ::=
    table_source UNPIVOT <unpivot_clause> [ AS ] table_alias

<unpivot_clause> ::=
        ( value_column FOR pivot_column IN ( <column_list> ) ) 

<column_list> ::=
          column_name [ ,...n ]

Argomenti

• <table_source>
  Specifica una tabella, vista, variabile di tabella o origine di tabella derivata con o senza un alias, da utilizzare nell'istruzione Transact-SQL. In un'istruzione sono consentite fino a 256 origini di tabella. Il limite varia tuttavia in base alla memoria disponibile e alla complessità delle altre espressioni nella query, ovvero alcune query specifiche potrebbero non supportare 256 origini di tabella.

  [!NOTA]

  Nelle query con riferimenti a molte tabelle le prestazioni di esecuzione potrebbero essere ridotte. I tempi di compilazione e ottimizzazione vengono influenzati anche da fattori aggiuntivi, ad esempio la presenza di indici e viste indicizzate in ogni <table_source> e le dimensioni di <select_list> nell'istruzione SELECT.

  L'ordine delle origini di tabella dopo la parola chiave FROM non influisce sul set di risultati restituito. Quando la clausola FROM include nomi duplicati, SQL Server restituisce un errore.

• table_or_view_name
  Nome di una tabella o di una vista.

  Se la tabella o la vista è presente in un altro database della stessa istanza di SQL Server, specificare un nome completo nel formato database.schema.object_name.

  Se la tabella o la vista è presente all'esterno dell'istanza di SQL Server, specificare un nome composto da quattro parti nel formato linked_server.catalog.schema.object. Per ulteriori informazioni, vedere sp_addlinkedserver (Transact-SQL). Per specificare l'origine della tabella remota è inoltre possibile utilizzare un nome composto da quattro parti formulato tramite la funzione OPENDATASOURCE come componente server del nome. Quando viene specificato OPENDATASOURCE, database_name e schema_name possono non essere validi per tutte le origini dati e non essere soggetti alle funzionalità del provider OLE DB che accede all'oggetto remoto.

• [AS] table_alias
  Alias per l'argomento table_source che può essere utilizzato per convenienza o per contraddistinguere una tabella o una vista in un self join o in una sottoquery. Un alias è spesso un nome di tabella abbreviato utilizzato per fare riferimento a colonne specifiche delle tabelle di un join. Se lo stesso nome di colonna è presente in più di una tabella del join, in SQL Server è necessario qualificarlo con un nome di tabella o di vista oppure con un alias. Se viene definito un alias, non è possibile utilizzare il nome di tabella.

  Quando viene utilizzata una tabella derivata, una funzione con valori di tabella o per i set di righe oppure una clausola con operatori (ad esempio PIVOT o UNPIVOT), il parametro table_alias necessario alla fine della clausola è il nome della tabella associata per tutte le colonne restituite, comprese le colonne di raggruppamento.

• WITH (<table_hint> )
  Specifica che Query Optimizer utilizza una strategia di ottimizzazione o di blocco con questa tabella e per questa istruzione. Per ulteriori informazioni, vedere Hint di tabella (Transact-SQL).

• rowset_function
  Specifica una delle funzioni per i set di righe, ad esempio OPENROWSET, che restituisce un oggetto che è possibile utilizzare in sostituzione di un riferimento alla tabella. Per ulteriori informazioni e un elenco delle funzioni per i set di righe, vedere Funzioni per i set di righe (Transact-SQL).

  L'utilizzo delle funzioni OPENROWSET e OPENQUERY per specificare un oggetto remoto dipende dalle funzionalità del provider OLE DB che accede all'oggetto.

• bulk_column_alias
  Alias facoltativo da utilizzare in sostituzione del nome di colonna nel set di risultati. Gli alias di colonna sono consentiti solo nelle istruzioni SELECT che utilizzano la funzione OPENROWSET con l'opzione BULK. Quando si utilizza bulk_column_alias, specificare un alias per ogni colonna di tabella nello stesso ordine delle colonne nel file.

  [!NOTA]

  Questo alias esegue l'override dell'attributo NAME negli elementi COLUMN di un file in formato XML, se presente.

• user_defined_function
  Specifica una funzione con valori di tabella.

• OPENXML <openxml_clause>
  Consente di visualizzare un documento XML come set di righe. Per ulteriori informazioni, vedere OPENXML (Transact-SQL).

• derived_table
  Sottoquery che recupera le righe dal database. derived_table viene utilizzato come input per la query esterna.

  derived_table consente di utilizzare il costruttore di valori di tabella Transact-SQL per specificare più righe, ad esempio SELECT * FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ) AS MyTable(a, b);. Per ulteriori informazioni, vedere Costruttore di valori di tabella (Transact-SQL).

• column_alias
  Alias facoltativo da utilizzare in sostituzione del nome di colonna nel set di risultati della tabella derivata. Includere un alias di colonna per ogni colonna nell'elenco di selezione e racchiudere tra parentesi l'intero elenco di alias di colonna.

• <tablesample_clause>
  Specifica che vengono restituiti dati di esempio dalla tabella. I dati di esempio possono essere approssimativi. Questa clausola può essere utilizzata in ogni tabella primaria o unita in join in un'istruzione SELECT, UPDATE o DELETE. Non è possibile specificare TABLESAMPLE con le viste.

  [!NOTA]

  Quando si utilizza TABLESAMPLE sui database aggiornati a SQL Server, il livello di compatibilità del database viene impostato su 110 o su un valore maggiore. L'operatore PIVOT non è consentito in una query ricorsiva dell'espressione di tabella comune. Per ulteriori informazioni, vedere Livello di compatibilità ALTER DATABASE (Transact-SQL).

• SYSTEM
  Metodo di campionamento dipendente dall'implementazione specificato dagli standard ISO. In SQL Server è l'unico metodo di campionamento disponibile e viene applicato per impostazione predefinita. SYSTEM applica un metodo di campionamento basato su pagine in cui come campione viene scelto un set di pagine casuale dalla tabella e tutte le righe di tali pagine vengono restituite come subset campione.

• sample_number
  Espressione numerica costante esatta o approssimativa che rappresenta la percentuale o il numero delle righe. Quando viene specificato con PERCENT, sample_number viene implicitamente convertito in valore di tipo float. In caso contrario, viene convertito in bigint. PERCENT è l'impostazione predefinita.

• PERCENT
  Specifica che una percentuale sample_number di righe della tabella deve essere recuperata dalla tabella. Quando viene specificato PERCENT, SQL Server restituisce un valore approssimativo della percentuale specificata. Quando viene specificato PERCENT l'espressione sample_number deve restituire un valore compreso tra 0 e 100.

• ROWS
  Specifica che verrà recuperato un numero di righe approssimativamente pari a sample_number. Quando viene specificato ROWS, SQL Server restituisce un'approssimazione del numero di righe specificato. Quando viene specificato ROWS, l'espressione sample_number deve restituire un valore integer maggiore di zero.

• REPEATABLE
  Indica che il campione selezionato può essere restituito nuovamente. Se specificato con lo stesso valore repeat_seed SQL Server restituisce lo stesso subset di righe a condizione che non siano state apportate modifiche alle righe della tabella. Se specificato con un valore repeat_seed diverso, SQL Server restituisce verosimilmente un campione diverso delle righe nella tabella. Le azioni seguenti nella tabella vengono considerate modifiche: inserimento, aggiornamento, eliminazione, ricompilazione o deframmentazione dell'indice e ripristino o collegamento del database.

• repeat_seed
  Espressione di tipo integer costante utilizzata da SQL Server per generare un numero casuale. repeat_seed è di tipo bigint. Se repeat_seed non viene specificato, SQL Server assegna un valore in modo casuale. Per un valore repeat_seed specifico, il risultato del campionamento è sempre lo stesso se non sono state applicate modifiche alla tabella. L'espressione repeat_seed deve restituire un valore integer maggiore di zero.

• <joined_table>
  Set di risultati che rappresenta il prodotto di due o più tabelle. In caso di più join, utilizzare le parentesi per modificarne l'ordine standard.

• <join_type>
  Specifica il tipo di operazione di join.

• INNER
  Specifica che vengono restituite tutte le coppie di righe corrispondenti. Le righe senza corrispondenza vengono eliminate da entrambe le tabelle. Corrisponde al valore predefinito se non viene specificato alcun tipo di join.

• FULL [OUTER]
  Specifica che una riga della tabella di destra o di sinistra che non rispetta la condizione di join è inclusa nel set di risultati e le colonne di output che corrispondono all'altra tabella sono impostate su NULL. Questa si aggiunge a tutte le righe normalmente restituite dall'INNER JOIN.

• LEFT [OUTER]
  Specifica che, oltre alle righe restituite dall'inner join, vengono incluse nel set di risultati tutte le righe della tabella sinistra che non rispettano la condizione di join e le colonne di output dell'altra tabella sono impostate su NULL.

• RIGHT [OUTER]
  Specifica che, oltre alle righe restituite dall'inner join, vengono incluse nel set di risultati tutte le righe della tabella destra che non rispettano le condizioni di join e le colonne di output che corrispondono all'altra tabella sono impostate su NULL.

• <join_hint>
  Specifica che, in SQL Server, Query Optimizer utilizza un hint di join, o algoritmo di esecuzione, per ogni join specificato nella clausola FROM della query. Per ulteriori informazioni, vedere Hint di join (Transact-SQL).

• JOIN
  Indica che l'operazione di join specificata deve essere eseguita tra le viste o le origini di tabella specificate.

• ON <search_condition>
  Specifica la condizione su cui è basato il join. La condizione può includere qualsiasi predicato, ma vengono in genere utilizzati nomi di colonne e operatori di confronto, ad esempio:

  USE AdventureWorks2012 ;
  GO
  SELECT p.ProductID, v.BusinessEntityID
  FROM Production.Product AS p 
  JOIN Purchasing.ProductVendor AS v
  ON (p.ProductID = v.ProductID);
  

  Quando nella condizione sono specificate le colonne, non è necessario che queste abbiano lo stesso nome o lo stesso tipo di dati. Se tuttavia i tipi di dati sono diversi, è necessario che siano compatibili o supportino la conversione implicita in SQL Server. Se non è possibile eseguire una conversione implicita dei tipi di dati, la condizione deve convertire in modo esplicito il tipo di dati tramite la funzione CONVERT.

  È possibile che alcuni predicati includano una sola delle tabelle unite in join nella clausola ON. Tali predicati potrebbero essere presenti inoltre nella clausola WHERE della query. La posizione di tali predicati non è rilevante nel caso di INNER join, ma potrebbe generare risultati diversi se vengono utilizzati OUTER join. I predicati inclusi nella clausola ON infatti vengono applicati alla tabella prima dell'esecuzione del join, mentre la clausola WHERE viene applicata semanticamente ai risultati del join.

  Per ulteriori informazioni sui predicati e sulle condizioni di ricerca, vedere Condizione di ricerca (Transact-SQL).

• CROSS JOIN
  Specifica il prodotto incrociato di due tabelle. Restituisce le righe che verrebbero restituite se non fosse specificata alcuna clausola WHERE in un join obsoleto, non SQL-92.

• left_table_source{ CROSS | OUTER } APPLY right_table_source
  Specifica che l'operando right_table_source dell'operatore APPLY viene valutato rispetto a ogni riga di left_table_source. Questa funzionalità risulta utile quando right_table_source include una funzione con valori di tabella che accetta i valori di colonna da left_table_source come uno dei relativi argomenti.

  È necessario specificare CROSS o OUTER con APPLY. Se si specifica CROSS, non vengono restituite righe quando right_table_source viene valutato rispetto a ogni riga specificata di left_table_source e viene restituito un set di risultati vuoto.

  Se si specifica OUTER, viene restituita una riga per ogni riga di left_table_source anche quando right_table_source viene valutato rispetto a tale riga e viene restituito un set di risultati vuoto.

  Per ulteriori informazioni, vedere la sezione Osservazioni.

• left_table_source
  Origine di tabella definita nell'argomento precedente. Per ulteriori informazioni, vedere la sezione Osservazioni.

• right_table_source
  Origine di tabella definita nell'argomento precedente. Per ulteriori informazioni, vedere la sezione Osservazioni.

• table_source PIVOT <pivot_clause>
  Specifica che table_source è stato trasformato tramite Pivot in base a pivot_column. table_source è una tabella o un'espressione di tabella. L'output è una tabella che include tutte le colonne di table_source ad eccezione di pivot_column e value_column. Le colonne di table_source, eccetto pivot_column e value_column, vengono definite colonne di raggruppamento dell'operatore PIVOT.

  PIVOT esegue un'operazione di raggruppamento sulla tabella di input relativamente alle colonne di raggruppamento e restituisce una riga per ogni gruppo. L'output contiene inoltre una colonna per ogni valore specificato nell'elenco column_list visualizzato nella colonna pivot_column della tabella input_table.

  Per ulteriori informazioni, vedere la sezione Osservazioni riportata di seguito.

• aggregate_function
  Funzione di aggregazione di sistema o definita dall'utente che accetta uno o più input. La funzione di aggregazione deve essere invariante rispetto ai valori Null. Una funzione di aggregazione invariante rispetto ai valori Null non considera i valori Null nel gruppo mentre valuta il valore di aggregazione.

  La funzione di aggregazione di sistema COUNT(*) non è consentita.

• value_column
  Indica la colonna dei valori dell'operatore PIVOT. Se utilizzato con UNPIVOT, value_column non può corrispondere al nome di una colonna esistente nell'origine di tabella di input specificata in table_source.

• FOR pivot_column
  Colonna pivot dell'operatore PIVOT. pivot_column deve essere di un tipo di dati che è possibile convertire in modo implicito o esplicito nel tipo nvarchar(). Questa colonna non può essere di tipo image o rowversion.

  Quando viene utilizzato UNPIVOT, pivot_column indica il nome della colonna di output risultante dal raggruppamento delle colonne di table_source. In table_source non può esistere già una colonna con questo nome.

• IN (column_list )
  Nella clausola PIVOT elenca i valori della colonna pivot_column che diventeranno i nomi di colonna della tabella di output. L'elenco non può includere nomi di colonna già presenti nell'origine di tabella di input, specificata in table_source, che viene trasformata tramite Pivot.

  Nella clausola UNPIVOT elenca le colonne in table_source che verranno raggruppate in un'unica colonna pivot_column.

• table_alias
  Nome dell'alias della tabella di output. pivot_table_alias deve essere specificato.

• UNPIVOT < unpivot_clause >
  Indica che la tabella di input viene ridotta da più colonne specificate in column_list a una singola colonna denominata pivot_column.

Osservazioni

La clausola FROM supporta la sintassi SQL-92 per le tabelle unite in join e per le tabelle derivate. Nella sintassi SQL-92 sono disponibili gli operatori di join INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER e CROSS.

In una clausola FROM le istruzioni UNION e JOIN sono supportate sia nelle viste, sia nelle tabelle derivate e nelle sottoquery.

Un self join è una tabella unita in join con se stessa. Nelle operazioni di inserimento e aggiornamento basate su un self join viene seguito l'ordine indicato nella clausola FROM.

Dato che in SQL Server vengono prese in considerazione le statistiche di distribuzione e cardinalità dei server collegati che forniscono statistiche sulla distribuzione delle colonne, non è necessario ricorrere all'hint di join REMOTE per imporre la valutazione di un join in remoto. In SQL Server Query Processor analizza le statistiche remote e determina se è appropriato adottare una strategia di join remoto. L'hint di join REMOTE risulta utile per i provider che non forniscono statistiche sulla distribuzione delle colonne.

Utilizzo di APPLY

Entrambi gli operandi sinistro e destro dell'operatore APPLY sono espressioni di tabella. La differenza principale tra questi operandi è rappresentata dal fatto che right_table_source può utilizzare una funzione con valori di tabella in cui una colonna di left_table_source è considerata uno degli argomenti. left_table_source può includere funzioni con valori di tabella, ma non può contenere come argomenti colonne di right_table_source.

L'operatore APPLY funziona nel modo seguente per restituire l'origine di tabella per la clausola FROM:

1. Valuta right_table_source rispetto a ogni riga di left_table_source per restituire set di righe.

   I valori di right_table_source dipendono da left_table_source. right_table_source può essere rappresentato approssimativamente in questo modo: TVF(left_table_source.row), dove TVF è una funzione con valori di tabella.

2. Combina i set di risultati restituiti per ogni riga nella valutazione di right_table_source con left_table_source tramite un'operazione UNION ALL.

   L'elenco di colonne restituito dal risultato dell'operatore APPLY corrisponde al set di colonne da left_table_source combinato con l'elenco di colonne da right_table_source.

Utilizzo di PIVOT e UNPIVOT

pivot_column e value_column sono colonne di raggruppamento utilizzate dall'operatore PIVOT. PIVOT segue il processo seguente per ottenere il set di risultati di output:

1. Esegue GROUP BY in input_table sulle colonne di raggruppamento e restituisce una riga di output per ogni gruppo.

   Le colonne di raggruppamento nella riga di output ottengono i valori delle colonne corrispondenti per tale gruppo in input_table.

2. Genera valori per le colonne nell'elenco delle colonne per ogni riga di output eseguendo le operazioni seguenti:

   1. Raggruppando le righe restituite in GROUP BY nel passaggio precedente rispetto a pivot_column.

      Selezionando per ogni colonna di output in column_list un sottogruppo che soddisfa la condizione:

      pivot_column = CONVERT(<data type of pivot_column>, 'output_column')

   2. aggregate_function viene valutata rispetto a value_column in questo sottogruppo e il risultato viene restituito come valore per la colonna output_column corrispondente. Se il sottogruppo è vuoto, SQL Server restituisce un valore Null per output_column. Se la funzione di aggregazione è COUNT e il sottogruppo è vuoto, viene restituito zero (0).

Autorizzazioni

Sono richieste le autorizzazioni per l'istruzione DELETE, SELECT o UPDATE.

Esempi

A.Utilizzo di una clausola FROM semplice

Nell'esempio seguente vengono recuperate le colonne TerritoryID e Name dalla tabella SalesTerritory nel database di esempio AdventureWorks2012.

USE AdventureWorks2012 ;
GO
SELECT TerritoryID, Name
FROM Sales.SalesTerritory
ORDER BY TerritoryID ;

Set di risultati:

TerritoryID Name                          
----------- ------------------------------
1           Northwest                     
2           Northeast                     
3           Central                       
4           Southwest                     
5           Southeast                     
6           Canada                        
7           France                        
8           Germany                       
9           Australia                     
10          United Kingdom                
(10 row(s) affected)

B.Utilizzo degli hint di ottimizzazione TABLOCK e HOLDLOCK

Nella transazione parziale seguente viene illustrato come impostare un blocco di tabella condiviso esplicito in Employee e come leggere l'indice. Il blocco viene mantenuto attivo fino al termine della transazione.

USE AdventureWorks2012 ;
GO
BEGIN TRAN
SELECT COUNT(*) 
FROM HumanResources.Employee WITH (TABLOCK, HOLDLOCK) ;

C.Utilizzo della sintassi CROSS JOIN di SQL-92

Nell'esempio seguente viene restituito il prodotto incrociato di due tabelle Employee e Department. Vengono restituiti inoltre un elenco di tutte le possibili combinazioni delle righe di BusinessEntityID e tutte le righe di nome Department .

USE AdventureWorks2012 ;
GO
SELECT e.BusinessEntityID, d.Name AS Department
FROM HumanResources.Employee AS e
CROSS JOIN HumanResources.Department AS d
ORDER BY e.BusinessEntityID, d.Name ;

D.Utilizzo della sintassi FULL OUTER JOIN di SQL-92

Nell'esempio seguente vengono restituiti il nome del prodotto e tutti gli eventuali ordini di vendita corrispondenti nella tabella SalesOrderDetail. Vengono inoltre restituiti gli ordini di vendita per cui non è elencato alcun prodotto nella tabella Product e tutti i prodotti con un ordine di vendita diverso da quello elencato nella tabella Product.

USE AdventureWorks2012 ;
GO
-- The OUTER keyword following the FULL keyword is optional.
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
FULL OUTER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
WHERE p.ProductID IS NULL OR sod.ProductID IS NULL
ORDER BY p.Name ;

E.Utilizzo della sintassi LEFT OUTER JOIN di SQL-92

Nell'esempio seguente vengono unite in join due tabelle tramite la colonna ProductID. Le righe della tabella sinistra prive di corrispondenza vengono mantenute. La tabella Product viene confrontata con la tabella SalesOrderDetail nelle colonne ProductID in ogni tabella. Tutti i prodotti, ordinati e non ordinati, vengono visualizzati nel set dei risultati.

USE AdventureWorks2012 ;
GO
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
LEFT OUTER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY p.Name ;

F.Utilizzo della sintassi INNER JOIN di SQL-92

Nell'esempio seguente vengono restituiti tutti i nomi di prodotti e gli ID degli ordini di vendita.

USE AdventureWorks2012 ;
GO
-- By default, SQL Server performs an INNER JOIN if only the JOIN 
-- keyword is specified.
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY p.Name ;

G.Utilizzo della sintassi RIGHT OUTER JOIN di SQL-92

Nell'esempio seguente vengono unite in join due tabelle tramite la colonna TerritoryID. Le righe della tabella destra prive di corrispondenza vengono mantenute. La tabella SalesTerritory viene confrontata con la tabella SalesPerson nella colonna TerritoryID in ogni tabella. Tutti i venditori vengono visualizzati nel set dei risultati, a prescindere dal fatto che siano assegnati a un'area o meno.

USE AdventureWorks2012 ;
GO
SELECT st.Name AS Territory, sp.BusinessEntityID
FROM Sales.SalesTerritory AS st 
RIGHT OUTER JOIN Sales.SalesPerson AS sp
ON st.TerritoryID = sp.TerritoryID ;

H.Utilizzo degli hint di join HASH e MERGE

Nell'esempio seguente viene eseguito un join delle tre tabelle Product, ProductVendor e Vendor per ottenere un elenco di prodotti e dei relativi fornitori. Query Optimizer unisce in join le tabelle Product e ProductVendor (p e pv) tramite un join di tipo MERGE. I risultati del join di tipo MERGE delle tabelle Product e ProductVendor (p e pv) vengono quindi uniti tramite join di tipo HASH alla tabella Vendor per ottenere (p e pv) e v.

Importante
Dopo avere specificato un hint di join, la parola chiave INNER non è più facoltativa e deve essere indicata in modo esplicito per l'esecuzione di un INNER JOIN.

USE AdventureWorks2012 ;
GO
SELECT p.Name AS ProductName, v.Name AS VendorName
FROM Production.Product AS p 
INNER MERGE JOIN Purchasing.ProductVendor AS pv 
ON p.ProductID = pv.ProductID
INNER HASH JOIN Purchasing.Vendor AS v
ON pv.BusinessEntityID = v.BusinessEntityID
ORDER BY p.Name, v.Name ;

I.Utilizzo di una tabella derivata

Nell'esempio seguente viene utilizzata una tabella derivata, con un'istruzione SELECT dopo la clausola FROM, per restituire nome e cognome di tutti i dipendenti e le città in cui abitano.

USE AdventureWorks2012 ;
GO
SELECT RTRIM(p.FirstName) + ' ' + LTRIM(p.LastName) AS Name, d.City
FROM Person.Person AS p
INNER JOIN HumanResources.Employee e ON p.BusinessEntityID = e.BusinessEntityID 
INNER JOIN
   (SELECT bea.BusinessEntityID, a.City 
    FROM Person.Address AS a
    INNER JOIN Person.BusinessEntityAddress AS bea
    ON a.AddressID = bea.AddressID) AS d
ON p.BusinessEntityID = d.BusinessEntityID
ORDER BY p.LastName, p.FirstName;

J.Utilizzo di TABLESAMPLE per leggere i dati di un campione di righe in una tabella

Nell'esempio seguente viene utilizzata l'opzione TABLESAMPLE nella clausola FROM per restituire approssimativamente il 10 percento di tutte le righe della tabella Customer.

USE AdventureWorks2012 ;
GO
SELECT *
FROM Sales.Customer TABLESAMPLE SYSTEM (10 PERCENT) ;

K.Utilizzo di APPLY

Nell'esempio seguente si presuppone che nel database siano presenti le tabelle seguenti con lo schema seguente:

• Departments: DeptID, DivisionID, DeptName, DeptMgrID

• EmpMgr: MgrID, EmpID

• Employees: EmpID, EmpLastName, EmpFirstName, EmpSalary

È anche presente una funzione con valori di tabella, GetReports(MgrID) che restituisce un elenco di tutti i dipendenti (EmpID, EmpLastName, EmpSalary) che sono subordinati direttamente o indirettamente all'ID MgrID specificato.

In questo esempio viene utilizzato APPLY per restituire tutti i reparti e tutti i dipendenti in ogni reparto. Se uno specifico reparto non ha dipendenti, non verranno restituite righe per tale reparto.

SELECT DeptID, DeptName, DeptMgrID, EmpID, EmpLastName, EmpSalary
FROM Departments d CROSS APPLY dbo.GetReports(d.DeptMgrID) ;

Se si desidera che la query restituisca righe per i reparti senza dipendenti, restituendo valori Null per le colonne EmpID, EmpLastName e EmpSalary, utilizzare invece OUTER APPLY.

SELECT DeptID, DeptName, DeptMgrID, EmpID, EmpLastName, EmpSalary
FROM Departments d OUTER APPLY dbo.GetReports(d.DeptMgrID) ;

L.Utilizzo di PIVOT e UNPIVOT

Nell'esempio seguente viene restituito il numero di ordini di acquisto effettuati per gli ID di dipendente 164, 198, 223, 231 e 233, suddivisi in base all'ID del fornitore.

USE AdventureWorks2012;
GO
SELECT VendorID, [250] AS Emp1, [251] AS Emp2, [256] AS Emp3, [257] AS Emp4, [260] AS Emp5
FROM 
(SELECT PurchaseOrderID, EmployeeID, VendorID
FROM Purchasing.PurchaseOrderHeader) AS p
PIVOT
(
COUNT (PurchaseOrderID)
FOR EmployeeID IN
( [250], [251], [256], [257], [260] )
) AS pvt
ORDER BY VendorID;

Di seguito viene fornito un set di risultati parziale:

VendorID    Emp1        Emp2        Emp3        Emp4        Emp5

----------------------------------------------------------------

1           4           3           5           4           4

2           4           1           5           5           5

3           4           3           5           4           4

4           4           2           5           5           4

5           5           1           5           5           5

Per trasformare la tabella tramite UnPivot, presupporre che il set di risultati restituito nell'esempio precedente sia archiviato come pvt. La query è simile alla seguente.

--Create the table and insert values as portrayed in the previous example.
CREATE TABLE dbo.pvt (VendorID int, Emp1 int, Emp2 int,
Emp3 int, Emp4 int, Emp5 int);
GO
INSERT INTO dbo.pvt VALUES 
 (1,4,3,5,4,4)
,(2,4,1,5,5,5)
,(3,4,3,5,4,4)
,(4,4,2,5,5,4)
,(5,5,1,5,5,5);
GO
--Unpivot the table.
SELECT VendorID, Employee, Orders
FROM 
    (SELECT VendorID, Emp1, Emp2, Emp3, Emp4, Emp5
    FROM dbo.pvt) AS p
UNPIVOT
    (Orders FOR Employee IN 
        (Emp1, Emp2, Emp3, Emp4, Emp5)
)AS unpvt
GO

Di seguito viene fornito un set di risultati parziale:

VendorID    Employee    Orders

------------------------------

1           Emp1        4

1           Emp2        3

1           Emp3        5

1           Emp4        4

1           Emp5        4

2           Emp1        4

2           Emp2        1

2           Emp3        5

2           Emp4        5

2           Emp5        5

M.Utilizzo di CROSS APPLY

Nell'esempio seguente viene recuperato uno snapshot di tutti i piani di query disponibili nella cache dei piani, eseguendo una query sulla DMV sys.dm_exec_cached_plans per recuperare gli handle per tutti i piani di query nella cache. Successivamente viene specificato l'operatore CROSS APPLY per passare gli handle del piano a sys.dm_exec_query_plan. L'output Showplan XML per ogni piano disponibile nella cache dei piani viene indicato nella colonna query_plan della tabella restituita.

USE master;
GO
SELECT dbid, object_id, query_plan 
FROM sys.dm_exec_cached_plans AS cp 
CROSS APPLY sys.dm_exec_query_plan(cp.plan_handle); 
GO

Vedere anche

Riferimento

CONTAINSTABLE (Transact-SQL)

DELETE (Transact-SQL)

FREETEXTTABLE (Transact-SQL)

INSERT (Transact-SQL)

OPENQUERY (Transact-SQL)

OPENROWSET (Transact-SQL)

Operatori (Transact-SQL)

UPDATE (Transact-SQL)

WHERE (Transact-SQL)