FROM (Transact-SQL)

Data aggiornamento: 5 dicembre 2005

Specifica le tabelle, le viste, le tabelle derivate e unite in join utilizzate nelle istruzioni DELETE, SELECT e UPDATE. Nell'istruzione SELECT, la clausola FROM è obbligatoria, tranne nel caso in cui l'elenco di selezione include 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 ] [ (column_alias [ ,...n ] ) ]
    | 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> table_alias

<pivot_clause> ::=
        ( aggregate_function ( value_column ) 
        FOR pivot_column 
        IN ( <column_list> ) 
    ) 

<unpivoted_table> ::=
        table_source UNPIVOT <unpivot_clause> table_alias

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

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

Argomenti

• <table_source>
  Specifica una tabella, vista 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 massimo 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. Una variabile table può essere specificata come origine 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 2005 restituisce errori.

• table_or_view_name
  Nome di una tabella o di una vista.

  Se la tabella o vista è disponibile in un altro database dello stesso computer SQL Server, specificare un nome completo nel formato database.schema.object_name. Se la tabella o vista è disponibile in un server collegato all'esterno del server locale, specificare un nome composto da quattro parti nel formato linked_server.catalog.schema.object. Un nome di tabella o vista composto da quattro parti formulato tramite la funzione OPENDATASOURCE come componente server del nome può essere utilizzato inoltre per specificare l'origine della tabella. Per ulteriori informazioni sulla funzione, vedere OPENDATASOURCE (Transact-SQL).

