DECLARE (Transact-SQL)DECLARE (Transact-SQL)

S’APPLIQUE À : ouiSQL Server ouiAzure SQL Database ouiAzure SQL Data Warehouse ouiParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database yesAzure SQL Data Warehouse yesParallel Data Warehouse

Les variables sont déclarées au sein d'un lot ou d'une procédure avec l'instruction DECLARE, et l'instruction SET ou SELECT leur affecte des valeurs.Variables are declared in the body of a batch or procedure with the DECLARE statement and are assigned values by using either a SET or SELECT statement. Les variables curseur peuvent être déclarées avec cette instruction, puis utilisées avec d'autres instructions liées aux curseurs.Cursor variables can be declared with this statement and used with other cursor-related statements. Après la déclaration, toutes les variables sont initialisées avec la valeur NULL., à moins qu'une valeur ne soit fournie dans le cadre de la déclaration.After declaration, all variables are initialized as NULL, unless a value is provided as part of the declaration.

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

SyntaxeSyntax

-- Syntax for SQL Server and Azure SQL Database  
  
DECLARE   
{   
    { @local_variable [AS] data_type  [ = value ] }  
  | { @cursor_variable_name CURSOR }  
} [,...n]   
| { @table_variable_name [AS] <table_type_definition> }   
  
<table_type_definition> ::=   
     TABLE ( { <column_definition> | <table_constraint> } [ ,...n] )   
  
<column_definition> ::=   
     column_name { scalar_data_type | AS computed_column_expression }  
     [ COLLATE collation_name ]   
     [ [ DEFAULT constant_expression ] | IDENTITY [ (seed ,increment ) ] ]   
     [ ROWGUIDCOL ]   
     [ <column_constraint> ]   
  
<column_constraint> ::=   
     { [ NULL | NOT NULL ]   
     | [ PRIMARY KEY | UNIQUE ]   
     | CHECK ( logical_expression )   
     | WITH ( <index_option > )  
     }   
  
<table_constraint> ::=   
     { { PRIMARY KEY | UNIQUE } ( column_name [ ,...n] )   
     | CHECK ( search_condition )   
     }   
  
<index_option> ::=  
See CREATE TABLE for index option syntax.  
  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
DECLARE   
{{ @local_variable [AS] data_type } [ =value [ COLLATE <collation_name> ] ] } [,...n]  
  

ArgumentsArguments

@local_variable@local_variable
Nom d'une variable.Is the name of a variable. Les noms de variables doivent commencer par le signe @.Variable names must begin with an at (@) sign. Les noms de variables locales doivent être conformes aux règles applicables aux identificateurs.Local variable names must comply with the rules for identifiers.

data_typedata_type
Il s'agit de tout type de table CLR (Common Language Runtime) défini par l'utilisateur, fourni par le système, ou type de données alias.Is any system-supplied, common language runtime (CLR) user-defined table type, or alias data type. Une variable ne peut pas être de type text, ntext ou image.A variable cannot be of text, ntext, or image data type.

Pour plus d’informations sur les types de données système, consultez Types de données (Transact-SQL).For more information about system data types, see Data Types (Transact-SQL). Pour plus d’informations sur les types de données CLR définis par l’utilisateur ou les types de données alias, consultez CREATE TYPE (Transact-SQL).For more information about CLR user-defined types or alias data types, see CREATE TYPE (Transact-SQL).

=value=value
Attribue une valeur à la variable en ligne.Assigns a value to the variable in-line. La valeur peut être une constante ou une expression, mais elle doit soit correspondre au type de déclaration de la variable, soit être implicitement convertible vers ce type.The value can be a constant or an expression, but it must either match the variable declaration type or be implicitly convertible to that type. Pour plus d’informations, consultez Expressions (Transact-SQL).For more information, see Expressions (Transact-SQL).

@cursor_variable_name@cursor_variable_name
Nom d’une variable de curseur.Is the name of a cursor variable. Les noms de variables curseur doivent commencer par le signe @ et être conformes aux règles des identificateurs.Cursor variable names must begin with an at (@) sign and conform to the rules for identifiers.

CURSORCURSOR
Indique que la variable est une variable curseur locale.Specifies that the variable is a local cursor variable.

