Résumé de l'expérience : analyse ASP et procédures stockées

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. Bien que le texte suivant ne puisse pas être absolument correct, il s'agit d'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. Il y a au moins trois avantages à cela :
Premièrement, améliorez 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, les classifications simples suivantes sont effectuées en fonction de l'entrée et de la sortie du processus stocké :
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 la syntaxe T-SQL, la procédure stockée ne donne donc que le code sans explication) :

/*SP1*/
CRÉER UNE PROCÉDURE dbo.getUserList
comme
ne définir aucun compte sur
commencer
sélectionnez * dans dbo.[userinfo]
fin

de go

obtient tous les enregistrements de la table userinfo et renvoie un jeu d'enregistrements. Le code ASP pour 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 Mon Comm, Mon Rst
Définir MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr est la chaîne de connexion à la base de données
MyComm.CommandText = "getUserList" '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 d'abord compilées
Définir MyRst = MyComm.Execute
Set MyComm = Nothing

L'ensemble d'enregistrements obtenu par la procédure stockée 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 CommandText est un type de commande général
2 indique que 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

. La procédure stockée peut également être appelée via l'objet Connection ou l'objet Recordset. Les méthodes sont les suivantes :

'**Appelez la procédure stockée via l'objet Connection**.
DIM MyConn, MyRst
Définir 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

'**Appeler la procédure stockée via l'objet Recordset**
DIM MyRst
Définir 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. Pour les procédures stockées sans entrée ni sortie, veuillez consulter les procédures stockées suivantes :

/*SP2*/
CRÉER UNE PROCÉDURE dbo.delUserAll
comme
ne définir aucun compte sur
commencer
supprimer de dbo.[userinfo]
fin

go

supprime tous les enregistrements de la table userinfo sans aucune entrée ni sortie. La méthode d'appel 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 la commande. objet**
DIM MonComm
Définir 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 d'abord compilées
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. Pour cela, modifiez le SP2 comme suit :

/*SP3*/.
CRÉER UNE PROCÉDURE dbo.delUserAll
comme
ne définir aucun compte sur
commencer
COMMENCER LA TRANSACTION
supprimer de dbo.[userinfo]
SI @@erreur=0
commencer
ENGAGER LA TRANSACTION
retour 1
fin
AUTRE
commencer
TRANSACTION D'ANNULATION
retourner 0
fin
retour
fin

go

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 MonComm,MonPara
Définir 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 d'abord compilées
'Déclarer la valeur de retour
Définir Mypara = MyComm.CreateParameter("RETURN",2,4)
MyComm.Parameters.Append MyPara
MonComm.Execute
'Obtenir la valeur de retour
Valeur ret DIM
retValue = MyComm(0) 'ou retValue = MyComm.Parameters(0)
Définir 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, je la règle généralement sur "RETURE" ;
Le deuxième paramètre (2) indique le type de données du paramètre. Veuillez vous référer à la référence ADO pour les codes de type spécifiques indiqués ci-dessous :
adBigInt : 20 ;
adBinaire : 128 ;
adBooléen : 11 ;
adChar : 129 ;
adDBTimeStamp : 135 ;
adVide : 0 ;
adInteger : 3 ;
adSmallInt : 2 ;
adTinyInt : 16 ;
adVarChar : 200 ;

Pour la valeur de retour, seules les valeurs entières peuvent être prises, et -1 à -99 sont des valeurs réservées ;
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ètres d'entrée ; 2 : Paramètres d'entrée ; 3 : Paramètres d'entrée ou de sortie ; 4 : Valeur de retour

Le code ASP donné ci-dessus doit être considéré comme un code complet, c'est-à-dire 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)

et peut même continuer à être simplifié, 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 d'entrée 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*/
CRÉER UNE PROCÉDURE dbo.getUserName
@UserID entier,
Sortie de @UserName varchar(40)
comme
ne définir aucun compte sur
commencer
si @UserID est nul, retour
sélectionnez @UserName=nom d'utilisateur
de dbo.[infoutilisateur]
où IDutilisateur=@IDUtilisateur
retour
fin

aller

appeler la procédure stockée est le suivant :

