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

S’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data WarehouseS’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data Warehouse

Modifie les données existantes d'une table ou d'une vue dans SQL Server 2019 (15.x)SQL Server 2019 (15.x).Changes existing data in a table or view in SQL Server 2019 (15.x)SQL Server 2019 (15.x). Pour obtenir des exemples, consultez Exemples.For examples, see Examples.

Icône du lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

-- 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 Synapse Analysis

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

<join_table_source> ::=   
{  
    [ database_name . [ schema_name ] . | schema_name . ] table_or_view_name [ AS ] table_or_view_alias 
    [ <tablesample_clause>]  
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ]  
}  
-- Syntax for 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 ) ]  
[;]  

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumentsArguments

WITH <common_table_expression>WITH <common_table_expression>
Spécifie l'ensemble de résultats ou la vue nommés temporaires, également appelés expression de table commune (CTE) et définis dans le cadre de l'instruction UPDATE.Specifies the temporary named result set or view, also known as common table expression (CTE), defined within the scope of the UPDATE statement. Le jeu de résultats CTE est dérivé d'une simple requête et l'instruction UPDATE y fait référence.The CTE result set is derived from a simple query and is referenced by UPDATE statement.

Vous pouvez également utiliser des expressions de table courantes avec les instructions SELECT, INSERT, DELETE et CREATE VIEW.Common table expressions can also be used with the SELECT, INSERT, DELETE, and CREATE VIEW statements. Pour plus d’informations, consultez WITH common_table_expression (Transact-SQL).For more information, see WITH common_table_expression (Transact-SQL).

TOP ( expression ) [ PERCENT ]TOP ( expression) [ PERCENT ]
Spécifie le nombre ou le pourcentage de lignes à mettre à jour.Specifies the number or percent of rows that are updated. L'argumentexpression peut être un nombre ou un pourcentage de lignes.expression can be either a number or a percent of the rows.

Les lignes référencées dans l'expression TOP utilisée dans les instructions INSERT, UPDATE ou DELETE ne sont pas triées dans un ordre précis.The rows referenced in the TOP expression used with INSERT, UPDATE, or DELETE are not arranged in any order.

Les parenthèses autour de l’argument expression dans TOP sont obligatoires dans les instructions INSERT, UPDATE et DELETE.Parentheses delimiting expression in TOP are required in INSERT, UPDATE, and DELETE statements. Pour plus d’informations, consultez TOP (Transact-SQL).For more information, see TOP (Transact-SQL).

table_aliastable_alias
Alias spécifié dans la clause FROM représentant la table ou la vue à partir de laquelle les lignes doivent être mises à jour.The alias specified in the FROM clause representing the table or view from which the rows are to be updated.

server_nameserver_name
Nom du serveur (avec un nom de serveur lié ou la fonction OPENDATASOURCE comme nom de serveur) contenant la table ou la vue.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. Si server_name est spécifié, database_name et schema_name sont obligatoires.If server_name is specified, database_name and schema_name are required.

database_namedatabase_name
Nom de la base de données.Is the name of the database.

schema_nameschema_name
Nom du schéma auquel la table ou la vue appartient.Is the name of the schema to which the table or view belongs.

table_or_view_nametable_or_view_name
Nom de la table ou de la vue à partir de laquelle les lignes doivent être mises à jour.Is the name of the table or view from which the rows are to be updated. La vue référencée par table_or_view_name doit pouvoir être mise à jour et faire référence à une seule table de base dans la clause FROM de la vue.The view referenced by table_or_view_name must be updatable and reference exactly one base table in the FROM clause of the view. Pour plus d’informations sur les vues pouvant être mises à jour, consultez CREATE VIEW (Transact-SQL).For more information about updatable views, see CREATE VIEW (Transact-SQL).

rowset_function_limitedrowset_function_limited
Fonction OPENQUERY ou OPENROWSET , selon les possibilités du fournisseur.Is either the OPENQUERY or OPENROWSET function, subject to provider capabilities.

WITH ( <Table_Hint_Limited> )WITH ( <Table_Hint_Limited> )
Spécifie un ou plusieurs indicateurs de table autorisés pour une table cible.Specifies one or more table hints that are allowed for a target table. Le mot clé WITH et les parenthèses sont obligatoires.The WITH keyword and the parentheses are required. NOLOCK et READUNCOMMITTED ne sont pas autorisés.NOLOCK and READUNCOMMITTED are not allowed. Pour plus d’informations sur les indicateurs de table, consultez Indicateurs de table (Transact-SQL).For information about table hints, see Table Hints (Transact-SQL).

@table_variable@table_variable
Spécifie une variable table comme source de table.Specifies a table variable as a table source.

SETSET
Spécifie la liste des noms des colonnes ou des variables à mettre à jour.Specifies the list of column or variable names to be updated.

column_namecolumn_name
Colonne qui contient les données à modifier.Is a column that contains the data to be changed. column_name doit être spécifié dans table_or view_name.column_name must exist in table_or view_name. Il est impossible de mettre à jour les colonnes d'identité.Identity columns cannot be updated.

expressionexpression
Variable, valeur littérale, expression ou sous-instruction SELECT (entre parenthèses) retournant une valeur unique.Is a variable, literal value, expression, or a subselect statement (enclosed with parentheses) that returns a single value. La valeur retournée par expression remplace la valeur existante dans column_name ou @variable.The value returned by expression replaces the existing value in column_name or @variable.

Notes

Quand vous faites référence aux types de données caractères Unicode nchar, nvarchar et ntext, 'expression' doit être précédé de la majuscule « N ».When referencing the Unicode character data types nchar, nvarchar, and ntext, 'expression' should be prefixed with the capital letter 'N'. Si vous ne spécifiez pas « N », SQL ServerSQL Server convertit la chaîne dans la page de codes qui correspond au classement par défaut de la base de données ou de la colonne.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. Tous les caractères absents de cette page de codes sont alors perdus.Any characters not found in this code page are lost.

DEFAULTDEFAULT
Spécifie que la valeur par défaut définie pour la colonne doit remplacer la valeur actuelle de la colonne.Specifies that the default value defined for the column is to replace the existing value in the column. Cet argument peut également être utilisé pour attribuer la valeur NULL à la colonne si celle-ci n'a pas de valeur par défaut et autorise les valeurs 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.

{ += | -= | *= | /= | %= | &= | ^= | |= }{ += | -= | *= | /= | %= | &= | ^= | |= }
Opérateur d'assignation composé :Compound assignment operator:
+= Ajouter et assigner+= Add and assign
-= Soustraire et assigner-= Subtract and assign
*= Multiplier et assigner*= Multiply and assign
/= Diviser et assigner/= Divide and assign
%= Modulo et assigner%= Modulo and assign
&= AND au niveau du bit et assigner&= Bitwise AND and assign
^= XOR au niveau du bit et assigner^= Bitwise XOR and assign
|= OR au niveau du bit et assigner|= Bitwise OR and assign

udt_column_nameudt_column_name
Colonne définie par l'utilisateur.Is a user-defined type column.

property_name | field_nameproperty_name | field_name
Propriété publique ou membre de données public d'un type défini par l'utilisateur.Is a public property or public data member of a user-defined type.

method_name ( argument [ , ... n] )method_name ( argument [ ,... n] )
Méthode de mutateur public non statique de udt_column_name qui prend au moins un argument.Is a nonstatic public mutator method of udt_column_name that takes one or more arguments.