@table_variable_name@table_variable_name
Nom d’une variable de type table.Is the name of a variable of type table. Les noms de variables doivent commencer par le signe @ et être conformes aux règles des identificateurs.Variable names must begin with an at (@) sign and conform to the rules for identifiers.

<table_type_definition><table_type_definition>
Définit le type de données table.Defines the table data type. La déclaration de table inclut des définitions de colonnes, des noms, des types de données et des contraintes.The table declaration includes column definitions, names, data types, and constraints. Les seuls types de contraintes autorisés sont PRIMARY KEY, UNIQUE, NULL et CHECK.The only constraint types allowed are PRIMARY KEY, UNIQUE, NULL, and CHECK. Un type de données alias ne peut pas être utilisé comme type de données scalaire de colonne si une règle ou une définition par défaut est liée au type.An alias data type cannot be used as a column scalar data type if a rule or default definition is bound to the type.

<table_type_definition> est un sous-ensemble d’informations utilisé pour définir une table dans CREATE TABLE.<table_type_definiton> Is a subset of information used to define a table in CREATE TABLE. Les éléments et les définitions essentielles sont inclus ici.Elements and essential definitions are included here. Pour plus d’informations, consultez CREATE TABLE (Transact-SQL).For more information, see CREATE TABLE (Transact-SQL).

nn
Espace réservé indiquant que plusieurs variables peuvent être spécifiées et que des valeurs peuvent leur être affectées.Is a placeholder indicating that multiple variables can be specified and assigned values. Lorsque vous déclarez des variables table, seules les variables table doivent être déclarées dans l’instruction DECLARE.When declaring table variables, the table variable must be the only variable being declared in the DECLARE statement.

column_namecolumn_name
Nom de la colonne dans la table.Is the name of the column in the table.

scalar_data_typescalar_data_type
Spécifie que la colonne est un type de données scalaire.Specifies that the column is a scalar data type.

computed_column_expressioncomputed_column_expression
Expression définissant la valeur d’une colonne calculée.Is an expression defining the value of a computed column. Elle est calculée à partir d'une expression qui utilise d'autres colonnes de la même table.It is computed from an expression using other columns in the same table. Par exemple, une colonne calculée peut avoir la définition cost AS price * qty. L’expression peut être un nom de colonne non calculée, une constante, une fonction intégrée ou une combinaison de ces éléments connectés par un ou plusieurs opérateurs.For example, a computed column can have the definition cost AS price * qty. The expression can be a noncomputed column name, constant, built-in function, variable, or any combination of these connected by one or more operators. L'expression ne peut pas être une sous-requête ou une fonction définie par l'utilisateur.The expression cannot be a subquery or a user-defined function. L'expression ne peut pas faire référence à un type CLR défini par l'utilisateur.The expression cannot reference a CLR user-defined type.

[ COLLATE collation_name][ COLLATE collation_name]
Indique le classement de la colonne.Specifies the collation for the column. collation_name peut être soit un nom de classement Windows, soit un nom de classement SQL et s’applique uniquement aux colonnes des types de données char, varchar, text, nchar, nvarchar et ntext.collation_name can be either a Windows collation name or an SQL collation name, and is applicable only for columns of the char, varchar, text, nchar, nvarchar, and ntext data types. Si cette valeur n'est pas spécifiée, la colonne reçoit le classement du type de données utilisateur (si la colonne est de type de données utilisateur), ou le classement de la base de données active.If not specified, the column is assigned either the collation of the user-defined data type (if the column is of a user-defined data type) or the collation of the current database.

Pour plus d’informations sur les noms de classements Windows et SQL, consultez COLLATE (Transact-SQL).For more information about the Windows and SQL collation names, see COLLATE (Transact-SQL).

DEFAULTDEFAULT
Spécifie la valeur fournie pour la colonne lorsque vous n'avez pas spécifié explicitement de valeur lors d'une insertion.Specifies the value provided for the column when a value is not explicitly supplied during an insert. Les définitions DEFAULT peuvent être appliquées à n’importe quelle colonne, sauf celles définies en tant que timestamp ou celles dotées de la propriété IDENTITY.DEFAULT definitions can be applied to any columns except those defined as timestamp or those with the IDENTITY property. Les définitions de valeurs par défaut sont supprimées lorsque la table est supprimée.DEFAULT definitions are removed when the table is dropped. Seule une valeur constante, telle qu'une chaîne de caractères, une fonction système comme SYSTEM_USER() ou la valeur NULL, peut être utilisée comme valeur par défaut.Only a constant value, such as a character string; a system function, such as a SYSTEM_USER(); or NULL can be used as a default. Pour maintenir la compatibilité avec les versions antérieures de SQL ServerSQL Server, un nom de contrainte peut être affecté à une définition DEFAULT.To maintain compatibility with earlier versions of SQL ServerSQL Server, a constraint name can be assigned to a DEFAULT.