'**Appeler une procédure stockée avec des paramètres d'entrée et de sortie**
DIM MyComm, ID utilisateur, nom d'utilisateur
ID utilisateur = 1
Définir 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 que les commandes SQL soient d'abord compilées
'Déclarer les paramètres
MyComm.Parameters.append MyComm.CreateParameter("@UserID",3,1,4,UserID)
MyComm.Parameters.append MyComm.CreateParameter("@UserName",200,2,40)
MonComm.Execute
'Obtenir les paramètres
Nom d'utilisateur = MonComm(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 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 des paramètres d’entrée, 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 a plusieurs paramètres, le code ASP semblera 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, ID utilisateur, nom d'utilisateur
ID utilisateur = 1
Définir 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 d'une procédure stockée
.Prepared = true 'Nécessite que les commandes SQL soient d'abord compilées
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName",200,2,40)
.Exécuter
terminer par
Nom d'utilisateur = MonComm(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, il vous suffit de modifier les paramètres d'entrée et vous obtiendrez différents paramètres d'entrée :

'**Appelez la même procédure stockée plusieurs fois**
DIM MyComm, ID utilisateur, nom d'utilisateur
Nom d'utilisateur = ""
Définir MyComm = Server.CreateObject("ADODB.Command")
pour UserID = 1 à 10
avecMyComm
.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'une procédure stockée
.Prepared = true 'Nécessite que les commandes SQL soient d'abord compilées
si ID utilisateur = 1 alors
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName",200,2,40)
.Exécuter
autre
'Réaffecter les valeurs aux 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 déclarés à nouveau)
.Parameters("@UserID") = ID utilisateur
.Exécuter
finir si
terminer par
UserName = UserName + MyComm(1) + "," 'Peut-être aimez-vous utiliser le stockage en tableau
suivant
Set MyComm = Nothing

Comme le montre le code ci-dessus : lors de l'appel répété de la même procédure stockée, il vous suffit de réaffecter les paramètres d'entrée dont les valeurs ont changé. Cette méthode a plusieurs paramètres d'entrée et de sortie, et un seul est appelé. à chaque fois. La quantité de code peut être considérablement réduite lorsque la valeur du paramètre d'entrée change.

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*/
CRÉER UNE PROCÉDURE dbo.getUserName
--Afin d'approfondir l'impression d'« ordre », inversez l'ordre de définition des deux paramètres suivants.
Sortie @UserName varchar(40),
@UserID entier
comme
ne définir aucun compte sur
commencer
si @UserID est nul, retour
sélectionnez @UserName=nom d'utilisateur
de dbo.[infoutilisateur]
où IDutilisateur=@IDUtilisateur
si @@rowcount>0
retour 1
autre
retourner 0
retour
fin
go

'**Appelle une procédure stockée avec une valeur de retour, des paramètres d'entrée et des paramètres de sortie**
DIM MyComm, ID utilisateur, nom d'utilisateur
ID utilisateur = 1
Définir MyComm = Server.CreateObject("ADODB.Command")
avecMyComm
.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'une procédure stockée
.Prepared = true 'Nécessite que les commandes SQL soient d'abord compilées