• [AS] table_alias
  Alias per l'argomento table_source che può essere utilizzato per convenienza o per contraddistinguere una tabella o vista in un self join o in una subquery. 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 esiste in più di una tabella del join, in SQL Server è necessario qualificarlo con un nome di tabella, di vista, o con un alias. Se è stato definito un alias, non è possibile utilizzare il nome di tabella.

  Quando viene utilizzata una tabella derivata, una funzione valutata a livello 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 table_hint (Transact-SQL).

  In SQL Server 2005, con alcune eccezioni, gli hint di tabella sono supportati nella clausola FROM solo se vengono specificati con la parola chiave WITH. Anche gli hint di tabella devono essere specificati tramite parentesi.

  Gli hint di tabella consentiti con e senza la parola chiave WITH sono i seguenti: NOLOCK, READUNCOMMITTED, UPDLOCK, REPEATABLEREAD, SERIALIZABLE, READCOMMITTED, FASTFIRSTROW, TABLOCK, TABLOCKX, PAGLOCK, ROWLOCK, NOWAIT, READPAST, XLOCK e NOEXPAND. Quando questi hint di tabella vengono specificati senza la parola chiave WITH, gli hint devono essere specificati da soli. Ad esempio: FROM t (fastfirstrow).

  Quando l'hint viene specificato con un'altra opzione, come in (fastfirstrow, index(myindex), l'hint deve essere specificato con la parola chiave WITH, ad esempio:

  FROM t WITH (fastfirstrow, index(myindex)).

  La parola chiave WITH non è obbligatoria con gli hint quando il database ha un livello di compatibilità 80 o precedente.

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

• bulk_column_alias
  Alias facoltativo da utilizzare in sostituzione del nome di colonna nel set di risultati. Gli alias di colonne 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 prevale sull'attributo NAME negli elementi COLUMN di un file in formato XML, se presente.

• user_defined_function
  Specifica una funzione valutata a livello di tabella.

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

• derived_table
  Subquery che recupera righe dal database. L'argomento derived_table viene utilizzato come input per la query esterna.

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

• <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. Per ulteriori informazioni, vedere Limitazione dei set di risultati utilizzando TABLESAMPLE.

  [!NOTA] Quando si utilizza TABLESAMPLE sui database aggiornati a SQL Server 2005, il livello di compatibilità del database deve essere impostato su 90. Per impostare il livello di compatibilità del database, vedere sp_dbcmptlevel (Transact-SQL).

• SYSTEM
  Metodo di campionamento che dipende dall'implementazione, specificato da ANSI SQL. In SQL Server 2005, si tratta dell'unico metodo di campionamento disponibile e viene applicato per impostazione predefinita. SYSTEM applica un metodo di campionamento basato su pagine in cui viene scelto come campione un set di pagine casuale dalla tabella, e tutte le righe di quelle pagine vengono restituite come subset campione. Per ulteriori informazioni, vedere Limitazione dei set di risultati utilizzando TABLESAMPLE.

• 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 delle 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à restituito approssimativamente un numero di righe indicato in 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. Quando specificato con lo stesso valore repeat_seed , SQL Server restituirà lo stesso subset di righe a condizione che non siano state apportate modifiche alle righe della tabella. Quando specificato con un valore repeat_seed diverso, SQL Server restituirà probabilmente un campione diverso delle righe nella tabella. Le azioni seguenti nella tabella vengono considerate modifiche: inserimento, aggiornamento, eliminazione, ricostruzione 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 viene omesso, 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 delle 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. Per join multipli, utilizzare le parentesi per modificare l'ordine standard dei join.

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

• INNER
  Specifica che vengono restituite tutte le coppie di righe corrispondenti. Elimina le righe senza corrispondenza 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. Questo in aggiunta rispetto 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 Query Optimizer di SQL Server viene utilizzato 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 origini di tabella o le viste 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:

  SELECT p.ProductID, v.VendorID
  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 2005. 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 la clausola ON includa alcuni predicati che coinvolgono una sola delle tabelle unite in join. Tali predicati potrebbero essere presenti inoltre nella clausola WHERE della query. La posizione dei predicati non è rilevante nel caso di INNER join, ma potrebbe generare risultati diversi se sono in uso 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 la clausola WHERE non fosse specificata in un join 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 valutata a livello di tabella che utilizza i valori di colonna da left_table_source come uno degli argomenti.

  È necessario specificare CROSS o OUTER con APPLY. Se si specifica CROSS, non vengono restituite righe quando l'operando 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 l'operando right_table_source esegue una valutazione rispetto a quella riga e restituisce un set di risultati vuoto.

  Per ulteriori informazioni, vedere la sezione Osservazioni e Utilizzo di APPLY.

• 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 viene trasformata 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 e Utilizzo di PIVOT e UNPIVOT.

  [!NOTA] Quando viene utilizzato l'operatore PIVOT sui database aggiornati a SQL Server 2005, il livello di compatibilità del database deve essere impostato su 90. Per impostare il livello di compatibilità del database, vedere sp_dbcmptlevel (Transact-SQL).

• aggregate_function
  Funzione di aggregazione definita dall'utente o dal sistema. 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. Quando utilizzata 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 dalla trasformazione 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 che esistono già 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 passa da più colonne specificate in column_list a una singola colonna denominata pivot_column.

  Per ulteriori informazioni, vedere la sezione Osservazioni e Utilizzo di PIVOT e UNPIVOT.

  [!NOTA] Quando si utilizza UNPIVOT su database aggiornati a SQL Server 2005, il livello di compatibilità del database deve essere impostato su 90. Per impostare il livello di compatibilità del database, vedere sp_dbcmptlevel (Transact-SQL).

Osservazioni

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

Quando il livello di compatibilità del database è impostato su 90, gli operatori di outer join (*= e =*) non sono supportati.

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

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 2005 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. Query Processor di SQL Server analizza le statistiche remote e determina se è adeguato o meno adottare una strategia di join remoto. L'hint di join REMOTE risulta utile per i provider che non forniscono statistiche sulla distribuzione delle colonne. Per ulteriori informazioni, vedere Requisiti relativi alle statistiche di distribuzione per i provider OLE DB.

Per ulteriori informazioni sull'utilizzo dei join, vedere Nozioni fondamentali sui join e Utilizzo dei join.

Utilizzo di APPLY

Sia l'operando sinistro che l'operando 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 valutata a livello di tabella che utilizza una colonna da left_table_source come uno degli argomenti della funzione. left_table_source può includere funzioni valutate a livello di tabella, ma non può includere colonne da right_table_source come argomenti.

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

1. Valuta right_table_source in rapporto 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 in maniera approssimativa in questo modo: TVF(left_table_source.row), dove TVF è una funzione valutata a livello 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 specificano 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 della colonna corrispondente per quel gruppo in input_table.
2. Restituisce 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 processo precedente in rapporto a pivot_column.
      Per ogni colonna di output in column_list, selezionando un sottogruppo che soddisfa la condizione:
      pivot_column = CONVERT(<data type of pivot_column>, 'output_column')
   2. aggregate_function viene valutata in rapporto a value_column in questo sottogruppo e il risultato viene restituito come valore per 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).