constant_expressionconstant_expression
Constante, valeur NULL ou fonction système utilisée comme valeur par défaut pour une colonne.Is a constant, NULL, or a system function used as the default value for the column.

IDENTITYIDENTITY
Indique que la nouvelle colonne est une colonne d'identité.Indicates that the new column is an identity column. Lorsqu'une nouvelle ligne est ajoutée à la table, SQL ServerSQL Server fournit une valeur incrémentielle unique pour la colonne.When a new row is added to the table, SQL ServerSQL Server provides a unique incremental value for the column. Les colonnes d'identité sont normalement utilisées avec les contraintes PRIMARY KEY comme identificateur unique de ligne pour la table.Identity columns are commonly used in conjunction with PRIMARY KEY constraints to serve as the unique row identifier for the table. La propriété IDENTITY peut être affectée à des colonnes tinyint, smallint, int, decimal(p,0) ou numeric(p,0) .The IDENTITY property can be assigned to tinyint, smallint, int, decimal(p,0), or numeric(p,0) columns. Une seule colonne d'identité peut être créée par table.Only one identity column can be created per table. Il n'est pas possible d'utiliser des valeurs par défaut liées et des contraintes DEFAULT avec une colonne d'identité.Bound defaults and DEFAULT constraints cannot be used with an identity column. Vous devez spécifier à la fois la valeur initiale et l'incrément, ou bien aucun des deux.You must specify both the seed and increment, or neither. Si vous n'en spécifiez aucun, la valeur par défaut est (1,1).If neither is specified, the default is (1,1).

seedseed
Valeur utilisée pour la toute première ligne chargée dans la table.Is the value used for the very first row loaded into the table.

incrementincrement
Valeur d’incrément ajoutée à la valeur d’identité de la ligne précédemment chargée.Is the incremental value added to the identity value of the previous row that was loaded.

ROWGUIDCOLROWGUIDCOL
Indique que la nouvelle colonne est une colonne d'identificateur unique global de ligne.Indicates that the new column is a row global unique identifier column. Une seule colonne uniqueidentifier par table peut être désignée comme colonne ROWGUIDCOL.Only one uniqueidentifier column per table can be designated as the ROWGUIDCOL column. La propriété ROWGUIDCOL ne peut être affectée qu’à une colonne uniqueidentifier.The ROWGUIDCOL property can be assigned only to a uniqueidentifier column.

NULL | NOT NULLNULL | NOT NULL
Indique si NULL est autorisé dans la variable.Indicates if null is allowed in the variable. La valeur par défaut est NULL.The default is NULL.

PRIMARY KEYPRIMARY KEY
Contrainte appliquant l'intégrité d'entité pour une ou plusieurs colonnes données via un index unique.Is a constraint that enforces entity integrity for a given column or columns through a unique index. Une seule contrainte PRIMARY KEY peut être créée par table.Only one PRIMARY KEY constraint can be created per table.

UNIQUEUNIQUE
Contrainte fournissant l'intégrité d'entité pour une ou plusieurs colonnes données via un index unique.Is a constraint that provides entity integrity for a given column or columns through a unique index. Une table peut comprendre plusieurs contraintes UNIQUE.A table can have multiple UNIQUE constraints.

CHECKCHECK
Contrainte qui assure l'intégrité du domaine en limitant les valeurs possibles pouvant être entrées dans une ou plusieurs colonnes.Is a constraint that enforces domain integrity by limiting the possible values that can be entered into a column or columns.

logical_expressionlogical_expression
Expression logique qui retourne TRUE ou FALSE.Is a logical expression that returns TRUE or FALSE.

NotesRemarks

Les variables locales sont souvent utilisées dans un traitement ou une procédure comme compteurs pour une boucle WHILE, LOOP ou pour un bloc IF...ELSE.Variables are often used in a batch or procedure as counters for WHILE, LOOP, or for an IF...ELSE block.

