UPDATE (Transact-SQL)UPDATE (Transact-SQL)

QUESTO ARGOMENTO SI APPLICA A: sìSQL Server (a partire dalla versione 2008)sìDatabase SQL di AzuresìAzure SQL Data Warehouse sìParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2008)yesAzure SQL DatabaseyesAzure SQL Data Warehouse yesParallel Data Warehouse

Modifica i dati esistenti in una tabella o vista in SQL Server 2017SQL Server 2017.Changes existing data in a table or view in SQL Server 2017SQL Server 2017. Per esempi, vedere esempi.For examples, see Examples.

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  

[ WITH <common_table_expression> [...n] ]  
UPDATE   
    [ TOP ( expression ) [ PERCENT ] ]   
    { { table_alias | <object> | rowset_function_limited   
         [ WITH ( <Table_Hint_Limited> [ ...n ] ) ]  
      }  
      | @table_variable      
    }  
    SET  
        { column_name = { expression | DEFAULT | NULL }  
          | { udt_column_name.{ { property_name = expression  
                                | field_name = expression }  
                                | method_name ( argument [ ,...n ] )  
                              }  
          }  
          | column_name { .WRITE ( expression , @Offset , @Length ) }  
          | @variable = expression  
          | @variable = column = expression  
          | column_name { += | -= | *= | /= | %= | &= | ^= | |= } expression  
          | @variable { += | -= | *= | /= | %= | &= | ^= | |= } expression  
          | @variable = column { += | -= | *= | /= | %= | &= | ^= | |= } expression  
        } [ ,...n ]   

    [ <OUTPUT Clause> ]  
    [ FROM{ <table_source> } [ ,...n ] ]   
    [ WHERE { <search_condition>   
            | { [ CURRENT OF   
                  { { [ GLOBAL ] cursor_name }   
                      | cursor_variable_name   
                  }   
                ]  
              }  
            }   
    ]   
    [ OPTION ( <query_hint> [ ,...n ] ) ]  
[ ; ]  

<object> ::=  
{   
    [ server_name . database_name . schema_name .   
    | database_name .[ schema_name ] .   
    | schema_name .  
    ]  
    table_or_view_name}  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  

UPDATE [ database_name . [ schema_name ] . | schema_name . ] table_name   
SET { column_name = { expression | NULL } } [ ,...n ]  
[ FROM from_clause ]  
[ WHERE <search_condition> ]   
[ OPTION ( LABEL = label_name ) ]  
[;]  

ArgomentiArguments

WITH <common_table_expression>WITH <common_table_expression>
Specifica una vista o un set di risultati denominato temporaneo, anche noto come espressione di tabella comune (CTE), definito nell'ambito di un'istruzione SELECT, INSERT, UPDATE o DELETE.Specifies the temporary named result set or view, also known as common table expression (CTE), defined within the scope of the UPDATE statement. Il set di risultati di espressione di tabella comune è derivato da una query semplice e vi viene fatto riferimento dall'istruzione UPDATE.The CTE result set is derived from a simple query and is referenced by UPDATE statement.

Le espressioni di tabella comune possono essere utilizzate anche con le istruzioni SELECT, INSERT, DELETE e CREATE VIEW.Common table expressions can also be used with the SELECT, INSERT, DELETE, and CREATE VIEW statements. Per ulteriori informazioni, vedere con common_table_expression ( Transact-SQL ) .For more information, see WITH common_table_expression (Transact-SQL).

INIZIO ( espressione * * *)* [percentuale]TOP ( expression) [ PERCENT ]
Specifica il numero o la percentuale di righe che vengono aggiornate.Specifies the number or percent of rows that are updated. Il valore diexpression può essere specificato come numero o come percentuale di righe.expression can be either a number or a percent of the rows.

Le righe a cui viene fatto riferimento nell'espressione TOP utilizzata con INSERT, UPDATE o DELETE non sono disposte in alcun ordine.The rows referenced in the TOP expression used with INSERT, UPDATE, or DELETE are not arranged in any order.

Le parentesi che delimitano espressione nell'espressione TOP sono necessarie nelle istruzioni INSERT, UPDATE e DELETE.Parentheses delimiting expression in TOP are required in INSERT, UPDATE, and DELETE statements. Per ulteriori informazioni, vedere torna all'inizio ( Transact-SQL ) .For more information, see TOP (Transact-SQL).

table_aliastable_alias
Alias specificato nella clausola FROM che rappresenta la tabella o la vista da cui vengono aggiornate le righe.The alias specified in the FROM clause representing the table or view from which the rows are to be updated.

server_nameserver_name
È il nome del server (nome di un server collegato o OPENDATASOURCE funzione come nome del server) in cui è contenuta la tabella o vista.Is the name of the server (using a linked server name or the OPENDATASOURCE function as the server name) on which the table or view is located. Se nome_server è specificato, database_name e schema_name sono necessari.If server_name is specified, database_name and schema_name are required.

database_namedatabase_name
Nome del database.Is the name of the database.

schema_nameschema_name
Nome dello schema a cui appartiene la tabella o la vista.Is the name of the schema to which the table or view belongs.

view_name table_ortable_or view_name
Nome della tabella o della vista da cui devono essere aggiornate le righe.Is the name of the table or view from which the rows are to be updated. La vista a cui fa riferimento table_or_view_name deve essere aggiornabile e fare riferimento esattamente a una tabella di base nella clausola FROM della vista.The view referenced by table_or_view_name must be updatable and reference exactly one base table in the FROM clause of the view. Per ulteriori informazioni sulle viste aggiornabili, vedere CREATE VIEW ( Transact-SQL ) .For more information about updatable views, see CREATE VIEW (Transact-SQL).

rowset_function_limitedrowset_function_limited
È il OPENQUERY o OPENROWSET funzione, soggetto alle funzionalità del provider.Is either the OPENQUERY or OPENROWSET function, subject to provider capabilities.

CON ( <Table_Hint_Limited > )WITH ( <Table_Hint_Limited> )
Specifica uno o più hint di tabella consentiti per una tabella di destinazione.Specifies one or more table hints that are allowed for a target table. La parola chiave WITH e le parentesi sono obbligatorie.The WITH keyword and the parentheses are required. Le opzioni NOLOCK e READUNCOMMITTED non sono consentite.NOLOCK and READUNCOMMITTED are not allowed. Per informazioni sugli hint di tabella, vedere hint di tabella ( Transact-SQL ) .For information about table hints, see Table Hints (Transact-SQL).

@table_variable@table_variable
Specifica un tabella variabile come origine di tabella.Specifies a table variable as a table source.

SETSET
Indica l'elenco dei nomi di colonna o di variabile da aggiornare.Specifies the list of column or variable names to be updated.

column_namecolumn_name
È una colonna contenente i dati da modificare.Is a column that contains the data to be changed. column_name deve essere presente in table_or view_name.column_name must exist in table_or view_name. Non è possibile aggiornare le colonne Identity.Identity columns cannot be updated.

espressioneexpression
Variabile, valore letterale, espressione o istruzione sub-SELECT racchiusa tra parentesi che restituisce un valore singolo.Is a variable, literal value, expression, or a subselect statement (enclosed with parentheses) that returns a single value. Il valore restituito da espressione sostituisce il valore esistente in column_name o @variable .The value returned by expression replaces the existing value in column_name or @variable.

Nota

Quando si fa riferimento a tipi di dati carattere Unicode nchar, nvarchar, e ntext, 'expression' deve essere preceduto dalla lettera maiuscola ' N' '.When referencing the Unicode character data types nchar, nvarchar, and ntext, 'expression' should be prefixed with the capital letter 'N'. Se la lettera "N" non è specificata, in SQL ServerSQL Server la stringa viene convertita in base alla tabella codici corrispondente alle regole di confronto predefinite del database o della colonna.If 'N' is not specified, SQL ServerSQL Server converts the string to the code page that corresponds to the default collation of the database or column. Tutti i caratteri non trovati nella tabella codici vengono persi.Any characters not found in this code page are lost.

DEFAULTDEFAULT
Specifica che il valore predefinito impostato per la colonna deve sostituire il valore esistente all'interno della colonna.Specifies that the default value defined for the column is to replace the existing value in the column. Questo argomento consente inoltre di modificare il valore della colonna in NULL se la colonna non dispone di un valore predefinito e ammette valori Null.This can also be used to change the column to NULL if the column has no default and is defined to allow null values.

{ += | -= | *= | /= | %= | &= | ^= | |= }{ += | -= | *= | /= | %= | &= | ^= | |= }
Operatore di assegnazione composto:Compound assignment operator:
+= Aggiunta e assegnazione+= Add and assign
-= Sottrazione e assegnazione-= Subtract and assign
*= Moltiplicazione e assegnazione*= Multiply and assign
/ = Divisione e assegnazione/= Divide and assign
% = Applicazione del coefficiente e assegnazione%= Modulo and assign
& = AND bit per bit e assegnazione&= Bitwise AND and assign
^ = XOR bit per bit e assegnazione^= Bitwise XOR and assign
| = OR bit per bit e assegnazione|= Bitwise OR and assign

udt_column_nameudt_column_name
Colonna definita dall'utente.Is a user-defined type column.

property_name | field_nameproperty_name | field_name
Proprietà pubblica o membro pubblico di dati di un tipo definito dall'utente.Is a public property or public data member of a user-defined type.

nome_metodo ( argomento [ ,... n] )method_name ( argument [ ,... n] )
È un metodo mutatore pubblico non static di udt_column_name che accetta uno o più argomenti.Is a nonstatic public mutator method of udt_column_name that takes one or more arguments.

. Scrivere (espressione,@Offset,@Length).WRITE (expression,@Offset,@Length)
Specifica che una sezione del valore di column_name deve essere modificato.Specifies that a section of the value of column_name is to be modified. espressione sostituisce @Length unità a partire da @Offset di column_name.expression replaces @Length units starting from @Offset of column_name. Solo le colonne di varchar (max), nvarchar (max), o varbinary (max) possono essere specificate con questa clausola.Only columns of varchar(max), nvarchar(max), or varbinary(max) can be specified with this clause. column_name non può essere NULL e non può essere qualificato con un nome di tabella o un alias di tabella.column_name cannot be NULL and cannot be qualified with a table name or table alias.

espressione è il valore copiato in column_name.expression is the value that is copied to column_name. espressione deve restituire o essere in grado di eseguire il cast implicito per il column_name tipo.expression must evaluate to or be able to be implicitly cast to the column_name type. Se espressione è impostato su NULL, @Length viene ignorato e il valore in column_name viene troncato in corrispondenza @Offset .If expression is set to NULL, @Length is ignored, and the value in column_name is truncated at the specified @Offset.

@Offsetè il punto di partenza nel valore di column_name in corrispondenza del quale espressione viene scritto.@Offset is the starting point in the value of column_name at which expression is written. @Offsetè una posizione ordinale in base zero, è bigint, e non può essere un numero negativo.@Offset is a zero-based ordinal position, is bigint, and cannot be a negative number. Se @Offset è NULL, l'operazione di aggiornamento Accoda espressione alla fine dell'oggetto esistente column_name valore e @Length viene ignorato.If @Offset is NULL, the update operation appends expression at the end of the existing column_name value and @Length is ignored. Se @Offset è maggiore della lunghezza del column_name valore, il Motore di databaseDatabase Engine restituisce un errore.If @Offset is greater than the length of the column_name value, the Motore di databaseDatabase Engine returns an error. Se @Offset più @Length supera la fine del valore sottostante nella colonna, l'eliminazione viene eseguita fino all'ultimo carattere del valore.If @Offset plus @Length exceeds the end of the underlying value in the column, the deletion occurs up to the last character of the value. Se @Offset più LEN (espressione) è maggiore di sottostante dimensioni dichiarate, viene generato un errore.If @Offset plus LEN(expression) is greater than the underlying declared size, an error is raised.

