sp_describe_undeclared_parameters (Transact-SQL)sp_describe_undeclared_parameters (Transact-SQL)

S’APPLIQUE À : ouiSQL Server ouiAzure SQL Database nonAzure SQL Data Warehouse nonParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Retourne un jeu de résultats qui contient des métadonnées sur les paramètres non déclarés dans un Transact-SQLTransact-SQL batch.Returns a result set that contains metadata about undeclared parameters in a Transact-SQLTransact-SQL batch. Considère chaque paramètre qui est utilisé dans le @tsql du lot, mais non déclaré dans @params.Considers each parameter that is used in the @tsql batch, but not declared in @params. Le jeu de résultats retourné contient une ligne pour chaque paramètre de ce genre, avec les informations de type déduites pour ce paramètre.A result set is returned that contains one row for each such parameter, with the deduced type information for that parameter. La procédure retourne un résultat vide si le @tsql lot d’entrée n’a aucun paramètre à l’exception de ceux déclarés dans @params.The procedure returns an empty result set if the @tsql input batch has no parameters except those declared in @params.

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

SyntaxeSyntax

  
sp_describe_undeclared_parameters   
    [ @tsql = ] 'Transact-SQL_batch'   
    [ , [ @params = ] N'parameters' data type ] [, ...n]  

ArgumentsArguments

[ \@tsql = ] 'Transact-SQL\_batch' Un ou plusieurs Transact-SQLTransact-SQL instructions.[ \@tsql = ] 'Transact-SQL\_batch' One or more Transact-SQLTransact-SQL statements. Transact-SQL_batch peut être nvarchar ( n ) ou nvarchar (max) .Transact-SQL_batch may be nvarchar(n) or nvarchar(max).

[ \@params = ] N'parameters' @params fournit une chaîne de déclaration pour les paramètres pour le Transact-SQLTransact-SQL fonctionne de lot, de même façon que sp_executesql.[ \@params = ] N'parameters' @params provides a declaration string for parameters for the Transact-SQLTransact-SQL batch, similarly to the way sp_executesql works. Paramètres peut être nvarchar ( n ) ou nvarchar (max) .Parameters may be nvarchar(n) or nvarchar(max).

Est une chaîne qui contient les définitions de tous les paramètres qui ont été incorporés dans Transact-SQL_batch.Is one string that contains the definitions of all parameters that have been embedded in Transact-SQL_batch. Cette chaîne doit être une constante Unicode ou une variable Unicode.The string must be either a Unicode constant or a Unicode variable. Chaque définition de paramètre se compose d'un nom de paramètre et d'un type de données.Each parameter definition consists of a parameter name and a data type. n correspond à un espace réservé pour d'autres définitions de paramètres.n is a placeholder that indicates additional parameter definitions. Si l’instruction Transact-SQL ou un lot dans l’instruction ne contient-elle pas de paramètres, @params n’est pas obligatoire.If the Transact-SQL statement or batch in the statement does not contain parameters, @params is not required. La valeur par défaut de ce paramètre est NULL.The default value for this parameter is NULL.

Type de donnéesDatatype
Type de données du paramètre.The data type of the parameter.

Valeurs des codes de retourReturn Code Values

sp_describe_undeclared_parameters toujours retourne statut de retour de zéro en cas de réussite.sp_describe_undeclared_parameters always returns return status of zero on success. Si la procédure génère une erreur et la procédure est appelée comme RPC, l’état de retour est remplie par le type d’erreur, comme décrit dans la colonne error_type de sys.dm_exec_describe_first_result_set.If the procedure throws an error and the procedure is called as an RPC, the return status is populated by the type of error as described in the error_type column of sys.dm_exec_describe_first_result_set. Si la procédure est appelée depuis Transact-SQLTransact-SQL, la valeur de retour est toujours égale à zéro, même en cas d'erreur.If the procedure is called from Transact-SQLTransact-SQL, the return value is always zero, even in error cases.

Jeux de résultatsResult Sets

sp_describe_undeclared_parameters retourne le jeu de résultats suivant.sp_describe_undeclared_parameters returns the following result set.