. WRITE ( expression , @Offset , @Length ). WRITE (expression,@Offset,@Length)
Indique qu’une section de la valeur de column_name doit être modifiée.Specifies that a section of the value of column_name is to be modified. expression remplace les unités @Length à partir de @Offset de column_name.expression replaces @Length units starting from @Offset of column_name. Seules des colonnes de type varchar(max) , nvarchar(max) ou varbinary(max) peuvent être spécifiées avec cette clause.Only columns of varchar(max), nvarchar(max), or varbinary(max) can be specified with this clause. column_name ne peut pas être NULL, ni être qualifié avec un nom ou un alias de table.column_name cannot be NULL and cannot be qualified with a table name or table alias.

expression est la valeur qui est copiée dans column_name.expression is the value that is copied to column_name. expression doit être du même type que column_name ou être implicitement casté dans ce type.expression must evaluate to or be able to be implicitly cast to the column_name type. Si expression a la valeur NULL, @Length est ignoré, et la valeur dans column_name est tronquée à la position @Offset spécifiée.If expression is set to NULL, @Length is ignored, and the value in column_name is truncated at the specified @Offset.

@Offset est le point de départ dans la valeur stockée dans column_nameexpression est inséré.@Offset is the starting point in the value stored in column_name at which expression is written. @Offset est une position d’octet ordinale calculée à partir de zéro, de type bigint et ne peut pas être un nombre négatif. @Offset is a zero-based ordinal byte position, is bigint, and cannot be a negative number. Si @Offset est NULL, la mise à jour ajoute expression à la fin de la valeur de column_name existante, et @Length est ignoré.If @Offset is NULL, the update operation appends expression at the end of the existing column_name value and @Length is ignored. Si @Offset est supérieur à la longueur d’octet de la valeur column_name, le Moteur de base de donnéesDatabase Engine retourne une erreur.If @Offset is greater than the byte length of the column_name value, the Moteur de base de donnéesDatabase Engine returns an error. Si @Offset plus @Length dépasse la fin de la valeur sous-jacente dans la colonne, toutes les données sont supprimées jusqu’au dernier caractère de la valeur.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.

@Length est la longueur de la section dans la colonne, à partir de @Offset, qui est remplacée par expression.@Length is the length of the section in the column, starting from @Offset, that is replaced by expression. @Length est de type bigint et ne peut pas être un nombre négatif. @Length is bigint and cannot be a negative number. Si @Length est NULL, la mise à jour supprime toutes les données entre @Offset et la fin de la valeur de column_name.If @Length is NULL, the update operation removes all data from @Offset to the end of the column_name value.

Pour plus d’informations, consultez la section Mise à jour des données de valeurs élevées.For more information, see Updating Large Value Data Types.

@ variable@ variable
Variable déclarée qui est définie à la valeur retournée par expression.Is a declared variable that is set to the value returned by expression.

SET @ variable = column = expression affecte à la variable la même valeur que la colonne.SET @variable = column = expression sets the variable to the same value as the column. Ceci est différent de SET @ variable = column, column = expression, qui affecte à la variable la valeur de la colonne avant la mise à jour.This differs from SET @variable = column, column = expression, which sets the variable to the pre-update value of the column.

<OUTPUT_Clause>
Retourne des données mises à jour ou des expressions associées dans le cadre de l'opération UPDATE.Returns updated data or expressions based on it as part of the UPDATE operation. La clause OUTPUT n'est pas prise en charge dans les instructions DML, qui ciblent les tables ou les vues distantes.The OUTPUT clause is not supported in any DML statements that target remote tables or views. Pour plus d’informations sur les arguments et le comportement de cette clause, consultez Clause OUTPUT (Transact-SQL).For more information about the arguments and behavior of this clause, see OUTPUT Clause (Transact-SQL).

FROM <table_source>FROM <table_source>
Spécifie qu'une table, une vue ou une source de table dérivée sont utilisées pour fournir les valeurs destinées à servir de critères en vue de la mise à jour.Specifies that a table, view, or derived table source is used to provide the criteria for the update operation. Pour plus d’informations, consultez FROM (Transact-SQL).For more information, see FROM (Transact-SQL).

Si l'objet mis à jour est le même que l'objet de la clause FROM et s'il n'existe qu'une seule référence à cet objet de la clause FROM, un alias d'objet pourra être spécifié ou non.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. Si l'objet mis à jour apparaît plusieurs fois dans la clause FROM, l'une des références, mais une seule, à cet objet ne doit pas spécifier un alias de la table.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. Toutes les autres références à l'objet dans la clause FROM doivent inclure un alias d'objet.All other references to the object in the FROM clause must include an object alias.

Une vue avec un déclencheur INSTEAD OF UPDATE ne peut pas servir de cible à une instruction UPDATE avec une clause FROM.A view with an INSTEAD OF UPDATE trigger cannot be a target of an UPDATE with a FROM clause.

Notes

Tout appel à OPENDATASOURCE, OPENQUERY ou OPENROWSET dans la clause FROM est évalué séparément et indépendamment de tout appel à ces fonctions utilisé comme cible de la mise à jour, même si des arguments identiques sont fournis aux deux appels.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. En particulier, les conditions de filtre ou de jointure appliquées sur le résultat de l'un de ces appels n'ont aucun effet sur les résultats de l'autre.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
Spécifie les conditions de limite des lignes mises à jour.Specifies the conditions that limit the rows that are updated. Il existe deux formes de mise à jour en fonction du contenu de la clause WHERE :There are two forms of update based on which form of the WHERE clause is used:

  • Les mises à jour avec recherche comportent une condition de recherche pour qualifier les lignes à supprimer.Searched updates specify a search condition to qualify the rows to delete.

  • Les mises à jour avec positions utilisent la clause CURRENT OF pour définir un curseur.Positioned updates use the CURRENT OF clause to specify a cursor. La mise à jour se produit à l'emplacement actuel du curseur.The update operation occurs at the current position of the cursor.

<search_condition>
Spécifie la condition à remplir pour mettre à jour les lignes.Specifies the condition to be met for the rows to be updated. La condition de recherche peut également être la condition sur laquelle est basée une jointure.The search condition can also be the condition upon which a join is based. Le nombre de prédicats inclus dans une condition de recherche est illimité.There is no limit to the number of predicates that can be included in a search condition. Pour plus d’informations sur les prédicats et conditions de recherche, consultez Condition de recherche (Transact-SQL).For more information about predicates and search conditions, see Search Condition (Transact-SQL).

CURRENT OFCURRENT OF
Spécifie que la mise à jour s'effectue à l'emplacement actuel du curseur spécifié.Specifies that the update is performed at the current position of the specified cursor.

Une mise à jour positionnée utilisant une clause WHERE CURRENT OF met à jour uniquement la ligne sur laquelle est positionné le curseur.A positioned update using a WHERE CURRENT OF clause updates the single row at the current position of the cursor. Cette opération peut s’avérer plus précise qu’une mise à jour avec recherche utilisant une clause WHERE <search_condition> pour définir les lignes à mettre à jour.This can be more accurate than a searched update that uses a WHERE <search_condition> clause to qualify the rows to be updated. Une mise à jour avec recherche modifie plusieurs lignes dès lors que la condition de recherche n'identifie pas de manière unique une seule ligne.A searched update modifies multiple rows when the search condition does not uniquely identify a single row.

GLOBALGLOBAL
Indique que cursor_name fait référence à un curseur global.Specifies that cursor_name refers to a global cursor.

cursor_namecursor_name
Nom du curseur ouvert grâce auquel s'effectue l'extraction.Is the name of the open cursor from which the fetch should be made. Si un curseur global et un curseur local portent tous les deux le nom cursor_name, cet argument fait référence au curseur global si GLOBAL est spécifié, et au curseur local dans tous les autres cas.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. Le curseur doit pouvoir gérer les mises à jour.The cursor must allow updates.

