Clausola FROM con JOIN, APPLY, PIVOT (Transact-SQL)FROM clause plus JOIN, APPLY, PIVOT (Transact-SQL)

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

In Transact-SQL, la clausola FROM è disponibile per le istruzioni seguenti:In Transact-SQL, the FROM clause is available on the following statements:

La clausola FROM è in genere obbligatoria per l'istruzione SELECT.The FROM clause is usually required on the SELECT statement. L'eccezione è quando non viene elencata alcuna colonna di tabella e gli unici elementi elencati sono valori letterali o variabili o espressioni aritmetiche.The exception is when no table columns are listed, and the only items listed are literals or variables or arithmetic expressions.

Questo articolo illustra anche le parole chiave seguenti che possono essere usate nella clausola FROM:This article also discusses the following keywords that can be used on the FROM clause:

  • JOINJOIN
  • APPLYAPPLY
  • PIVOTPIVOT

Icona di collegamento a un argomentoConvenzioni della sintassi Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SintassiSyntax

-- Syntax for SQL Server and Azure SQL Database  
  
[ 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 ] ) ]  
    | FOR SYSTEM_TIME <system_time>   
}  
<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 ]   
  
<system_time> ::=  
{  
       AS OF <date_time>  
    |  FROM <start_date_time> TO <end_date_time>  
    |  BETWEEN <start_date_time> AND <end_date_time>  
    |  CONTAINED IN (<start_date_time> , <end_date_time>)   
    |  ALL  
}  
  
    <date_time>::=  
        <date_time_literal> | @date_time_variable  
  
    <start_date_time>::=  
        <date_time_literal> | @date_time_variable  
  
    <end_date_time>::=  
        <date_time_literal> | @date_time_variable  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
FROM { <table_source> [ ,...n ] }  
  
<table_source> ::=   
{  
    [ database_name . [ schema_name ] . | schema_name . ] table_or_view_name [ AS ] table_or_view_alias 
    [<tablesample_clause>]  
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ]  
    | <joined_table>  
}  
  
<tablesample_clause> ::=
    TABLESAMPLE ( sample_number [ PERCENT ] ) -- SQL Data Warehouse only  
 
<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 ] [ <join hint> ] JOIN  
    | LEFT  [ OUTER ] JOIN  
    | RIGHT [ OUTER ] JOIN  
    | FULL  [ OUTER ] JOIN  
  
<join_hint> ::=   
    REDUCE  
    | REPLICATE  
    | REDISTRIBUTE  

ArgomentiArguments

<table_source><table_source>
Specifica una tabella, vista, variabile di tabella o origine di tabella derivata con o senza un alias, da utilizzare nell'istruzione Transact-SQLTransact-SQL.Specifies a table, view, table variable, or derived table source, with or without an alias, to use in the Transact-SQLTransact-SQL statement. 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,Up to 256 table sources can be used in a statement, although the limit varies depending on available memory and the complexity of other expressions in the query. ovvero alcune query specifiche potrebbero non supportare 256 origini di tabella.Individual queries may not support up to 256 table sources.

Nota

Nelle query con riferimenti a molte tabelle le prestazioni di esecuzione potrebbero essere ridotte.Query performance may suffer with lots of tables referenced in a query. I tempi di compilazione e ottimizzazione vengono influenzati anche da fattori aggiuntivi,Compilation and optimization time is also affected by additional factors. ad esempio la presenza di indici e visualizzazioni indicizzate in ogni <table_source> e le dimensioni di <select_list> nell'istruzione SELECT.These include the presence of indexes and indexed views on each <table_source> and the size of the <select_list> in the SELECT statement.

L'ordine delle origini di tabella dopo la parola chiave FROM non influisce sul set di risultati restituito.The order of table sources after the FROM keyword does not affect the result set that is returned. Quando la clausola FROM include nomi duplicati, SQL ServerSQL Server restituisce un errore.SQL ServerSQL Server returns errors when duplicate names appear in the FROM clause.

table_or_view_nametable_or_view_name
Nome di una tabella o di una vista.Is the name of a table or view.

Se la tabella o la visualizzazione è presente in un altro database della stessa istanza di SQL ServerSQL Server, specificare un nome completo nel formato database.schema.object_name.If the table or view exists in another database on the same instance of SQL ServerSQL Server, use a fully qualified name in the form database.schema.object_name.

Se la tabella o la visualizzazione è presente all'esterno dell'istanza di SQL ServerSQL Serverl, specificare un nome composto da quattro parti nel formato linked_server.catalog.schema.object.If the table or view exists outside the instance of SQL ServerSQL Serverl, use a four-part name in the form linked_server.catalog.schema.object. Per altre informazioni, vedere sp_addlinkedserver (Transact-SQL).For more information, see sp_addlinkedserver (Transact-SQL). Per specificare l'origine della tabella remota è anche possibile usare un nome composto da quattro parti formulato tramite la funzione OPENDATASOURCE come componente server del nome.A four-part name that is constructed by using the OPENDATASOURCE function as the server part of the name can also be used to specify the remote table source. 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.When OPENDATASOURCE is specified, database_name and schema_name may not apply to all data sources and is subject to the capabilities of the OLE DB provider that accesses the remote object.

[AS] table_alias[AS] table_alias
Alias per table_source che può essere usato per convenienza o per contraddistinguere una tabella o una visualizzazione in un self-join o in una sottoquery.Is an alias for table_source that can be used either for convenience or to distinguish a table or view in a self-join or subquery. Un alias è spesso un nome di tabella abbreviato utilizzato per fare riferimento a colonne specifiche delle tabelle di un join.An alias is frequently a shortened table name used to refer to specific columns of the tables in a join. Se lo stesso nome di colonna è presente in più di una tabella del join, in SQL ServerSQL Server è necessario qualificarlo con un nome di tabella o di vista oppure con un alias.If the same column name exists in more than one table in the join, SQL ServerSQL Server requires that the column name be qualified by a table name, view name, or alias. Se viene definito un alias, non è possibile utilizzare il nome di tabella.The table name cannot be used if an alias is defined.

Quando viene usata 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.When a derived table, rowset or table-valued function, or operator clause (such as PIVOT or UNPIVOT) is used, the required table_alias at the end of the clause is the associated table name for all columns, including grouping columns, returned.

WITH (<table_hint> )WITH (<table_hint> )
Specifica che Query Optimizer utilizza una strategia di ottimizzazione o di blocco con questa tabella e per questa istruzione.Specifies that the query optimizer use an optimization or locking strategy with this table and for this statement. Per altre informazioni, vedere Hint di tabella (Transact-SQL).For more information, see Table Hints (Transact-SQL).

rowset_functionrowset_function

