php : explication détaillée des types de fonctions définies par l'utilisateur de SQL Server

Concernant les fonctions définies par l'utilisateur de SQL Server, il en existe deux types : les fonctions scalaires et les fonctions table (fonctions table en ligne, fonctions table à plusieurs instructions).

En passant, certains amis ne savent peut-être pas où les fonctions définies par l'utilisateur de SQL Server doivent être écrites. Voici un bref rappel dans Microsoft SQL Server Management Studio, développez les besoins spécifiques. une base de données avec l'utilisateur SQL Server fonction personnalisée (c'est-à-dire que chaque fonction définie par l'utilisateur n'est utile que pour une base de données spécifique), puis recherchez l'option Programmabilité, puis développez et recherchez Fonction , dans les options de fonction spécifiques, vous pouvez cliquer avec le bouton droit et sélectionner pour ajouter comme indiqué dans la figure ci-dessous.

La soi-disant fonction scalairePour faire simple, le résultat renvoyé n'est qu'un scalaire pour. moi, le résultat renvoyé est une valeur d'un type.

s'écrit comme suit :

CREATE FUNCTION <Scalar_Function_Name, sysname, FunctionName> 
(
    -- Add the parameters for the function here
    <@Param1, sysname, @p1> <Data_Type_For_Param1, , int>
)
RETURNS <Function_Data_Type, ,int>
AS
BEGIN
    -- Declare the return variable here
    DECLARE <@ResultVar, sysname, @Result> <Function_Data_Type, ,int>

    -- Add the T-SQL statements to compute the return value here
    SELECT <@ResultVar, sysname, @Result> = <@Param1, sysname, @p1>

    -- Return the result of the function
    RETURN <@ResultVar, sysname, @Result>

CREATE FUNCTION GetSum
(
    @firstNum int,
    @secondNum int
)
RETURNS int
AS
BEGIN
    -- Declare the return variable here
    DECLARE @result int

    -- Add the T-SQL statements to compute the return value here
    SELECT @result=@firstNum+@secondNum

    -- Return the result of the function
    RETURN @result

Hors sujet : Jetons un coup d'œil à l'écriture ci-dessus Pour SQL Server De manière générale, la façon dont nous déclarons une variable consiste à utiliser @ nom de variable , et par rapport à la programmation, la façon dont SQL Server déclare est une blague pour nous, c'est une blague. est d'abord la variable, puis c'est le type. La méthode de transmission ou non des paramètres est en fait la même que notre méthode de programmation. S'il y a des paramètres, la méthode est la suivante :

CREATE FUNCTION GetSum
(
    @firstNum int,
    @secondNum int
)

S'il n'y a pas de paramètres, gardez simplement les parenthèses. Cela est cohérent avec notre compréhension de l’écriture de fonctions.

CREATE FUNCTION GetSum
(
)

Quant à la méthode de retour, elle est différente de la façon dont nous programmons. Le type de retour de la fonction SQL Server n'est pas placé devant le nom de la fonction, mais après les crochets du nom de la fonction. De plus, le type de retour de la fonction doit utiliser le mot-clé return RETURNS au lieu de RETURN.

Pour les fonctions, il existe bien sûr aussi ce qu'on appelle un corps de fonction. Il en va de même pour les fonctions scalaires. Son corps de fonction est inclus dans :

AS
BEGIN
    -- 函数体
END

Si vous devez déclarer des variables dans le corps de la fonction, vous devez utiliser le mot-clé DECLARE pour déclarer. Le retour dans le corps de la fonction est le mot-clé RETURN.

D'accord, nous avons fini de donner des exemples de fonctions scalaires. Pour les enregistrer dans la base de données, vous devez cliquer sur dans l'outil Microsoft SQL Server Management Studio pour effectuer l'opération . Après cela, vous pouvez interroger les résultats dans la fenêtre Requête, tout comme les données de la table de requête. L'utilisation de

est facile à comprendre, mais il convient de noter que le nom de l'objet [dbo] ne peut pas être omis, et () ne doit pas être omis après le [GetSum] fonction. Curieusement, pour les fonctions table, le nom de l'objet [dbo] peut être exécuté correctement sans l'écrire.

select [dbo].[GetSum]()

Par rapport aux fonctions scalaires qui renvoient uniquement une valeur scalaire, les fonctions table en ligne renvoient des données de table. Bien entendu, les données des tables sont de type Table.

s'écrit comme suit :

CREATE FUNCTION <Inline_Function_Name, sysname, FunctionName> 
(    
    -- Add the parameters for the function here
    <@param1, sysname, @p1> <Data_Type_For_Param1, , int>, 
    <@param2, sysname, @p2> <Data_Type_For_Param2, , char>
)
RETURNS TABLE 
AS
RETURN 
(
    -- Add the SELECT statement with parameter references here
    SELECT 0
)
GO

CREATE FUNCTION [GetMoreThanSalary]
(    
    @salary int
)
RETURNS TABLE 
AS
RETURN 
(
    SELECT [FName],[FCity],[FAge],[FSalary] FROM [Demo].[dbo].[T_Person] Where [FSalary] > @salary
)

Digression : Fonction scalaire Le contenu mentionné ci-dessus ne sera pas répété ici. La structure de table renvoyée par la fonction de table en ligne est déterminée par l'instruction SELECT dans le corps de la fonction.

Pour les fonctions scalaires, le corps de la fonction est inclus dans la structure suivante.

AS
BEGIN
    -- 函数体
END

Mais pour les fonctions table en ligne, la structure du corps de la fonction est la suivante. Les fonctions table en ligne n'exécutent qu'une seule instruction SQL et renvoient le résultat de la table.

AS
RETURN
    -- 函数体
END

La manière d'exécuter les fonctions table est la suivante :

select [FName],[FCity],[FAge],[FSalary] from [dbo].[GetMoreThanSalary](8000)

On peut voir que cette méthode d'exécution est la même que la méthode d'exécution des tables ordinaires. Les fonctions table sont en fait équivalentes à une table virtuelle stockée dans l’espace mémoire.

Les fonctions table à instructions multiples et les fonctions table en ligne sont toutes deux des fonctions table, et les résultats qu'elles renvoient sont tous de type Table. Comme son nom l'indique, la fonction table multi-instructions peut créer des données de type table via plusieurs instructions. Ceci est différent de la fonction table en ligne. Le résultat renvoyé par la fonction table en ligne est déterminé par l'instruction SELECT dans le corps de la fonction. Les fonctions table à plusieurs instructions nécessitent de spécifier une structure de type Table spécifique. En d’autres termes, la table renvoyée a déjà défini les champs à renvoyer. Il peut donc prendre en charge l'exécution de plusieurs instructions pour créer des données de table.

CREATE FUNCTION <Table_Function_Name, sysname, FunctionName> 
(
    -- Add the parameters for the function here
    <@param1, sysname, @p1> <data_type_for_param1, , int>, 
    <@param2, sysname, @p2> <data_type_for_param2, , char>
)
RETURNS 
<@Table_Variable_Name, sysname, @Table_Var> TABLE 
(
    -- Add the column definitions for the TABLE variable here
    <Column_1, sysname, c1> <Data_Type_For_Column1, , int>, 
    <Column_2, sysname, c2> <Data_Type_For_Column2, , int>
)
AS
BEGIN
    -- Fill the table variable with the rows for your result set
    
    RETURN 
END
GO

ALTER FUNCTION DemoFun
(

)
RETURNS 
@result TABLE 
(
    name nvarchar(20),
    city nvarchar(20),
    age int,
    salary int
)
AS
BEGIN
    -- Fill the table variable with the rows for your result set
    insert into @result(name, city, age, salary)
    select FName,FCity,FAge,FSalary from dbo.T_Person where FSalary>8000
    insert into @result(name, city, age, salary) values
    ('测试','China', 1, 0)
    RETURN 
END
GO

题外话：可以看得出，多语句表值函数的返回结果是定义好表结构的虚拟表。这又跟标量函数一样了吧，只不过标量函数是返回一种类型的标量值而已。而且在多语句表值函数里面，你也会发现最后一句是RETURN。告诉执行程序，多语句表值函数已经执行完成。函数体结构跟标量函数的结构一样。对于类型放在变量后面这种方式确实需要好好转换一下观念。

RETURNS 
<@Table_Variable_Name, sysname, @Table_Var> TABLE 
(
    -- Add the column definitions for the TABLE variable here
    <Column_1, sysname, c1> <Data_Type_For_Column1, , int>, 
    <Column_2, sysname, c2> <Data_Type_For_Column2, , int>
)

内容倒是不多，但是要熟练使用的话，还是需要在项目中多加使用才行。网上有一些网友总结出来的常用自定义函数大家可以收集积累，就像做项目一样，好的方法要形成所谓的开发库，帮助我们在下一个项目中复用。节省我们的开发时间，提高我们的工作效率。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!