cursor_variable_namecursor_variable_name
Nom d’une variable de curseur.Is the name of a cursor variable. cursor_variable_name doit référencer un curseur qui autorise les mises à jour.cursor_variable_name must reference a cursor that allows updates.

OPTION ( <query_hint> [ , ... n ] )OPTION ( <query_hint> [ ,... n ] )
Spécifie que des indicateurs d’optimiseur sont utilisés pour personnaliser la façon dont le Moteur de base de donnéesDatabase Engine traite l’instruction.Specifies that optimizer hints are used to customize the way the Moteur de base de donnéesDatabase Engine processes the statement. Pour plus d’informations, consultez Indicateurs de requête (Transact-SQL).For more information, see Query Hints (Transact-SQL).

Meilleures pratiquesBest practices

Utilisez la fonction @@ROWCOUNT pour retourner le nombre de lignes insérées dans l’application cliente.Use the @@ROWCOUNT function to return the number of inserted rows to the client application. Pour plus d’informations, consultez @@ROWCOUNT (Transact-SQL).For more information, see @@ROWCOUNT (Transact-SQL).

Vous pouvez utiliser des noms de variables dans les instructions UPDATE pour présenter les anciennes et les nouvelles valeurs affectées, mais ceci n'est applicable que si l'instruction UPDATE n'affecte qu'un seul enregistrement.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. Si l’instruction UPDATE affecte plusieurs enregistrements, utilisez la clause OUTPUT pour retourner les anciennes et nouvelles valeurs de chaque enregistrement.If the UPDATE statement affects multiple records, to return the old and new values for each record, use the OUTPUT clause.

Soyez vigilant lors de la spécification de la clause FROM pour fournir les valeurs destinées à servir de critères en vue de la mise à jour.Use caution when specifying the FROM clause to provide the criteria for the update operation. Les résultats d'une instruction UPDATE ne sont pas définis si celle-ci comprend une clause FROM qui ne spécifie pas qu'une seule valeur doit être disponible pour chaque occurrence de colonne mise à jour ; à savoir, si l'instruction UPDATE n'est pas déterministe.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. Par exemple, étant donné l'instruction UPDATE dans le script suivant, les deux lignes dans Table1 correspondent aux qualifications de la clause FROM dans l'instruction UPDATE, mais il n'y a aucune précision quant à savoir quelle ligne de Table1 est utilisée pour mettre à jour la ligne de 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;  

Le même problème peut avoir lieu lors de la combinaison des deux clauses FROM et WHERE CURRENT OF.The same problem can occur when the FROM and WHERE CURRENT OF clauses are combined. Dans cet exemple, les deux lignes de Table2 correspondent aux qualifications de la clause FROM de l'instruction UPDATE.In the following example, both rows in Table2 meet the qualifications of the FROM clause in the UPDATE statement. Aucune précision n'est fournie quant à savoir quelle ligne de Table2 est utilisée pour mettre à jour la ligne de Table1.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  

Prise en charge de la compatibilitéCompatibility support

La prise en charge des indicateurs READUNCOMMITTED et NOLOCK dans la clause FROM s'appliquant à la table cible d'une instruction UPDATE ou DELETE sera supprimée dans une version future de SQL ServerSQL Server.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. Évitez d'utiliser ces indicateurs dans ce contexte lors de vos nouvelles tâches de développement, et pensez à modifier les applications qui les utilisent actuellement.Avoid using these hints in this context in new development work, and plan to modify applications that currently use them.

Types de donnéesData types

Toutes les colonnes char et nchar sont remplies par des espaces à droite jusqu’à la longueur définie.All char and nchar columns are right-padded to the defined length.

Si l’option ANSI_PADDING est désactivée (OFF), tous les espaces à droite sont supprimés des données insérées dans les colonnes varchar et nvarchar, sauf dans les chaînes contenant uniquement des espaces.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. Ces chaînes sont tronquées en une chaîne vide.These strings are truncated to an empty string. Si l'option ANSI_PADDING est activée (ON), des espaces supplémentaires sont insérés.If ANSI_PADDING is set to ON, trailing spaces are inserted. Au moment de la connexion, le pilote ODBC de Microsoft SQL Server et le fournisseur OLE DB pour SQL Server attribuent automatiquement la valeur ON à SET ANSI_PADDING.The Microsoft SQL Server ODBC driver and OLE DB Provider for SQL Server automatically set ANSI_PADDING ON for each connection. Ceci peut être configuré dans les sources de données ODBC ou lors de la définition des attributs ou des propriétés de connexion.This can be configured in ODBC data sources or by setting connection attributes or properties. Pour plus d’informations, consultez SET ANSI_PADDING (Transact-SQL).For more information, see SET ANSI_PADDING (Transact-SQL).

Mise à jour des colonnes de type text, ntext et imageUpdating text, ntext, and image columns

La modification d’une colonne text, ntext ou image avec une instruction UPDATE initialise la colonne, lui assigne un pointeur de texte valide et lui alloue au moins une page de données, sauf si la colonne est mise à jour avec des valeurs 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.

Pour remplacer ou modifier de grands blocs de données text, ntext ou image, utilisez WRITETEXT ou UPDATETEXT au lieu de l’instruction UPDATE.To replace or modify large blocks of text, ntext, or image data, use WRITETEXT or UPDATETEXT instead of the UPDATE statement.

Si l’instruction UPDATE peut modifier plusieurs lignes en mettant à jour la clé de clustering et une ou plusieurs colonnes text, ntext ou image, la mise à jour de ces colonnes est partiellement exécutée en remplaçant toutes ces valeurs.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.

Important

Les types de données ntext, text et image seront supprimés dans une version ultérieure de MicrosoftMicrosoftSQL ServerSQL Server.The ntext, text, and image data types will be removed in a future version of MicrosoftMicrosoftSQL ServerSQL Server. Évitez d'utiliser ces types de données dans un nouveau développement. Prévoyez de modifier les applications qui les utilisent actuellement.Avoid using these data types in new development work, and plan to modify applications that currently use them. Utilisez plutôt les types de données nvarchar(max), varchar(max)et varbinary(max) .Use nvarchar(max), varchar(max), and varbinary(max) instead.

Mise à jour des données de valeurs élevéesUpdating large value data types

Utilisez la clause . WRITE ( expression , @Offset , @Length ) pour effectuer une mise à jour partielle ou complète des types de données varchar(max) , nvarchar(max) et varbinary(max) .Use the . WRITE (expression,@Offset,@Length) clause to perform a partial or full update of varchar(max), nvarchar(max), and varbinary(max) data types.

Par exemple, une mise à jour partielle d’une colonne varchar(max) risque de supprimer ou modifier uniquement les 200 premiers octets de la colonne (200 caractères en cas d’utilisation de caractères ASCII), alors qu’une mise à jour complète supprime ou modifie toutes les données de cette colonne.For example, a partial update of a varchar(max) column might delete or modify only the first 200 bytes of the column (200 characters if using ASCII characters), whereas a full update would delete or modify all the data in the column. Les mises à jour .WRITE, qui insèrent ou ajoutent de nouvelles données, sont journalisées de façon minimale si vous avez spécifié un mode de récupération des bases de données simple ou journalisé en bloc..WRITE updates that insert or append new data are minimally logged if the database recovery model is set to bulk-logged or simple. La journalisation minimale n'est pas utilisée lors de la mise à jour de valeurs existantes.Minimal logging is not used when existing values are updated. Pour plus d'informations, consultez Journal des transactions (SQL Server).For more information, see The Transaction Log (SQL Server).