Si applica a : da SQL Server 2008SQL Server 2008 fino a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

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.Specifies one of the rowset functions, such as OPENROWSET, that returns an object that can be used instead of a table reference. Per altre informazioni su un elenco delle funzioni per i set di righe, vedere Funzioni per i set di righe (Transact-SQL).For more information about a list of rowset functions, see Rowset Functions (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.Using the OPENROWSET and OPENQUERY functions to specify a remote object depends on the capabilities of the OLE DB provider that accesses the object.

bulk_column_aliasbulk_column_alias

Si applica a : da SQL Server 2008SQL Server 2008 fino a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Alias facoltativo da utilizzare in sostituzione del nome di colonna nel set di risultati.Is an optional alias to replace a column name in the result set. Gli alias di colonna sono consentiti solo nelle istruzioni SELECT che utilizzano la funzione OPENROWSET con l'opzione BULK.Column aliases are allowed only in SELECT statements that use the OPENROWSET function with the BULK option. Quando si usa bulk_column_alias, specificare un alias per ogni colonna di tabella nello stesso ordine delle colonne nel file.When you use bulk_column_alias, specify an alias for every table column in the same order as the columns in the file.

Nota

Questo alias esegue l'override dell'attributo NAME negli elementi COLUMN di un file in formato XML, se presente.This alias overrides the NAME attribute in the COLUMN elements of an XML format file, if present.

user_defined_functionuser_defined_function
Specifica una funzione con valori di tabella.Specifies a table-valued function.

OPENXML <openxml_clause>OPENXML <openxml_clause>

Si applica a : da SQL Server 2008SQL Server 2008 fino a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Consente di visualizzare un documento XML come set di righe.Provides a rowset view over an XML document. Per altre informazioni, vedere OPENXML (Transact-SQL).For more information, see OPENXML (Transact-SQL).

derived_tablederived_table
Sottoquery che recupera le righe dal database.Is a subquery that retrieves rows from the database. derived_table viene usato come input per la query esterna.derived_table is used as input to the outer query.

derived _table può usare la funzione di costruttore di valori di tabella Transact-SQLTransact-SQL per specificare più righe.derived _table can use the Transact-SQLTransact-SQL table value constructor feature to specify multiple rows. Ad esempio, SELECT * FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ) AS MyTable(a, b);.For example, SELECT * FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ) AS MyTable(a, b);. Per altre informazioni, vedere Costruttore di valori di tabella (Transact-SQL).For more information, see Table Value Constructor (Transact-SQL).

column_aliascolumn_alias
Alias facoltativo da utilizzare in sostituzione del nome di colonna nel set di risultati della tabella derivata.Is an optional alias to replace a column name in the result set of the derived table. Includere un alias di colonna per ogni colonna nell'elenco di selezione e racchiudere tra parentesi l'intero elenco di alias di colonna.Include one column alias for each column in the select list, and enclose the complete list of column aliases in parentheses.

table_or_view_name FOR SYSTEM_TIME <system_time>table_or_view_name FOR SYSTEM_TIME <system_time>

Si applica a: da SQL Server 2016 (13.x)SQL Server 2016 (13.x) a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Specifica che venga restituita una determinata versione dei dati della tabella temporale indicata e della relativa tabella di cronologia con controllo delle versioni di sistema collegataSpecifies that a specific version of data is returned from the specified temporal table and its linked system-versioned history table

Clausola TABLESAMPLETablesample clause

Si applica a: SQL Server, database SQLApplies to: SQL Server, SQL Database

Specifica che vengono restituiti dati di esempio dalla tabella.Specifies that a sample of data from the table is returned. I dati di esempio possono essere approssimativi.The sample may be approximate. Questa clausola può essere usata in ogni tabella primaria o unita in join in un'istruzione SELECT o UPDATE.This clause can be used on any primary or joined table in a SELECT or UPDATE statement. Non è possibile specificare TABLESAMPLE con le viste.TABLESAMPLE cannot be specified with views.

Nota

Quando si utilizza TABLESAMPLE sui database aggiornati a SQL ServerSQL 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.When you use TABLESAMPLE against databases that are upgraded to SQL ServerSQL Server, the compatibility level of the database is set to 110 or higher, PIVOT is not allowed in a recursive common table expression (CTE) query. Per altre informazioni, vedere Livello di compatibilità ALTER DATABASE (Transact-SQL).For more information, see ALTER DATABASE Compatibility Level (Transact-SQL).

SYSTEMSYSTEM
Metodo di campionamento dipendente dall'implementazione specificato dagli standard ISO.Is an implementation-dependent sampling method specified by ISO standards. In SQL ServerSQL Server è l'unico metodo di campionamento disponibile e viene applicato per impostazione predefinita.In SQL ServerSQL Server, this is the only sampling method available and is applied by default. 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.SYSTEM applies a page-based sampling method in which a random set of pages from the table is chosen for the sample, and all the rows on those pages are returned as the sample subset.

sample_numbersample_number
Espressione numerica costante esatta o approssimativa che rappresenta la percentuale o il numero delle righe.Is an exact or approximate constant numeric expression that represents the percent or number of rows. Quando viene specificato con PERCENT, sample_number viene implicitamente convertito in valore di tipo float. In caso contrario, viene convertito in bigint.When specified with PERCENT, sample_number is implicitly converted to a float value; otherwise, it is converted to bigint. PERCENT è l'impostazione predefinita.PERCENT is the default.

PERCENTPERCENT
Specifica che una percentuale sample_number di righe della tabella deve essere recuperata dalla tabella.Specifies that a sample_number percent of the rows of the table should be retrieved from the table. Quando viene specificato PERCENT, SQL ServerSQL Server restituisce un valore approssimativo della percentuale specificata.When PERCENT is specified, SQL ServerSQL Server returns an approximate of the percent specified. Quando viene specificato PERCENT l'espressione sample_number deve restituire un valore compreso tra 0 e 100.When PERCENT is specified the sample_number expression must evaluate to a value from 0 to 100.

ROWSROWS
Specifica che verrà recuperato un numero di righe approssimativamente pari a sample_number.Specifies that approximately sample_number of rows will be retrieved. Quando viene specificato ROWS, SQL ServerSQL Server restituisce un'approssimazione del numero di righe specificato.When ROWS is specified, SQL ServerSQL Server returns an approximation of the number of rows specified. Quando viene specificato ROWS, l'espressione sample_number deve restituire un valore integer maggiore di zero.When ROWS is specified, the sample_number expression must evaluate to an integer value greater than zero.

REPEATABLEREPEATABLE
Indica che il campione selezionato può essere restituito nuovamente.Indicates that the selected sample can be returned again. Se specificato con lo stesso valore repeat_seed, SQL ServerSQL Server restituisce lo stesso subset di righe a condizione che non siano state apportate modifiche alle righe della tabella.When specified with the same repeat_seed value, SQL ServerSQL Server will return the same subset of rows as long as no changes have been made to any rows in the table. Se specificato con un valore repeat_seed diverso, SQL ServerSQL Server restituirà probabilmente un campione diverso delle righe nella tabella.When specified with a different repeat_seed value, SQL ServerSQL Server will likely return some different sample of the rows in the table. Le azioni seguenti nella tabella vengono considerate modifiche: inserimento, aggiornamento, eliminazione, ricompilazione o deframmentazione dell'indice e ripristino o collegamento del database.The following actions to the table are considered changes: insert, update, delete, index rebuild or defragmentation, and database restore or attach.

repeat_seedrepeat_seed
Espressione di tipo integer costante utilizzata da SQL ServerSQL Server per generare un numero casuale.Is a constant integer expression used by SQL ServerSQL Server to generate a random number. repeat_seed è bigint.repeat_seed is bigint. Se repeat_seed non viene specificato, SQL ServerSQL Server assegna un valore in modo casuale.If repeat_seed is not specified, SQL ServerSQL Server assigns a value at random. Per un valore repeat_seed specifico, il risultato del campionamento è sempre lo stesso se non sono state applicate modifiche alla tabella.For a specific repeat_seed value, the sampling result is always the same if no changes have been applied to the table. L'espressione repeat_seed deve restituire un valore integer maggiore di zero.The repeat_seed expression must evaluate to an integer greater than zero.

Clausola TABLESAMPLETablesample clause

Si applica a: SQL Data WarehouseApplies to: SQL Data Warehouse