@Lengthè la lunghezza della sezione nella colonna, a partire da @Offset , che viene sostituito da espressione.@Length is the length of the section in the column, starting from @Offset, that is replaced by expression. @Lengthè bigint e non può essere un numero negativo.@Length is bigint and cannot be a negative number. Se @Length è NULL, l'operazione di aggiornamento rimuove tutti i dati da @Offset alla fine del column_name valore.If @Length is NULL, the update operation removes all data from @Offset to the end of the column_name value.

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

@variabile@ variable
È una variabile dichiarata impostata sul valore restituito da espressione.Is a declared variable that is set to the value returned by expression.

IMPOSTARE @ * variabile* = colonna = espressione imposta la variabile sullo stesso valore della colonna.SET **@variable = column = expression sets the variable to the same value as the column. Questo comportamento è diverso dal SET @ * variabile* = colonna, colonna = espressione, che imposta il variabile in cui il valore precedente all'aggiornamento della colonna.This differs from SET **@variable = column, column = expression, which sets the variable to the pre-update value of the column.

<OUTPUT_Clause><OUTPUT_Clause>
Restituisce dati aggiornati o espressioni basate su di essi come parte dell'operazione UPDATE.Returns updated data or expressions based on it as part of the UPDATE operation. La clausola OUTPUT non è supportata in alcuna istruzione DML applicata a tabelle o viste remote.The OUTPUT clause is not supported in any DML statements that target remote tables or views. Per ulteriori informazioni, vedere clausola OUTPUT ( Transact-SQL ) .For more information, see OUTPUT Clause (Transact-SQL).

DA <table_source >FROM <table_source>
Specifica che una tabella, vista o origine di tabella derivata viene utilizzata per fornire i criteri per l'operazione di aggiornamento.Specifies that a table, view, or derived table source is used to provide the criteria for the update operation. Per altre informazioni, vedere FROM (Transact-SQL).For more information, see FROM (Transact-SQL).

Se l'oggetto da aggiornare coincide con l'oggetto specificato nella clausola FROM e la clausola FROM include un solo riferimento all'oggetto, non è necessario specificare un alias di oggetto.If the object being updated is the same as the object in the FROM clause and there is only one reference to the object in the FROM clause, an object alias may or may not be specified. Se l'oggetto da aggiornare è specificato più di una volta nella clausola FROM, un solo riferimento all'oggetto non deve specificare un alias della tabella.If the object being updated appears more than one time in the FROM clause, one, and only one, reference to the object must not specify a table alias. Tutti gli altri riferimenti all'oggetto nella clausola FROM devono includere un alias dell'oggetto.All other references to the object in the FROM clause must include an object alias.

Una vista in cui è incluso un trigger INSTEAD OF UPDATE non può essere la destinazione di un'istruzione UPDATE in cui è specificata la clausola FROM.A view with an INSTEAD OF UPDATE trigger cannot be a target of an UPDATE with a FROM clause.

Nota

Qualsiasi chiamata a OPENDATASOURCE, OPENQUERY o OPENROWSET nella clausola FROM viene valutata separatamente e indipendentemente da qualsiasi altra chiamata a queste funzioni utilizzate come destinazione dell'aggiornamento, anche se alle due chiamate vengono forniti argomenti identici.Any call to OPENDATASOURCE, OPENQUERY, or OPENROWSET in the FROM clause is evaluated separately and independently from any call to these functions used as the target of the update, even if identical arguments are supplied to the two calls. In particolare, le condizioni di filtro o join applicate al risultato di una di tali chiamate non hanno effetto sui risultati dell'altra.In particular, filter or join conditions applied on the result of one of those calls have no effect on the results of the other.

WHEREWHERE
Vengono specificate le condizioni che consentono di limitare le righe da aggiornare.Specifies the conditions that limit the rows that are updated. Sono disponibili due tipi di aggiornamento basati sul tipo di clausola WHERE:There are two forms of update based on which form of the WHERE clause is used:

  • Gli aggiornamenti con ricerca specificano una condizione di ricerca che qualifica le righe da eliminare.Searched updates specify a search condition to qualify the rows to delete.

  • Gli aggiornamenti posizionati utilizzano la clausola CURRENT OF per specificare un cursore.Positioned updates use the CURRENT OF clause to specify a cursor. L'operazione di aggiornamento viene in questo caso eseguita nella posizione corrente del cursore.The update operation occurs at the current position of the cursor.

<search_condition><search_condition>
Specifica la condizione che le righe da aggiornare devono soddisfare.Specifies the condition to be met for the rows to be updated. La condizione di ricerca può inoltre essere rappresentata dalla condizione per un join.The search condition can also be the condition upon which a join is based. Non sono previsti limiti per il numero di predicati che è possibile includere in una condizione di ricerca.There is no limit to the number of predicates that can be included in a search condition. Per ulteriori informazioni sui predicati e condizioni di ricerca, vedere condizione di ricerca ( Transact-SQL ) .For more information about predicates and search conditions, see Search Condition (Transact-SQL).

CURRENT OFCURRENT OF
Specifica che l'aggiornamento viene eseguito nella posizione corrente del cursore specificato.Specifies that the update is performed at the current position of the specified cursor.

Se si esegue un aggiornamento posizionato tramite la clausola WHERE CURRENT OF, viene aggiornata la riga singola che corrisponde alla posizione corrente del cursore.A positioned update using a WHERE CURRENT OF clause updates the single row at the current position of the cursor. Può trattarsi di un aggiornamento con ricerca che utilizza una clausola WHERE più accurata <search_condition > clausola che qualifica le righe da aggiornare.This can be more accurate than a searched update that uses a WHERE <search_condition> clause to qualify the rows to be updated. Un aggiornamento con ricerca modifica più righe se le condizioni di ricerca non identificano una singola riga in modo univoco.A searched update modifies multiple rows when the search condition does not uniquely identify a single row.

GLOBALGLOBAL
Specifica che cursor_name fa riferimento a un cursore globale.Specifies that cursor_name refers to a global cursor.

cursor_namecursor_name
Nome del cursore aperto dal quale deve essere eseguita l'operazione di recupero.Is the name of the open cursor from which the fetch should be made. Se entrambe globale e un cursore locale con il nome cursor_name esiste, questo argomento fa riferimento il cursore globale se globale è specificata; in caso contrario, fa riferimento al cursore locale.If both a global and a local cursor with the name cursor_name exist, this argument refers to the global cursor if GLOBAL is specified; otherwise, it refers to the local cursor. Il cursore deve consentire operazioni di aggiornamento.The cursor must allow updates.

cursor_variable_namecursor_variable_name
Nome di una variabile di cursore.Is the name of a cursor variable. cursor_variable_name deve fare riferimento a un cursore che consente gli aggiornamenti.cursor_variable_name must reference a cursor that allows updates.

OPZIONE ( <query_hint > [ ,... n ] )OPTION ( <query_hint> [ ,... n ] )
Specifica che vengono utilizzati hint di ottimizzazione per personalizzare la modalità di elaborazione dell'istruzione nel Motore di databaseDatabase Engine.Specifies that optimizer hints are used to customize the way the Motore di databaseDatabase Engine processes the statement. Per altre informazioni, vedere Hint per la query (Transact-SQL).For more information, see Query Hints (Transact-SQL).

Procedure consigliateBest Practices

Utilizzo di @@ROWCOUNT inserito di funzione per restituire il numero di righe per l'applicazione client.Use the @@ROWCOUNT function to return the number of inserted rows to the client application. Per ulteriori informazioni, vedere @@ROWCOUNT ( Transact-SQL ) .For more information, see @@ROWCOUNT (Transact-SQL).

Nelle istruzioni UPDATE è possibile utilizzare nomi di variabili per indicare il valore da aggiornare e il valore in base a cui eseguire l'aggiornamento. I nomi di variabili, tuttavia, devono essere utilizzati solo quando l'istruzione UPDATE è relativa a un unico record.Variable names can be used in UPDATE statements to show the old and new values affected, but this should be used only when the UPDATE statement affects a single record. Se l'istruzione UPDATE interessa più record, per restituire i valori vecchi e nuovi per ogni record, utilizzare il clausola OUTPUT.If the UPDATE statement affects multiple records, to return the old and new values for each record, use the OUTPUT clause.

Prestare attenzione nello specificare la clausola FROM per fornire i criteri per l'operazione di aggiornamento.Use caution when specifying the FROM clause to provide the criteria for the update operation. I risultati di un'istruzione UPDATE sono indefiniti se l'istruzione include una clausola FROM non specificata in modo che sia disponibile un unico valore per ogni occorrenza di colonna che viene aggiornata, ovvero se l'istruzione UPDATE non è deterministica.The results of an UPDATE statement are undefined if the statement includes a FROM clause that is not specified in such a way that only one value is available for each column occurrence that is updated, that is if the UPDATE statement is not deterministic. Ad esempio, nell'istruzione UPDATE dello script riportato di seguito entrambe le righe in Table1 soddisfano le condizioni della clausola FROM nell'istruzione UPDATE, ma non viene specificato quale riga di Table1 viene utilizzata per aggiornare la riga in Table2.For example, in the UPDATE statement in the following script, both rows in Table1 meet the qualifications of the FROM clause in the UPDATE statement; but it is undefined which row from Table1 is used to update the row in Table2.

USE AdventureWorks2012;  
GO  
IF OBJECT_ID ('dbo.Table1', 'U') IS NOT NULL  
    DROP TABLE dbo.Table1;  
GO  
IF OBJECT_ID ('dbo.Table2', 'U') IS NOT NULL  
    DROP TABLE dbo.Table2;  
GO  
CREATE TABLE dbo.Table1   
    (ColA int NOT NULL, ColB decimal(10,3) NOT NULL);  
GO  
CREATE TABLE dbo.Table2   
    (ColA int PRIMARY KEY NOT NULL, ColB decimal(10,3) NOT NULL);  
GO  
INSERT INTO dbo.Table1 VALUES(1, 10.0), (1, 20.0);  
INSERT INTO dbo.Table2 VALUES(1, 0.0);  
GO  
UPDATE dbo.Table2   
SET dbo.Table2.ColB = dbo.Table2.ColB + dbo.Table1.ColB  
FROM dbo.Table2   
    INNER JOIN dbo.Table1   
    ON (dbo.Table2.ColA = dbo.Table1.ColA);  
GO  
SELECT ColA, ColB   
FROM dbo.Table2;  

Lo stesso problema può verificarsi quando si combinano le clausole FROM e WHERE CURRENT OF.The same problem can occur when the FROM and WHERE CURRENT OF clauses are combined. Nell'esempio seguente, entrambe le righe nella tabella Table2 soddisfano le condizioni della clausola FROM nell'istruzione UPDATE.In the following example, both rows in Table2 meet the qualifications of the FROM clause in the UPDATE statement. La riga di Table2 da utilizzare per l'aggiornamento della riga in Table1 non viene specificata.It is undefined which row from Table2 is to be used to update the row in Table1.

USE AdventureWorks2012;  
GO  
IF OBJECT_ID ('dbo.Table1', 'U') IS NOT NULL  
    DROP TABLE dbo.Table1;  
GO  
IF OBJECT_ID ('dbo.Table2', 'U') IS NOT NULL  
    DROP TABLE dbo.Table2;  