Le Moteur de base de donnéesDatabase Engine change une mise à jour partielle en mise à jour complète quand l’instruction UPDATE provoque l’une des actions suivantes :The Moteur de base de donnéesDatabase Engine converts a partial update to a full update when the UPDATE statement causes either of these actions:

  • Modification d'une colonne clé de la vue ou table partitionnée.Changes a key column of the partitioned view or table.
  • Modification de plusieurs lignes et mise à jour de la clé d'un index cluster non unique sur une valeur non constante.Modifies more than one row and also updates the key of a nonunique clustered index to a nonconstant value.

Vous ne pouvez pas utiliser la clause .WRITE pour mettre à jour une colonne NULL ou définir column_name avec la valeur NULL.You cannot use the .WRITE clause to update a NULL column or set the value of column_name to NULL.

@Offset et @Length sont spécifiés en octets pour les types de données varbinary et varchar, et en paires d’octets pour le type de données nvarchar.@Offset and @Length are specified in bytes for varbinary and varchar data types and in byte-pairs for the nvarchar data type. Pour plus d’informations sur les longueurs de type de données String, consultez char et varchar (Transact-SQL) et nchar et nvarchar (Transact-SQL).For more information on string data type lengths, see char and varchar (Transact-SQL) and nchar and nvarchar (Transact-SQL).

Pour optimiser les performances, nous recommandons l'insertion ou la mise à jour de données en blocs multiples de 8 040 octets.For best performance, we recommend that data be inserted or updated in chunk sizes that are multiples of 8040 bytes.

Si une clause OUTPUT référence la colonne modifiée par la clause .WRITE, la valeur complète de cette colonne (l’image avant dans deleted. column_name ou l’image après dans inserted. column_name) est retournée dans la colonne spécifiée dans la variable de table.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. Consultez l’exemple R ci-dessous.See example R that follows.

Pour utiliser les mêmes fonctions de la clause .WRITE avec des données de type caractère ou binaire, utilisez STUFF (Transact-SQL).To achieve the same functionality of .WRITE with other character or binary data types, use the STUFF (Transact-SQL).

Mise à jour des colonnes définies par l’utilisateurUpdating User-defined Type columns

La mise à jour des valeurs dans des colonnes de type défini par l'utilisateur peut s'effectuer de l'une des façons suivantes :Updating values in user-defined type columns can be accomplished in one of the following ways:

  • Fournir une valeur dans un type de données système SQL ServerSQL Server, à condition que le type défini par l'utilisateur prenne en charge la conversion de façon implicite ou explicite.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. L'exemple suivant indique comment mettre à jour une valeur dans une colonne définie par l'utilisateur Point, en la convertissant explicitement à partir d'une chaîne.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';  
    
  • Appeler une méthode, marquée comme mutateur, d'un type défini par l'utilisateur, pour procéder à la mise à jour.Invoking a method, marked as a mutator, of the user-defined type, to perform the update. L'exemple suivant appelle une méthode de mutateur du type Point appelé SetXY.The following example invokes a mutator method of type Point named SetXY. L'état de l'instance de ce type est mis à jour.This updates the state of the instance of the type.

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

    Notes

    SQL ServerSQL Server retourne une erreur si une méthode mutateur est appelée sur une valeur NULL Transact-SQLTransact-SQL ou si une nouvelle valeur produite par une méthode mutateur est 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.

  • Modifier la valeur d'une propriété enregistrée ou d'un membre de données public, défini par l'utilisateur.Modifying the value of a registered property or public data member of the user-defined type. L'expression qui fournit la valeur doit être implicitement convertible au type de propriété.The expression supplying the value must be implicitly convertible to the type of the property. L'exemple suivant modifie la valeur de propriété X du type défini par l'utilisateur 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';  
    

    Pour modifier différentes propriétés d'une colonne du même type défini par l'utilisateur, vous devez émettre plusieurs instructions UPDATE ou appeler la méthode du mutateur correspondant à ce type.To modify different properties of the same user-defined type column, issue multiple UPDATE statements, or invoke a mutator method of the type.

Mise à jour de données FILESTREAMUpdating FILESTREAM data

Vous pouvez utiliser l'instruction UPDATE pour mettre à jour un champ FILESTREAM avec une valeur Null, une valeur vide ou une quantité relativement faible de données incluses.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. Toutefois, une grande quantité de données est diffusée en continu plus efficacement dans un fichier à l'aide des interfaces Win32.However, a large amount of data is more efficiently streamed into a file by using Win32 interfaces. Lorsque vous mettez à jour un champ FILESTREAM, vous modifiez les données d'objet blob sous-jacentes dans le système de fichiers.When you update a FILESTREAM field, you modify the underlying BLOB data in the file system. Lorsqu'un champ FILESTREAM a la valeur NULL, les données d'objet blob associées au champ sont supprimées.When a FILESTREAM field is set to NULL, the BLOB data associated with the field is deleted. Vous ne pouvez pas utiliser .WRITE() pour appliquer des mises à jour partielles aux données FILESTREAM.You cannot use .WRITE(), to perform partial updates to FILESTREAM data. Pour plus d’informations, consultez FILESTREAM (SQL Server).For more information, see FILESTREAM (SQL Server).

Gestion des erreursError handling

Si la mise à jour d'une ligne enfreint une contrainte ou une règle, qu'elle viole le paramètre NULL de la colonne ou que la nouvelle valeur est d'un type de données incompatible, l'instruction est annulée, une erreur est retournée et aucun enregistrement n'est mis à jour.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.

Lorsqu'une instruction UPDATE rencontre une erreur arithmétique (erreur de dépassement de capacité, de division par zéro ou de domaine) lors de l'évaluation de l'expression, la mise à jour n'est pas effectuée.When an UPDATE statement encounters an arithmetic error (overflow, divide by zero, or a domain error) during expression evaluation, the update is not performed. Le reste du traitement n'est pas exécuté et un message d'erreur est retourné.The rest of the batch is not executed, and an error message is returned.

Si la mise à jour d'une ou de plusieurs colonnes participant à un index cluster conduit à une taille d'index et de ligne supérieure à 8 060 octets, la mise à jour n'est pas effectuée et un message d'erreur est retourné.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.

InteropérabilitéInteroperability

Vous pouvez insérer des instructions UPDATE dans le corps des fonctions définies par l'utilisateur uniquement si la table en cours de modification est une variable de table.UPDATE statements are allowed in the body of user-defined functions only if the table being modified is a table variable.

Quand un déclencheur INSTEAD OF est défini sur des actions UPDATE appliquées à une table, il est exécuté à la place de l’instruction UPDATE.When an INSTEAD OF trigger is defined on UPDATE actions against a table, the trigger is running instead of the UPDATE statement. Les versions antérieures de SQL ServerSQL Server prennent uniquement en charge les déclencheurs AFTER définis sur UPDATE et autres instructions de modification de données.Earlier versions of SQL ServerSQL Server only support AFTER triggers defined on UPDATE and other data modification statements. La clause FROM ne peut pas être spécifiée dans une instruction UPDATE qui référence, directement ou indirectement, à une vue sur laquelle est défini un déclencheur 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. Pour plus d’informations sur les déclencheurs INSTEAD OF, consultez CREATE TRIGGER (Transact-SQL).For more information about INSTEAD OF triggers, see CREATE TRIGGER (Transact-SQL).

Limitations et restrictionsLimitations and restrictions