Nom de la colonneColumn name Type de donnéesData type DescriptionDescription
parameter_ordinalparameter_ordinal int non NULLint NOT NULL Contient la position ordinale du paramètre dans le jeu de résultats.Contains the ordinal position of the parameter in the result set. La position du premier paramètre sera spécifiée comme 1.Position of the first parameter will be specified as 1.
namename sysname pas NULLsysname NOT NULL Contient le nom du paramètre.Contains the name of the parameter.
suggested_system_type_idsuggested_system_type_id int non NULLint NOT NULL Contient le system_type_id du type de données du paramètre comme spécifié dans sys.types.Contains the system_type_id of the data type of the parameter as specified in sys.types.

Pour les types CLR, bien que le system_type_name colonne retournera la valeur NULL, cette colonne retournera la valeur 240.For CLR types, even though the system_type_name column will return NULL, this column will return the value 240.
suggested_system_type_namesuggested_system_type_name nvarchar (256) NULLnvarchar (256) NULL Contient le nom du type de données.Contains the data type name. Inclut des arguments (tels que la longueur, la précision, l'échelle) spécifiés pour le type de données du paramètre.Includes arguments (such as length, precision, scale) specified for the data type of the parameter. Si le type de données est un type d'alias défini par l'utilisateur, le type de système sous-jacent est spécifié ici.If the data type is a user-defined alias type, the underlying system type is specified here. S'il s'agit d'un type de données CLR défini par l'utilisateur, NULL est retourné dans cette colonne.If it is a CLR user-defined data type, NULL is returned in this column. Si le type du paramètre ne peut pas être déduit, NULL est retourné.If the type of the parameter cannot be deduced, NULL is returned.
suggested_max_lengthsuggested_max_length smallint non NULLsmallint NOT NULL Consultez sys.columns.See sys.columns. pour max_length description de la colonne.for max_length column description.
suggested_precisionsuggested_precision tinyint non NULLtinyint NOT NULL Consultez sys.columns.See sys.columns. pour la description de la colonne de précision.for precision column description.
suggested_scalesuggested_scale tinyint non NULLtinyint NOT NULL Consultez sys.columns.See sys.columns. pour la description de la colonne d'échelle.for scale column description.
suggested_user_type_idsuggested_user_type_id int NULLint NULL Pour les types d'alias et CLR, contient l'information user_type_id du type de données de la colonne comme spécifié dans sys.types.For CLR and alias types, contains the user_type_id of the data type of the column as specified in sys.types. Sinon, a la valeur NULL.Otherwise is NULL.
suggested_user_type_databasesuggested_user_type_database sysname NULLsysname NULL Pour les types d'alias et CLR, contient le nom de la base de données dans laquelle le type est défini.For CLR and alias types, contains the name of the database in which the type is defined. Sinon, a la valeur NULL.Otherwise is NULL.
suggested_user_type_schemasuggested_user_type_schema sysname NULLsysname NULL Pour les types d'alias et CLR, contient le nom du schéma dans lequel le type est défini.For CLR and alias types, contains the name of the schema in which the type is defined. Sinon, a la valeur NULL.Otherwise is NULL.
suggested_user_type_namesuggested_user_type_name sysname NULLsysname NULL Pour les types d'alias et CLR, contient le nom du type.For CLR and alias types, contains the name of the type. Sinon, a la valeur NULL.Otherwise is NULL.
suggested_assembly_qualified_type_namesuggested_assembly_qualified_type_name nvarchar (4000) NULLnvarchar (4000) NULL Pour les types CLR, retourne le nom de l'assembly et de la classe qui définit le type.For CLR types, returns the name of the assembly and class that defines the type. Sinon, a la valeur NULL.Otherwise is NULL.
suggested_xml_collection_idsuggested_xml_collection_id int NULLint NULL Contient l’information xml_collection_id du type de données du paramètre comme spécifié dans sys.columns.Contains the xml_collection_id of the data type of the parameter as specified in sys.columns. Cette colonne retournera NULL si le type retourné n'est pas associé à une collection de schémas XML.This column will return NULL if the type returned is not associated with an XML schema collection.
suggested_xml_collection_databasesuggested_xml_collection_database sysname NULLsysname NULL Contient la base de données dans laquelle la collection de schémas XML associée à ce type est définie.Contains the database in which the XML schema collection associated with this type is defined. Cette colonne retournera NULL si le type retourné n'est pas associé à une collection de schémas XML.This column will return NULL if the type returned is not associated with an XML schema collection.
suggested_xml_collection_schemasuggested_xml_collection_schema sysname NULLsysname NULL Contient le schéma dans lequel la collection de schémas XML associée à ce type est définie.Contains the schema in which the XML schema collection associated with this type is defined. Cette colonne retournera NULL si le type retourné n'est pas associé à une collection de schémas XML.This column will return NULL if the type returned is not associated with an XML schema collection.
suggested_xml_collection_namesuggested_xml_collection_name sysname NULLsysname NULL Contient le nom de la collection de schémas XML associé à ce type.Contains the name of the XML schema collection associated with this type. Cette colonne retournera NULL si le type retourné n'est pas associé à une collection de schémas XML.This column will return NULL if the type returned is not associated with an XML schema collection.
suggested_is_xml_documentsuggested_is_xml_document bit pas NULLbit NOT NULL Retourne 1 si le type qui est retourné est XML et que ce type est garanti être un document XML.Returns 1 if the type being returned is XML and that type is guaranteed to be an XML document. Dans le cas contraire, retourne la valeur 0.Otherwise returns 0.
suggested_is_case_sensitivesuggested_is_case_sensitive bit pas NULLbit NOT NULL Retourne 1 si la colonne est d'un type chaîne sensible à la casse et 0 si ce n'est pas le cas.Returns 1 if the column is of a case-sensitive string type and 0 if it is not.
suggested_is_fixed_length_clr_typesuggested_is_fixed_length_clr_type bit pas NULLbit NOT NULL Retourne 1 si la colonne est d'un type CLR de longueur fixe et 0 si ce n'est pas le cas.Returns 1 if the column is of a fixed-length CLR type and 0 if it is not.
suggested_is_inputsuggested_is_input bit pas NULLbit NOT NULL Retourne 1 si le paramètre est utilisé n'importe où autre que le côté gauche d'une attribution.Returns 1 if the parameter is used anywhere other than left side of an assignment. Dans le cas contraire, retourne la valeur 0.Otherwise returns 0.
suggested_is_outputsuggested_is_output bit pas NULLbit NOT NULL Retourne 1 si le paramètre est utilisé du côté gauche d'une attribution ou est passé à un paramètre de sortie d'une procédure stockée.Returns 1 if the parameter is used on the left side of an assignment or is passed to an output parameter of a stored procedure. Dans le cas contraire, retourne la valeur 0.Otherwise returns 0.
formal_parameter_nameformal_parameter_name sysname NULLsysname NULL Si le paramètre est un argument d'une procédure stockée ou une fonction définie par l'utilisateur, retourne le nom du paramètre formel correspondant.If the parameter is an argument to a stored procedure or a user-defined function, returns the name of the corresponding formal parameter. Sinon, retourne NULL.Otherwise returns NULL.
suggested_tds_type_idsuggested_tds_type_id int non NULLint NOT NULL À usage interne uniquement.For internal use.
suggested_tds_lengthsuggested_tds_length int non NULLint NOT NULL À usage interne uniquement.For internal use.

NotesRemarks

sp_describe_undeclared_parameters toujours retourne statut de retour de zéro.sp_describe_undeclared_parameters always returns return status of zero.

Le cas d'utilisation le plus courant est celui d'une application qui reçoit une instruction Transact-SQLTransact-SQL pouvant contenir des paramètres et devant les traiter d'une certaine façon.The most common use is when an application is given a Transact-SQLTransact-SQL statement that might contain parameters and must process them in some way. Un exemple est une interface utilisateur (par exemple, ODBCTest ou RowsetViewer) où l’utilisateur fournit une requête avec la syntaxe de paramètre ODBC.An example is a user interface (such as ODBCTest or RowsetViewer) where the user provides a query with ODBC parameter syntax. L'application doit découvrir dynamiquement le nombre de paramètres et inviter l'utilisateur à fournir chacun d'eux.The application must dynamically discover the number of parameters and prompt the user for each one.

Autre exemple : en l'absence d'entrée de la part de l'utilisateur, une application doit faire une boucle sur les paramètres et obtenir les données pour ces derniers depuis un autre emplacement (tel qu'une table).Another example is when without user input, an application must loop over the parameters and obtain the data for them from some other location (such as a table). Dans ce cas, l'application ne doit pas passer l'ensemble des informations de paramètre à la fois.In this case, the application does not have to pass all the parameter information at once. À la place, l'application peut obtenir toutes les informations de paramètres du fournisseur et obtenir les données proprement dites de la table.Instead, the application can get all the parameters information from the provider and obtain the data itself from the table. À l’aide de code sp_describe_undeclared_parameters est plus générique et est moins susceptible de nécessiter une modification si la structure de données modifications ultérieurement.Code using sp_describe_undeclared_parameters is more generic and is less likely to require modification if the data structure changes later.