GO  
CREATE TABLE dbo.Table1  
    (c1 int PRIMARY KEY NOT NULL, c2 int NOT NULL);  
GO  
CREATE TABLE dbo.Table2  
    (d1 int PRIMARY KEY NOT NULL, d2 int NOT NULL);  
GO  
INSERT INTO dbo.Table1 VALUES (1, 10);  
INSERT INTO dbo.Table2 VALUES (1, 20), (2, 30);  
GO  
DECLARE abc CURSOR LOCAL FOR  
    SELECT c1, c2   
    FROM dbo.Table1;  
OPEN abc;  
FETCH abc;  
UPDATE dbo.Table1   
SET c2 = c2 + d2   
FROM dbo.Table2   
WHERE CURRENT OF abc;  
GO  
SELECT c1, c2 FROM dbo.Table1;  
GO  

Informazioni sulla compatibilitàCompatibility Support

In una versione futura di SQL ServerSQL Server verrà rimosso il supporto per l'utilizzo degli hint READUNCOMMITTED e NOLOCK nella clausola FROM per la tabella di destinazione di un'istruzione UPDATE o DELETE.Support for use of the READUNCOMMITTED and NOLOCK hints in the FROM clause that apply to the target table of an UPDATE or DELETE statement will be removed in a future version of SQL ServerSQL Server. Evitare di usare questi hint in questo contesto nei nuovi progetti di sviluppo e pianificare la modifica delle applicazioni in cui sono attualmente usati.Avoid using these hints in this context in new development work, and plan to modify applications that currently use them.

Tipi di datiData Types

Tutti char e nchar colonne vengono aggiunti a destra per la lunghezza definita.All char and nchar columns are right-padded to the defined length.

Se l'opzione ANSI_PADDING è impostata su OFF, tutti gli spazi finali vengono rimossi dai dati inseriti varchar e nvarchar colonne, tranne che in stringhe che contengono solo spazi.If ANSI_PADDING is set to OFF, all trailing spaces are removed from data inserted into varchar and nvarchar columns, except in strings that contain only spaces. le quali vengono troncate come stringhe vuote.These strings are truncated to an empty string. Se l'opzione ANSI_PADDING è impostata su ON, vengono inseriti spazi finali.If ANSI_PADDING is set to ON, trailing spaces are inserted. Il driver ODBC di Microsoft SQL Server e il provider OLE DB per SQL Server impostano automaticamente l'opzione ANSI_PADDING su ON per ogni connessione.The Microsoft SQL Server ODBC driver and OLE DB Provider for SQL Server automatically set ANSI_PADDING ON for each connection. Questa opzione può essere configurata in origini dati ODBC oppure impostando gli attributi o le proprietà della connessione.This can be configured in ODBC data sources or by setting connection attributes or properties. Per altre informazioni, vedere SET ANSI_PADDING (Transact-SQL).For more information, see SET ANSI_PADDING (Transact-SQL).

Aggiornamento di colonne text, ntext e imageUpdating text, ntext, and image Columns

Modifica di un testo, ntext, o immagine colonna con l'aggiornamento consente di inizializzare la colonna, assegna un puntatore di testo valido e consente di allocare almeno una pagina di dati, a meno che non la colonna venga aggiornata con NULL.Modifying a text, ntext, or image column with UPDATE initializes the column, assigns a valid text pointer to it, and allocates at least one data page, unless the column is being updated with NULL.

Per sostituire o modificare grandi blocchi di testo, ntext, o immagine dei dati, utilizzare WRITETEXT o UPDATETEXT anziché l'istruzione UPDATE.To replace or modify large blocks of text, ntext, or image data, use WRITETEXT or UPDATETEXT instead of the UPDATE statement.

Se l'istruzione UPDATE modifica più righe durante l'aggiornamento sia la chiave di clustering e uno o più testo, ntext, o immagine colonne, l'aggiornamento parziale di Queste colonne viene eseguito come sostituzione completa dei valori.If the UPDATE statement could change more than one row while updating both the clustering key and one or more text, ntext, or image columns, the partial update to these columns is executed as a full replacement of the values.

Importante

Il ntext, testo, e immagine tipi di dati verranno rimossa in una versione futura di MicrosoftMicrosoft SQL ServerSQL Server.The ntext, text, and image data types will be removed in a future version of MicrosoftMicrosoft SQL ServerSQL Server. Evitare di utilizzare questi tipi di dati in un nuovo progetto di sviluppo e prevedere interventi di modifica nelle applicazioni che attualmente li utilizzano.Avoid using these data types in new development work, and plan to modify applications that currently use them. Usare in alternativa nvarchar(max), varchar(max)e varbinary(max) .Use nvarchar(max), varchar(max), and varbinary(max) instead.

Aggiornamento dei tipi di dati per valori di grandi dimensioniUpdating Large Value Data Types

Utilizzare il . SCRIVERE (espressione * * *,* @Offset,@Length) clausola per eseguire un aggiornamento parziale o completo di varchar (max), nvarchar (max), e varbinary (max) tipi di dati.Use the .WRITE (expression, @Offset,@Length) clause to perform a partial or full update of varchar(max), nvarchar(max), and varbinary(max) data types. Ad esempio, un aggiornamento parziale di un varchar (max) colonna potrebbe eliminare o modificare solo i primi 200 caratteri della colonna, mentre un aggiornamento completo Elimina o modifica di tutti i dati nella colonna.For example, a partial update of a varchar(max) column might delete or modify only the first 200 characters of the column, whereas a full update would delete or modify all the data in the column. . Scrivere gli aggiornamenti che inseriscono o accodano nuovi dati vengono registrati tramite registrazione se il modello di recupero del database è impostato su bulk oppure su registrazione minima..WRITE updates that insert or append new data are minimally logged if the database recovery model is set to bulk-logged or simple. La registrazione minima non viene utilizzata in caso di aggiornamento di valori esistenti.Minimal logging is not used when existing values are updated. Per altre informazioni, vedere Log delle transazioni (SQL Server).For more information, see The Transaction Log (SQL Server).

In Motore di databaseDatabase Engine un aggiornamento parziale viene convertito in aggiornamento completo quando l'istruzione UPDATE provoca una di queste azioni:The Motore di databaseDatabase Engine converts a partial update to a full update when the UPDATE statement causes either of these actions:

  • modifica una colonna chiave della vista o tabella partizionataChanges a key column of the partitioned view or table.
  • modifica più di una riga e allo stesso tempo aggiorna la chiave di un indice cluster non univoco ad un valore non costante.Modifies more than one row and also updates the key of a nonunique clustered index to a nonconstant value.

Non è possibile utilizzare il . Clausola di scrittura per aggiornare una colonna NULL o impostare il valore di column_name su NULL.You cannot use the .WRITE clause to update a NULL column or set the value of column_name to NULL.

@Offsete @Length vengono specificate in byte per varbinary e varchar tipi di dati e in caratteri per il nvarchartipo di dati.@Offset and @Length are specified in bytes for varbinary and varchar data types and in characters for the nvarchar data type. Gli offset appropriati vengono calcolati per le regole di confronto DBCS (Double-Byte Character Set).The appropriate offsets are computed for double-byte character set (DBCS) collations.

Per prestazioni ottimali, è consigliabile inserire o aggiornare i dati in dimensioni di blocco multiple di 8040 byte.For best performance, we recommend that data be inserted or updated in chunk sizes that are multiples of 8040 bytes.

Se la colonna modificata dal . SCRIVERE clausola fa riferimento in una clausola OUTPUT, il valore completo della colonna, ovvero l'immagine precedente in eliminato. * * * column_name* o l'immagine successiva in *inserito. * * * column_name, viene restituito Nella colonna specificata nella variabile di tabella.If the column modified by the **.WRITE clause is referenced in an OUTPUT clause, the complete value of the column, either the before image in deleted.column_name or the after image in inserted.column_name, is returned to the specified column in the table variable. Vedere l'esempio che segue R.See example R that follows.

Per ottenere la stessa funzionalità di . WRITE con altri caratteri o i tipi di dati binari, utilizzare il STUFF ( Transact-SQL ) .To achieve the same functionality of .WRITE with other character or binary data types, use the STUFF (Transact-SQL).

Aggiornamento delle colonne di tipo definito dall'utenteUpdating User-defined Type Columns

L'aggiornamento dei valori nelle colonne di tipo definito dall'utente può essere eseguito in uno dei modi seguenti:Updating values in user-defined type columns can be accomplished in one of the following ways:

  • Specificando un valore in un tipo di dati di sistema SQL ServerSQL Server, a condizione che i tipi definiti dall'utente supportino la conversione implicita o esplicita da quel tipo.Supplying a value in a SQL ServerSQL Server system data type, as long as the user-defined type supports implicit or explicit conversion from that type. Nell'esempio seguente viene illustrato come aggiornare un valore in una colonna del tipo Point definito dall'utente, eseguendo la conversione esplicita da una stringa.The following example shows how to update a value in a column of user-defined type Point, by explicitly converting from a string.

    UPDATE Cities  
    SET Location = CONVERT(Point, '12.3:46.2')  
    WHERE Name = 'Anchorage';  
    
  • Richiamando un metodo, contrassegnato come mutatore, del tipo definito dall'utente, per eseguire l'aggiornamento.Invoking a method, marked as a mutator, of the user-defined type, to perform the update. Nell'esempio seguente viene richiamato un metodo mutatore di tipo Point denominato SetXY.The following example invokes a mutator method of type Point named SetXY. Viene aggiornato lo stato dell'istanza del tipo.This updates the state of the instance of the type.

    UPDATE Cities  
    SET Location.SetXY(23.5, 23.5)  
    WHERE Name = 'Anchorage';  
    

    Nota

    SQL ServerSQL Server restituisce un errore se viene richiamato un metodo mutatore in un valore Null Transact-SQLTransact-SQL oppure se un nuovo valore prodotto da un metodo mutatore è Null. returns an error if a mutator method is invoked on a Transact-SQLTransact-SQL null value, or if a new value produced by a mutator method is null.

  • Modificando il valore di una proprietà registrata o di un membro pubblico di dati del tipo definito dall'utente.Modifying the value of a registered property or public data member of the user-defined type. È necessario che l'espressione che fornisce il valore possa essere convertita in modo implicito nel tipo della proprietà.The expression supplying the value must be implicitly convertible to the type of the property. Nell'esempio seguente viene modificato il valore di proprietà X del tipo definito dall'utente Point.The following example modifies the value of property X of user-defined type Point.

    UPDATE Cities  
    SET Location.X = 23.5  
    WHERE Name = 'Anchorage';  
    

    Per modificare proprietà diverse della stessa colonna di tipo definito dall'utente, eseguire più istruzioni UPDATE o richiamare un metodo mutatore del tipo.To modify different properties of the same user-defined type column, issue multiple UPDATE statements, or invoke a mutator method of the type.

Aggiornamento di dati FILESTREAMUpdating FILESTREAM Data

È possibile utilizzare l'istruzione UPDATE per aggiornare un campo FILESTREAM a un valore Null, a un valore vuoto o a una quantità di dati inline relativamente piccola.You can use the UPDATE statement to update a FILESTREAM field to a null value, empty value, or a relatively small amount of inline data. Tuttavia, una grande quantità di dati viene trasmessa in modo più efficace in un file mediante l'utilizzo di interfacce Win32.However, a large amount of data is more efficiently streamed into a file by using Win32 interfaces. Quando si aggiorna un campo FILESTREAM, si modificano i dati BLOB sottostanti nel file system.When you update a FILESTREAM field, you modify the underlying BLOB data in the file system. Quando un campo FILESTREAM viene impostato su NULL, i dati BLOB associati al campo vengono eliminati.When a FILESTREAM field is set to NULL, the BLOB data associated with the field is deleted. Non è possibile utilizzare. Write () per eseguire aggiornamenti parziali a dati FILESTREAM.You cannot use .WRITE(), to perform partial updates to FILESTREAM data. Per altre informazioni, vedere FILESTREAM (SQL Server).For more information, see FILESTREAM (SQL Server).