Les variables ne peuvent être utilisées que dans des expressions et pas la place de noms d'objets ou de mots clés.Variables can be used only in expressions, not in place of object names or keywords. Pour créer des instructions dynamiques SQL, utilisez EXECUTE.To construct dynamic SQL statements, use EXECUTE.

La portée d'une variable correspond au traitement dans lequel elle est déclarée.The scope of a local variable is the batch in which it is declared.

Une variable de table ne réside pas nécessairement en mémoire.A table variable is not necessarily memory resident. En cas de sollicitation de la mémoire, les pages appartenant à une variable de table peuvent être envoyées (push) à tempdb.Under memory pressure, the pages belonging to a table variable can be pushed out to tempdb.

Une variable curseur à laquelle un curseur a été affecté peut être référencée en tant que source dans les instructions suivantes :A cursor variable that currently has a cursor assigned to it can be referenced as a source in a:

  • Instruction CLOSE.CLOSE statement.

  • Instruction DEALLOCATE.DEALLOCATE statement.

  • Instruction FETCH.FETCH statement.

  • Instruction OPEN.OPEN statement.

  • Instruction positionnée DELETE ou UPDATE.Positioned DELETE or UPDATE statement.

  • Instruction variable (sur le côté droit) SET CURSOR.SET CURSOR variable statement (on the right side).

Dans toutes ces instructions, SQL ServerSQL Server génère une erreur si une variable curseur référencée existe et qu'un curseur ne lui est pas alloué.In all of these statements, SQL ServerSQL Server raises an error if a referenced cursor variable exists but does not have a cursor currently allocated to it. Si une variable curseur référencée n'existe pas, SQL ServerSQL Server génère la même erreur que pour une variable non déclarée d'un autre type.If a referenced cursor variable does not exist, SQL ServerSQL Server raises the same error raised for an undeclared variable of another type.

Une variable de curseur :A cursor variable:

  • peut être la cible d'une autre type de curseur ou d'une autre variable curseur ;Can be the target of either a cursor type or another cursor variable. Pour plus d’informations, consultez SET @local_variable (Transact-SQL).For more information, see SET @local_variable (Transact-SQL).

  • peut être référencée en tant que cible d'un paramètre de curseur de sortie dans une instruction EXECUTE si aucun curseur ne lui est actuellement affecté ;Can be referenced as the target of an output cursor parameter in an EXECUTE statement if the cursor variable does not have a cursor currently assigned to it.

  • doit être considérée comme un pointeur vers le curseur.Should be regarded as a pointer to the cursor.

ExemplesExamples

A.A. Utilisation de DECLAREUsing DECLARE

L'exemple suivant utilise une variable locale nommée @find pour extraire les informations de contact de tous les noms commençant par Man.The following example uses a local variable named @find to retrieve contact information for all last names beginning with Man.

USE AdventureWorks2012;  
GO  
DECLARE @find varchar(30);   
/* Also allowed:   
DECLARE @find varchar(30) = 'Man%';   
*/  
SET @find = 'Man%';   
SELECT p.LastName, p.FirstName, ph.PhoneNumber  
FROM Person.Person AS p   
JOIN Person.PersonPhone AS ph ON p.BusinessEntityID = ph.BusinessEntityID  
WHERE LastName LIKE @find;  
  

Voici l'ensemble des résultats.Here is the result set.

LastName            FirstName               Phone
------------------- ----------------------- -------------------------
Manchepalli         Ajay                    1 (11) 500 555-0174
Manek               Parul                   1 (11) 500 555-0146
Manzanares          Tomas                   1 (11) 500 555-0178
 
(3 row(s) affected)

B.B. Utilisation de DECLARE avec deux variablesUsing DECLARE with two variables

L'exemple suivant extrait les noms des vendeurs de Adventure Works CyclesAdventure Works Cycles qui se trouvent sur le secteur de vente North American et qui génèrent un chiffre d'affaires annuel minimum de 2 000 000 de dollars.The following example retrieves the names of Adventure Works CyclesAdventure Works Cycles sales representatives who are located in the North American sales territory and have at least $2,000,000 in sales for the year.