Specifica che vengono restituiti dati di esempio dalla tabella.Specifies that a sample of data from the table is returned. I dati di esempio possono essere approssimativi.The sample may be approximate. Questa clausola può essere usata in ogni tabella primaria o unita in join in un'istruzione SELECT o UPDATE.This clause can be used on any primary or joined table in a SELECT or UPDATE statement. Non è possibile specificare TABLESAMPLE con le viste.TABLESAMPLE cannot be specified with views.

PERCENTPERCENT
Specifica che una percentuale sample_number di righe della tabella deve essere recuperata dalla tabella.Specifies that a sample_number percent of the rows of the table should be retrieved from the table. Quando viene specificato PERCENT, SQL Data Warehouse restituisce un valore approssimativo della percentuale specificata.When PERCENT is specified, SQL Data Warehouse returns an approximate of the percent specified. Quando viene specificato PERCENT, l'espressione sample_number deve restituire un valore compreso tra 0 e 100.When PERCENT is specified, the sample_number expression must evaluate to a value from 0 to 100.

Tabella unita in joinJoined table

Un tabella unita in join è un set di risultati che rappresenta il prodotto di due o più tabelle.A joined table is a result set that is the product of two or more tables. In caso di più join, utilizzare le parentesi per modificarne l'ordine standard.For multiple joins, use parentheses to change the natural order of the joins.

Tipo di joinJoin type

Specifica il tipo di operazione di join.Specifies the type of join operation.

INNERINNER
Specifica che vengono restituite tutte le coppie di righe corrispondenti.Specifies all matching pairs of rows are returned. Le righe senza corrispondenza vengono eliminate da entrambe le tabelle.Discards unmatched rows from both tables. Corrisponde al valore predefinito se non viene specificato alcun tipo di join.When no join type is specified, this is the default.

FULL [OUTER]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.Specifies that a row from either the left or right table that does not meet the join condition is included in the result set, and output columns that correspond to the other table are set to NULL. Questa si aggiunge a tutte le righe normalmente restituite dall'INNER JOIN.This is in addition to all rows typically returned by the INNER JOIN.

LEFT [OUTER]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.Specifies that all rows from the left table not meeting the join condition are included in the result set, and output columns from the other table are set to NULL in addition to all rows returned by the inner join.

RIGHT [OUTER]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.Specifies all rows from the right table not meeting the join condition are included in the result set, and output columns that correspond to the other table are set to NULL, in addition to all rows returned by the inner join.

Hint per il joinJoin hint

Per SQL ServerSQL Server e Database SQLSQL Database, specifica che Query Optimizer di SQL ServerSQL Server usa un hint di join o un algoritmo di esecuzione per ogni join specificato nella clausola FROM della query.For SQL ServerSQL Server and Database SQLSQL Database, specifies that the SQL ServerSQL Server query optimizer use one join hint, or execution algorithm, per join specified in the query FROM clause. Per altre informazioni, vedere Hint (Transact-SQL) - Join.For more information, see Join Hints (Transact-SQL).

Per SQL Data WarehouseSQL Data Warehouse e Parallel Data WarehouseParallel Data Warehouse, questi hint di join si applicano ai join INNER in due colonne non compatibili di distribuzione.For SQL Data WarehouseSQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse, these join hints apply to INNER joins on two distribution incompatible columns. Possono migliorare le prestazioni delle query limitando lo spostamento dei dati che si verifica durante l'elaborazione delle query.They can improve query performance by restricting the amount of data movement that occurs during query processing. Gli hint di join consentiti per SQL Data WarehouseSQL Data Warehouse e Parallel Data WarehouseParallel Data Warehouse sono i seguenti:The allowable join hints for SQL Data WarehouseSQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse are as follows:

REDUCEREDUCE
Riduce il numero di righe da spostare per la tabella sul lato destro del join per rendere compatibili due tabelle non compatibili di distribuzione.Reduces the number of rows to be moved for the table on the right side of the join in order to make two distribution incompatible tables compatible. L'hint REDUCE è chiamato anche hint di semi-join.The REDUCE hint is also called a semi-join hint.

REPLICATEREPLICATE
Fa in modo che i valori nella colonna di join della tabella sul lato sinistro del join vengano replicati in tutti i nodi.Causes the values in the joining column from the table on the left side of the join to be replicated to all nodes. La tabella di destra viene unita alla versione replicata delle colonne.The table on the right is joined to the replicated version of those columns.

REDISTRIBUTEREDISTRIBUTE
Forza la distribuzione di due origini dati nelle colonne specificate nella clausola JOIN.Forces two data sources to be distributed on columns specified in the JOIN clause. Per una tabella distribuita, Parallel Data WarehouseParallel Data Warehouse esegue uno spostamento casuale.For a distributed table, Parallel Data WarehouseParallel Data Warehouse will perform a shuffle move. Per una tabella replicata, Parallel Data WarehouseParallel Data Warehouse esegue uno spostamento di taglio.For a replicated table, Parallel Data WarehouseParallel Data Warehouse will perform a trim move. Per comprendere questi tipi di spostamento, vedere la sezione "DMS Query Plan Operations" (Operazioni del piano di query del Servizio Migrazione del database) in "Understanding Query Plans" (Informazioni sui piani di query) in Documentazione del prodotto Parallel Data WarehouseParallel Data Warehouse product documentation.To understand these move types, see the "DMS Query Plan Operations" section in the "Understanding Query Plans" topic in the Documentazione del prodotto Parallel Data WarehouseParallel Data Warehouse product documentation. Questo hint può migliorare le prestazioni quando il piano di query usa uno spostamento dei dati trasmessi per risolvere un join non compatibile di distribuzione.This hint can improve performance when the query plan is using a broadcast move to resolve a distribution incompatible join.

JOINJOIN
Indica che l'operazione di join specificata deve essere eseguita tra le viste o le origini di tabella specificate.Indicates that the specified join operation should occur between the specified table sources or views.

ON <search_condition>ON <search_condition>
Specifica la condizione su cui è basato il join.Specifies the condition on which the join is based. La condizione può includere qualsiasi predicato, ma vengono in genere utilizzati nomi di colonne e operatori di confronto, ad esempio:The condition can specify any predicate, although columns and comparison operators are frequently used, for example:

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 ServerSQL Server.When the condition specifies columns, the columns do not have to have the same name or same data type; however, if the data types are not the same, they must be either compatible or types that SQL ServerSQL Server can implicitly convert. 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.If the data types cannot be implicitly converted, the condition must explicitly convert the data type by using the CONVERT function.

È possibile che alcuni predicati includano una sola delle tabelle unite in join nella clausola ON.There can be predicates that involve only one of the joined tables in the ON clause. Tali predicati potrebbero essere presenti inoltre nella clausola WHERE della query.Such predicates also can be in the WHERE clause in the query. La posizione di tali predicati non è rilevante nel caso di INNER join, ma potrebbe generare risultati diversi se vengono utilizzati OUTER join.Although the placement of such predicates does not make a difference for INNER joins, they might cause a different result when OUTER joins are involved. 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.This is because the predicates in the ON clause are applied to the table before the join, whereas the WHERE clause is semantically applied to the result of the join.

Per altre informazioni sulle condizioni di ricerca e i predicati, vedere Condizioni di ricerca (Transact-SQL).For more information about search conditions and predicates, see Search Condition (Transact-SQL).

CROSS JOINCROSS JOIN
Specifica il prodotto incrociato di due tabelle.Specifies the cross-product of two tables. Restituisce le righe che verrebbero restituite se non fosse specificata alcuna clausola WHERE in un join obsoleto, non SQL-92.Returns the same rows as if no WHERE clause was specified in an old-style, non-SQL-92-style join.