Gestione degli erroriError Handling

Se un'operazione di aggiornamento in una riga non rispetta un vincolo o una regola, viola l'impostazione NULL per la colonna oppure il nuovo valore è un tipo di dati incompatibile, l'istruzione viene annullata, viene restituito un errore e non viene aggiornato alcun record.If an update to a row violates a constraint or rule, violates the NULL setting for the column, or the new value is an incompatible data type, the statement is canceled, an error is returned, and no records are updated.

Quando un'istruzione UPDATE rileva un errore aritmetico (un errore di overflow, una divisione per zero o un errore di dominio) durante la valutazione di un'espressione, l'aggiornamento non viene eseguito.When an UPDATE statement encounters an arithmetic error (overflow, divide by zero, or a domain error) during expression evaluation, the update is not performed. La parte rimanente del batch non viene eseguita e viene visualizzato un messaggio di errore.The rest of the batch is not executed, and an error message is returned.

Se dopo un aggiornamento a una o più colonne che fanno parte di un indice cluster le dimensioni dell'indice cluster e della riga superano gli 8.060 byte, l'aggiornamento non viene eseguito correttamente e viene restituito un messaggio di errore.If an update to a column or columns participating in a clustered index causes the size of the clustered index and the row to exceed 8,060 bytes, the update fails and an error message is returned.

InteroperabilitàInteroperability

Le istruzioni UPDATE sono consentite all'interno delle funzioni definite dall'utente solo se la tabella da modificare è una variabile di tabella.UPDATE statements are allowed in the body of user-defined functions only if the table being modified is a table variable.

Quando viene definito un trigger INSTEAD OF in azioni UPDATE eseguite su una tabella, viene eseguito il trigger anziché l'istruzione UPDATE.When an INSTEAD OF trigger is defined on UPDATE actions against a table, the trigger is running instead of the UPDATE statement. Nelle versioni precedenti di SQL ServerSQL Server sono supportati solo i trigger AFTER definiti in UPDATE e altre istruzioni di modifica dei dati.Earlier versions of SQL ServerSQL Server only support AFTER triggers defined on UPDATE and other data modification statements. La clausola FROM non può essere specificata in un'istruzione UPDATE in cui si fa riferimento diretto o indiretto a una vista in cui è definito un trigger INSTEAD OF.The FROM clause cannot be specified in an UPDATE statement that references, either directly or indirectly, a view with an INSTEAD OF trigger defined on it. Per ulteriori informazioni sui trigger INSTEAD OF, vedere CREATE TRIGGER ( Transact-SQL ) .For more information about INSTEAD OF triggers, see CREATE TRIGGER (Transact-SQL).

Limitazioni e restrizioniLimitations and Restrictions

La clausola FROM non può essere specificata in un'istruzione UPDATE in cui si fa riferimento diretto o indiretto a una vista in cui è definito un trigger INSTEAD OF.The FROM clause cannot be specified in an UPDATE statement that references, either directly or indirectly, a view that has an INSTEAD OF trigger defined on it. Per ulteriori informazioni sui trigger INSTEAD OF, vedere CREATE TRIGGER ( Transact-SQL ) .For more information about INSTEAD OF triggers, see CREATE TRIGGER (Transact-SQL).

Quando un'espressione di tabella comune (CTE) è la destinazione di un'istruzione UPDATE, tutti i riferimenti a tale espressione nell'istruzione devono corrispondere.When a common table expression (CTE) is the target of an UPDATE statement, all references to the CTE in the statement must match. Se, ad esempio, alla CTE è assegnato un alias nella clausola FROM, l'alias deve essere utilizzato per tutti gli altri riferimenti alla CTE.For example, if the CTE is assigned an alias in the FROM clause, the alias must be used for all other references to the CTE. Sono necessari riferimenti CTE non ambigui perché una CTE non dispone di un ID oggetto utilizzato da SQL ServerSQL Server per riconoscere la relazione implicita tra l'oggetto e il relativo alias.Unambiguous CTE references are required because a CTE does not have an object ID, which SQL ServerSQL Server uses to recognize the implicit relationship between an object and its alias. Senza questa relazione è possibile che il piano di query produca un comportamento del join e risultati della query imprevisti.Without this relationship, the query plan may produce unexpected join behavior and unintended query results. Negli esempi seguenti vengono illustrati i metodi corretti ed errati della definizione di una CTE quando questa è l'oggetto di destinazione dell'operazione di aggiornamento.The following examples demonstrate correct and incorrect methods of specifying a CTE when the CTE is the target object of the update operation.

USE tempdb;  
GO  
-- UPDATE statement with CTE references that are correctly matched.  
DECLARE @x TABLE (ID int, Value int);  
DECLARE @y TABLE (ID int, Value int);  
INSERT @x VALUES (1, 10), (2, 20);  
INSERT @y VALUES (1, 100),(2, 200);  

WITH cte AS (SELECT * FROM @x)  
UPDATE x -- cte is referenced by the alias.  
SET Value = y.Value  
FROM cte AS x  -- cte is assigned an alias.  
INNER JOIN @y AS y ON y.ID = x.ID;  
SELECT * FROM @x;  
GO  

Set di risultati:Here is the result set.

ID     Value  
------ -----  
1      100  
2      200  
(2 row(s) affected)  

Istruzione UPDATE con riferimenti CTE corrispondente in modo non corretto.UPDATE statement with CTE references that are incorrectly matched.

USE tempdb;  
GO  
DECLARE @x TABLE (ID int, Value int);  
DECLARE @y TABLE (ID int, Value int);  
INSERT @x VALUES (1, 10), (2, 20);  
INSERT @y VALUES (1, 100),(2, 200);  

WITH cte AS (SELECT * FROM @x)  
UPDATE cte   -- cte is not referenced by the alias.  
SET Value = y.Value  
FROM cte AS x  -- cte is assigned an alias.  
INNER JOIN @y AS y ON y.ID = x.ID;   
SELECT * FROM @x;   
GO  

Set di risultati:Here is the result set.

ID     Value  
------ -----  
1      100  
2      100  
(2 row(s) affected)  

Comportamento di bloccoLocking Behavior

Un'istruzione UPDATE acquisisce sempre un blocco esclusivo (X) sulla tabella che modifica e mantiene tale blocco fino al completamento della transazione.An UPDATE statement always acquires an exclusive (X) lock on the table it modifies, and holds that lock until the transaction completes. Con un blocco esclusivo, nessuna altra transazione può modificare dati.With an exclusive lock, no other transactions can modify data. È possibile specificare hint di tabella per eseguire l'override di questo comportamento predefinito per la durata dell'istruzione UPDATE specificando un altro metodo di blocco. Gli hint dovrebbero comunque essere utilizzati solo se strettamente necessario ed esclusivamente da sviluppatori e amministratori di database esperti.You can specify table hints to override this default behavior for the duration of the UPDATE statement by specifying another locking method, however, we recommend that hints be used only as a last resort by experienced developers and database administrators. Per altre informazioni, vedere Hint di tabella (Transact-SQL).For more information, see Table Hints (Transact-SQL).

Comportamento di registrazioneLogging Behavior

L'istruzione UPDATE viene registrata. Tuttavia, per gli aggiornamenti parziali a tipi di dati di valori di grandi dimensioni tramite la . SCRIVERE la clausola con registrazione minima.The UPDATE statement is logged; however, partial updates to large value data types using the .WRITE clause are minimally logged. Per altre informazioni, vedere "Aggiornamento dei tipi di dati per valori di grandi dimensioni" nella sezione precedente "Tipi di dati".For more information, see "Updating Large Value Data Types" in the earlier section “Data Types”.

SicurezzaSecurity

AutorizzazioniPermissions

Le autorizzazioni UPDATE sono necessarie nella tabella di destinazione.UPDATE permissions are required on the target table. Le autorizzazioni SELECT sono necessari anche per la tabella da aggiornare se l'istruzione UPDATE include una clausola WHERE, oppure se espressione nel SET di clausola utilizza una colonna nella tabella.SELECT permissions are also required for the table being updated if the UPDATE statement contains a WHERE clause, or if expression in the SET clause uses a column in the table.

AGGIORNAMENTO delle autorizzazioni per impostazione predefinita ai membri del sysadmin ruolo predefinito del server, il db_owner e db_datawriter fissa ruoli del database e il proprietario della tabella.UPDATE permissions default to members of the sysadmin fixed server role, the db_owner and db_datawriter fixed database roles, and the table owner. I membri del sysadmin, db_owner, e db_securityadmin ruoli e il proprietario della tabella possono trasferire autorizzazioni ad altri utenti.Members of the sysadmin, db_owner, and db_securityadmin roles, and the table owner can transfer permissions to other users.

EsempiExamples

CategoryCategory Elementi di sintassi inclusiFeatured syntax elements
Sintassi di baseBasic Syntax UPDATEUPDATE
Limitazione delle righe aggiornateLimiting the Rows that Are Updated WHERE • TOP • espressione di tabella comune WITH • WHERE CURRENT OFWHERE • TOP • WITH common table expression • WHERE CURRENT OF
Impostazione dei valori di colonnaSetting Column Values valori calcolati • operatori composti • valori predefiniti • sottoquerycomputed values • compound operators • default values • subqueries
Specifica di oggetti di destinazione diversi dalle tabelle StandardSpecifying Target Objects Other than Standard Tables viste • variabili di tabella • alias di tabellaviews • table variables • table aliases
L'aggiornamento dei dati in base ai dati da altre tabelleUpdating Data Based on Data From Other Tables FROMFROM
L'aggiornamento delle righe in una tabella remotaUpdating Rows in a Remote Table server collegato • OPENQUERY • OPENDATASOURCElinked server • OPENQUERY • OPENDATASOURCE
Aggiornamento di tipi di dati LOBUpdating Large Object Data Types . WRITE • OPENROWSET.WRITE • OPENROWSET
Aggiornamento di tipi definiti dall'utenteUpdating User-defined Types tipi definiti dall'utenteuser-defined types
Override del comportamento predefinito di Query Optimizer tramite hintOverriding the Default Behavior of the Query Optimizer by Using Hints hint di tabella • hint per la querytable hints • query hints
Acquisizione dei risultati dell'istruzione UPDATECapturing the Results of the UPDATE Statement Clausola OUTPUTOUTPUT clause
Utilizzo di UPDATE in altre istruzioniUsing UPDATE in Other Statements Stored procedure • TRY…CATCHStored Procedures • TRY…CATCH

Sintassi di baseBasic Syntax

Negli esempi contenuti in questa sezione vengono illustrate le funzionalità di base dell'istruzione UPDATE tramite la sintassi minima richiesta.Examples in this section demonstrate the basic functionality of the UPDATE statement using the minimum required syntax.

A.A. Esecuzione di un'istruzione UPDATE sempliceUsing a simple UPDATE statement

Nell'esempio seguente viene aggiornata una singola colonna per tutte le righe della tabella Person.Address.The following example updates a single column for all rows in the Person.Address table.

USE AdventureWorks2012;  
GO  
UPDATE Person.Address  
SET ModifiedDate = GETDATE();  