sp_describe_undeclared_parameters retourne une erreur dans chacun des cas suivants.sp_describe_undeclared_parameters returns an error in any of the following cases.

  • Si l’entrée @tsql n’est pas valide Transact-SQLTransact-SQL batch.If the input @tsql is not a valid Transact-SQLTransact-SQL batch. La validité est déterminée en analysant le Transact-SQLTransact-SQL batch.Validity is determined by parsing and analyzing the Transact-SQLTransact-SQL batch. Toutes les erreurs provoquées par le lot pendant l’optimisation des requêtes ou lors de l’exécution ne sont pas considérés lors de la détermination de si le Transact-SQLTransact-SQL lot est valide.Any errors caused by the batch during query optimization or during execution are not considered when determining whether the Transact-SQLTransact-SQL batch is valid.

  • Si @params n’est pas NULL et contient une chaîne qui n’est pas une chaîne de déclaration syntaxiquement valide pour les paramètres, ou si elle contient une chaîne qui déclare un paramètre plusieurs fois.If @params is not NULL and contains a string that is not a syntactically valid declaration string for parameters, or if it contains a string that declares any parameter more than one time.

  • Si l’entrée Transact-SQLTransact-SQL lot déclare une variable locale du même nom qu’un paramètre déclaré dans @params.If the input Transact-SQLTransact-SQL batch declares a local variable of the same name as a parameter declared in @params.

  • Si l’instruction fait référence à des tables temporaires.If the statement references temporary tables.

  • La requête inclut la création d'une table permanente qui est alors interrogée.The query includes the creation of a permanent table that is then queried.