La clause FROM ne peut pas être spécifiée dans une instruction UPDATE qui référence, directement ou indirectement, une vue sur laquelle est défini un déclencheur 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. Pour plus d’informations sur les déclencheurs INSTEAD OF, consultez CREATE TRIGGER (Transact-SQL).For more information about INSTEAD OF triggers, see CREATE TRIGGER (Transact-SQL).

Lorsqu'une expression de table commune (CTE) est la cible d'une instruction UPDATE, toutes les références cette expression de table commune dans l'instruction doivent correspondre.When a common table expression (CTE) is the target of an UPDATE statement, all references to the CTE in the statement must match. Par exemple, si un alias est affecté à l'expression de table commune dans la clause FROM, cet alias doit être utilisé pour toutes les autres références à l'expression de table commune.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. Des références non ambiguës à l'expression de table commune sont requises, car une expression de table commune n'a pas d'ID d'objet, lequel est utilisé par SQL ServerSQL Server pour identifier la relation implicite entre un objet et son 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. Sans cette relation, le plan de requête peut avoir un comportement de jointure et des résultats de requête inattendus.Without this relationship, the query plan may produce unexpected join behavior and unintended query results. Les exemples suivants illustrent l'utilisation de méthodes correctes et incorrectes en matière de spécification d'une expression de table commune lorsque celle-ci est l'objet cible de l'opération de mise à jour.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  

Voici le jeu de résultats obtenu.Here is the result set.

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

Instruction UPDATE avec des références d’expression de table commune qui ne sont pas mappées correctement.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  

Voici le jeu de résultats obtenu.Here is the result set.

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

Comportement du verrouillageLocking behavior

Une instruction UPDATE acquiert un verrou exclusif (X) sur les lignes qu’elle modifie et maintient ces verrous jusqu’à la fin de la transaction.An UPDATE statement acquires an exclusive (X) lock on any rows that it modifies, and holds these locks until the transaction completes. Selon le plan de requête de l’instruction UPDATE, le nombre de lignes modifiées et le niveau d’isolation de la transaction, les verrous peuvent être acquis au niveau de PAGE ou de TABLE plutôt qu’au niveau de ROW.Depending on the query plan for the UPDATE statement, the number of rows being modified, and the isolation level of the transaction, locks may be acquired at the PAGE level or TABLE level rather than the ROW level. Pour éviter ces verrous de niveau supérieur, scindez les instructions UPDATE qui portent sur des milliers de lignes voire plus en lots et vérifiez que les conditions de jointure et de filtre sont prises en charge par les index.To avoid these higher level locks, consider dividing update statements that affect thousands of rows or more into batches, and ensure that any join and filter conditions are supported by indexes. Pour plus d’informations sur les mécanismes de verrouillage dans SQL Server, consultez l’article traitant du verrouillage dans le moteur de base de données.See the article on Locking in the Database Engine for more details on locking mechanics in SQL Server.

Comportement de journalisationLogging behavior

L’instruction UPDATE est journalisée. Cependant, les mises à jour partielles de données de valeurs élevées avec la clause .WRITE sont journalisées de façon minimale.The UPDATE statement is logged; however, partial updates to large value data types using the .WRITE clause are minimally logged. Pour plus d’informations, consultez « Mise à jour des données de valeurs élevées » de la section précédente « Types de données ».For more information, see "Updating Large Value Data Types" in the earlier section "Data Types".

SécuritéSecurity

AutorisationsPermissions

Les autorisations UPDATE sont obligatoires sur la table cible.UPDATE permissions are required on the target table. Les autorisations SELECT sont également obligatoires pour la table mise à jour si l’instruction UPDATE contient une clause WHERE ou si expression dans la clause SET utilise une colonne de la table.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.

Les autorisations UPDATE sont attribuées par défaut aux membres du rôle serveur fixe sysadmin, aux membres des rôles de base de données fixes db_owner et db_datawriter ainsi qu’au propriétaire de la table.UPDATE permissions default to members of the sysadmin fixed server role, the db_owner and db_datawriter fixed database roles, and the table owner. Les membres des rôles sysadmin, db_owner, et db_securityadmin ainsi que le propriétaire de la table peuvent transférer des autorisations à d’autres utilisateurs.Members of the sysadmin, db_owner, and db_securityadmin roles, and the table owner can transfer permissions to other users.

ExemplesExamples

CategoryCategory Éléments syntaxiques proposésFeatured syntax elements
Syntaxe de baseBasic Syntax UPDATEUPDATE
Limitation des lignes mises à jourLimiting the Rows that Are Updated WHERE • TOP • WITH expression de table commune • WHERE CURRENT OFWHERE • TOP • WITH common table expression • WHERE CURRENT OF
Définition des valeurs de colonneSetting Column Values valeurs calculées • opérateurs composés • valeurs par défaut • sous-requêtescomputed values • compound operators • default values • subqueries
Spécification d’objets cibles autres que les tables standardSpecifying Target Objects Other than Standard Tables vues • variables de table • alias de tableviews • table variables • table aliases
Mise à jour de données en fonction des données d’autres tablesUpdating Data Based on Data From Other Tables FROMFROM
Mise à jour de lignes dans une table distanteUpdating Rows in a Remote Table serveur lié • OPENQUERY • OPENDATASOURCElinked server • OPENQUERY • OPENDATASOURCE
Mise à jour de types de données Large Object (LOB)Updating Large Object Data Types .WRITE • OPENROWSET.WRITE • OPENROWSET
Mise à jour de types définis par l’utilisateurUpdating User-defined Types types définis par l'utilisateuruser-defined types
Substitution du comportement par défaut de l’optimiseur de requête à l’aide d’indicateursOverriding the Default Behavior of the Query Optimizer by Using Hints indicateurs de table • indicateurs de requêtetable hints • query hints
Capture des résultats de l’instruction UPDATECapturing the Results of the UPDATE Statement Clause OUTPUTOUTPUT clause
Utilisation de l’instruction UPDATE dans d’autres instructionsUsing UPDATE in Other Statements Procédures stockées • TRY...CATCHStored Procedures • TRY...CATCH

Syntaxe de baseBasic syntax

Les exemples fournis dans cette section présentent les fonctionnalités de base de l'instruction UPDATE en utilisant la syntaxe minimale requise.Examples in this section demonstrate the basic functionality of the UPDATE statement using the minimum required syntax.

R.A. Utilisation d'une instruction UPDATE simpleUsing a simple UPDATE statement

L'exemple suivant met à jour une colonne unique pour toutes les lignes de la table 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. Mise à jour de plusieurs colonnesUpdating multiple columns

L'exemple suivant met à jour les valeurs dans les colonnes Bonus, CommissionPct et SalesQuota pour toutes les lignes de la table 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  

Limitation des lignes mises à jourLimiting the Rows that Are Updated

Les exemples de cette section montrent les différentes méthodes que vous pouvez utiliser pour limiter le nombre de lignes affectées par l'instruction UPDATE.Examples in this section demonstrate ways that you can use to limit the number of rows affected by the UPDATE statement.

C.C. Utilisation de la clause WHEREUsing the WHERE clause

L'exemple suivant utilise la clause WHERE pour spécifier quelles lignes mettre à jour.The following example uses the WHERE clause to specify which rows to update. L'instruction met à jour la valeur dans la colonne Color de la table Production.Product pour toutes les lignes qui ont une valeur existante de « Red » (rouge) dans la colonne Color et ont une valeur dans la colonne Name qui commence par « 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. Utilisation de la clause TOPUsing the TOP clause