left_table_source { CROSS | OUTER } APPLY right_table_sourceleft_table_source { CROSS | OUTER } APPLY right_table_source
Specifica che right_table_source dell'operatore APPLY viene valutato rispetto a ogni riga di left_table_source.Specifies that the right_table_source of the APPLY operator is evaluated against every row of the 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.This functionality is useful when the right_table_source contains a table-valued function that takes column values from the left_table_source as one of its arguments.

È necessario specificare CROSS o OUTER con APPLY.Either CROSS or OUTER must be specified with 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.When CROSS is specified, no rows are produced when the right_table_source is evaluated against a specified row of the left_table_source and returns an empty result set.

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.When OUTER is specified, one row is produced for each row of the left_table_source even when the right_table_source evaluates against that row and returns an empty result set.

Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

left_table_sourceleft_table_source
Origine di tabella definita nell'argomento precedente.Is a table source as defined in the previous argument. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

right_table_sourceright_table_source
Origine di tabella definita nell'argomento precedente.Is a table source as defined in the previous argument. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Clausola PIVOTPIVOT clause

table_source PIVOT <pivot_clause>table_source PIVOT <pivot_clause>
Specifica che table_source venga trasformato tramite Pivot in base a pivot_column.Specifies that the table_source is pivoted based on the pivot_column. table_source è una tabella o un'espressione di tabella.table_source is a table or table expression. L'output è una tabella che contiene tutte le colonne di table_source ad eccezione di pivot_column e value_column.The output is a table that contains all columns of the table_source except the pivot_column and value_column. Le colonne di table_source, eccetto pivot_column e value_column, vengono definite colonne di raggruppamento dell'operatore PIVOT.The columns of the table_source, except the pivot_column and value_column, are called the grouping columns of the pivot operator. Per altre informazioni su PIVOT e UNPIVOT, vedere Uso di PIVOT e UNPIVOT.For more information about PIVOT and UNPIVOT, see Using PIVOT and UNPIVOT.

PIVOT esegue un'operazione di raggruppamento sulla tabella di input relativamente alle colonne di raggruppamento e restituisce una riga per ogni gruppo.PIVOT performs a grouping operation on the input table with regard to the grouping columns and returns one row for each group. L'output contiene anche una colonna per ogni valore specificato in column_list visualizzato in pivot_column in input_table.Additionally, the output contains one column for each value specified in the column_list that appears in the pivot_column of the input_table.

Per ulteriori informazioni, vedere la sezione Osservazioni riportata di seguito.For more information, see the Remarks section that follows.

aggregate_functionaggregate_function
Funzione di aggregazione di sistema o definita dall'utente che accetta uno o più input.Is a system or user-defined aggregate function that accepts one or more inputs. La funzione di aggregazione deve essere invariante rispetto ai valori Null.The aggregate function should be invariant to null values. Una funzione di aggregazione invariante rispetto ai valori Null non considera i valori Null nel gruppo mentre valuta il valore di aggregazione.An aggregate function invariant to null values does not consider null values in the group while it is evaluating the aggregate value.

La funzione di aggregazione di sistema COUNT(*) non è consentita.The COUNT(*) system aggregate function is not allowed.

value_columnvalue_column
Indica la colonna dei valori dell'operatore PIVOT.Is the value column of the PIVOT operator. Se usato con UNPIVOT, value_column non può corrispondere al nome di una colonna esistente in table_source nell'input.When used with UNPIVOT, value_column cannot be the name of an existing column in the input table_source.

FOR pivot_columnFOR pivot_column
Colonna pivot dell'operatore PIVOT.Is the pivot column of the PIVOT operator. pivot_column deve essere di un tipo di dati che è possibile convertire in modo implicito o esplicito nel tipo nvarchar() .pivot_column must be of a type implicitly or explicitly convertible to nvarchar(). Questa colonna non può essere image o rowversion.This column cannot be image or rowversion.

Quando viene usato UNPIVOT, pivot_column indica il nome della colonna di output risultante dal raggruppamento delle colonne di table_source.When UNPIVOT is used, pivot_column is the name of the output column that becomes narrowed from the table_source. In table_source non può esistere già una colonna con questo nome.There cannot be an existing column in table_source with that name.

IN (column_list )IN (column_list )
Nella clausola PIVOT elenca i valori della colonna pivot_column che diventeranno i nomi di colonna della tabella di output.In the PIVOT clause, lists the values in the pivot_column that will become the column names of the output table. 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.The list cannot specify any column names that already exist in the input table_source that is being pivoted.

Nella clausola UNPIVOT elenca le colonne in table_source che verranno raggruppate in un'unica colonna pivot_column.In the UNPIVOT clause, lists the columns in table_source that will be narrowed into a single pivot_column.

table_aliastable_alias
Nome dell'alias della tabella di output.Is the alias name of the output table. È necessario specificare pivot_table_alias.pivot_table_alias must be specified.

UNPIVOT <unpivot_clause>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.Specifies that the input table is narrowed from multiple columns in column_list into a single column called pivot_column. Per altre informazioni su PIVOT e UNPIVOT, vedere Uso di PIVOT e UNPIVOT.For more information about PIVOT and UNPIVOT, see Using PIVOT and UNPIVOT.

AS OF <date_time>AS OF <date_time>

Si applica a : da SQL Server 2016 (13.x)SQL Server 2016 (13.x) fino a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Restituisce una tabella con un singolo record per ogni riga contenente i valori che erano effettivi (correnti) in un momento specificato nel passato.Returns a table with single record for each row containing the values that were actual (current) at the specified point in time in the past. Internamente, viene eseguita un'unione tra la tabella temporale e la relativa tabella di cronologia e i risultati vengono filtrati in modo da restituire i valori nella riga che era valida nel momento specificato dal parametro <date_time> .Internally, a union is performed between the temporal table and its history table and the results are filtered to return the values in the row that was valid at the point in time specified by the <date_time> parameter. Il valore per una riga viene considerato valido se il valore system_start_time_column_name è minore o uguale al valore del parametro <date_time> e il valore system_end_time_column_name è maggiore del valore del parametro <date_time> .The value for a row is deemed valid if the system_start_time_column_name value is less than or equal to the <date_time> parameter value and the system_end_time_column_name value is greater than the <date_time> parameter value.

FROM <start_date_time> TO <end_date_time>FROM <start_date_time> TO <end_date_time>

Si applica a: da SQL Server 2016 (13.x)SQL Server 2016 (13.x) a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Restituisce una tabella con i valori per tutte le versioni di riga che erano attive nell'intervallo di tempo specificato, indipendentemente dal fatto che abbiano iniziato a essere attive prima del valore del parametro <start_date_time> per l'argomento FROM o non siano più state attive dopo il valore del parametro <end_date_time> per l'argomento TO.Returns a table with the values for all record versions that were active within the specified time range, regardless of whether they started being active before the <start_date_time> parameter value for the FROM argument or ceased being active after the <end_date_time> parameter value for the TO argument. Internamente, viene eseguita un'unione tra la tabella temporale e la relativa tabella di cronologia e i risultati vengono filtrati in modo da restituire i valori per tutte le versioni di riga che erano attive in qualsiasi momento durante l'intervallo di tempo specificato.Internally, a union is performed between the temporal table and its history table and the results are filtered to return the values for all row versions that were active at any time during the time range specified. Le righe diventate attive esattamente in corrispondenza del limite inferiore definito dall'endpoint FROM sono incluse e le righe diventate attive esattamente in corrispondenza del limite superiore definito dall'endpoint TO non sono incluse.Rows that became active exactly on the lower boundary defined by the FROM endpoint are included and rows that became active exactly on the upper boundary defined by the TO endpoint are not included.