B.B. Aggiornamento di più colonneUpdating multiple columns

Nell'esempio seguente vengono aggiornati i valori nelle colonne Bonus, CommissionPct e SalesQuota per tutte le righe nella tabella SalesPerson.The following example updates the values in the Bonus, CommissionPct, and SalesQuota columns for all rows in the SalesPerson table.

USE AdventureWorks2012;  
GO  
UPDATE Sales.SalesPerson  
SET Bonus = 6000, CommissionPct = .10, SalesQuota = NULL;  
GO  

Limitazione delle righe aggiornateLimiting the Rows that Are Updated

Negli esempi contenuti in questa sezione vengono illustrati i modi che è possibile utilizzare per limitare il numero di righe interessate dall'istruzione UPDATE.Examples in this section demonstrate ways that you can use to limit the number of rows affected by the UPDATE statement.

C.C. Utilizzo della clausola WHEREUsing the WHERE clause

Nell'esempio seguente viene utilizzata la clausola WHERE per specificare le righe da aggiornare.The following example uses the WHERE clause to specify which rows to update. L'istruzione aggiorna il valore nella colonna Color della tabella Production.Product per tutte le righe che contengono un valore "Red" esistente nella colonna Color e un valore nella colonna Name che inizia con "Road-250".The statement updates the value in the Color column of the Production.Product table for all rows that have an existing value of 'Red' in the Color column and have a value in the Name column that starts with 'Road-250'.

USE AdventureWorks2012;  
GO  
UPDATE Production.Product  
SET Color = N'Metallic Red'  
WHERE Name LIKE N'Road-250%' AND Color = N'Red';  
GO  

D.D. Utilizzo della clausola TOPUsing the TOP clause

Negli esempi seguenti viene utilizzata la clausola TOP per limitare il numero di righe modificate in un'istruzione UPDATE.The following examples use the TOP clause to limit the number of rows that are modified in an UPDATE statement. Quando TOP (n) clausola viene utilizzata con l'aggiornamento, l'operazione di aggiornamento viene eseguita su una selezione casuale di 'n' numero di righe.When a TOP (n) clause is used with UPDATE, the update operation is performed on a random selection of 'n' number of rows. Nell'esempio seguente viene aggiornata la colonna VacationHours del 25% per 10 righe casuali nella tabella Employee.The following example updates the VacationHours column by 25 percent for 10 random rows in the Employee table.

USE AdventureWorks2012;
GO
UPDATE TOP (10) HumanResources.Employee
SET VacationHours = VacationHours * 1.25 ;
GO  

Se è necessario utilizzare TOP per applicare gli aggiornamenti in un ordine cronologico significativo, è necessario utilizzare TOP insieme a ORDER BY in un'istruzione sub-SELECT.If you must use TOP to apply updates in a meaningful chronology, you must use TOP together with ORDER BY in a subselect statement. Nell'esempio seguente le ore di ferie dei 10 dipendenti vengono aggiornate con le prime date di assunzione.The following example updates the vacation hours of the 10 employees with the earliest hire dates.

UPDATE HumanResources.Employee  
SET VacationHours = VacationHours + 8  
FROM (SELECT TOP 10 BusinessEntityID FROM HumanResources.Employee  
     ORDER BY HireDate ASC) AS th  
WHERE HumanResources.Employee.BusinessEntityID = th.BusinessEntityID;  
GO  

E.E. Utilizzo della clausola WITH common_table_expressionUsing the WITH common_table_expression clause

Nell'esempio seguente viene aggiornato il valore PerAssemnblyQty per tutte le parti e tutti i componenti utilizzati direttamente o indirettamente per creare ProductAssemblyID 800.The following example updates the PerAssemnblyQty value for all parts and components that are used directly or indirectly to create the ProductAssemblyID 800. L'espressione di tabella comune restituisce un elenco gerarchico di parti utilizzate direttamente per compilare ProductAssemblyID 800 e di parti utilizzate per compilare tali componenti e così via.The common table expression returns a hierarchical list of parts that are used directly to build ProductAssemblyID 800 and parts that are used to build those components, and so on. Vengono modificate solo le righe restituite dall'espressione di tabella comune.Only the rows returned by the common table expression are modified.

USE AdventureWorks2012;  
GO  
WITH Parts(AssemblyID, ComponentID, PerAssemblyQty, EndDate, ComponentLevel) AS  
(  
    SELECT b.ProductAssemblyID, b.ComponentID, b.PerAssemblyQty,  
        b.EndDate, 0 AS ComponentLevel  
    FROM Production.BillOfMaterials AS b  
    WHERE b.ProductAssemblyID = 800  
          AND b.EndDate IS NULL  
    UNION ALL  
    SELECT bom.ProductAssemblyID, bom.ComponentID, p.PerAssemblyQty,  
        bom.EndDate, ComponentLevel + 1  
    FROM Production.BillOfMaterials AS bom   
        INNER JOIN Parts AS p  
        ON bom.ProductAssemblyID = p.ComponentID  
        AND bom.EndDate IS NULL  
)  
UPDATE Production.BillOfMaterials  
SET PerAssemblyQty = c.PerAssemblyQty * 2  
FROM Production.BillOfMaterials AS c  
JOIN Parts AS d ON c.ProductAssemblyID = d.AssemblyID  
WHERE d.ComponentLevel = 0;  

F.F. Utilizzo della clausola WHERE CURRENT OFUsing the WHERE CURRENT OF clause

Nell'esempio seguente viene utilizzata la clausola WHERE CURRENT OF per aggiornare solo la riga in cui è posizionato il cursore.The following example uses the WHERE CURRENT OF clause to update only the row on which the cursor is positioned. Se un cursore è basato su un join, viene modificato solo il valore table_name specificato nell'istruzione UPDATE.When a cursor is based on a join, only the table_name specified in the UPDATE statement is modified. Le altre tabelle interessate dal cursore rimangono invariate.Other tables participating in the cursor are not affected.

USE AdventureWorks2012;  
GO  
DECLARE complex_cursor CURSOR FOR  
    SELECT a.BusinessEntityID  
    FROM HumanResources.EmployeePayHistory AS a  
    WHERE RateChangeDate <>   
         (SELECT MAX(RateChangeDate)  
          FROM HumanResources.EmployeePayHistory AS b  
          WHERE a.BusinessEntityID = b.BusinessEntityID) ;  
OPEN complex_cursor;  
FETCH FROM complex_cursor;  
UPDATE HumanResources.EmployeePayHistory  
SET PayFrequency = 2   
WHERE CURRENT OF complex_cursor;  
CLOSE complex_cursor;  
DEALLOCATE complex_cursor;  
GO  

Impostazione dei valori di colonnaSetting Column Values

Negli esempi contenuti in questa sezione viene illustrato l'aggiornamento di colonne tramite valori calcolati, sottoquery e valori DEFAULT.Examples in this section demonstrate updating columns by using computed values, subqueries, and DEFAULT values.

G.G. Specifica di un valore calcolatoSpecifying a computed value

Negli esempi seguenti vengono utilizzati valori calcolati in un'istruzione UPDATE.The following examples uses computed values in an UPDATE statement. Nell'esempio viene raddoppiato il valore della colonna ListPrice per tutte le righe della tabella Product.The example doubles the value in the ListPrice column for all rows in the Product table.

USE AdventureWorks2012 ;  
GO  
UPDATE Production.Product  
SET ListPrice = ListPrice * 2;  
GO  

H.H. Specifica di un operatore compostoSpecifying a compound operator

Nell'esempio seguente viene utilizzata la variabile @NewPrice per incrementare il prezzo di tutte le biciclette rosse aggiungendo 10 al prezzo corrente.The following example uses the variable @NewPrice to increment the price of all red bicycles by taking the current price and adding 10 to it.

USE AdventureWorks2012;  
GO  
DECLARE @NewPrice int = 10;  
UPDATE Production.Product  
SET ListPrice += @NewPrice  
WHERE Color = N'Red';  
GO  

Nell'esempio seguente viene utilizzato l'operatore composto + = per aggiungere i dati ' - tool malfunction' al valore esistente nella colonna Name per le righe con ScrapReasonID tra 10 e 12.The following example uses the compound operator += to append the data ' - tool malfunction' to the existing value in the column Name for rows that have a ScrapReasonID between 10 and 12.

USE AdventureWorks2012;  
GO  
UPDATE Production.ScrapReason   
SET Name += ' - tool malfunction'  
WHERE ScrapReasonID BETWEEN 10 and 12;  

I.I. Specifica di una sottoquery nella clausola SETSpecifying a subquery in the SET clause

Nell'esempio seguente viene utilizzata una sottoquery nella clausola SET per determinare il valore utilizzato per aggiornare la colonna.The following example uses a subquery in the SET clause to determine the value that is used to update the column. La sottoquery deve restituire solo un valore scalare, ovvero un solo valore per riga.The subquery must return only a scalar value (that is, a single value per row). Nell'esempio la colonna SalesYTD della tabella SalesPerson viene modificata in modo che includa le vendite più recenti registrate nella tabella SalesOrderHeader.The example modifies the SalesYTD column in the SalesPerson table to reflect the most recent sales recorded in the SalesOrderHeader table. Con la sottoquery vengono aggregate le vendite per ogni venditore nell'istruzione UPDATE.The subquery aggregates the sales for each salesperson in the UPDATE statement.

USE AdventureWorks2012;  
GO  
UPDATE Sales.SalesPerson  
SET SalesYTD = SalesYTD +   
    (SELECT SUM(so.SubTotal)   
     FROM Sales.SalesOrderHeader AS so  
     WHERE so.OrderDate = (SELECT MAX(OrderDate)  
                           FROM Sales.SalesOrderHeader AS so2  
                           WHERE so2.SalesPersonID = so.SalesPersonID)  
     AND Sales.SalesPerson.BusinessEntityID = so.SalesPersonID  
     GROUP BY so.SalesPersonID);  
GO  

J.J. Aggiornamento di righe tramite valori DEFAULTUpdating rows using DEFAULT values

Nell'esempio seguente viene impostata la colonna CostRate sul valore predefinito (0.00) per tutte le righe con un valore CostRate maggiore di 20.00.The following example sets the CostRate column to its default value (0.00) for all rows that have a CostRate value greater than 20.00.

USE AdventureWorks2012;  
GO  
UPDATE Production.Location  
SET CostRate = DEFAULT  
WHERE CostRate > 20.00;  

Specifica di oggetti di destinazione diversi dalle tabelle StandardSpecifying Target Objects Other Than Standard Tables

Negli esempi contenuti in questa sezione viene illustrato come aggiornare le righe specificando una vista, un alias di tabella o una variabile di tabella.Examples in this section demonstrate how to update rows by specifying a view, table alias, or table variable.

K.K. Specifica di una vista come oggetto di destinazioneSpecifying a view as the target object

Nell'esempio seguente vengono aggiornate le righe di una tabella specificando una vista come oggetto di destinazione.The following example updates rows in a table by specifying a view as the target object. La definizione di vista fa riferimento a più tabelle, tuttavia l'istruzione UPDATE ha esito positivo perché fa riferimento alle colonne di una sola delle tabelle sottostanti.The view definition references multiple tables, however, the UPDATE statement succeeds because it references columns from only one of the underlying tables. L'istruzione UPDATE avrebbe esito negativo se venissero specificate colonne di entrambe le tabelle.The UPDATE statement would fail if columns from both tables were specified. Per ulteriori informazioni, vedere modificare dati tramite una vista.For more information, see Modify Data Through a View.