Les exemples suivants utilisent la clause TOP pour limiter le nombre de lignes modifiées dans une instruction UPDATE.The following examples use the TOP clause to limit the number of rows that are modified in an UPDATE statement. Quand une clause TOP (n) est utilisée avec UPDATE, la mise à jour est effectuée sur une sélection aléatoire de n lignes.When a TOP (n) clause is used with UPDATE, the update operation is performed on a random selection of 'n' number of rows. L'exemple suivant met à jour la colonne VacationHours à hauteur de 25 % pour 10 lignes aléatoires dans la table 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  

Si vous devez utiliser la clause TOP pour appliquer des mises à jour en respectant une certaine chronologie, vous devez combiner les clauses TOP et ORDER BY dans une instruction de sous-sélection.If you must use TOP to apply updates in a meaningful chronology, you must use TOP together with ORDER BY in a subselect statement. L'exemple ci-dessous met à jour les heures de congé des 10 employés dont la date d'embauche est la plus ancienne.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. Utilisation de la clause WITH common_table_expressionUsing the WITH common_table_expression clause

L'exemple suivant met à jour la valeur PerAssemblyQty pour l'ensemble des parties et des composants utilisés directement ou indirectement pour créer ProductAssemblyID 800.The following example updates the PerAssemblyQty value for all parts and components that are used directly or indirectly to create the ProductAssemblyID 800. L’expression de table commune retourne une liste hiérarchique des parties utilisées directement pour générer ProductAssemblyID 800 et des parties utilisées pour générer ces composants, et ainsi de suite.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. Seules les lignes renvoyées par l'expression de table commune récursive sont modifiées.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. Utilisation de la clause WHERE CURRENT OFUsing the WHERE CURRENT OF clause

L'exemple suivant utilise la clause WHERE CURRENT OF pour mettre à jour uniquement la ligne sur laquelle le curseur est positionné.The following example uses the WHERE CURRENT OF clause to update only the row on which the cursor is positioned. Dans le cas d'un curseur basé sur une jointure, seul le paramètre table_name spécifié dans l'instruction UPDATE est modifié.When a cursor is based on a join, only the table_name specified in the UPDATE statement is modified. Les autres tables participant au curseur ne sont pas affectées.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  

Définition des valeurs de colonneSetting Column Values

Les exemples de cette section illustrent la mise à jour de colonnes à l'aide de valeurs calculées, de sous-requêtes et des valeurs DEFAULT.Examples in this section demonstrate updating columns by using computed values, subqueries, and DEFAULT values.

G.G. Spécification d'une valeur calculéeSpecifying a computed value

Les exemples suivants utilisent des valeurs calculées dans une instruction UPDATE.The following examples uses computed values in an UPDATE statement. Cet exemple double la valeur dans la colonne ListPrice pour toutes les lignes de la table 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. Spécification d'un opérateur composéSpecifying a compound operator

L'exemple suivant utilise la variable @NewPrice pour incrémenter le prix de toutes les bicyclettes rouges en prenant le prix actuel et en lui ajoutant 10.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  

L'exemple suivant utilise l'opérateur composé += pour ajouter les données ' - tool malfunction' à la valeur existante dans la colonne Name pour les lignes qui ont un ScrapReasonID compris entre 10 et 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. Spécification d'une sous-requête dans la clause SETSpecifying a subquery in the SET clause

L'exemple suivant utilise une sous-requête dans la clause SET pour déterminer la valeur utilisée pour mettre à jour la colonne.The following example uses a subquery in the SET clause to determine the value that is used to update the column. La sous-requête doit retourner uniquement une valeur scalaire (autrement dit, une valeur unique par ligne).The subquery must return only a scalar value (that is, a single value per row). Cet exemple modifie la colonne SalesYTD dans la table SalesPerson pour illustrer les dernières ventes enregistrées dans la table SalesOrderHeader.The example modifies the SalesYTD column in the SalesPerson table to reflect the most recent sales recorded in the SalesOrderHeader table. La sous-requête agrège les ventes de chaque commercial dans l'instruction 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. Mise à jour de lignes à l'aide des valeurs DEFAULTUpdating rows using DEFAULT values

L'exemple suivant définit la colonne CostRate sur sa valeur par défaut (0.00) pour toutes les lignes qui ont une valeur CostRate supérieure à 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;  

Spécification d’objets cibles autres que les tables standardSpecifying Target Objects Other Than Standard Tables

Les exemples présentés dans cette section montrent comment mettre à jour des lignes en spécifiant une variable de table, un alias de table ou une vue.Examples in this section demonstrate how to update rows by specifying a view, table alias, or table variable.

K.K. Spécification d'une vue comme objet cibleSpecifying a view as the target object

L'exemple suivant met à jour des lignes dans une table en spécifiant une vue comme objet cible.The following example updates rows in a table by specifying a view as the target object. La définition de la vue référence plusieurs tables. Toutefois, l'instruction UPDATE réussit car elle référence des colonnes d'une seule des tables sous-jacentes.The view definition references multiple tables, however, the UPDATE statement succeeds because it references columns from only one of the underlying tables. L'instruction UPDATE échouerait si des colonnes des deux tables étaient spécifiées.The UPDATE statement would fail if columns from both tables were specified. Pour plus d’informations, consultez Modifier les données par l’intermédiaire d’une vue.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. Spécification d'un alias de table comme objet cibleSpecifying a table alias as the target object

L'exemple suivant met à jour des lignes dans la table Production.ScrapReason.The follow example updates rows in the table Production.ScrapReason. L'alias de table affecté à ScrapReason dans la clause FROM est spécifié comme objet cible dans la clause 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. Spécification d'une variable de table comme objet cibleSpecifying a table variable as the target object

L'exemple suivant met à jour des lignes dans une variable de table.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  

Mise à jour de données en fonction des données d’autres tablesUpdating Data Based on Data From Other Tables

Les exemples fournis dans cette section présentent des méthodes de mise à jour de lignes d'une table en fonction d'informations contenues dans une autre table.Examples in this section demonstrate methods of updating rows from one table based on information in another table.

N.N. Utilisation de l'instruction UPDATE avec des informations provenant d'une autre tableUsing the UPDATE statement with information from another table

L'exemple suivant modifie la colonne SalesYTD dans la table SalesPerson pour illustrer les dernières ventes enregistrées dans la table 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  

L'exemple précédent suppose qu'une seule vente est enregistrée pour un vendeur particulier sur une date donnée et que les mises à jour sont actuelles.The previous example assumes that only one sale is recorded for a specified salesperson on a specific date and that updates are current. Cet exemple ne convient pas si plusieurs ventes peuvent être enregistrées pour un vendeur donné au cours d'une même journée.If more than one sale for a specified salesperson can be recorded on the same day, the example shown does not work correctly. Il s’exécutera sans erreur, mais chaque valeur SalesYTD ne sera mise à jour que pour une seule vente, en dépit du nombre de ventes ayant réellement eu lieu ce jour-là.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. En effet, une instruction UPDATE ne met jamais une même ligne à jour à deux reprises.This is because a single UPDATE statement never updates the same row two times.

Au cas où plusieurs ventes pourraient avoir lieu le même jour pour un commercial donné, toutes les ventes de chaque commercial doivent être agrégées dans l'instruction UPDATE, comme le montre l'exemple suivant :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  

Mise à jour de lignes dans une table distanteUpdating rows in a remote table

Les exemples présentés dans cette section montrent comment mettre à jour des lignes dans une table cible distante en utilisant un serveur lié ou une fonction d’ensemble de lignes pour référencer la table distante.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. Mise à jour de données dans une table distante en utilisant un serveur liéUpdating data in a remote table by using a linked server

