Il existe de nombreux articles sur ASP et les procédures stockées (Stored Procedures), mais je doute que les auteurs les aient réellement mis en pratique. Lorsque j’étais débutant, j’ai consulté beaucoup d’informations pertinentes et j’ai constaté que bon nombre des méthodes proposées n’étaient pas les mêmes dans la pratique. Pour des applications simples, ces documents peuvent être utiles, mais ils se limitent à cela, car ils sont fondamentalement identiques et se copient les uns les autres. Pour les applications légèrement plus complexes, ils ne sont pas tous clairs.
Maintenant, j'accède essentiellement à SQL Server en appelant des procédures stockées. Le texte suivant est un résumé de la pratique. J'espère qu'il sera utile à tout le monde.
Une procédure stockée est une ou plusieurs commandes SQL stockées dans la base de données en tant qu'objets exécutables.
Les définitions sont toujours abstraites. Une procédure stockée est en fait un ensemble d'instructions SQL permettant d'effectuer certaines opérations, mais cet ensemble d'instructions est placé dans la base de données (on ne parle ici que de SQL Server). Si nous créons des procédures stockées et appelons des procédures stockées dans ASP, nous pouvons éviter de mélanger les instructions SQL avec le code ASP. Cela présente au moins trois avantages :
Premièrement, cela améliore considérablement l’efficacité. La vitesse d'exécution de la procédure stockée elle-même est très rapide et l'appel de la procédure stockée peut réduire considérablement le nombre d'interactions avec la base de données.
Deuxièmement, améliorer la sécurité. Si vous mélangez des instructions SQL dans du code ASP, une fois le code compromis, cela signifie également que la structure de la bibliothèque est compromise.
Troisièmement, cela favorise la réutilisation des instructions SQL.
Dans ASP, les procédures stockées sont généralement appelées via l'objet commande. Selon la situation, cet article présente également d'autres méthodes d'appel. Pour faciliter l'explication, la classification simple suivante est effectuée en fonction de l'entrée et de la sortie de la procédure stockée :
1. La procédure stockée qui ne renvoie qu'un seul jeu d'enregistrements
suppose la procédure stockée suivante (le but de cet article n'est pas de décrire Syntaxe T-SQL, donc la procédure stockée ne donne que le code, aucune explication) :
/*SP1*/
CREATE PROCEDURE dbo.getUserList
as
set nocount on
start
select * from dbo.[userinfo]
end
go
La procédure stockée ci-dessus obtient tous les enregistrements dans la table userinfo et renvoie un jeu d'enregistrements. Le code ASP permettant d'appeler la procédure stockée via l'objet Command est le suivant :
'**Appel de la procédure stockée via l'objet Command**
DIM MyComm,MyRst
Set MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr est la connexion à la base de données String
MyComm.CommandText = "getUserList" 'Spécifiez le nom de la procédure stockée
MyComm.CommandType = 4 'Indiquez qu'il s'agit d'une procédure stockée
MyComm.Prepared = true 'Exige que la commande SQL soit d'abord compilée
Set MyRst = MyComm.Execute
Set MyComm = Nothing
procédure stockée L'ensemble d'enregistrements obtenu est affecté à MyRst Ensuite, MyRst peut être utilisé.
Dans le code ci-dessus, l'attribut CommandType indique le type de requête. La valeur et la description sont les suivantes :
-1 indique que le type du paramètre CommandText ne peut pas être déterminé
1 indique que le paramètre CommandText est un type de commande général2 indique que le
paramètre CommandText est un type de commande général.
Le paramètre CommandText est un nom de table existant
4 indique que le paramètre CommandText est Le nom d'une procédure stockée
peut également appeler la procédure stockée via l'objet Connection ou l'objet Recordset. Les méthodes sont les suivantes :
'**Appeler la procédure stockée via la connexion. object**
DIM MyConn,MyRst
Set MyConn = Server.CreateObject("ADODB.Connection")
MyConn .open MyConStr 'MyConStr est la chaîne de connexion à la base de données
Set MyRst = MyConn.Execute("getUserList",0,4) 'Le dernier paramètre a la même signification que CommandType
Set MyConn = Nothing
'**Appel de la procédure stockée via l'objet Recordset**
DIM MyRst
Set MyRst = Server.CreateObject("ADODB.Recordset")
MyRst.open "getUserList",MyConStr,0,1 ,4
'MyConStr est la chaîne de connexion à la base de données, le dernier paramètre a la même signification que CommandType
2. Il n'y a pas de stockage d'entrée et de sortie. Veuillez consulter la procédure stockée suivante pour le processus
:
/*SP2*/
CREATE PROCEDURE dbo.delUserAll
tel que
défini nocount on
start
delete from dbo.[userinfo]
end
go
Cette procédure stockée supprime tous les enregistrements de la table userinfo sans aucune entrée ni sortie. Appel La méthode est fondamentalement la même que celle mentionnée ci-dessus, sauf qu'il n'est pas nécessaire d'obtenir le jeu d'enregistrements. :
'**Appelez la procédure stockée via l'objet Command**
DIM MyComm
Set MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données
MyComm.CommandText = "delUserAll" 'Spécifiez le nom de la procédure stockée
MyComm.CommandType = 4 'Indique qu'il s'agit d'une procédure stockée
MyComm.Prepared = true 'Exige que la commande SQL soit d'abord compilée
MyComm.Execute 'Pas besoin d'obtenir l'enregistrement défini ici
Set MyComm = Nothing
Bien sûr, ces procédures stockées peuvent également être appelées via l'objet Connection ou l'objet Recordset, mais l'objet Recordset est créé pour obtenir le jeu d'enregistrements. Si le jeu d'enregistrements n'est pas renvoyé, il est préférable d'utiliser l'objet Command.
3.Lors de l'exécution d'opérations similaires à SP2,
les procédures stockées avec des valeurs de retour
doivent exploiter pleinement les puissantes capacités de traitement des transactions de SQL Server pour maintenir la cohérence des données.De plus, nous pouvons avoir besoin que la procédure stockée renvoie l'état d'exécution. À cette fin, modifiez SP2 comme suit :
/*SP3*/
CREATE PROCEDURE dbo.delUserAll
as
set nocount on
start
BEGIN TRANSACTION
delete from dbo.[userinfo]
IF error= 0
start
COMMIT TRANSACTION
return 1
end
ELSE
start
ROLLBACK TRANSACTION
return 0
end
return
end
go
La procédure stockée ci-dessus renvoie 1 lorsque la suppression est exécutée avec succès, sinon elle renvoie 0 et effectue une opération de restauration. Afin d'obtenir la valeur de retour dans ASP, vous devez utiliser la collection Parameters pour déclarer les paramètres :
'**Appelez la procédure stockée avec la valeur de retour et obtenez la valeur de retour**
DIM MyComm,MyPara
Set MyComm = Server.CreateObject ("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données
MyComm.CommandText = "delUserAll" 'Spécifiez le nom de la procédure stockée
MyComm.CommandType = 4 'Indique qu'il s'agit d'une procédure stockée
MyComm.Prepared = true 'Nécessite que les commandes SQL soient compilées en premier
' instruction Valeur de retour
Set Mypara = MyComm.CreateParameter("RETURN",2,4)
MyComm.Parameters.Append MyPara
MyComm.Execute
'Obtenir la valeur de retour
DIM retValue
retValue = MyComm(0) ' ou retValue = MyComm.Parameters(0)
Set MyComm = Nothing
Dans MyComm.CreateParameter("RETURN",2,4), la signification de chaque paramètre est la suivante :
Le premier paramètre ("RETURE") est le nom du paramètre. Le nom du paramètre peut être défini arbitrairement, mais il doit généralement être identique au nom du paramètre déclaré dans la procédure stockée. Voici la valeur de retour, que je règle habituellement sur "RETURE" ;
le deuxième paramètre (2) indique le type de données du paramètre. Pour les codes de type spécifiques, veuillez vous référer à la référence ADO. Ce qui suit est un code de type couramment utilisé :
adBigInt : 20 ;
adBinary : 128 ;
adBoolean
:
11
;
adTinyInt
: 16 ;
adVarChar
: 200
;
peut être prise, et -1 à - 99 est une valeur réservée ;
le troisième paramètre (4) indique la nature du paramètre, où 4 indique qu'il s'agit d'une valeur de retour. La description de la valeur de ce paramètre est la suivante :
0 : Le type ne peut pas être déterminé ; 1 : Paramètre d'entrée ; 2 : Paramètre d'entrée ou de sortie 4 : Valeur de retour
Le code ASP donné ci-dessus doit être indiqué. être un code complet, c'est aussi le code le plus complexe. En fait,
Set Mypara = MyComm.CreateParameter("RETURN",2,4)
MyComm.Parameters.Append MyPara
peut être simplifié en
MyComm.Parameters.Append MyComm.CreateParameter( "RETURN",2,4)
ou encore Vous pouvez continuer à simplifier, ce qui sera expliqué plus tard.
Pour les procédures stockées avec des paramètres, elles ne peuvent être appelées qu'à l'aide de l'objet Command (il existe également des informations selon lesquelles elles peuvent être appelées via l'objet Connection ou l'objet Recordset, mais je ne l'ai pas essayé).
4. La valeur de retour d'une procédure stockée avec des paramètres d'entrée et des paramètres de sortie
est en fait un paramètre de sortie spécial. Dans la plupart des cas, nous utilisons des procédures stockées qui ont à la fois des paramètres d'entrée et de sortie. Par exemple, nous souhaitons obtenir le nom d'utilisateur d'un utilisateur avec un certain ID dans la table d'informations utilisateur. À ce stade, il existe un paramètre d'entrée. --ID utilisateur et un paramètre de sortie ----nom d'utilisateur. La procédure stockée pour implémenter cette fonction est la suivante :
/*SP4*/
CREATE PROCEDURE dbo.getUserName
@UserID int,
@UserName varchar(40) affiche
comme
défini nocount au
début
si @UserID est nul return
select @UserName=username
from dbo .[ userinfo]
return
end
go
Le code ASP pour appeler la procédure stockée est le suivant :
'**Appeler la procédure stockée avec les paramètres d'entrée et de sortie**
DIM MyComm,UserID,UserName
UserID = 1
Set MyComm = Server.CreateObject(" ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données
MyComm.CommandText = "getUserName" 'Spécifiez le nom de la procédure stockée
MyComm.CommandType = 4 'Indique qu'il s'agit d'une procédure stockée
MyComm. Prepared = true 'Nécessite SQL Compilez d'abord la commande
et déclarez les paramètres
MyComm.Parameters.append MyComm.CreateParameter("@UserID",3,1,4,UserID)
MyComm.Parameters.append MyComm.CreateParameter("@UserName", 200,2,40)
MyComm. Exécuter
'Obtenir les paramètres
UserName = MyComm(1)
Set MyComm = Nothing
Dans le code ci-dessus, vous pouvez voir que, contrairement à la déclaration de la valeur de retour, 5 paramètres sont requis lors de la déclaration des paramètres d'entrée, et 4 les paramètres sont requis lors de la déclaration des paramètres de sortie. Lors de la déclaration des paramètres d'entrée, les cinq paramètres sont : le nom du paramètre, le type de données du paramètre, le type de paramètre, la longueur des données et la valeur du paramètre. Lors de la déclaration d'un paramètre de sortie, il n'y a pas de dernier paramètre : la valeur du paramètre.
Une attention particulière doit être portée aux points suivants : lors de la déclaration des paramètres, l'ordre doit être le même que celui défini dans la procédure stockée, et le type de données et la longueur de chaque paramètre doivent également être les mêmes que ceux définis dans la procédure stockée.
Si la procédure stockée comporte plusieurs paramètres, le code ASP apparaîtra encombrant. Vous pouvez utiliser la commande with pour simplifier le code :
'**Appeler une procédure stockée avec des paramètres d'entrée et de sortie (code simplifié)**
DIM MyComm,UserID,UserName.
UserID = 1
Définissez MyComm = Server.CreateObject("ADODB.Command")
avec MyComm
.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données.CommandText
= "getUserName" 'Spécifiez le nom de la procédure stockée.CommandType
= 4 'Indique qu'il s'agit une procédure stockée.Prepared
= true 'Exige que la commande SQL soit d'abord compilée.Parameters.append
.CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName",200, 2,40)
.Execute
end with
UserName = MyComm(1)
Set MyComm = Nothing
Si nous voulons obtenir les noms d'utilisateur de 10 utilisateurs avec les ID 1 à 10, devons-nous créer l'objet Command 10 fois ? Non. Si vous devez appeler la même procédure stockée plusieurs fois, modifiez simplement les paramètres d'entrée et vous obtiendrez des sorties différentes :
'**Plusieurs appels à la même procédure stockée**
DIM MyComm,UserID,UserName
UserName = ""
Set MyComm = Server .CreateObject( "ADODB.Command")
pour UserID = 1 à 10
avec MyComm
.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données.CommandText
= "getUserName" 'Spécifiez le nom de la procédure stockée.CommandType
= 4 'Indique qu'il s'agit d'un procédure stockée.Prepared
= true 'Nécessite que les commandes SQL soient d'abord compilées
si UserID = 1 puis
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName" ,200,2,40 )
.Execute
else
'Réaffecter les paramètres d'entrée (les paramètres d'entrée et les paramètres de sortie dont les valeurs de paramètre ne changent pas à ce moment n'ont pas besoin d'être re-déclarés)
.Parameters("@UserID") = UserID
.Execute
end if
end with
UserName = UserName + MyComm( 1) + "," 'Peut-être aimez-vous utiliser un tableau pour stocker
ensuite
Set MyComm = Nothing
Commevous pouvez le voir dans le code ci-dessus : lors de l'appel de la même procédure stockée. à plusieurs reprises, il vous suffit de réaffecter les paramètres d'entrée dont les valeurs ont changé. Cette méthode est Lorsqu'il y a plusieurs paramètres d'entrée et de sortie et que la valeur d'un seul paramètre d'entrée change à chaque appel, la quantité de code peut être. fortement réduit.
5. Procédures stockées qui ont à la fois des valeurs de retour, des paramètres d'entrée et des paramètres de sortie, comme
mentionné précédemment, lors de l'appel d'une procédure stockée, l'ordre dans lequel les paramètres sont déclarés doit être le même que celui défini dans la procédure stockée. . Autre point à prendre particulièrement en compte : si la procédure stockée possède à la fois une valeur de retour et des paramètres d'entrée et de sortie, la valeur de retour doit être déclarée en premier.
Pour démontrer la méthode d'appel dans ce cas, améliorons l'exemple ci-dessus. Obtenez toujours le nom d'utilisateur de l'utilisateur avec l'ID 1, mais il est possible que l'utilisateur n'existe pas (l'utilisateur a été supprimé et l'ID utilisateur est un champ auto-croissant). La procédure stockée renvoie des valeurs différentes selon que l'utilisateur existe ou non. À l'heure actuelle, la procédure stockée et le code ASP sont les suivants :
/*SP5*/
CREATE PROCEDURE dbo.getUserName
--Afin d'approfondir l'impression de « séquence », inversez l'ordre de définition des deux paramètres suivants
@UserName varchar( 40) sortie,
@UserID int
comme
défini nocount au
début
si @UserID est nul, retournez
sélectionnez @UserName=username
from dbo.[userinfo]
if rowcount> 0
retournez 1
sinon
retournez 0
retournez
la fin
go
'**Le l'appel a à la fois une valeur de retour et une entrée Procédures stockées pour les paramètres et les paramètres de sortie**
DIM MyComm,UserID,UserName
UserID = 1
Set MyComm = Server.CreateObject("ADODB.Command")
with MyComm
.ActiveConnection = MyConStr 'MyConStr est la connexion à la base de données string.CommandText
= "getUserName" 'Spécifiez le nom de la procédure stockée.CommandType
= 4 'Indique qu'il s'agit d'une procédure stockée
. Prepared = true 'Nécessite que la commande SQL soit d'abord compilée
' La valeur de retour doit être déclarée en premier.Parameters.Append.
.CreateParameter("RETURN",2,4)
'L'ordre de déclaration des deux paramètres suivants est également inversé en conséquence.Parameters.append
.CreateParameter("@UserName",200,2,40)
.Parameters.append .CreateParameter(" @UserID",3,1,4,UserID)
. Exécuter
end with
if MyComm(0) = 1 then
UserName = MyComm(1)
else
UserName = "Cet utilisateur n'existe pas"
end if
Set MyComm = Nothing
6. Procédures stockées qui renvoient des paramètres et des jeux d'enregistrements en même temps
Parfois, nous avons besoin de procédures stockées pour renvoyer des paramètres et des jeux d'enregistrements en même temps. Par exemple, lors de l'utilisation de procédures stockées pour la pagination, des paramètres tels que les jeux d'enregistrements et le volume total de données doivent être renvoyés en même temps. temps. Ce qui suit est une procédure stockée pour le traitement de la pagination :
/*SP6*/
CREATE PROCEDURE dbo.getUserList
@iPageCount int OUTPUT, --Total number of pages
@iPage int, --Current page number
@iPageSize int --Number of records per page
comme
défini nocount au
début
--Créer une table temporaire
créer une table #t (ID int IDENTITY, --Auto-increment field
userid int,
username varchar(40))
--Écrire les données dans la table temporaire
insérer dans #t
sélectionner l'ID utilisateur, username from dbo.[UserInfo]
order by userid
--Obtenir le nombre total d'enregistrements
déclarer @iRecordCount int
set @iRecordCount = rowcount
--Déterminer le nombre total de pages
IF @iRecordCount%@iPageSize=0
SET @iPageCount=CEILING(@ iRecordCount/@iPageSize)
ELSE
SET @iPageCount=CEILING(@iRecordCount/@iPageSize)+1
--Si le numéro de page demandé est supérieur au nombre total de pages, afficher la dernière page
IF @iPage > @iPageCount
SELECT @iPage = @iPageCount
--Détermine les enregistrements de début et de fin de la page actuelle
DECLARE @iStart int --start record
DECLARE @iEnd int --end record
SELECT @iStart = (@iPage - 1) * @iPageSize
SELECT @iEnd = @iStart + @iPageSize + 1
--Obtenir l'enregistrement de la page actuelle,
sélectionner * à partir de # t où ID> @iStart et ID <@iEnd
--Supprimer la table temporaire
DROP TABLE #t
--Renvoyer le nombre total d'enregistrements
return @iRecordCount
end
goIn
the procédure stockée ci-dessus, entrez le numéro de page actuel et le nombre d'enregistrements par page, et renvoyez la page actuelle L'ensemble d'enregistrements, le nombre total de pages et le nombre total d'enregistrements. Pour être plus typique, le nombre total d'enregistrements est renvoyé sous forme de valeur de retour. Voici le code ASP qui appelle la procédure stockée (l'opération de pagination spécifique est omise) :
'**Appelez la procédure stockée de pagination**
DIM pagenow,pagesize,pagecount,recordcount
DIM MyComm,MyRst
pagenow = Request("pn")
'Custom La fonction est utilisée pour vérifier les nombres naturels
si CheckNar(pagenow) = false then pagenow = 1
pagesize = 20
Set MyComm = Server.CreateObject("ADODB.Command")
with MyComm
.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données .CommandText
= "getUserList " 'Spécifiez le nom de la procédure stockée.CommandType
= 4 'Indique qu'il s'agit d'une procédure stockée
' Prepared = true ' Nécessite que les commandes SQL soient d'abord compilées
' Valeur de retour (nombre total d'enregistrements)
.Parameters.Append . CreateParameter("RETURN",2,4 )
'Paramètres de sortie (nombre total de pages)
.Parameters.Append .CreateParameter("@iPageCount",3,2)
'Paramètres d'entrée (numéro de page actuel)
.Parameters.append .CreateParameter( "@iPage",3,1,4 ,pagenow)
'Paramètres d'entrée (nombre d'enregistrements par page)
.Parameters.append .CreateParameter("@iPageSize",3,1,4,pagesize)
Set MyRst = .Execute
end with
if MyRst.state = 0 then 'Données non obtenues, MyRst close
recordcount = -1
else
MyRst.close 'Remarque : Pour obtenir la valeur du paramètre, vous devez d'abord fermer l'objet du jeu d'enregistrements
recordcount = MyComm(0)
pagecount = MyComm( 1)
if cint(pagenow)> =cint(pagecount) then pagenow=pagecount
end if
Set MyComm = Nothing
'Ce qui suit affiche l'enregistrement
si recordcount = 0 alors
Response.Write "Aucun enregistrement"
sinon si recordcount > 0 alors
MyRst.open
do jusqu'à MyRst.EOF
......
boucle
'Ce qui suit affiche les informations de pagination
...
else 'recordcount=-1
Response.Write "Erreur de paramètre"
end if
Concernant le code ci-dessus, il n'y a qu'un seul point qui doit être expliqué : lors du renvoi du jeu d'enregistrements et des paramètres en même temps, si vous souhaitez obtenir les paramètres, vous devez d'abord fermer le jeu d'enregistrements, puis ouvrir le jeu d'enregistrements lorsque vous l'utilisez.
7. Procédures stockées qui renvoient plusieurs jeux d'enregistrements
La première chose que cet article présente concerne les procédures stockées qui renvoient des jeux d'enregistrements. Parfois, une procédure stockée est nécessaire pour renvoyer plusieurs jeux d'enregistrements. Dans ASP, comment obtenir ces jeux d'enregistrements en même temps ? Afin d'illustrer ce problème, ajoutez deux champs à la table userinfo : usertel et usermail, et définissez que seuls les utilisateurs connectés peuvent voir ces deux contenus.
/*SP7*/
CREATE PROCEDURE dbo.getUserInfo
@userid int,
@checklogin bit
comme
défini nocount au
début
si @userid est nul ou @checklogin est nul, renvoie
le nom d'utilisateur sélectionné
à partir de dbo.[usrinfo]
--if Log dans user, obtenez usertel et usermail
si @checklogin=1
select usertel,usermail
from dbo.[userinfo]
return
end
goVoici
le code ASP :
'**Appelez une procédure stockée qui renvoie plusieurs jeux d'enregistrements**
DIM checklg,UserID,UserName,UserTel,UserMail
DIM MyComm,MyRst
UserID = 1
'checklogin() est une fonction personnalisée permettant de déterminer si le visiteur est connecté
checklg = checklogin()
Set MyComm = Server.CreateObject("ADODB.Command" )
avec MyComm
.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données.CommandText
= "getUserInfo" 'Spécifiez le nom de la procédure stockée.CommandType
= 4 'Indique qu'il s'agit d'une procédure stockée.Prepared
= true 'Nécessite que la commande SQL soit compilée first.Parameters.append
.CreateParameter ("@userid",3,1,4,UserID)
.Parameters.append .CreateParameter("@checklogin",11,1,1,checklg)
Set MyRst = .Execute
terminer avec
Set MyComm = Nothing
'Du premier Obtenez la valeur du jeu d'enregistrements
UserName = MyRst(0)
'Obtenez la valeur du deuxième jeu d'enregistrements
si non MyRst est Nothing alors
Set MyRst = MyRst.NextRecordset()
UserTel = MyRst(0)
UserMail = MyRst(1)
se termine si
Set MyRst = Nothing
Dans le code ci-dessus, la méthode NextRecordset de l'objet Recordset est utilisée pour obtenir plusieurs jeux d'enregistrements renvoyés par la procédure stockée.
Jusqu'à présent, cet article a donné une explication relativement complète de diverses situations dans lesquelles ASP appelle des procédures stockées. Enfin, parlons des différentes méthodes d'appel de plusieurs procédures stockées dans un programme ASP.
Dans un programme ASP, il est possible d'appeler plusieurs procédures stockées d'au moins les trois manières suivantes :
1. Créez plusieurs objets Command
DIM MyComm
Set MyComm = Server.CreateObject("ADODB.Command")
'Appelez la première procédure stockée
.. . ...
Set MyComm = Nothing
Set MyComm = Server.CreateObject("ADODB.Command")
'Appelez la procédure stockée deux
...
Set MyComm = Nothing
...
2. Créez un seul objet Command, à la fin d'un appel, effacez son paramètres
DIM MyComm
Set MyComm = Server.CreateObject("ADODB.Command")
'Appeler la procédure stockée 1
...
'Effacer les paramètres (en supposant qu'il y ait trois paramètres)
MyComm.Parameters.delete 2
MyComm.delete 1
MyComm.Parameters. delete 0
'Appelez la procédure stockée deux et effacez les paramètres
...
Set MyComm = Nothing
À ce stade, veuillez noter : l'ordre d'effacement des paramètres est opposé à l'ordre de déclaration des paramètres. La raison est que je ne sais pas. .
3. Utilisez la méthode Refresh de la collection de données Parameters pour réinitialiser l'objet Parameter
DIM MyComm
Set MyComm = Server.CreateObject("ADODB.Command")
'Appeler la procédure stockée 1
...
'Réinitialiser tous les objets Parameter contenus dans la collection de données Parameters.
MyComm.Parameters.Refresh
'Appeler la procédure stockée 2
...
Set MyComm = Nothing
On pense généralement que la création répétée d'objets est une méthode moins efficace, mais après les tests (l'outil de test est Microsoft Application Center Test), les résultats sont inattendus :
Méthode 2 > = Méthode 1 >> Méthode 3
La vitesse d'exécution de la méthode 2 est supérieure ou égale à la méthode 1 (jusqu'à environ 4 % de plus). La vitesse d'exécution de ces deux méthodes est beaucoup plus rapide que la méthode 3 (jusqu'à 130). %), il est donc recommandé de : Lorsqu'il y a de nombreux paramètres, la méthode 1 est utilisée ; lorsqu'il y a peu de paramètres, la méthode 2 est utilisée ;
Il m'a fallu une journée pour enfin mettre par écrit une partie de mon expérience superficielle dans l'appel de procédures stockées en ASP. Parmi eux, certains d’entre eux dont je ne connais que les effets mais pas les causes, et certains peuvent être erronés, mais tout cela résulte de ma pratique personnelle. Veuillez l’accepter d’un œil critique, lecteurs. Si vous avez des avis différents, n'hésitez pas à me le faire savoir. Merci d'avance.