BETWEEN <start_date_time> AND <end_date_time>BETWEEN <start_date_time> AND <end_date_time>

Si applica a: da SQL Server 2016 (13.x)SQL Server 2016 (13.x) a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Come sopra per la descrizione di FROM <start_date_time> TO <end_date_time> , tranne per il fatto che include le righe diventate attive in corrispondenza del limite superiore definito dall'endpoint <end_date_time>.Same as above in the FROM <start_date_time> TO <end_date_time> description, except it includes rows that became active on the upper boundary defined by the <end_date_time> endpoint.

CONTAINED IN (<start_date_time> , <end_date_time>)CONTAINED IN (<start_date_time> , <end_date_time>)

Si applica a : da SQL Server 2016 (13.x)SQL Server 2016 (13.x) fino a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

Restituisce una tabella con i valori per tutte le versioni di record che sono state aperte e chiuse nell'intervallo di tempo specificato, definito dai due valori datetime per l'argomento CONTAINED IN.Returns a table with the values for all record versions that were opened and closed within the specified time range defined by the two datetime values for the CONTAINED IN argument. Sono incluse le righe diventate attive esattamente in corrispondenza del limite inferiore o che non sono più state attive esattamente in corrispondenza del limite superiore.Rows that became active exactly on the lower boundary or ceased being active exactly on the upper boundary are included.

ALLALL
Restituisce una tabella con i valori di tutte le righe della tabella corrente e della tabella di cronologia.Returns a table with the values from all rows from both the current table and the history table.

RemarksRemarks

La clausola FROM supporta la sintassi SQL-92 per le tabelle unite in join e per le tabelle derivate.The FROM clause supports the SQL-92-SQL syntax for joined tables and derived tables. Nella sintassi SQL-92 sono disponibili gli operatori di join INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER e CROSS.SQL-92 syntax provides the INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER, and CROSS join operators.

In una clausola FROM le istruzioni UNION e JOIN sono supportate sia nelle viste, sia nelle tabelle derivate e nelle sottoquery.UNION and JOIN within a FROM clause are supported within views and in derived tables and subqueries.

Un self join è una tabella unita in join con se stessa.A self-join is a table that is joined to itself. Nelle operazioni di inserimento e aggiornamento basate su un self join viene seguito l'ordine indicato nella clausola FROM.Insert or update operations that are based on a self-join follow the order in the FROM clause.

Dato che in SQL ServerSQL 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.Because SQL ServerSQL Server considers distribution and cardinality statistics from linked servers that provide column distribution statistics, the REMOTE join hint is not required to force evaluating a join remotely. In SQL ServerSQL Server Query Processor analizza le statistiche remote e determina se è appropriato adottare una strategia di join remoto.The SQL ServerSQL Server query processor considers remote statistics and determines whether a remote-join strategy is appropriate. L'hint di join REMOTE risulta utile per i provider che non forniscono statistiche sulla distribuzione delle colonne.REMOTE join hint is useful for providers that do not provide column distribution statistics.

Utilizzo di APPLYUsing APPLY

Entrambi gli operandi sinistro e destro dell'operatore APPLY sono espressioni di tabella.Both the left and right operands of the APPLY operator are table expressions. La differenza principale tra questi operandi è rappresentata dal fatto che right_table_source può usare una funzione con valori di tabella in cui una colonna di left_table_source è considerata uno degli argomenti.The main difference between these operands is that the right_table_source can use a table-valued function that takes a column from the left_table_source as one of the arguments of the function. left_table_source può includere funzioni con valori di tabella, ma non può contenere come argomenti colonne di right_table_source.The left_table_source can include table-valued functions, but it cannot contain arguments that are columns from the right_table_source.

L'operatore APPLY funziona nel modo seguente per restituire l'origine di tabella per la clausola FROM:The APPLY operator works in the following way to produce the table source for the FROM clause:

  1. Valuta right_table_source rispetto a ogni riga di left_table_source per produrre set di righe.Evaluates right_table_source against each row of the left_table_source to produce rowsets.

    I valori di right_table_source dipendono da left_table_source.The values in the right_table_source depend on 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.right_table_source can be represented approximately this way: TVF(left_table_source.row), where TVF is a table-valued function.

  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.Combines the result sets that are produced for each row in the evaluation of right_table_source with the left_table_source by performing a UNION ALL operation.

    L'elenco di colonne restituito dal risultato dell'operatore APPLY corrisponde al set di colonne di left_table_source combinato con l'elenco di colonne di right_table_source.The list of columns produced by the result of the APPLY operator is the set of columns from the left_table_source that is combined with the list of columns from the right_table_source.

Utilizzo di PIVOT e UNPIVOTUsing PIVOT and UNPIVOT

pivot_column e value_column sono colonne di raggruppamento usate dall'operatore PIVOT.The pivot_column and value_column are grouping columns that are used by the PIVOT operator. PIVOT segue il processo seguente per ottenere il set di risultati di output:PIVOT follows the following process to obtain the output result set:

  1. Esegue GROUP BY in input_table sulle colonne di raggruppamento e restituisce una riga di output per ogni gruppo.Performs a GROUP BY on its input_table against the grouping columns and produces one output row for each group.

    Le colonne di raggruppamento nella riga di output ottengono i valori delle colonne corrispondenti per tale gruppo in input_table.The grouping columns in the output row obtain the corresponding column values for that group in the input_table.

  2. Genera valori per le colonne nell'elenco delle colonne per ogni riga di output eseguendo le operazioni seguenti:Generates values for the columns in the column list for each output row by performing the following:

    1. Raggruppando le righe restituite in GROUP BY nel passaggio precedente rispetto a pivot_column.Grouping additionally the rows generated in the GROUP BY in the previous step against the pivot_column.

      Selezionando per ogni colonna di output in column_list un sottogruppo che soddisfa la condizione:For each output column in the column_list, selecting a subgroup that satisfies the condition:

      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.aggregate_function is evaluated against the value_column on this subgroup and its result is returned as the value of the corresponding output_column. Se il sottogruppo è vuoto, SQL ServerSQL Server genera un valore Null per output_column.If the subgroup is empty, SQL ServerSQL Server generates a null value for that output_column. Se la funzione di aggregazione è COUNT e il sottogruppo è vuoto, viene restituito zero (0).If the aggregate function is COUNT and the subgroup is empty, zero (0) is returned.

Nota

Gli identificatori di colonna nella clausola UNPIVOT seguono le regole di confronto dei cataloghi.The column identifiers in the UNPIVOT clause follow the catalog collation. Per il Database SQLSQL Database, le regole di confronto sono sempre SQL_Latin1_General_CP1_CI_AS.For Database SQLSQL Database, the collation is always SQL_Latin1_General_CP1_CI_AS. Per i database parzialmente indipendenti di SQL ServerSQL Server, le regole di confronto sono sempre Latin1_General_100_CI_AS_KS_WS_SC.For SQL ServerSQL Server partially contained databases, the collation is always Latin1_General_100_CI_AS_KS_WS_SC. Se la colonna è combinata con altre colonne, sarà necessaria una clausola COLLATE, ovvero COLLATE DATABASE_DEFAULT, per evitare conflitti.If the column is combined with other columns, then a collate clause (COLLATE DATABASE_DEFAULT) is required to avoid conflicts.