USE AdventureWorks2012;  
GO  
UPDATE Person.vStateProvinceCountryRegion  
SET CountryRegionName = 'United States of America'  
WHERE CountryRegionName = 'United States';  

L.L. Specifica di un alias di tabella come oggetto di destinazioneSpecifying a table alias as the target object

Nell'esempio seguente vengono aggiornate le righe della tabella Production.ScrapReason.The follow example updates rows in the table Production.ScrapReason. L'alias di tabella assegnato a ScrapReason nella clausola FROM viene specificato come oggetto di destinazione nella clausola UPDATE.The table alias assigned to ScrapReason in the FROM clause is specified as the target object in the UPDATE clause.

USE AdventureWorks2012;  
GO  
UPDATE sr  
SET sr.Name += ' - tool malfunction'  
FROM Production.ScrapReason AS sr  
JOIN Production.WorkOrder AS wo   
     ON sr.ScrapReasonID = wo.ScrapReasonID  
     AND wo.ScrappedQty > 300;  

M.M. Specifica di una variabile di tabella come oggetto di destinazioneSpecifying a table variable as the target object

Nell'esempio seguente vengono aggiornate le righe in una variabile di tabella.The following example updates rows in a table variable.

USE AdventureWorks2012;  
GO  
-- Create the table variable.  
DECLARE @MyTableVar table(  
    EmpID int NOT NULL,  
    NewVacationHours int,  
    ModifiedDate datetime);  

-- Populate the table variable with employee ID values from HumanResources.Employee.  
INSERT INTO @MyTableVar (EmpID)  
    SELECT BusinessEntityID FROM HumanResources.Employee;  

-- Update columns in the table variable.  
UPDATE @MyTableVar  
SET NewVacationHours = e.VacationHours + 20,  
    ModifiedDate = GETDATE()  
FROM HumanResources.Employee AS e   
WHERE e.BusinessEntityID = EmpID;  

-- Display the results of the UPDATE statement.  
SELECT EmpID, NewVacationHours, ModifiedDate FROM @MyTableVar  
ORDER BY EmpID;  
GO  

L'aggiornamento dei dati in base ai dati da altre tabelleUpdating Data Based on Data From Other Tables

Negli esempi contenuti in questa sezione vengono illustrati i metodi per l'aggiornamento delle righe di una tabella in base alle informazioni contenute in un'altra.Examples in this section demonstrate methods of updating rows from one table based on information in another table.

N.N. Utilizzo dell'istruzione UPDATE con informazioni di un'altra tabellaUsing the UPDATE statement with information from another table

Nell'esempio seguente la colonna SalesYTD della tabella SalesPerson viene modificata in modo che includa le vendite più recenti registrate nella tabella SalesOrderHeader.The following example modifies the SalesYTD column in the SalesPerson table to reflect the most recent sales recorded in the SalesOrderHeader table.

USE AdventureWorks2012;  
GO  
UPDATE Sales.SalesPerson  
SET SalesYTD = SalesYTD + SubTotal  
FROM Sales.SalesPerson AS sp  
JOIN Sales.SalesOrderHeader AS so  
    ON sp.BusinessEntityID = so.SalesPersonID  
    AND so.OrderDate = (SELECT MAX(OrderDate)  
                        FROM Sales.SalesOrderHeader  
                        WHERE SalesPersonID = sp.BusinessEntityID);  
GO  

Nell'esempio precedente si presume che venga registrata una sola vendita per un determinato venditore in una data specifica e che i dati siano aggiornati.The previous example assumes that only one sale is recorded for a specified salesperson on a specific date and that updates are current. Se è possibile registrare più vendite per un determinato venditore nello stesso giorno, l'esempio non funziona correttamente.If more than one sale for a specified salesperson can be recorded on the same day, the example shown does not work correctly. Nell'esempio viene eseguito senza errori, ma ogni SalesYTD valore viene aggiornato con una sola vendita, indipendentemente dal numero effettivo di vendite del giorno corrente.The example runs without error, but each SalesYTD value is updated with only one sale, regardless of how many sales actually occurred on that day. Un'istruzione UPDATE infatti non aggiorna mai la stessa riga due volte.This is because a single UPDATE statement never updates the same row two times.

Nel caso in cui sia necessario registrare più vendite per un determinato venditore nello stesso giorno, tutte le vendite relative allo stesso venditore devono essere aggregate all'interno dell'istruzione UPDATE, come illustrato nell'esempio seguente:In the situation in which more than one sale for a specified salesperson can occur on the same day, all the sales for each sales person must be aggregated together within the UPDATE statement, as shown in the following example:

USE AdventureWorks2012;  
GO  
UPDATE Sales.SalesPerson  
SET SalesYTD = SalesYTD +   
    (SELECT SUM(so.SubTotal)   
     FROM Sales.SalesOrderHeader AS so  
     WHERE so.OrderDate = (SELECT MAX(OrderDate)  
                           FROM Sales.SalesOrderHeader AS so2  
                           WHERE so2.SalesPersonID = so.SalesPersonID)  
     AND Sales.SalesPerson.BusinessEntityID = so.SalesPersonID  
     GROUP BY so.SalesPersonID);  
GO  

L'aggiornamento delle righe in una tabella remotaUpdating Rows in a Remote Table

In questa sezione viene illustrato come aggiornare le righe in una tabella di destinazione remota tramite un server collegato o funzione rowset fare riferimento alla tabella remota.Examples in this section demonstrate how to update rows in a remote target table by using a linked server or a rowset function to reference the remote table.

O.O. Aggiornamento di dati in una tabella remota tramite un server collegatoUpdating data in a remote table by using a linked server

Nell'esempio seguente viene aggiornata una tabella in un server remoto.The following example updates a table on a remote server. L'esempio inizia creando un collegamento all'origine dati remota tramite sp_addlinkedserver.The example begins by creating a link to the remote data source by using sp_addlinkedserver. Il nome del server collegato, MyLinkServer, viene quindi specificato come parte del nome dell'oggetto in quattro parti nel formato server.catalogo.schema.oggetto.The linked server name, MyLinkServer, is then specified as part of the four-part object name in the form server.catalog.schema.object. Si noti che è necessario specificare un nome server valido per @datasrc.Note that you must specify a valid server name for @datasrc.

USE master;  
GO  
-- Create a link to the remote data source.   
-- Specify a valid server name for @datasrc as 'server_name' or 'server_nameinstance_name'.  

EXEC sp_addlinkedserver @server = N'MyLinkServer',  
    @srvproduct = N' ',  
    @provider = N'SQLNCLI10',   
    @datasrc = N'<server name>',  
    @catalog = N'AdventureWorks2012';  
GO  
USE AdventureWorks2012;  
GO  
-- Specify the remote data source using a four-part name   
-- in the form linked_server.catalog.schema.object.  

UPDATE MyLinkServer.AdventureWorks2012.HumanResources.Department  
SET GroupName = N'Public Relations'  
WHERE DepartmentID = 4;  

P.P. Aggiornamento di dati in una tabella remota tramite una funzione OPENQUERYUpdating data in a remote table by using the OPENQUERY function

Nell'esempio seguente viene aggiornata una riga in una tabella remota specificando la OPENQUERY funzione set di righe.The following example updates a row in a remote table by specifying the OPENQUERY rowset function. Viene utilizzato il nome del server collegato creato nell'esempio precedente.The linked server name created in the previous example is used in this example.

UPDATE OPENQUERY (MyLinkServer, 'SELECT GroupName FROM HumanResources.Department WHERE DepartmentID = 4')   
SET GroupName = 'Sales and Marketing';  

Q.Q. Aggiornamento di dati in una tabella remota tramite una funzione OPENDATASOURCEUpdating data in a remote table by using the OPENDATASOURCE function

Nell'esempio seguente viene inserita una riga in una tabella remota specificando la OPENDATASOURCE funzione set di righe.The following example inserts a row into a remote table by specifying the OPENDATASOURCE rowset function. Specificare un nome server valido per l'origine dati utilizzando il formato nome_server o server_name\instance_name.Specify a valid server name for the data source by using the format server_name or server_name\instance_name. Potrebbe essere necessario configurare l'istanza di SQL ServerSQL Server per Ad Hoc Distributed Queries.You may need to configure the instance of SQL ServerSQL Server for Ad Hoc Distributed Queries. Per ulteriori informazioni, vedere opzione di configurazione Server ad hoc distributed queries.For more information, see ad hoc distributed queries Server Configuration Option.

UPDATE OPENQUERY (MyLinkServer, 'SELECT GroupName FROM HumanResources.Department WHERE DepartmentID = 4')   
SET GroupName = 'Sales and Marketing';  

Aggiornamento di tipi di dati LOBUpdating Large Object Data Types

Negli esempi contenuti in questa sezione vengono illustrati i metodi per l'aggiornamento di valori in colonne definite con tipi di dati LOB (Large Object).Examples in this section demonstrate methods of updating values in columns that are defined with large object (LOB) data types.

R.R. Utilizzo di UPDATE con la clausola .WRITE per modificare dati in una colonna nvarchar(max)Using UPDATE with .WRITE to modify data in an nvarchar(max) column

L'esempio seguente usa il. Clausola di scrittura per l'aggiornamento di un valore parziale DocumentSummary, un nvarchar (max) colonna il Production.Document tabella.The following example uses the .WRITE clause to update a partial value in DocumentSummary, an nvarchar(max) column in the Production.Document table. La parola components viene sostituita con la parola features specificando la parola sostitutiva, il percorso iniziale (offset) della parola da sostituire nei dati esistenti e il numero di caratteri da sostituire (lunghezza).The word components is replaced with the word features by specifying the replacement word, the starting location (offset) of the word to be replaced in the existing data, and the number of characters to be replaced (length). Nell'esempio viene inoltre utilizzata la clausola OUTPUT per restituire la prima e dopo le immagini del DocumentSummary colonna per il @MyTableVar variabile di tabella.The example also uses the OUTPUT clause to return the before and after images of the DocumentSummary column to the @MyTableVar table variable.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table (  
    SummaryBefore nvarchar(max),  
    SummaryAfter nvarchar(max));  
UPDATE Production.Document  
SET DocumentSummary .WRITE (N'features',28,10)  
OUTPUT deleted.DocumentSummary,   
       inserted.DocumentSummary   
    INTO @MyTableVar  
WHERE Title = N'Front Reflector Bracket Installation';  
SELECT SummaryBefore, SummaryAfter   
FROM @MyTableVar;  
GO  

S.S. Utilizzo di UPDATE con la clausola .WRITE per aggiungere e rimuovere dati in una colonna di tipo nvarchar(max)Using UPDATE with .WRITE to add and remove data in an nvarchar(max) column

Negli esempi seguenti aggiungere e rimuovere dati da un nvarchar (max) colonna con un valore impostato su NULL.The following examples add and remove data from an nvarchar(max) column that has a value currently set to NULL. Poiché il. SCRIVERE clausola non può essere usata per modificare una colonna NULL, la colonna viene prima popolata con dati temporanei.Because the .WRITE clause cannot be used to modify a NULL column, the column is first populated with temporary data. Questi dati vengono quindi sostituiti con i dati corretti tramite la clausola .WRITE.This data is then replaced with the correct data by using the .WRITE clause. Negli esempi aggiuntivi vengono accodati dati al termine del valore della colonna, rimossi (troncati) dati dalla colonna e infine rimossi dati parziali dalla colonna.The additional examples append data to the end of the column value, remove (truncate) data from the column and, finally, remove partial data from the column. Le istruzioni SELECT consentono di visualizzare la modifica dei dati generata da ogni istruzione UPDATE.The SELECT statements display the data modification generated by each UPDATE statement.