L'exemple suivant met à jour une table sur un serveur distant.The following example updates a table on a remote server. L’exemple commence par créer un lien vers la source de données distante en utilisant sp_addlinkedserver.The example begins by creating a link to the remote data source by using sp_addlinkedserver. Le nom du serveur lié, MyLinkedServer, est ensuite spécifié dans un nom d'objet en quatre parties qui se présente sous la forme server.catalog.schema.object.The linked server name, MyLinkedServer, is then specified as part of the four-part object name in the form server.catalog.schema.object. Notez que vous devez spécifier un nom de serveur valide pour @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'MyLinkedServer',  
    @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 MyLinkedServer.AdventureWorks2012.HumanResources.Department  
SET GroupName = N'Public Relations'  
WHERE DepartmentID = 4;  

P.P. Mise à jour de données dans une table distante en utilisant la fonction OPENQUERYUpdating data in a remote table by using the OPENQUERY function

L’exemple suivant met à jour une ligne dans une table distante en spécifiant la fonction d’ensemble de lignes OPENQUERY.The following example updates a row in a remote table by specifying the OPENQUERY rowset function. Le nom de serveur lié créé dans l'exemple précédent est utilisé dans cet exemple.The linked server name created in the previous example is used in this example.

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

Q.Q. Mise à jour de données dans une table distante en utilisant la fonction OPENDATASOURCEUpdating data in a remote table by using the OPENDATASOURCE function

L’exemple suivant met à jour une ligne dans une table distante en spécifiant la fonction d’ensemble de lignes OPENDATASOURCE.The following example updates a row in a remote table by specifying the OPENDATASOURCE rowset function. Spécifiez un nom de serveur valide pour la source de données en utilisant le format server_name ou server_name\instance_name.Specify a valid server name for the data source by using the format server_name or server_name\instance_name. Vous devrez peut-être configurer l'instance de SQL ServerSQL Server pour les requêtes distribuées appropriées.You may need to configure the instance of SQL ServerSQL Server for Ad Hoc Distributed Queries. Pour plus d’informations, consultez la page Option de configuration du serveur : requêtes distribuées ad hoc.For more information, see ad hoc distributed queries Server Configuration Option.

UPDATE OPENDATASOURCE('SQLNCLI', 'Data Source=<server name>;Integrated Security=SSPI').AdventureWorks2012.HumanResources.Department
SET GroupName = 'Sales and Marketing' WHERE DepartmentID = 4;  

Mise à jour de types de données Large Object (LOB)Updating Large Object data types

Les exemples de cette section illustrent des méthodes de mise à jour de valeurs dans les colonnes définies avec les types de données LOB.Examples in this section demonstrate methods of updating values in columns that are defined with large object (LOB) data types.

R.R. Utilisation de l'instruction UPDATE avec la clause .WRITE pour modifier les données dans une colonne nvarchar(max)Using UPDATE with .WRITE to modify data in an nvarchar(max) column

L’exemple suivant utilise la clause .WRITE pour mettre à jour une valeur partielle dans DocumentSummary, une colonnenvarchar(max) dans la table Production.Document.The following example uses the .WRITE clause to update a partial value in DocumentSummary, an nvarchar(max) column in the Production.Document table. Le terme components est remplacé par le terme features, en spécifiant le terme de remplacement, l'emplacement de départ (décalage) du terme à remplacer dans les données existantes et le nombre de caractères à remplacer (longueur).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). L’exemple utilise également la clause OUTPUT pour retourner les images avant et après de la colonne DocumentSummary à la variable de table @MyTableVar.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. Utilisation de l'instruction UPDATE avec la clause .WRITE pour ajouter et supprimer des données dans une colonne nvarchar(max)Using UPDATE with .WRITE to add and remove data in an nvarchar(max) column

Les exemples suivants ajoutent et suppriment les données d’une colonne nvarchar(max) dont la valeur est définie à NULL.The following examples add and remove data from an nvarchar(max) column that has a value currently set to NULL. Étant donné que la clause .WRITE ne peut pas être utilisée pour modifier une colonne NULL, celle-ci est d’abord remplie avec des données provisoires.Because the .WRITE clause cannot be used to modify a NULL column, the column is first populated with temporary data. Ces données sont ensuite remplacées par les données appropriées à l'aide de la clause .WRITE.This data is then replaced with the correct data by using the .WRITE clause. Les exemples supplémentaires ajoutent des données à la fin de la valeur de colonne, suppriment (tronquent) les données de la colonne et, pour finir, suppriment les données partielles de la colonne.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. Les instructions SELECT affichent la modification de données générée par chaque instruction 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. Utilisation de l'instruction UPDATE avec OPENROWSET pour modifier une colonne varbinary(max)Using UPDATE with OPENROWSET to modify a varbinary(max) column

L’exemple suivant remplace une image existante stockée dans une colonne varbinary(max) par une nouvelle image.The following example replaces an existing image stored in a varbinary(max) column with a new image. La fonction OPENROWSET est utilisée en conjonction avec l’option BULK pour charger l’image dans la colonne.The OPENROWSET function is used with the BULK option to load the image into the column. Cet exemple suppose qu'un fichier nommé Tires.jpg existe dans le chemin d'accès spécifié.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. Utilisation de l'instruction UPDATE pour modifier des données FILESTREAMUsing UPDATE to modify FILESTREAM data

L'exemple suivant utilise l'instruction UPDATE pour modifier les données dans le fichier de système de fichiers.The following example uses the UPDATE statement to modify the data in the file system file. Nous déconseillons cette méthode pour transmettre en continu de grandes quantités de données à un fichier.We do not recommend this method for streaming large amounts of data to a file. Utilisez les interfaces Win32 appropriées.Use the appropriate Win32 interfaces. L'exemple suivant remplace tout texte dans l'enregistrement de fichier par le texte Xray 1.The following example replaces any text in the file record with the text Xray 1. Pour plus d’informations, consultez 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;  

Mise à jour de types définis par l’utilisateurUpdating User-defined Types

Les exemples suivants modifient des valeurs dans les colonnes de type clr défini par l'utilisateur (UDT).The following examples modify values in CLR user-defined type (UDT) columns. Trois méthodes sont illustrées.Three methods are demonstrated. Pour plus d’informations sur les colonnes définies par l’utilisateur, consultez Types CLR définis par l’utilisateur.For more information about user-defined columns, see CLR User-Defined Types.

V.V. Utilisation d'un type de données systèmeUsing a system data type

Vous pouvez mettre à jour un UDT en fournissant une valeur dans un type de données système SQL ServerSQL Server, à condition que le type défini par l'utilisateur prenne en charge la conversion de façon implicite ou explicite.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. L'exemple suivant indique comment mettre à jour une valeur dans une colonne définie par l'utilisateur Point, en la convertissant explicitement à partir d'une chaîne.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';  

Heure standardW. Appel d’une méthodeInvoking a method

Vous pouvez mettre à jour un UDT en appelant une méthode, marquée en tant que mutateur, du type défini par l'utilisateur afin d'effectuer la mise à jour.You can update a UDT by invoking a method, marked as a mutator, of the user-defined type, to perform the update. L'exemple suivant appelle une méthode de mutateur du type Point appelé SetXY.The following example invokes a mutator method of type Point named SetXY. L'état de l'instance de ce type est mis à jour.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. Modification de la valeur d'une propriété ou d'un membre de donnéesModifying the value of a property or data member

Vous pouvez mettre à jour un UDT en modifiant la valeur d'une propriété inscrite ou d'un membre de données publiques du type défini par l'utilisateur.You can update a UDT by modifying the value of a registered property or public data member of the user-defined type. L'expression qui fournit la valeur doit être implicitement convertible au type de propriété.The expression supplying the value must be implicitly convertible to the type of the property. L'exemple suivant modifie la valeur de propriété X du type défini par l'utilisateur 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';  