Si @tsql n’a aucun paramètre, autres que ceux déclarés dans @params, la procédure retourne un jeu de résultats vide.If @tsql has no parameters, other than those declared in @params, the procedure returns an empty result set.

Algorithme de sélection du paramètreParameter Selection Algorithm

Dans le cas d'une requête avec des paramètres non déclarés, la déduction de type de données pour les paramètres non déclarés s'effectue en trois étapes.For a query with undeclared parameters, data type deduction for undeclared parameters proceeds in three steps.

Étape 1Step 1

La première étape dans la déduction du type de données pour une requête avec des paramètres non déclarés consiste à rechercher les types de données de toutes les sous-expressions dont les types de données ne dépendent pas des paramètres non déclarés.The first step in data type deduction for a query with undeclared parameters is to find the data types of all the sub-expressions whose data types do not depend on the undeclared parameters. Le type peut être déterminé pour les expressions suivantes :The type can be determined for the following expressions:

  • Colonnes, constantes, variables et paramètres déclarés.Columns, constants, variables, and declared parameters.

  • Résultats d'un appel à une fonction définie par l'utilisateur (UDF).Results of a call to a user-defined function (UDF).

  • Expression dont les types de données ne dépendent pas des paramètres non déclarés pour toutes les entrées.An expression with data types that do not depend on the undeclared parameters for all inputs.