USE AdventureWorks2012;  
GO  
-- Replacing NULL value with temporary data.  
UPDATE Production.Document  
SET DocumentSummary = N'Replacing NULL value'  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
SELECT DocumentSummary   
FROM Production.Document  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
-- Replacing temporary data with the correct data. Setting @Length to NULL   
-- truncates all existing data from the @Offset position.  
UPDATE Production.Document  
SET DocumentSummary .WRITE(N'Carefully inspect and maintain the tires and crank arms.',0,NULL)  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
SELECT DocumentSummary   
FROM Production.Document  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
-- Appending additional data to the end of the column by setting   
-- @Offset to NULL.  
UPDATE Production.Document  
SET DocumentSummary .WRITE (N' Appending data to the end of the column.', NULL, 0)  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
SELECT DocumentSummary   
FROM Production.Document  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
-- Removing all data from @Offset to the end of the existing value by   
-- setting expression to NULL.   
UPDATE Production.Document  
SET DocumentSummary .WRITE (NULL, 56, 0)  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
SELECT DocumentSummary   
FROM Production.Document  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
-- Removing partial data beginning at position 9 and ending at   
-- position 21.  
UPDATE Production.Document  
SET DocumentSummary .WRITE ('',9, 12)  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  
SELECT DocumentSummary   
FROM Production.Document  
WHERE Title = N'Crank Arm and Tire Maintenance';  
GO  

T.T. Utilizzo di UPDATE con OPENROWSET per modificare una colonna di tipo varbinary(max)Using UPDATE with OPENROWSET to modify a varbinary(max) column

Nell'esempio seguente sostituisce un'immagine esistente archiviata in un varbinary (max) colonna con una nuova immagine.The following example replaces an existing image stored in a varbinary(max) column with a new image. Il OPENROWSET funzione viene utilizzata con l'opzione BULK per caricare l'immagine nella colonna.The OPENROWSET function is used with the BULK option to load the image into the column. In questo esempio si presuppone che un file Tires.jpg esista nel percorso di file specificato.This example assumes that a file named Tires.jpg exists in the specified file path.

USE AdventureWorks2012;  
GO  
UPDATE Production.ProductPhoto  
SET ThumbNailPhoto = (  
    SELECT *  
    FROM OPENROWSET(BULK 'c:Tires.jpg', SINGLE_BLOB) AS x )  
WHERE ProductPhotoID = 1;  
GO  

U.U. Utilizzo di UPDATE per modificare dati FILESTREAMUsing UPDATE to modify FILESTREAM data

Nell'esempio seguente viene utilizzata l'istruzione UPDATE per modificare i dati nel file del file system.The following example uses the UPDATE statement to modify the data in the file system file. Questo metodo non è consigliabile per trasmettere tramite flusso grandi quantità di dati in un file.We do not recommend this method for streaming large amounts of data to a file. Utilizzare le interfacce Win32 appropriate.Use the appropriate Win32 interfaces. Nel seguente esempio il testo nel record del file viene sostituito con il testo Xray 1.The following example replaces any text in the file record with the text Xray 1. Per altre informazioni, vedere FILESTREAM (SQL Server).For more information, see FILESTREAM (SQL Server).

UPDATE Archive.dbo.Records  
SET [Chart] = CAST('Xray 1' as varbinary(max))  
WHERE [SerialNumber] = 2;  

Aggiornamento di tipi definiti dall'utenteUpdating User-defined Types

Negli esempi seguenti vengono modificati i valori nelle colonne di tipo CLR definito dall'utente.The following examples modify values in CLR user-defined type (UDT) columns. Vengono illustrati tre metodi.Three methods are demonstrated. Per ulteriori informazioni sulle colonne definite dall'utente, vedere tipi CLR definiti dall'utente.For more information about user-defined columns, see CLR User-Defined Types.

V.V. Utilizzo di un tipo di dati di sistemaUsing a system data type

È possibile aggiornare un tipo definito dall'utente specificando un valore in un tipo di dati di sistema di SQL ServerSQL Server, a condizione che il tipo definito dall'utente supporti la conversione implicita o esplicita da tale tipo.You can update a UDT by supplying a value in a SQL ServerSQL Server system data type, as long as the user-defined type supports implicit or explicit conversion from that type. Nell'esempio seguente viene illustrato come aggiornare un valore in una colonna del tipo Point definito dall'utente, eseguendo la conversione esplicita da una stringa.The following example shows how to update a value in a column of user-defined type Point, by explicitly converting from a string.

UPDATE dbo.Cities  
SET Location = CONVERT(Point, '12.3:46.2')  
WHERE Name = 'Anchorage';  

W.W. Chiamata di un metodoInvoking a method

È possibile aggiornare un tipo definito dall'utente richiamando un metodo, contrassegnato come mutatore, del tipo definito dall'utente per eseguire l'aggiornamento.You can update a UDT by invoking a method, marked as a mutator, of the user-defined type, to perform the update. Nell'esempio seguente viene richiamato un metodo mutatore di tipo Point denominato SetXY.The following example invokes a mutator method of type Point named SetXY. Viene aggiornato lo stato dell'istanza del tipo.This updates the state of the instance of the type.

UPDATE dbo.Cities  
SET Location.SetXY(23.5, 23.5)  
WHERE Name = 'Anchorage';  

X.X. Modifica del valore di una proprietà o di un membro datiModifying the value of a property or data member

È possibile aggiornare un tipo definito dall'utente modificando il valore di una proprietà registrata o di un membro dati pubblico del tipo definito dall'utente.You can update a UDT by modifying the value of a registered property or public data member of the user-defined type. È necessario che l'espressione che fornisce il valore possa essere convertita in modo implicito nel tipo della proprietà.The expression supplying the value must be implicitly convertible to the type of the property. Nell'esempio seguente viene modificato il valore di proprietà X del tipo definito dall'utente Point.The following example modifies the value of property X of user-defined type Point.

UPDATE dbo.Cities  
SET Location.X = 23.5  
WHERE Name = 'Anchorage';  

Override del comportamento predefinito di Query Optimizer tramite hintOverriding the Default Behavior of the Query Optimizer by Using Hints

Negli esempi contenuti in questa sezione viene illustrato come utilizzare gli hint di tabella e gli hint per le query per eseguire temporaneamente l'override del comportamento predefinito di Query Optimizer durante l'elaborazione dell'istruzione UPDATE.Examples in this section demonstrate how to use table and query hints to temporarily override the default behavior of the query optimizer when processing the UPDATE statement.

Attenzione

Poiché Query Optimizer di SQL ServerSQL Server consente in genere di selezionare il piano di esecuzione migliore per una query, gli hint devono essere usati solo se strettamente necessari ed esclusivamente da sviluppatori e amministratori di database esperti.Because the SQL ServerSQL Server query optimizer typically selects the best execution plan for a query, we recommend that hints be used only as a last resort by experienced developers and database administrators.

Y.Y. Specifica di un hint di tabellaSpecifying a table hint

Nell'esempio seguente viene specificato il hint di tabella TABLOCK.The following example specifies the table hint TABLOCK. L'hint specifica l'acquisizione di un blocco condiviso sulla tabella Production.Product. Tale blocco viene mantenuto attivo fino al termine dell'istruzione UPDATE.This hint specifies that a shared lock is taken on the table Production.Product and held until the end of the UPDATE statement.

USE AdventureWorks2012;  
GO  
UPDATE Production.Product  
WITH (TABLOCK)  
SET ListPrice = ListPrice * 1.10  
WHERE ProductNumber LIKE 'BK-%';  
GO  

Z.Z. Specifica di un hint per la querySpecifying a query hint

Nell'esempio seguente viene specificato il hint per la query OPTIMIZE FOR (@variable) nell'istruzione UPDATE.The following example specifies the query hintOPTIMIZE FOR (@variable) in the UPDATE statement. Tramite questo hint si indica a Query Optimizer di utilizzare un valore specifico per una variabile locale quando la query viene compilata e ottimizzata.This hint instructs the query optimizer to use a particular value for a local variable when the query is compiled and optimized. Il valore viene utilizzato solo durante l'ottimizzazione della query e non durante l'esecuzione.The value is used only during query optimization, and not during query execution.

USE AdventureWorks2012;  
GO  
CREATE PROCEDURE Production.uspProductUpdate  
@Product nvarchar(25)  
AS  
SET NOCOUNT ON;  
UPDATE Production.Product  
SET ListPrice = ListPrice * 1.10  
WHERE ProductNumber LIKE @Product  
OPTION (OPTIMIZE FOR (@Product = 'BK-%') );  
GO  
-- Execute the stored procedure   
EXEC Production.uspProductUpdate 'BK-%';  

Acquisizione dei risultati dell'istruzione UPDATECapturing the Results of the UPDATE Statement

Negli esempi riportati in questa sezione viene illustrato come utilizzare il clausola OUTPUT per restituire informazioni da o espressioni basate su, ogni riga interessata da un'istruzione UPDATE.Examples in this section demonstrate how to use the OUTPUT Clause to return information from, or expressions based on, each row affected by an UPDATE statement. Questi risultati possono essere restituiti all'applicazione di elaborazione per l'utilizzo nei messaggi di errore, l'archiviazione e altri scopi simili dell'applicazione.These results can be returned to the processing application for use in such things as confirmation messages, archiving, and other such application requirements.

AA.AA. Utilizzo di UPDATE con la clausola OUTPUTUsing UPDATE with the OUTPUT clause

Nell'esempio seguente viene aggiornata la colonna VacationHours nella tabella Employee del 25% per le prime 10 righe e viene inoltre impostato il valore nella colonna ModifiedDate sulla data corrente.The following example updates the column VacationHours in the Employee table by 25 percent for the first 10 rows and also sets the value in the column ModifiedDate to the current date. La clausola OUTPUT restituisce il valore di VacationHours esistente prima di applicare l'istruzione UPDATE nella colonna deleted.VacationHours e il valore aggiornato nella colonna inserted.VacationHours alla variabile di tabella @MyTableVar.The OUTPUT clause returns the value of VacationHours that exists before applying the UPDATE statement in the deleted.VacationHours column and the updated value in the inserted.VacationHours column to the @MyTableVar table variable.

Questa variabile è seguita da due istruzioni SELECT che restituiscono i valori in @MyTableVar e i risultati dell'operazione di aggiornamento nella tabella Employee.Two SELECT statements follow that return the values in @MyTableVar and the results of the update operation in the Employee table. Per ulteriori esempi di utilizzo della clausola OUTPUT, vedere clausola OUTPUT ( Transact-SQL ) .For more examples using the OUTPUT clause, see OUTPUT Clause (Transact-SQL).

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table(  
    EmpID int NOT NULL,  
    OldVacationHours int,  
    NewVacationHours int,  
    ModifiedDate datetime);  
UPDATE TOP (10) HumanResources.Employee  
SET VacationHours = VacationHours * 1.25,  
    ModifiedDate = GETDATE()   
OUTPUT inserted.BusinessEntityID,  
       deleted.VacationHours,  
       inserted.VacationHours,  
       inserted.ModifiedDate  
INTO @MyTableVar;  
--Display the result set of the table variable.  
SELECT EmpID, OldVacationHours, NewVacationHours, ModifiedDate  
FROM @MyTableVar;  
GO  
--Display the result set of the table.  
SELECT TOP (10) BusinessEntityID, VacationHours, ModifiedDate  
FROM HumanResources.Employee;  
GO  

Utilizzo di UPDATE in altre istruzioniUsing UPDATE in other statements