Remplacement du comportement par défaut de l’optimiseur de requête à l’aide d’indicateursOverriding the Default Behavior of the Query Optimizer by Using Hints

Les exemples présentés dans cette section montrent comment utiliser des indicateurs de table et de requête pour substituer temporairement le comportement par défaut de l'optimiseur de requête lors du traitement de l'instruction 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.

Attention

Étant donné que l'optimiseur de requête SQL ServerSQL Server sélectionne généralement le meilleur plan d'exécution pour une requête, nous vous recommandons de ne recourir à ces conseils qu'en dernier ressort et seulement si vous êtes un développeur ou un administrateur de base de données expérimenté.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. Spécification d'un indicateur de tableSpecifying a table hint

L’exemple suivant spécifie l’indicateur de table TABLOCK.The following example specifies the table hint TABLOCK. Cet indicateur spécifie qu'un verrou partagé est établi sur la table Production.Product et maintenu jusqu'à la fin de l'instruction 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. Spécification d'un indicateur de requêteSpecifying a query hint

L’exemple suivant spécifie l’indicateur de requêteOPTIMIZE FOR (@variable) dans l’instruction UPDATE.The following example specifies the query hintOPTIMIZE FOR (@variable) in the UPDATE statement. Cet indicateur spécifie à l'optimiseur de requête d'attribuer à une variable locale une valeur déterminée lors de la compilation et de l'optimisation de la requête.This hint instructs the query optimizer to use a particular value for a local variable when the query is compiled and optimized. Cette valeur n'est utilisée que pendant l'optimisation de la requête, et non pas lors de son exécution.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-%';  

Capture des résultats de l’instruction UPDATECapturing the results of the UPDATE statement

Les exemples présentés dans cette section montrent comment utiliser la clause OUTPUT pour retourner des informations de chaque ligne affectée par une instruction UPDATE, ou des expressions basées sur ces lignes.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. Ces résultats peuvent être retournés à l'application en cours de traitement afin d'être utilisés notamment avec des messages de confirmation, des opérations d'archivage et d'autres spécifications d'application similaires.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. Utilisation de l'instruction UPDATE avec la clause OUTPUTUsing UPDATE with the OUTPUT clause

L'exemple suivant met à jour la colonne VacationHours dans la table Employee par 25 pour cent pour les 10 premières lignes et définit également la valeur dans la colonne ModifiedDate sur la date actuelle.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 clause OUTPUT retourne la valeur de VacationHours qui existe avant l'application de l'instruction UPDATE dans la colonne deleted.VacationHours et la valeur mise à jour dans la colonne inserted.VacationHours sur la variable de table @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.

Deux instructions SELECT suivent ; elles retournent les valeurs dans @MyTableVar, ainsi que les résultats de la mise à jour dans la table Employee.Two SELECT statements follow that return the values in @MyTableVar and the results of the update operation in the Employee table. Pour plus d’exemples d’utilisation de la clause OUTPUT, consultez OUTPUT, clause (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  

Utilisation de l’instruction UPDATE dans d’autres instructionsUsing UPDATE in other statements

Les exemples de cette section montrent comment utiliser UPDATE dans d'autres instructions.Examples in this section demonstrate how to use UPDATE in other statements.

AB.AB. Utilisation de l'instruction UPDATE dans une procédure stockéeUsing UPDATE in a stored procedure

L'exemple ci-dessous utilise une instruction UPDATE dans une procédure stockée.The following example uses an UPDATE statement in a stored procedure. La procédure accepte un paramètre d'entrée, @NewHours et un paramètre de sortie @RowCount.The procedure takes one input parameter, @NewHours and one output parameter @RowCount. La valeur du paramètre @NewHours est utilisée dans l’instruction UPDATE pour mettre à jour la colonne VacationHours de la table HumanResources.Employee.The @NewHours parameter value is used in the UPDATE statement to update the column VacationHours in the table HumanResources.Employee. Le paramètre de sortie @RowCount est utilisé pour retourner le nombre de lignes affectées à une variable locale.The @RowCount output parameter is used to return the number of rows affected to a local variable. L'expression CASE est utilisée dans la clause SET pour déterminer de manière conditionnelle la valeur qui est définie pour VacationHours.The CASE expression is used in the SET clause to conditionally determine the value that is set for VacationHours. Lorsque l'employé est payé à l'heure (SalariedFlag = 0), VacationHours est défini avec le nombre actuel d'heures plus la valeur spécifiée dans @NewHours ; sinon, VacationHours est défini avec la valeur spécifiée dans @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. Utilisation de l’instruction UPDATE dans un bloc TRY...CATCHUsing UPDATE in a TRY...CATCH Block

L’exemple suivant utilise une instruction UPDATE dans un bloc TRY...CATCH pour gérer les erreurs d’exécution qui peuvent se produire pendant l’opération de mise à jour.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  

Exemples : Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) et Parallel Data WarehouseParallel Data WarehouseExamples: Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) and Parallel Data WarehouseParallel Data Warehouse

AD.AD. Utilisation d'une instruction UPDATE simpleUsing a simple UPDATE statement

Les exemples suivants montrent comment une mise à jour peut affecter toutes les lignes quand la clause WHERE n’est pas utilisée pour spécifier la ou les lignes à mettre à jour.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.

Cet exemple met à jour les valeurs dans les colonnes EndDate et CurrentFlag pour toutes les lignes de la table DimEmployee.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';  

Vous pouvez également utiliser des valeurs calculées dans une instruction UPDATE.You can also use computed values in an UPDATE statement. L'exemple suivant double la valeur dans la colonne ListPrice pour toutes les lignes de la table 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. Utilisation de l’instruction UPDATE avec une clause WHEREUsing the UPDATE statement with a WHERE clause

L'exemple suivant utilise la clause WHERE pour spécifier quelles lignes mettre à jour.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. Utilisation de l’instruction UPDATE avec une étiquetteUsing the UPDATE statement with label

L’exemple suivant montre comment ajouter une étiquette (LABEL) dans l’instruction 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. Utilisation de l'instruction UPDATE avec des informations provenant d'une autre tableUsing the UPDATE statement with information from another table

Cet exemple crée une table qui stocke le total des ventes annuelles.This example creates a table to store total sales by year. Il met à jour le total des ventes durant l’année 2004 en exécutant une instruction SELECT sur la table 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. Jointure ANSI pour les instructions de mise à jourANSI join for update statements

Cet exemple montre comment mettre à jour des données en fonction du résultat de la jointure d’une autre table.This example shows how to update data based on the result from joining another table.

CREATE TABLE dbo.Table1   
    (ColA INT NOT NULL, ColB DECIMAL(10,3) NOT NULL);  
GO  
CREATE TABLE dbo.Table2   
    (ColA INT NOT NULL, ColB DECIMAL(10,3) NOT NULL);  
GO  
INSERT INTO dbo.Table1 VALUES(1, 10.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;
GO

Voir aussiSee Also

CREATE TABLE (Transact-SQL) CREATE TABLE (Transact-SQL)
CREATE TRIGGER (Transact-SQL) CREATE TRIGGER (Transact-SQL)
Curseurs (Transact-SQL) Cursors (Transact-SQL)
DELETE (Transact-SQL) DELETE (Transact-SQL)
INSERT (Transact-SQL) INSERT (Transact-SQL)
Fonctions texte et image (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)
Prise en charge d'Unicode et du classement Collation and Unicode Support
Jeux de caractères codés sur un octet et multioctetsSingle-Byte and Multibyte Character Sets