Per altre informazioni su PIVOT e UNPIVOT ed esempi, vedere Uso di PIVOT e UNPIVOT.For more information about PIVOT and UNPIVOT including examples, see Using PIVOT and UNPIVOT.

AutorizzazioniPermissions

Sono richieste le autorizzazioni per l'istruzione DELETE, SELECT o UPDATE.Requires the permissions for the DELETE, SELECT, or UPDATE statement.

EsempiExamples

A.A. Utilizzo di una clausola FROM sempliceUsing a simple FROM clause

Nell'esempio seguente vengono recuperate le colonne TerritoryID e Name dalla tabella SalesTerritory nel database di esempio AdventureWorks2012AdventureWorks2012.The following example retrieves the TerritoryID and Name columns from the SalesTerritory table in the AdventureWorks2012AdventureWorks2012 sample database.

SELECT TerritoryID, Name  
FROM Sales.SalesTerritory  
ORDER BY TerritoryID ;  

Set di risultati:Here is the result set.

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.B. Utilizzo degli hint di ottimizzazione TABLOCK e HOLDLOCKUsing the TABLOCK and HOLDLOCK optimizer hints

Nella transazione parziale seguente viene illustrato come impostare un blocco di tabella condiviso esplicito in Employee e come leggere l'indice.The following partial transaction shows how to place an explicit shared table lock on Employee and how to read the index. Il blocco viene mantenuto attivo fino al termine della transazione.The lock is held throughout the whole transaction.

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

C.C. Utilizzo della sintassi CROSS JOIN di SQL-92Using the SQL-92 CROSS JOIN syntax

Nell'esempio seguente viene restituito il prodotto incrociato delle due tabelle Employee e Department nel database AdventureWorks2012AdventureWorks2012.The following example returns the cross product of the two tables Employee and Department in the AdventureWorks2012AdventureWorks2012 database. Vengono restituiti inoltre un elenco di tutte le possibili combinazioni delle righe di BusinessEntityID e tutte le righe di nome Department.A list of all possible combinations of BusinessEntityID rows and all Department name rows are returned.

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.D. Utilizzo della sintassi FULL OUTER JOIN di SQL-92Using the SQL-92 FULL OUTER JOIN syntax

Nell'esempio seguente vengono restituiti il nome del prodotto ed eventuali ordini di vendita corrispondenti nella tabella SalesOrderDetail del database AdventureWorks2012AdventureWorks2012.The following example returns the product name and any corresponding sales orders in the SalesOrderDetail table in the AdventureWorks2012AdventureWorks2012 database. 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.It also returns any sales orders that have no product listed in the Product table, and any products with a sales order other than the one listed in the Product table.

-- 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  
ORDER BY p.Name ;  

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

Nell'esempio seguente vengono unite in join due tabelle tramite la colonna ProductID. Le righe della tabella sinistra prive di corrispondenza vengono mantenute.The following example joins two tables on ProductID and preserves the unmatched rows from the left table. La tabella Product viene confrontata con la tabella SalesOrderDetail nelle colonne ProductID in ogni tabella.The Product table is matched with the SalesOrderDetail table on the ProductID columns in each table. Tutti i prodotti, ordinati e non ordinati, vengono visualizzati nel set dei risultati.All products, ordered and not ordered, appear in the result set.

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.F. Utilizzo della sintassi INNER JOIN di SQL-92Using the SQL-92 INNER JOIN syntax

Nell'esempio seguente vengono restituiti tutti i nomi di prodotti e gli ID degli ordini di vendita.The following example returns all product names and sales order IDs.

-- 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.G. Utilizzo della sintassi RIGHT OUTER JOIN di SQL-92Using the SQL-92 RIGHT OUTER JOIN syntax

Nell'esempio seguente vengono unite in join due tabelle tramite la colonna TerritoryID. Le righe della tabella destra prive di corrispondenza vengono mantenute.The following example joins two tables on TerritoryID and preserves the unmatched rows from the right table. La tabella SalesTerritory viene confrontata con la tabella SalesPerson nella colonna TerritoryID in ogni tabella.The SalesTerritory table is matched with the SalesPerson table on the TerritoryID column in each table. Tutti i venditori vengono visualizzati nel set dei risultati, a prescindere dal fatto che siano assegnati a un'area o meno.All salespersons appear in the result set, whether or not they are assigned a territory.

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.H. Utilizzo degli hint di join HASH e MERGEUsing HASH and MERGE join hints

Nell'esempio seguente viene eseguito un join delle tre tabelle Product, ProductVendor e Vendor per ottenere un elenco di prodotti e dei relativi fornitori.The following example performs a three-table join among the Product, ProductVendor, and Vendor tables to produce a list of products and their vendors. Query Optimizer unisce in join le tabelle Product e ProductVendor (p e pv) tramite un join di tipo MERGE.The query optimizer joins Product and ProductVendor (p and pv) by using a MERGE join. 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.Next, the results of the Product and ProductVendor MERGE join (p and pv) are HASH joined to the Vendor table to produce (p and pv) and 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.After a join hint is specified, the INNER keyword is no longer optional and must be explicitly stated for an INNER JOIN to be performed.

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.I. Utilizzo di una tabella derivataUsing a derived table

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.The following example uses a derived table, a SELECT statement after the FROM clause, to return the first and last names of all employees and the cities in which they live.

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.J. Utilizzo di TABLESAMPLE per leggere i dati di un campione di righe in una tabellaUsing TABLESAMPLE to read data from a sample of rows in a table

Nell'esempio seguente viene utilizzata l'opzione TABLESAMPLE nella clausola FROM per restituire approssimativamente il 10 percento di tutte le righe della tabella Customer.The following example uses TABLESAMPLE in the FROM clause to return approximately 10 percent of all the rows in the Customer table.

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

K.K. Utilizzo di APPLYUsing APPLY

Nell'esempio seguente si presuppone che nel database siano presenti le tabelle e la funzione con valori di tabella seguenti:The following example assumes that the following tables and table-valued function exist in the database:

Nome oggettoObject Name Nomi di colonnaColumn Names
RepartiDepartments DeptID, DivisionID, DeptName, DeptMgrIDDeptID, DivisionID, DeptName, DeptMgrID
EmpMgrEmpMgr MgrID, EmpIDMgrID, EmpID
EmployeesEmployees EmpID, EmpSalary EmpLastName, EmpFirstNameEmpID, EmpLastName, EmpFirstName, EmpSalary
GetReports(MgrID)GetReports(MgrID) EmpSalary EmpID, EmpLastNameEmpID, EmpLastName, EmpSalary

La funzione con valori di tabella GetReports restituisce un elenco di tutti i dipendenti che sono subordinati direttamente o indirettamente all'elemento MgrID specificato.The GetReports table-valued function, returns the list of all employees that report directly or indirectly to the specified MgrID.

In questo esempio viene utilizzato APPLY per restituire tutti i reparti e tutti i dipendenti in ogni reparto.The example uses APPLY to return all departments and all employees in that department. Se uno specifico reparto non ha dipendenti, non verranno restituite righe per tale reparto.If a particular department does not have any employees, there will not be any rows returned for that department.

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.If you want the query to produce rows for those departments without employees, which will produce null values for the EmpID, EmpLastName and EmpSalary columns, use OUTER APPLY instead.

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