Negli esempi inclusi in questa sezione viene illustrato l'utilizzo di UPDATE in altre istruzioni.Examples in this section demonstrate how to use UPDATE in other statements.

AB.AB. Utilizzo di UPDATE in una stored procedureUsing UPDATE in a stored procedure

Nell'esempio seguente viene usata un'istruzione UPDATE in una stored procedure.The following example uses an UPDATE statement in a stored procedure. Per la stored procedure sono previsti un unico parametro di input @NewHours e un unico parametro di output @RowCount.The procedure takes one input parameter, @NewHours and one output parameter @RowCount. Il @NewHours valore del parametro viene utilizzato nell'istruzione UPDATE per aggiornare la colonna VacationHours nella tabella HumanResources.Employee.The @NewHours parameter value is used in the UPDATE statement to update the column VacationHours in the table HumanResources.Employee. Il parametro di output @RowCount viene usato per restituire il numero di righe interessate a una variabile locale.The @RowCount output parameter is used to return the number of rows affected to a local variable. L'espressione CASE viene utilizzata nella clausola SET per determinare in modo condizionale il valore impostato per VacationHours.The CASE expression is used in the SET clause to conditionally determine the value that is set for VacationHours. Quando un dipendente percepisce una paga oraria (SalariedFlag = 0), VacationHours viene impostato sul numero corrente di ore più il valore specificato in @NewHours. In caso contrario, VacationHours viene impostato sul valore specificato in @NewHours.When the employee is paid hourly (SalariedFlag = 0), VacationHours is set to the current number of hours plus the value specified in @NewHours; otherwise, VacationHours is set to the value specified in @NewHours.

USE AdventureWorks2012;  
GO  
CREATE PROCEDURE HumanResources.Update_VacationHours  
@NewHours smallint  
AS   
SET NOCOUNT ON;  
UPDATE HumanResources.Employee  
SET VacationHours =   
    ( CASE  
         WHEN SalariedFlag = 0 THEN VacationHours + @NewHours  
         ELSE @NewHours  
       END  
    )  
WHERE CurrentFlag = 1;  
GO  

EXEC HumanResources.Update_VacationHours 40;  

AC.AC. Utilizzo di UPDATE in un blocco TRY...CATCHUsing UPDATE in a TRY…CATCH Block

Nell'esempio seguente viene utilizzata un'istruzione UPDATE in un blocco TRY... CATCH per gestire gli errori di esecuzione che potrebbero verificarsi durante l'operazione di aggiornamento.The following example uses an UPDATE statement in a TRY…CATCH block to handle execution errors that may occur during the update operation.

USE AdventureWorks2012;  
GO  
BEGIN TRANSACTION;  

BEGIN TRY  
    -- Intentionally generate a constraint violation error.  
    UPDATE HumanResources.Department  
    SET Name = N'MyNewName'  
    WHERE DepartmentID BETWEEN 1 AND 2;  
END TRY  
BEGIN CATCH  
    SELECT   
         ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_LINE() AS ErrorLine  
        ,ERROR_MESSAGE() AS ErrorMessage;  

    IF @@TRANCOUNT > 0  
        ROLLBACK TRANSACTION;  
END CATCH;  

IF @@TRANCOUNT > 0  
    COMMIT TRANSACTION;  
GO  

Esempi: SQL Data WarehouseSQL Data Warehouse e Parallel Data WarehouseParallel Data WarehouseExamples: SQL Data WarehouseSQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

AD.AD. Esecuzione di un'istruzione UPDATE sempliceUsing a simple UPDATE statement

I seguenti esempi viene illustrato come possono essere interessate tutte le righe quando una clausola WHERE non utilizzata per specificare la riga (o le righe) per l'aggiornamento.The following examples show how all rows can be affected when a WHERE clause is not used to specify the row (or rows) to update.

In questo esempio aggiorna i valori nel EndDate e CurrentFlag colonne per tutte le righe di DimEmployee tabella.This example updates the values in the EndDate and CurrentFlag columns for all rows in the DimEmployee table.

-- Uses AdventureWorks  

UPDATE DimEmployee  
SET EndDate = '2010-12-31', CurrentFlag='False';  

In un'istruzione UPDATE è inoltre possibile utilizzare valori calcolati.You can also use computed values in an UPDATE statement. Nell'esempio seguente viene raddoppiato il valore della colonna ListPrice per tutte le righe della tabella Product.The following example doubles the value in the ListPrice column for all rows in the Product table.

-- Uses AdventureWorks  

UPDATE DimEmployee  
SET BaseRate = BaseRate * 2;  

AE.AE. Utilizzo dell'istruzione UPDATE con una clausola WHEREUsing the UPDATE statement with a WHERE clause

Nell'esempio seguente viene utilizzata la clausola WHERE per specificare le righe da aggiornare.The following example uses the WHERE clause to specify which rows to update.

-- Uses AdventureWorks  

UPDATE DimEmployee  
SET FirstName = 'Gail'  
WHERE EmployeeKey = 500;  

AF.AF. Utilizzo dell'istruzione UPDATE con etichettaUsing the UPDATE statement with label

Nell'esempio riportato di seguito viene illustrato l'utilizzo di un'etichetta per l'istruzione UPDATE.The following example shows use of a LABEL for the UPDATE statement.

-- Uses AdventureWorks  

UPDATE DimProduct  
SET ProductSubcategoryKey = 2   
WHERE ProductKey = 313  
OPTION (LABEL = N'label1');  

AG.AG. Utilizzo dell'istruzione UPDATE con informazioni di un'altra tabellaUsing the UPDATE statement with information from another table

Questo esempio viene creata una tabella per archiviare le vendite totali per anno.This example creates a table to store total sales by year. Aggiorna le vendite totali per l'anno 2004 eseguendo un'istruzione SELECT sulla tabella FactInternetSales.It updates the total sales for the year 2004 by running a SELECT statement against the FactInternetSales table.

-- Uses AdventureWorks  

CREATE TABLE YearlyTotalSales (  
    YearlySalesAmount money NOT NULL,  
    Year smallint NOT NULL )  
WITH ( DISTRIBUTION = REPLICATE );  

INSERT INTO YearlyTotalSales VALUES (0, 2004);  
INSERT INTO YearlyTotalSales VALUES (0, 2005);  
INSERT INTO YearlyTotalSales VALUES (0, 2006);  

UPDATE YearlyTotalSales  
SET YearlySalesAmount=  
(SELECT SUM(SalesAmount) FROM FactInternetSales WHERE OrderDateKey >=20040000 AND OrderDateKey < 20050000)  
WHERE Year=2004;  

SELECT * FROM YearlyTotalSales;   

AH.AH. Sostituzione di join ANSI per le istruzioni updateANSI join replacement for update statements

È possibile che si dispone di un aggiornamento complesso che unisce in join più di due tabelle utilizzando la sintassi join ANSI per eseguire l'aggiornamento o eliminazione.You may find you have a complex update that joins more than two tables together using ANSI joining syntax to perform the UPDATE or DELETE.

Si supponga che era necessario aggiornare la tabella:Imagine you had to update this table:

CREATE TABLE [dbo].[AnnualCategorySales]
(   [EnglishProductCategoryName]    NVARCHAR(50)    NOT NULL
,   [CalendarYear]                  SMALLINT        NOT NULL
,   [TotalSalesAmount]              MONEY           NOT NULL
)
WITH
(
    DISTRIBUTION = ROUND_ROBIN
)
;  

La query originale potrebbe siano presenti simile al seguente:The original query might have looked something like this:

UPDATE  acs
SET     [TotalSalesAmount] = [fis].[TotalSalesAmount]
FROM    [dbo].[AnnualCategorySales]     AS acs
JOIN    (
        SELECT  [EnglishProductCategoryName]
        ,       [CalendarYear]
        ,       SUM([SalesAmount])              AS [TotalSalesAmount]
        FROM    [dbo].[FactInternetSales]       AS s
        JOIN    [dbo].[DimDate]                 AS d    ON s.[OrderDateKey]             = d.[DateKey]
        JOIN    [dbo].[DimProduct]              AS p    ON s.[ProductKey]               = p.[ProductKey]
        JOIN    [dbo].[DimProductSubCategory]   AS u    ON p.[ProductSubcategoryKey]    = u.[ProductSubcategoryKey]
        JOIN    [dbo].[DimProductCategory]      AS c    ON u.[ProductCategoryKey]       = c.[ProductCategoryKey]
        WHERE   [CalendarYear] = 2004
        GROUP BY
                [EnglishProductCategoryName]
        ,       [CalendarYear]
        ) AS fis
ON  [acs].[EnglishProductCategoryName]  = [fis].[EnglishProductCategoryName]
AND [acs].[CalendarYear]                = [fis].[CalendarYear]
;  

Poiché SQL Data WarehouseSQL Data Warehouse non supporta ANSI join nella clausola FROM di un'istruzione UPDATE, non è possibile copiare questo codice su senza modificarla leggermente.Since SQL Data WarehouseSQL Data Warehouse does not support ANSI joins in the FROM clause of an UPDATE statement, you cannot copy this code over without changing it slightly.

È possibile utilizzare una combinazione di una istruzione CTAS e un join implicito per sostituire questo codice:You can use a combination of a CTAS and an implicit join to replace this code:

-- Create an interim table
CREATE TABLE CTAS_acs
WITH (DISTRIBUTION = ROUND_ROBIN)
AS
SELECT  ISNULL(CAST([EnglishProductCategoryName] AS NVARCHAR(50)),0)    AS [EnglishProductCategoryName]
,       ISNULL(CAST([CalendarYear] AS SMALLINT),0)                      AS [CalendarYear]
,       ISNULL(CAST(SUM([SalesAmount]) AS MONEY),0)                     AS [TotalSalesAmount]
FROM    [dbo].[FactInternetSales]       AS s
JOIN    [dbo].[DimDate]                 AS d    ON s.[OrderDateKey]             = d.[DateKey]
JOIN    [dbo].[DimProduct]              AS p    ON s.[ProductKey]               = p.[ProductKey]
JOIN    [dbo].[DimProductSubCategory]   AS u    ON p.[ProductSubcategoryKey]    = u.[ProductSubcategoryKey]
JOIN    [dbo].[DimProductCategory]      AS c    ON u.[ProductCategoryKey]       = c.[ProductCategoryKey]
WHERE   [CalendarYear] = 2004
GROUP BY
        [EnglishProductCategoryName]
,       [CalendarYear]
;

-- Use an implicit join to perform the update
UPDATE  AnnualCategorySales
SET     AnnualCategorySales.TotalSalesAmount = CTAS_ACS.TotalSalesAmount
FROM    CTAS_acs
WHERE   CTAS_acs.[EnglishProductCategoryName] = AnnualCategorySales.[EnglishProductCategoryName]
AND     CTAS_acs.[CalendarYear]               = AnnualCategorySales.[CalendarYear]
;

--Drop the interim table
DROP TABLE CTAS_acs
;

Vedere ancheSee Also

CREATE TABLE (Transact-SQL) CREATE TABLE (Transact-SQL)
CREATE TRIGGER (Transact-SQL) CREATE TRIGGER (Transact-SQL)
Cursori (Transact-SQL) Cursors (Transact-SQL)
DELETE (Transact-SQL) DELETE (Transact-SQL)
INSERISCI ( Transact-SQL ) INSERT (Transact-SQL)
Testo e immagine funzioni ( Transact-SQL ) Text and Image Functions (Transact-SQL)
WITH common_table_expression (Transact-SQL) WITH common_table_expression (Transact-SQL)
FILESTREAM (SQL Server)FILESTREAM (SQL Server)