' La valeur de retour doit être déclarée en premier
.Parameters.Append .CreateParameter("RETOUR",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
terminer par
si MonComm(0) = 1 alors
Nom d'utilisateur = MonComm(1)
autre
UserName = "Cet utilisateur n'existe pas"
finir si
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, lorsque nous utilisons des procédures stockées pour la pagination, nous devons renvoyer des paramètres tels que. en tant que jeux d'enregistrements et données totales en même temps. Ce qui suit est une procédure stockée pour la pagination :

/*SP6*/
CRÉER UNE PROCÉDURE dbo.getUserList
@iPageCount int OUTPUT, --Nombre total de pages
@iPage int, --Numéro de page actuel
@iPageSize int --Nombre d'enregistrements par page
comme
ne définir aucun compte sur
commencer
--Créer une table temporaire
créer la table #t (ID int IDENTITY, champ --auto-increment
ID utilisateur int,
nom d'utilisateur varchar(40))
--Écrire les données dans une table temporaire
insérer dans #t
sélectionnez l'ID utilisateur, le nom d'utilisateur de dbo.[UserInfo]
trier par ID utilisateur

--Obtenir le nombre total d'enregistrements
déclarer @iRecordCount int
set @iRecordCount = @@rowcount

--détermine le nombre total de pages
SI @iRecordCount%@iPageSize=0
SET @iPageCount=PLAFOND (@iRecordCount/@iPageSize)
AUTRE
SET @iPageCount=CEILING(@iRecordCount/@iPageSize)+1

--Si le numéro de page demandé est supérieur au nombre total de pages, la dernière page sera affichée
SI @iPage > @iPageCount
SELECT @iPage = @iPageCount

-- détermine le début et la fin de la page actuelle
DÉCLARE @iStart int --start record
DÉCLARE @iEnd int --end record
SELECT @iStart = (@iPage - 1) * @iPageSize
SELECT @iEnd = @iStart + @iPageSize + 1

--Obtenir l'enregistrement de la page actuelle
sélectionnez * à partir de #t où ID>@iStart et ID<@iEnd

--Delete table temporaire
DROP TABLE #t

--renvoie le nombre total d'enregistrements
retourner @iRecordCount
fin

Dans la procédure stockée ci-dessus,

go

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**
Page DIM maintenant, taille des pages, nombre de pages, nombre d'enregistrements
DIM Mon Comm, Mon Rst
pagenow = Requête("pn")
'Fonction personnalisée utilisée pour vérifier les nombres naturels
si CheckNar(pagenow) = false alors pagenow = 1
taille de la page = 20
Définissez MyComm = Server.CreateObject("ADODB.Command")

avec 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 renvoyée (nombre total d'enregistrements)
.Parameters.Append .CreateParameter("RETOUR",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)
SetMyRst = .Exécuter
terminer par
si MyRst.state = 0 alors 'Aucune donnée n'a été obtenue, MyRst est fermé
nombre d'enregistrements = -1
autre
MyRst.close 'Remarque : Pour obtenir les valeurs des paramètres, vous devez d'abord fermer l'objet Recordset
nombre d'enregistrements = MonComm(0)
nombre de pages = MonComm(1)
si cint(pagenow)>=cint(pagecount) alors pagenow=pagecount
finir si
Set MyComm = Nothing

'Afficher les enregistrements ci-dessous
si nombre d'enregistrements = 0 alors
Réponse.Écrivez "Aucun enregistrement"
sinon si nombre d'enregistrements > 0 alors
MonRst.open
faire jusqu'à MyRst.EOF
...
boucle
'Ce qui suit affiche les informations de pagination
...
sinon 'recordcount=-1
Response.Write "Erreur de paramètre"
end if

Concernant le code ci-dessus, il n'y a qu'un seul point à expliquer : 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 l'ouvrir lorsque en utilisant le jeu d'enregistrements.

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*/
CRÉER UNE PROCÉDURE dbo.getUserInfo
@useridint,
@checkloginbit
comme
ne définir aucun compte sur
commencer
si @userid est nul ou @checklogin est nul, retour
sélectionner le nom d'utilisateur
de dbo.[usrinfo]
où IDutilisateur=@IDutilisateur
--Si vous êtes un utilisateur connecté, prenez usertel et usermail
si @checklogin=1
sélectionnez usertel, usermail
de dbo.[infoutilisateur]
où IDutilisateur=@IDutilisateur
retour
fin
Voici

le code ASP :

'**Appelle une procédure stockée qui renvoie plusieurs jeux d'enregistrements**
Vérification DIM, ID utilisateur, nom d'utilisateur, UserTel, UserMail
DIM Mon Comm, Mon Rst
ID utilisateur = 1
'checklogin() est une fonction personnalisée pour déterminer si le visiteur est connecté
checklg = checklogin()
Définir MyComm = Server.CreateObject("ADODB.Command")
avec 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
.Parameters.append .CreateParameter("@userid",3,1,4,UserID)
.Parameters.append .CreateParameter("@checklogin",11,1,1,checklg)
SetMyRst = .Exécuter
terminer par
Set MyComm = Nothing

'Obtenir la valeur du premier jeu d'enregistrements
Nom d'utilisateur = MonRst(0)
'Obtenir la valeur du deuxième jeu d'enregistrements
sinon MyRst n'est rien alors
Définir MyRst = MyRst.NextRecordset()
UserTel = MonRst(0)
UserMail = MonRst(1)
finir 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, au moins les trois méthodes suivantes sont possibles pour appeler plusieurs procédures stockées :
1. Créez plusieurs objets Commande.

DIM MonComm
Définir MyComm = Server.CreateObject("ADODB.Command")
'Appeler la procédure stockée 1
...
Définir MyComm = Rien
Définir MyComm = Server.CreateObject("ADODB.Command")
'Appeler la procédure stockée deux
...
Définir MyComm = Rien
......

2. Créez uniquement un objet Command, et à la fin d'un appel, effacez son paramètre

DIM MyComm
Définir 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.Parameters.delete 1
MyComm.Parameters.delete 0
'Appelle la procédure stockée deux et efface les paramètres
...
Set MyComm = Nothing

Pour le moment, veuillez noter : l'ordre d'effacement des paramètres est opposé à l'ordre de déclaration des paramètres, je ne connais pas la raison.

3. Utilisez la méthode Refresh de la collecte de données Parameters pour réinitialiser l'objet Parameter

DIM MyComm.
Définir 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 deux
.....
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 à celle de 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 %). méthode 1 lorsqu’il y a de nombreux paramètres. Sinon, utilisez la méthode 2.

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.