Per ulteriori informazioni, vedere Utilizzo di PIVOT e UNPIVOT.

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 AdventureWorks.

USE AdventureWorks ;
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 TABLOCK e HOLDLOCK di Query Optimizer

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

USE AdventureWorks ;
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. Viene restituito inoltre un elenco di tutte le possibili combinazioni delle righe di EmployeeID e Department .

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

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

Nell'esempio seguente viene restituito 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 AdventureWorks ;
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 restituite. 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 AdventureWorks ;
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 AdventureWorks ;
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 restituite. 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 AdventureWorks ;
GO
SELECT st.Name AS Territory, sp.SalesPersonID
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 MERGE join delle tabelle Product e ProductVendor (p e pv) vengono quindi uniti tramite HASH join con la 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 AdventureWorks ;
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.VendorID = v.VendorID
ORDER BY p.Name, v.Name ;

I. Utilizzo di una tabella derivata

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

USE AdventureWorks ;
GO
SELECT RTRIM(c.FirstName) + ' ' + LTRIM(c.LastName) AS Name,
 d.City
FROM Person.Contact AS c
INNER JOIN HumanResources.Employee e ON c.ContactID = e.ContactID 
INNER JOIN
   (SELECT ea.AddressID, ea.EmployeeID, a.City 
    FROM Person.Address AS a
    INNER JOIN HumanResources.EmployeeAddress AS ea
    ON a.AddressID = ea.AddressID) AS d
ON e.EmployeeID = d.EmployeeID
ORDER BY c.LastName, c.FirstName;

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

Nell'esempio seguente viene utilizzato TABLESAMPLE nella clausola FROM per restituire circa il 10 percento di tutte le righe nella tabella Customer del database AdventureWorks.

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

K. Utilizzo di APPLY

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

• Departments: DeptID, DivisionID, DeptName, DeptMgrID
• EmpMgr: MgrID, EmpID
• Employees: EmpID, EmpLastName, EmpFirstName, EmpSalary

È anche presente una funzione valutata a livello 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 quel reparto. Se uno specifico reparto non ha dipendenti, non verranno restituite righe per quel 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, che causerà la restituzione di 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 di fornitore.

USE AdventureWorks
GO
SELECT VendorID, [164] AS Emp1, [198] AS Emp2, [223] AS Emp3, [231] AS Emp4, [233] AS Emp5
FROM 
(SELECT PurchaseOrderID, EmployeeID, VendorID
FROM Purchasing.PurchaseOrderHeader) AS p
PIVOT
(
COUNT (PurchaseOrderID)
FOR EmployeeID IN
( [164], [198], [223], [231], [233] )
) AS pvt
ORDER BY VendorID;

Quello che segue è un set dei 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 seguente sia archiviato come pvt. La query è la seguente.

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

Quello che segue è un set dei 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

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)

Guida in linea e informazioni

Assistenza su SQL Server 2005

Cronologia modifiche

Versione	Cronologia
5 dicembre 2005	Contenuto modificato Correzione dell'esempio I: Utilizzo di una tabella derivata.