L.L. Utilizzo di CROSS APPLYUsing 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.The following example retrieves a snapshot of all query plans residing in the plan cache, by querying the sys.dm_exec_cached_plans dynamic management view to retrieve the plan handles of all query plans in the cache. Successivamente viene specificato l'operatore CROSS APPLY per passare gli handle del piano a sys.dm_exec_query_plan.Then the CROSS APPLY operator is specified to pass the plan handles to 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.The XML Showplan output for each plan currently in the plan cache is in the query_plan column of the table that is returned.

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  

M.M. Uso di FOR SYSTEM_TIMEUsing FOR SYSTEM_TIME

Si applica a: da SQL Server 2016 (13.x)SQL Server 2016 (13.x) a SQL Server 2017SQL Server 2017 e Database SQLSQL Database.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017 and Database SQLSQL Database.

L'esempio seguente usa l'argomento FOR SYSTEM_TIME AS OF date_time_literal_or_variable per restituire le righe di tabella correnti in data 1 gennaio 2014.The following example uses the FOR SYSTEM_TIME AS OF date_time_literal_or_variable argument to return table rows that were actual (current) as of January 1, 2014.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME AS OF '2014-01-01'  
WHERE ManagerID = 5;

L'esempio seguente usa l'argomento FOR SYSTEM_TIME FROM date_time_literal_or_variable TO date_time_literal_or_variable per restituire tutte le righe attive durante il periodo definito che inizia l'1 gennaio 2013 e termina l'1 gennaio 2014, escluso il limite superiore.The following example uses the FOR SYSTEM_TIME FROM date_time_literal_or_variable TO date_time_literal_or_variable argument to return all rows that were active during the period defined as starting with January 1, 2013 and ending with January 1, 2014, exclusive of the upper boundary.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME FROM '2013-01-01' TO '2014-01-01'  
WHERE ManagerID = 5;

L'esempio seguente usa l'argomento FOR SYSTEM_TIME BETWEEN date_time_literal_or_variable AND date_time_literal_or_variable per restituire tutte le righe attive durante il periodo definito che inizia l'1 gennaio 2013 e termina l'1 gennaio 2014, incluso il limite superiore.The following example uses the FOR SYSTEM_TIME BETWEEN date_time_literal_or_variable AND date_time_literal_or_variable argument to return all rows that were active during the period defined as starting with January 1, 2013 and ending with January 1, 2014, inclusive of the upper boundary.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME BETWEEN '2013-01-01' AND '2014-01-01'  
WHERE ManagerID = 5;

L'esempio seguente usa l'argomento FOR SYSTEM_TIME CONTAINED IN ( date_time_literal_or_variable, date_time_literal_or_variable ) per restituire tutte le righe aperte e chiuse durante il periodo definito che inizia l'1 gennaio 2013 e termina l'1 gennaio 2014.The following example uses the FOR SYSTEM_TIME CONTAINED IN ( date_time_literal_or_variable, date_time_literal_or_variable ) argument to return all rows that were opened and closed during the period defined as starting with January 1, 2013 and ending with January 1, 2014.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME CONTAINED IN ( '2013-01-01', '2014-01-01' )  
WHERE ManagerID = 5;

L'esempio seguente usa una variabile anziché un letterale per specificare i valori limite di data per la query.The following example uses a variable rather than a literal to provide the date boundary values for the query.

DECLARE @AsOfFrom datetime2 = dateadd(month,-12, sysutcdatetime());
DECLARE @AsOfTo datetime2 = dateadd(month,-6, sysutcdatetime());
  
SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME FROM @AsOfFrom TO @AsOfTo  
WHERE ManagerID = 5;

Esempi: Azure SQL Data WarehouseAzure SQL Data Warehouse e Parallel Data WarehouseParallel Data WarehouseExamples: Azure SQL Data WarehouseAzure SQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

N.N. Uso della sintassi INNER JOINUsing the INNER JOIN syntax

L'esempio seguente restituisce le colonne SalesOrderNumber, ProductKey e EnglishProductName delle tabelle FactInternetSales e DimProduct in cui la chiave di join ProductKey corrisponde in entrambe le tabelle.The following example returns the SalesOrderNumber, ProductKey, and EnglishProductName columns from the FactInternetSales and DimProduct tables where the join key, ProductKey, matches in both tables. Poiché ogni colonna SalesOrderNumber e EnglishProductName è presente solo in una delle tabelle, non è necessario specificare l'alias di tabella con queste colonne; in questo caso gli alias sono inclusi per favorire la leggibilità.The SalesOrderNumber and EnglishProductName columns each exist in one of the tables only, so it is not necessary to specify the table alias with these columns, as is shown; these aliases are included for readability. La parola AS prima di un nome di alias non è obbligatoria ma è consigliabile specificarla per migliorare la leggibilità e per conformità allo standard ANSI.The word AS before an alias name is not required but is recommended for readability and to conform to the ANSI standard.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis 
INNER JOIN DimProduct AS dp  
    ON dp.ProductKey = fis.ProductKey;  

Poiché la parola chiave INNER non è obbligatoria per gli inner join, la stessa query può essere scritta come segue:Since the INNER keyword is not required for inner joins, this same query could be written as:

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis 
JOIN DimProduct AS dp  
ON dp.ProductKey = fis.ProductKey;  

È anche possibile usare una clausola WHERE con questa query per limitare i risultati.A WHERE clause could also be used with this query to limit results. Questo esempio limita i risultati ai valori SalesOrderNumber maggiori di 'SO5000':This example limits results to SalesOrderNumber values higher than 'SO5000':

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis 
JOIN DimProduct AS dp  
    ON dp.ProductKey = fis.ProductKey  
WHERE fis.SalesOrderNumber > 'SO50000'  
ORDER BY fis.SalesOrderNumber;  

O.O. Uso della sintassi LEFT OUTER JOIN e RIGHT OUTER JOINUsing the LEFT OUTER JOIN and RIGHT OUTER JOIN syntax

L'esempio seguente unisce le tabelle FactInternetSales e DimProduct nelle colonne ProductKey.The following example joins the FactInternetSales and DimProduct tables on the ProductKey columns. La sintassi LEFT OUTER JOIN mantiene le righe senza corrispondenza della tabella di sinistra (FactInternetSales).The left outer join syntax preserves the unmatched rows from the left (FactInternetSales) table. Poiché la tabella FactInternetSales non contiene valori ProductKey che non corrispondono alla tabella DimProduct, la query restituisce le stesse righe dell'esempio del primo inner join precedente.Since the FactInternetSales table does not contain any ProductKey values that do not match the DimProduct table, this query returns the same rows as the first inner join example above.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis 
LEFT OUTER JOIN DimProduct AS dp  
    ON dp.ProductKey = fis.ProductKey;  

Questa query può essere scritta anche senza la parola chiave OUTER.This query could also be written without the OUTER keyword.

Nei right outer join le righe senza corrispondenza della tabella di destra vengono mantenute.In right outer joins, the unmatched rows from the right table are preserved. L'esempio seguente restituisce le stesse righe dell'esempio di left outer join precedente.The following example returns the same rows as the left outer join example above.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM DimProduct AS dp 
RIGHT OUTER JOIN FactInternetSales AS fis  
    ON dp.ProductKey = fis.ProductKey;  