Par exemple, envisagez la requête SELECT dbo.tbl(@p1) + c1 FROM t1 WHERE c2 = @p2 + 2.For example, consider the query SELECT dbo.tbl(@p1) + c1 FROM t1 WHERE c2 = @p2 + 2. Les expressions dbo.tbl (@p1) + c1 et c2 ont des types de données et expression @p1 et @p2 + 2 ne le faites pas.The expressions dbo.tbl(@p1) + c1 and c2 have data types, and expression @p1 and @p2 + 2 do not.

Après cette étape, si une expression (autre qu'un appel à une fonction UDF) compte deux arguments sans types de données, la déduction du type se solde par une erreur.After this step, if any expression (other than a call to a UDF) has two arguments without data types, type deduction fails with an error. Les exemples suivants entraînent tous des erreurs :For example, the following all produce errors:

SELECT * FROM t1 WHERE @p1 = @p2  
SELECT * FROM t1 WHERE c1 = @p1 + @p2  
SELECT * FROM t1 WHERE @p1 = SUBSTRING(@p2, 2, 3)  

L'exemple suivant ne génère pas d'erreur :The following example does not produce an error:

SELECT * FROM t1 WHERE @p1 = dbo.tbl(c1, @p2, @p3)  

Étape 2Step 2

Pour un paramètre non déclaré donné @p, l’algorithme de déduction de type recherche l’expression la plus profonde E (@p) qui contient @p et est une des opérations suivantes :For a given undeclared parameter @p, the type deduction algorithm finds the innermost expression E(@p) that contains @p and is one of the following:

  • Argument d'une comparaison ou d'opérateur d'assignation.An argument to a comparison or assignment operator.

  • Argument d'une fonction définie par l'utilisateur (notamment une fonction UDF table), d'une procédure ou d'une méthode.An argument to a user-defined function (including table-valued UDF), procedure, or method.

  • Un argument pour un valeurs clause d’une insérer instruction.An argument to a VALUES clause of an INSERT statement.

  • Un argument pour un CAST ou convertir.An argument to a CAST or CONVERT.

L’algorithme de déduction de type recherche un type de données cible TT (@p) pour E (@p).The type deduction algorithm finds a target data type TT(@p) for E(@p). Les types de données cibles des exemples précédents sont les suivants :Target data types for the previous examples are as follows:

  • Type de données de l'autre côté de la comparaison ou de l'attribution.The data type of the other side of the comparison or assignment.

  • Type de données déclaré du paramètre auquel cet argument est passé.The declared data type of the parameter to which this argument is passed.

  • Type de données de la colonne dans laquelle cette valeur est insérée.The data type of the column into which this value is inserted.

  • Type de données vers lequel l'instruction effectue la conversion.The data type to which the statement is casting or converting.

Par exemple, envisagez la requête SELECT * FROM t WHERE @p1 = dbo.tbl(@p2 + c1).For example, consider the query SELECT * FROM t WHERE @p1 = dbo.tbl(@p2 + c1). Puis E (@p1) = @p1, E (@p2) = @p2 + c1, TT (@p1) est le type de données de retour déclaré de dbo.tbl et TT (@p2) est le type de données de paramètre déclaré pour dbo.tbl.Then E(@p1) = @p1, E(@p2) = @p2 + c1, TT(@p1) is the declared return data type of dbo.tbl, and TT(@p2) is the declared parameter data type for dbo.tbl.

Si @p n’est pas contenu dans n’importe quelle expression répertoriée au début de l’étape 2, l’algorithme de déduction de type détermine que E (@p) est la plus grande expression scalaire qui contient @p et l’algorithme de déduction de type est pas le cas calcul d’un type de données cible TT (@p) pour E (@p).If @p is not contained in any expression listed at the beginning of step 2, the type deduction algorithm determines that E(@p) is the largest scalar expression that contains @p, and the type deduction algorithm does not compute a target data type TT(@p) for E(@p). Par exemple, si la requête est SELECT @p + 2 puis E (@p) = @p + 2, et il n’existe aucun TT (@p).For example, if the query is SELECT @p + 2 then E(@p) = @p + 2, and there is no TT(@p).

Étape 3Step 3

Maintenant que E (@p) et TT (@p) sont identifiés, l’algorithme de déduction de type déduit un type de données pour @p dans un des deux manières suivantes :Now that E(@p) and TT(@p) are identified, the type deduction algorithm deduces a data type for @p in one of the following two ways:

  • Déduction simpleSimple deduction

    Si E (@p) = @p et TT (@p) existe, par exemple, si @p est directement un argument à une des expressions répertoriées au début de l’étape 2, l’algorithme de déduction de type déduit le type de données @p en TT ( @p).If E(@p) = @p and TT(@p) exists, i.e., if @p is directly an argument to one of the expressions listed at the beginning of step 2, the type deduction algorithm deduces the data type of @p to be TT(@p). Exemple :For example:

    SELECT * FROM t WHERE c1 = @p1 AND @p2 = dbo.tbl(@p3)  
    

    Le type de données pour @p1, @p2, et @p3 sera le type de données de c1, le type de données de retour de dbo.tbl, et les paramètre de type de données pour dbo.tbl respectivement.The data type for @p1, @p2, and @p3 will be the data type of c1, the return data type of dbo.tbl, and the parameter data type for dbo.tbl respectively.

    Comme un cas particulier, si @p est un argument dans un <, >, <=, ou > =, opérateur, déduction simple règles ne s’appliquent pas.As a special case, if @p is an argument to a <, >, <=, or >= operator, simple deduction rules do not apply. L'algorithme de la déduction du type utilisera les règles de déduction générales expliquées dans la section suivante.The type deduction algorithm will use the general deduction rules explained in the next section. Par exemple, si c1 est une colonne de type de données char(30), considérez les deux requêtes suivantes :For example, if c1 is a column of data type char(30), consider the following two queries:

    SELECT * FROM t WHERE c1 = @p  
    SELECT * FROM t WHERE c1 > @p  
    

    Dans le premier cas, l’algorithme de déduction de type déduit char (30) comme type de données pour @p conformément aux règles précédemment dans cette rubrique.In the first case, the type deduction algorithm deduces char(30) as the data type for @p as per rules earlier in this topic. Dans le deuxième cas, l’algorithme de déduction de type déduit varchar (8000) selon les règles de déduction générales décrites dans la section suivante.In the second case, the type deduction algorithm deduces varchar(8000) according to the general deduction rules in the next section.

  • Déduction généraleGeneral deduction

    Si la déduction simple ne s'applique pas, les types de données suivants sont considérés pour les paramètres non déclarés :If simple deduction does not apply, the following data types are considered for undeclared parameters:

    • Types de données Integer (bits, tinyint, smallint, int, bigint)Integer data types (bit, tinyint, smallint, int, bigint)

    • Types de données Money (smallmoney, money)Money data types (smallmoney, money)

    • Types de données à virgule flottante (float, réel)Floating-point data types (float, real)

    • NUMERIC (38, 19) -autres types de données décimal ou numérique ne sont pas considérés.numeric(38, 19) - Other numeric or decimal data types are not considered.

    • varchar (8000) , varchar (max) , nvarchar (4000) , et nvarchar (max) - les autres types de données string (tels que texte, char (8000) , nvarchar (30) , etc.) ne sont pas considérés.varchar(8000), varchar(max), nvarchar(4000), and nvarchar(max) - Other string data types (such as text, char(8000), nvarchar(30), etc.) are not considered.

    • varbinary (8000) et varbinary (max) -autres types de données binaires ne sont pas considérés (tels que image, binary(8000) , varbinary (30) , etc..).varbinary(8000) and varbinary(max) - Other binary data types are not considered (such as image, binary(8000), varbinary(30), etc.).

    • date, Time (7) , smalldatetime, datetime, datetime2 (7) , DateTimeOffset (7) - Autres date et heure des types, tels que time(4) , ne sont pas considérés.date, time(7), smalldatetime, datetime, datetime2(7), datetimeoffset(7) - Other date and time types, such as time(4), are not considered.

    • sql_variantsql_variant

    • xmlxml

    • Types CLR définis par le système (hierarchyid, geometry, geography)CLR system-defined types (hierarchyid, geometry, geography)

    • Types CLR définis par l’utilisateurCLR user-defined types

Critères de sélectionSelection Criteria

Parmi les types de données candidats, tout type de données qui invaliderait la requête est rejeté.Of the candidate data types, any data type that would invalidate the query is rejected. Parmi les types de données candidats restants, l'algorithme de déduction du type en sélectionne un d'après les règles suivantes.Of the remaining candidate data types, the type deduction algorithm selects one according to the following rules.

  1. Le type de données qui produit le plus petit nombre de conversions implicites dans E (@p) est sélectionné.The data type that produces the smallest number of implicit conversions in E(@p) is selected. Si un type de données particulier produit un type de données pour E (@p) qui est différent de TT (@p), l’algorithme de déduction de type considère qu’il s’agit d’une conversion implicite supplémentaire du type de données de E (@p) pour TT (@p).If a particular data type produces a data type for E(@p) that is different from TT(@p), the type deduction algorithm considers this to be an extra implicit conversion from the data type of E(@p) to TT(@p).

    Exemple :For example:

    SELECT * FROM t WHERE Col_Int = Col_Int + @p  
    

    Dans ce cas, E (@p) est Col_Int + @p et TT (@p) est int. int est choisi pour @p car il ne produit pas de conversions implicites.In this case, E(@p) is Col_Int + @p and TT(@p) is int. int is chosen for @p because it produces no implicit conversions. Tout autre choix de type de données produit au moins une conversion implicite.Any other choice of data type produces at least one implicit conversion.

  2. Si plusieurs types de données sont liés pour le plus petit nombre de conversions, le type de données dont la priorité est supérieure est utilisé.If multiple data types tie for the smallest number of conversions, the data type with greater precedence is used. Exemple :For example

    SELECT * FROM t WHERE Col_Int = Col_smallint + @p  
    

    Dans ce cas, int et smallint entraînent une conversion.In this case, int and smallint produce one conversion. Chaque autre type de données entraîne plusieurs conversions.Every other data type produces more than one conversion. Étant donné que int est prioritaire sur smallint, int est utilisé pour @p.Because int takes precedence over smallint, int is used for @p. Pour plus d’informations sur la priorité des types de données, consultez priorité des types de données (Transact-SQL).For more information about data type precedence, see Data Type Precedence (Transact-SQL).

    Cette règle s'applique uniquement s'il existe une conversion implicite entre chaque type de données lié d'après la règle 1 et le type de données présentant la priorité la plus élevée.This rule only applies if there is an implicit conversion between every data type that ties according to rule 1 and the data type with the greatest precedence. S'il n'existe aucune conversion implicite, la déduction du type de données se solde par une erreur.If there is no implicit conversion, then data type deduction fails with an error. Par exemple, dans la requête SELECT @p FROM t, type de données déduction échoue, car tout type de données pour @p serait aussi bonnes.For example in the query SELECT @p FROM t, data type deduction fails because any data type for @p would be equally good. Par exemple, il n’existe aucune conversion implicite à partir de int à xml.For example, there is no implicit conversion from int to xml.

  3. Si les deux types de données semblables sont liés par exemple sous la règle 1, varchar (8000) et varchar (max) , le plus petit type de données (varchar (8000) ) est choisie.If two similar data types tie under rule 1, for example varchar(8000) and varchar(max), the smaller data type (varchar(8000)) is chosen. Le même principe s’applique aux nvarchar et varbinary types de données.The same principle applies to nvarchar and varbinary data types.

  4. Pour les besoins de la règle 1, l'algorithme de la déduction du type préfère certaines conversions plutôt que d'autres.For purposes of rule 1, the type deduction algorithm prefers certain conversions as better than others. Conversions classées de la meilleure à la pire :Conversions in order from best to worst are:

Nous sommes à votre écoute : Si vous trouvez des informations obsolètes ou incorrectes dans cet article, par exemple une étape ou une erreur dans un code, n’hésitez pas à nous en faire part.We are listening: If you find something outdated or incorrect in this article, such as a step or a code example, please tell us. Vous pouvez cliquer sur le bouton Cette page dans la section Commentaires au bas de cette page.You can click the This page button in the Feedback section at the bottom of this page. Nous lisons chaque commentaire concernant SQL, généralement le jour suivant.We read every item of feedback about SQL, typically the next day. Nous vous remercions.Thanks.

1.  <span data-ttu-id="bfc5b-318">Conversion entre un même type de données de base de longueur différente.</span><span class="sxs-lookup"><span data-stu-id="bfc5b-318">Conversion between same basic data type of different length.</span></span>  

2.  <span data-ttu-id="bfc5b-319">Conversion entre la version de longueur fixe et de longueur variable de mêmes types de données (par exemple, **char** à **varchar**).</span><span class="sxs-lookup"><span data-stu-id="bfc5b-319">Conversion between fixed-length and variable-length version of same data types (e.g., **char** to **varchar**).</span></span>  

3.  <span data-ttu-id="bfc5b-320">Conversion entre **NULL** et **int**.</span><span class="sxs-lookup"><span data-stu-id="bfc5b-320">Conversion between **NULL** and **int**.</span></span>  

4.  <span data-ttu-id="bfc5b-321">Toute autre conversion.</span><span class="sxs-lookup"><span data-stu-id="bfc5b-321">Any other conversion.</span></span>  

Par exemple, pour la requête SELECT * FROM t WHERE [Col_varchar(30)] > @p, varchar (8000) est choisi car la conversion (a) est préférable.For example, for the query SELECT * FROM t WHERE [Col_varchar(30)] > @p, varchar(8000) is chosen because conversion (a) is best. Pour la requête SELECT * FROM t WHERE [Col_char(30)] > @p, varchar (8000) est encore choisi car il provoque une conversion de type (b) et un autre choix (tel que varchar (4000) ) provoque une conversion de type (d).For the query SELECT * FROM t WHERE [Col_char(30)] > @p, varchar(8000) is still chosen because it causes a type (b) conversion, and because another choice (such as varchar(4000)) would cause a type (d) conversion.

En dernier exemple, considérons une requête SELECT NULL + @p, int est choisi pour @p, car il en résulte une conversion de type (c).As a final example, given a query SELECT NULL + @p, int is chosen for @p because it results in a type (c) conversion.

AutorisationsPermissions

Nécessite l’autorisation d’exécuter le @tsql argument.Requires permission to execute the @tsql argument.

ExemplesExamples

L'exemple suivant retourne des informations telles que le type de données attendu pour les paramètres non déclarés @id et @name.The following example returns information such as the expected data type for the undeclared @id and @name parameters.

sp_describe_undeclared_parameters @tsql =   
N'SELECT object_id, name, type_desc   
FROM sys.indexes  
WHERE object_id = @id OR name = @name'  
  

Lorsque le paramètre @id est fourni comme référence @params, le paramètre @id est omis du jeu de résultats et seul le paramètre @name est décrit.When the @id parameter is provided as a @params reference, the @id parameter is omitted from the result set and only the @name parameter is described.

sp_describe_undeclared_parameters @tsql =   
N'SELECT object_id, name, type_desc   
FROM sys.indexes  
WHERE object_id = @id OR NAME = @name',  
@params = N'@id int'  
  

Voir aussiSee Also

sp_describe_first_result_set (Transact-SQL) sp_describe_first_result_set (Transact-SQL)
sys.dm_exec_describe_first_result_set (Transact-SQL) sys.dm_exec_describe_first_result_set (Transact-SQL)
sys.dm_exec_describe_first_result_set_for_object (Transact-SQL)sys.dm_exec_describe_first_result_set_for_object (Transact-SQL)