USE AdventureWorks2012;  
GO  
SET NOCOUNT ON;  
GO  
DECLARE @Group nvarchar(50), @Sales money;  
SET @Group = N'North America';  
SET @Sales = 2000000;  
SET NOCOUNT OFF;  
SELECT FirstName, LastName, SalesYTD  
FROM Sales.vSalesPerson  
WHERE TerritoryGroup = @Group and SalesYTD >= @Sales;  

C.C. Déclaration d'une variable de type tableDeclaring a variable of type table

L'exemple suivant crée une variable table qui stocke les valeurs définies dans la clause OUTPUT de l'instruction UPDATE.The following example creates a table variable that stores the values specified in the OUTPUT clause of the UPDATE statement. 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. Notez que les résultats dans la colonne INSERTED.ModifiedDate sont différents des valeurs de la colonne ModifiedDate dans la table Employee.Note that the results in the INSERTED.ModifiedDate column differ from the values in the ModifiedDate column in the Employee table. Ceci s'explique par le fait que le déclencheur AFTER UPDATE, qui met à jour la valeur de ModifiedDate en fonction de la date actuelle, est défini sur la table Employee.This is because the AFTER UPDATE trigger, which updates the value of ModifiedDate to the current date, is defined on the Employee table. Toutefois, les colonnes renvoyées par OUTPUT reflètent les données avant l'activation des déclencheurs.However, the columns returned from OUTPUT reflect the data before triggers are fired. Pour plus d’informations, consultez Clause OUTPUT (Transact-SQL).For more information, 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   
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.  
--Note that ModifiedDate reflects the value generated by an  
--AFTER UPDATE trigger.  
SELECT TOP (10) BusinessEntityID, VacationHours, ModifiedDate  
FROM HumanResources.Employee;  
GO  

D.D. Déclaration d'une variable de type table défini par l'utilisateurDeclaring a variable of user-defined table type

L'exemple suivant crée un paramètre table ou une variable de table portant le nom @LocationTVP.The following example creates a table-valued parameter or table variable called @LocationTVP. Cela nécessite un type de table défini par l'utilisateur correspondant appelé LocationTableType.This requires a corresponding user-defined table type called LocationTableType. Pour plus d’informations sur la création d’un type de table défini par l’utilisateur, consultez CREATE TYPE (Transact-SQL).For more information about how to create a user-defined table type, see CREATE TYPE (Transact-SQL). Pour plus d’informations sur les paramètres table, consultez Utiliser les paramètres table (moteur de base de données).For more information about table-valued parameters, see Use Table-Valued Parameters (Database Engine).

DECLARE @LocationTVP   
AS LocationTableType;  

Exemples : Azure SQL Data WarehouseAzure SQL Data Warehouse et Parallel Data WarehouseParallel Data WarehouseExamples: Azure SQL Data WarehouseAzure SQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

E.E. Utilisation de DECLAREUsing DECLARE

L'exemple suivant utilise une variable locale nommée @find pour extraire les informations de contact de tous les noms commençant par Walt.The following example uses a local variable named @find to retrieve contact information for all last names beginning with Walt.

-- Uses AdventureWorks  
  
DECLARE @find varchar(30);  
/* Also allowed:   
DECLARE @find varchar(30) = 'Man%';  
*/  
SET @find = 'Walt%';  
  
SELECT LastName, FirstName, Phone  
FROM DimEmployee   
WHERE LastName LIKE @find;  

F.F. Utilisation de DECLARE avec deux variablesUsing DECLARE with two variables

L’exemple suivant récupère des variables pour spécifier les prénoms et noms des employés dans la table DimEmployee.The following example retrieves uses variables to specify the first and last names of employees in the DimEmployee table.

-- Uses AdventureWorks  
  
DECLARE @lastName varchar(30), @firstName varchar(30);  
  
SET @lastName = 'Walt%';  
SET @firstName = 'Bryan';  
  
SELECT LastName, FirstName, Phone  
FROM DimEmployee   
WHERE LastName LIKE @lastName AND FirstName LIKE @firstName;  

Voir aussiSee Also

EXECUTE (Transact-SQL) EXECUTE (Transact-SQL)
Fonctions intégrées (Transact-SQL) Built-in Functions (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
table (Transact-SQL) table (Transact-SQL)
Comparer du XML typé et du XML non typéCompare Typed XML to Untyped XML