La query seguente usa la tabella DimSalesTerritory come tabella di sinistra in un left outer join.The following query uses the DimSalesTerritory table as the left table in a left outer join. Recupera i valori SalesOrderNumber della tabella FactInternetSales.It retrieves the SalesOrderNumber values from the FactInternetSales table. Se non sono presenti ordini per un particolare SalesTerritoryKey, la query restituisce NULL per SalesOrderNumber per la riga.If there are no orders for a particular SalesTerritoryKey, the query will return a NULL for the SalesOrderNumber for that row. Poiché questa query viene ordinata dalla colonna SalesOrderNumber, tutti i valori NULL in questa colonna verranno visualizzati per primi nei risultati.This query is ordered by the SalesOrderNumber column, so that any NULLs in this column will appear at the top of the results.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst 
LEFT OUTER JOIN FactInternetSales AS fis  
    ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Questa query potrebbe essere riscritta con un right outer join per recuperare gli stessi risultati:This query could be rewritten with a right outer join to retrieve the same results:

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM FactInternetSales AS fis 
RIGHT OUTER JOIN DimSalesTerritory AS dst  
    ON fis.SalesTerritoryKey = dst.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

P.P. Uso della sintassi FULL OUTER JOINUsing the FULL OUTER JOIN syntax

L'esempio seguente illustra un full outer join che restituisce tutte le righe di entrambe le tabelle unite ma restituisce NULL per i valori che non corrispondono dell'altra tabella.The following example demonstrates a full outer join, which returns all rows from both joined tables but returns NULL for values that do not match from the other table.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst 
FULL OUTER JOIN FactInternetSales AS fis  
    ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Questa query può essere scritta anche senza la parola chiave OUTER.This query could also be written without the OUTER keyword.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst 
FULL JOIN FactInternetSales AS fis  
    ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Q.Q. Uso della sintassi CROSS JOINUsing the CROSS JOIN syntax

L'esempio seguente restituisce il prodotto presente in entrambe le tabelle FactInternetSales e DimSalesTerritory.The following example returns the cross-product of the FactInternetSales and DimSalesTerritory tables. Viene restituito un elenco delle combinazioni possibili di SalesOrderNumber e SalesTerritoryKey.A list of all possible combinations of SalesOrderNumber and SalesTerritoryKey are returned. Si noti l'assenza della clausola ON della query di cross join.Notice the absence of the ON clause in the cross join query.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst 
CROSS JOIN FactInternetSales AS fis  
ORDER BY fis.SalesOrderNumber;  

R.R. Utilizzo di una tabella derivataUsing a derived table

L'esempio seguente usa una tabella derivata (un'istruzione SELECT dopo la clausola FROM) per restituire le colonne CustomerKey e LastName di tutti i clienti della tabella DimCustomer con valori BirthDate successivi all'1 gennaio 1970 e il cognome 'Smith'.The following example uses a derived table (a SELECT statement after the FROM clause) to return the CustomerKey and LastName columns of all customers in the DimCustomer table with BirthDate values later than January 1, 1970 and the last name 'Smith'.

-- Uses AdventureWorks  
  
SELECT CustomerKey, LastName  
FROM  
   (SELECT * FROM DimCustomer  
    WHERE BirthDate > '01/01/1970') AS DimCustomerDerivedTable  
WHERE LastName = 'Smith'  
ORDER BY LastName;  

S.S. Esempio di hint di join REDUCEREDUCE join hint example

L'esempio seguente usa l'hint di join REDUCE per modificare l'elaborazione della tabella derivata all'interno della query.The following example uses the REDUCE join hint to alter the processing of the derived table within the query. Quando si usa l'hint di join REDUCE in questa query, fis.ProductKey viene proiettato, replicato e differenziato e quindi unito a DimProduct durante lo spostamento casuale di DimProduct in ProductKey.When using the REDUCE join hint in this query, the fis.ProductKey is projected, replicated and made distinct, and then joined to DimProduct during the shuffle of DimProduct on ProductKey. La tabella derivata risultante viene distribuita in fis.ProductKey.The resulting derived table is distributed on fis.ProductKey.

-- Uses AdventureWorks  
  
EXPLAIN SELECT SalesOrderNumber  
FROM  
   (SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
    FROM DimProduct AS dp   
      INNER REDUCE JOIN FactInternetSales AS fis   
          ON dp.ProductKey = fis.ProductKey  
   ) AS dTable  
ORDER BY SalesOrderNumber;  

T.T. Esempio di hint di join REPLICATEREPLICATE join hint example

L'esempio successivo illustra la stessa query dell'esempio precedente in cui viene usato un hint di join REPLICATE anziché l'hint di join REDUCE.This next example shows the same query as the previous example, except that a REPLICATE join hint is used instead of the REDUCE join hint. L'uso dell'hint REPLICATE causa la replica dei valori della colonna ProductKey (di join) della tabella FactInternetSales in tutti i nodi.Use of the REPLICATE hint causes the values in the ProductKey (joining) column from the FactInternetSales table to be replicated to all nodes. La tabella DimProduct viene unita alla versione replicata dei valori.The DimProduct table is joined to the replicated version of those values.

-- Uses AdventureWorks  
  
EXPLAIN SELECT SalesOrderNumber  
FROM  
   (SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
    FROM DimProduct AS dp   
      INNER REPLICATE JOIN FactInternetSales AS fis  
          ON dp.ProductKey = fis.ProductKey  
   ) AS dTable  
ORDER BY SalesOrderNumber;  

U.U. Uso dell'hint REDISTRIBUTE per garantire uno spostamento casuale per un join non compatibile di distribuzioneUsing the REDISTRIBUTE hint to guarantee a Shuffle move for a distribution incompatible join

La query seguente usa l'hint di query REDISTRIBUTE in un join non compatibile di distribuzione.The following query uses the REDISTRIBUTE query hint on a distribution incompatible join. In questo modo si garantisce che Query Optimizer userà uno spostamento casuale nel piano di query.This guarantees the query optimizer will use a Shuffle move in the query plan. Si garantisce anche che il piano di query non userà uno spostamento di trasmissione che sposta una tabella distribuita in una tabella replicata.This also guarantees the query plan will not use a Broadcast move which moves a distributed table to a replicated table.

Nell'esempio seguente l'hint REDISTRIBUTE impone uno spostamento casuale nella tabella FactInternetSales poiché ProductKey è la colonna di distribuzione di DimProduct e non è la colonna di distribuzione di FactInternetSales.In the following example, the REDISTRIBUTE hint forces a Shuffle move on the FactInternetSales table because ProductKey is the distribution column for DimProduct, and is not the distribution column for FactInternetSales.

-- Uses AdventureWorks  
  
EXPLAIN  
SELECT dp.ProductKey, fis.SalesOrderNumber, fis.TotalProductCost  
FROM DimProduct AS dp 
INNER REDISTRIBUTE JOIN FactInternetSales AS fis  
    ON dp.ProductKey = fis.ProductKey;  

V.V. Utilizzo di TABLESAMPLE per leggere i dati di un campione di righe in una tabellaUsing TABLESAMPLE to read data from a sample of rows in a table

Nell'esempio seguente viene utilizzata l'opzione TABLESAMPLE nella clausola FROM per restituire approssimativamente il 10 percento di tutte le righe della tabella Customer.The following example uses TABLESAMPLE in the FROM clause to return approximately 10 percent of all the rows in the Customer table.

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

Vedere ancheSee Also

CONTAINSTABLE (Transact-SQL) CONTAINSTABLE (Transact-SQL)
FREETEXTTABLE (Transact-SQL) FREETEXTTABLE (Transact-SQL)
INSERT (Transact-SQL) INSERT (Transact-SQL)
OPENQUERY (Transact-SQL) OPENQUERY (Transact-SQL)
OPENROWSET (Transact-SQL) OPENROWSET (Transact-SQL)
Operatori (Transact-SQL) Operators (Transact-SQL)
WHERE (Transact-SQL)WHERE (Transact-SQL)