Programmation d`un site Web côté Serveur avec ASP et ADO : le

Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
SOMMAIRE
SOMMAIRE ........................................................................................................... 1
INTRODUCTION ................................................................................................... 3
Champ couvert ................................................................................................................................... 3
Pre-requis ........................................................................................................................................... 3
Environnement technique : ASP 1.0................................................................................................... 3
Environnement technique : ASP 2.0................................................................................................... 3
outils possibles ................................................................................................................................... 3
CONVENTIONS D'UTILISATION DU SUPPORT .................................................. 4
T.P. N°1 L'OBJET CONNECTION DU MODELE ADO ......................................... 5
1.1
1.2
Objectifs ........................................................................................................................... 5
Ce qu’il faut savoir .......................................................................................................... 5
Un tour d'horizon d'.ADO ...................................................................................... 5
Le modèle Objet ADO .......................................................................................... 6
L'objet Connection ................................................................................................ 6
1.3 Travail a réaliser TP1.asp ........................................................................................................... 13
T.P. N°2 L'OBJET COMMAND DU MODELE ADO ............................................ 14
1.1
1.2
Objectifs ......................................................................................................................... 14
Ce qu’il faut savoir ........................................................................................................ 14
L'objet Command ............................................................................................... 14
Définir la taille et le type du paramètre ............................................................................................ 19
2.3 Travail a réaliser TP2.asp ........................................................................................................... 20
T.P. N°3 L'OBJET RECORDSET DU MODELE ADO ......................................... 21
1.1
1.2
Objectifs ......................................................................................................................... 21
Ce qu’il faut savoir ........................................................................................................ 21
L'objet Recordset................................................................................................ 21
Utiliser les recordset avec ADO ......................................................................... 26
Travailler avec la collection Fields ..................................................................... 30
Explorer la collection Field ................................................................................. 32
3.3 Travail a réaliser TP3.asp ........................................................................................................... 33
T.P. N°4 METTRE A JOUR UNE BASE DE DONNEES...................................... 34
4.1.
4.2
Objectifs ......................................................................................................................... 34
Ce qu’il faut savoir ........................................................................................................ 34
Utiliser SQL pour mettre à jour des enregistrements ......................................... 34
Utiliser les méthodes du recordset pour mettre à jour et supprimer des
enregistrements .................................................................................................. 35
4.3 Travail a réaliser TP4.asp ........................................................................................................... 36
T.P. N°5 LES TRANSACTIONS .......................................................................... 37
5.1.
5.2
Objectifs ......................................................................................................................... 37
Ce qu’il faut savoir ........................................................................................................ 37
Utiliser des transactions ..................................................................................... 37
Transaction sur plusieurs pages ........................................................................ 38
5.3 Travail a réaliser TP5.ASP ......................................................................................................... 39
T.P. N°6 GESTION DES ERREURS.................................................................... 40
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 1
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
6.1
6.2
Support de formation
Objectifs ......................................................................................................................... 40
Ce qu’il faut savoir ........................................................................................................ 40
Gestion des erreurs par l'objet ERR et par la collection Errors ......................... 40
6.3 Travail a réaliser TP6.ASP ......................................................................................................... 41
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 2
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
INTRODUCTION
CHAMP COUVERT
Ce support traite de la programmation de l'accès aux bases de données avec le
modèle ADO, dans le cadre de réalisation de sites Web en utilisant la technologie
ASP, avec le langage VBScript.
PRE-REQUIS
Le langage HTML est supposé maîtrisé, ainsi que les principes régissant les serveurs
et sites Web .
Le langage VBScript doît être connu.
Le langage SQL et les concepts des bases de données relationnelles sont maîtrisés.
ENVIRONNEMENT TECHNIQUE : ASP 1.0
Serveur NT et IIS 3.0 ( incluant ASP ), ou Win95 avec Personnel Web Server + ASP
et extensions FrontPage.
Bibliothèque Microsoft Activex Data Objects 1.5 pour modèle de classes ADO
ENVIRONNEMENT TECHNIQUE : ASP 2.0
Serveur NT et IIS 4.0 ( incluant ASP ), ou Win95 avec Personnel Web Server 4.0 qui
inclut ASP 2.0 .
Bibliothèque Microsoft Activex Data Objects 1.5 pour modèle de classes ADO
OUTILS POSSIBLES
Visual Interdev, Access 97 ( génère des pages ASP ) , éditeur HTML, éditeur de
texte ( bloc notes ) pour pages ASP, gestionnaire de site ( Front Page , ...)
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 3
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
CONVENTIONS D'UTILISATION DU SUPPORT
Ce support de formation est constitué d'une série d'exercices permettant de
s'approprier les différentes difficultés dans la programmation client/serveur de sites
Web avec les technologies Microsoft ASP et ADO.
Chaque exercice est structuré de la façon suivante :
 Description des objectifs visés.
 Explications des techniques à utiliser (Ce qu'il faut savoir).
 Enoncé du problème à résoudre (Travail à réaliser).
 Renvois bibliographiques éventuels dans les ouvrages traitant de ces techniques
(Lectures).
Des propositions de corrigé se trouvent dans le Dossier ADO_COR.
La base de données Contacts.MDB est fournie dans ce dossier.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 4
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°1 L'OBJET CONNECTION DU MODELE ADO
1.1 OBJECTIFS
 Comprendre le modèle ADO
 Etre capable de créer un objet Connection.
1.2 CE QU’IL FAUT SAVOIR
Un tour d'horizon d'.ADO
Active Server Pages dispose d'un modèle objet complet, appelé ADO (Active Data
Object), qui fait le lien entre les pages web et quasiment tout type de données. Dans
ce support, nous allons voir combien ce composant est important pour construire un
vrai site dynamique.
ADO constitue réellement un mécanisme de connexion à tous les types de données,
dont le plus commun est une base de données relationnelle. Dans le contexte
d'Active Server Pages, on peut écrire du code dans un langage de script, comme
VBScript ou JScript, capable d'interagir avec une base de données. Vu la souplesse
intrinsèque d'ASP, ADO permet de créer des applications client-serveur exécutables
via Intemet et indépendantes du type de navigateur client.
L'interface de données d'ADO
Dans sa forme la plus simple, ADO est conçu pour s'interfacer avec des bases de
données grâce à des méthodes ODBC (Open Database Connectivity). Il peut donc
être utilisé avec toute source de données possédant un pilote ODBC, non seulement
avec des systèmes de gestion de base de données comme SQL Server, Oracle,
Access, mais encore avec des fichiers comme ceux de Microsoft Excel, des fichiers
texte ou de tout autre type.
Cependant, le modèle objet ADO est construit sur une autre technologie de pointe,
OLE-DB, qui met en oeuvre une interface uniforme de données grâce aux méthodes
et propriétés qu'elle possède en propre. ODBC correspond à un des types de données
auquel ADO et ASP peuvent accéder, mais ce n'est pas le seul. Par exemple, il peut
accéder aux données de l'annuaire Windows NT.
Le fournisseur de données
Puisque ADO est construit sur une autre couche (OLE-DB), il faut pouvoir spécifier
une couche de connectivité dans les liens à une source de données. En d'autres
termes, il ne suffit plus de penser au pilote, il faut aussi prendre en compte le
fournisseur de données. ODBC n'est que le plus répandu des fournisseurs d'OLEDB.
Les capacités d'ADO dépendent directement de celles du fournisseur OLE-DB :
certains objets peuvent fonctionner autrement, des propriétés être absentes ou
certains objets ne pas exister.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 5
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Elles dépendent aussi, quand on passe par le fournisseur ODBC, de celles du pilote
ODBC. La plupart des pilotes ODBC ne proposent pas tous les types de curseur par
exemple, ou bien les pilotes SQL Server et Access proposent la propriété
AbsolutePage, que n'ont pas les autres pilotes.
Le modèle Objet ADO
Connection
Errors
Error
Command
Parameters
Parameter
Fields
Field
Recordset
La combinaison fournisseur/pilote utilisée dans ce support
Dans ce support, nous utiliserons Microsoft Access. Dans certains cas, comme les
procédures stockées, le pilote ODBC d'Access admet une syntaxe qui ne fonctionne
pas avec d'autres pilotes ODBC. Cependant, il est compact, simple à configurer et
universellement disponible, raisons pour lesquelles nous l'avons retenu, pour que
vous puissiez faire vos propres essais au fur et à mesure de vos découvertes. Nous
commencerons par étudier les principaux objets du modèle objet ADO. Mais tout
d'abord, voyons comment établir une connexion à une source de données et
manipuler les données, en commençant par un aperçu des trois principaux objets
d'ADO.
L'objet Connection
Définir une connexion à une base de données est une opération simple. La première
étape consiste à créer une instance de l'objet Connection, implémenté par le
composant Active Database, dont l'identifiant (progID) est ADODB :
Set objConn = Server.CreateObject("ADODB.Connection")
Avec la méthode Create0bject de l'objet Server, nous définissons une variable
contenant une référence à l'instance de l'objet Connection
Remarquez la différence avec Visual Basic et les définitions de variables de type
Database. Dans la mesure où VBScript gère des données de type variant, on ne peut
pas directement déclarer le type de la variable.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 6
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Définir l'étendue de la connexion
On ne va pas ouvrir une nouvelle connexion à chaque accès. On peut la créer une
seule fois dans la page et la réutiliser, ou encore la créer avec une portée qui s'étend
au niveau de la session ou de l'application, et la réutiliser dans plusieurs pages.
Quand on exécute plusieurs opérations, il est préférable de maintenir la connexion
active. De cette façon, l'accès à la base est amélioré, puisque nombre de tests se font
une fois pour toutes à l'ouverture. Pour ce faire, on place l'instruction
Server.CreateObject dans les instructions Session_onStart ou Application_onStart du
fichier global. asa, ou bien on utilise une balise <OBJECT>.
Voici comment créer une instance de la connexion disponible pendant toute la durée
de vie de l'application :
Sub Application_OnStart()
Set objConn = Server.CreateObject("'ADODB.Connection")
End Sub
ou:
<OBJECT> RUNAT=Server Scope = Application ID=objConn
ProgId="ADODB.Ccnnection">
</OBJECT>
Voici comment créer une instance de la connexion disponible pendant la durée de la session
Sub Session_onStart()
Set objConn = Server.CreateObject("ADODB.Connection")
End Sub
ou:
<OBJECT RUNAT=Server Scope=Session ID=objConn
ProgID="ADODB.Connection">
</OBJECT>
De plus, ODBC 3.0 propose une fonctionnalité de mise en commun desconnexions
(connection pooling) qui gère les connexions pour plusieurs utilisateurs. Quand elle
est active, il vaut mieux ouvrir et fermer la connexion à la base à chaque page, car
cela permet à ODBC d'être plus efficace.
Dans ce chapitre, comme nous utilisons ODBC 3.0 et Microsoft Access 97, nous
créerons chaque connexion au démarrage de la page et l'utiliserons tout au long de
cette page.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 7
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Les méthodes et les propriétés de l'objet Connection.
Les méthodes et les propriétés de l'objet Connection se répartissent en trois groupes :
l'ouverture et la fermeture d'une connexion, l'exécution d'une commande sur la
source de données et le contrôle des transactions. Nous allons étudier chaque groupe
l'un après l'autre, mais tout d'abord, voici une liste exhaustive des méthodes et
propriétés de l'objet Connection
Methodes
Méthode
Open
Close
Execute
BeginTrans
CommitTrans
RollbackTrans
Description
Ouvre une nouvelle connexion.
Ferme une connexion.
Exécute une requête, une instruction SQL ou une
procédure stockée.
Lance une nouvelle transaction.
Enregistre les modifications et termine la transaction. Peut
egalement débuter une nouvelle transaction
Annule les modifications et termine la transaction
Peut également débuter une nouvelle transaction
Propriétés
Propriété
Attributes
Description
Détermine si, à la fin d'une transaction, il est nécessaire
d'en commencer une nouvelle.
CommandTimeout
Nombre de secondes d'attente avant de renvoyer une
erreur, suite à une tentative d'exécution d'une commande
ConnectionString
Information utilisée pour créer une connexion à une source
de données
Nombre de secondes d'attente avant de renvoyer une erreur,
suite à une tentative de connexion échouée
Définit ou renvoie la base de données par défaut de cette
connexion
Définit ou renvoie le niveau d'isolation des transactions
Définit ou renvoie les permissions d'accès du fournisseur
Définit ou renvoie le nom du fournisseur
Renvoie le numéro de version d'ADO
ConnectionTimeout
DefaultDataBase
IsolationLevel
Mode
Provider
Version
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 8
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Ouvrir une connexion
Dès que l'on a créé une instance de l'objet Connection, on peut l'utiliser.
Cependant, elle ne fait encore référence à rien. L'étape suivante consiste à se servir
de la connexion pour ouvrir la source de données, afin d'accéder aux données et de
les manipuler, avec la méthode Open de l'objet Connection :
connection.0pen ChaineDeConnexion, Utilisateur, MotDePasse
Le paramètre ChaîneDeConnexion est une chaîne contenant le nom de la source de
données (DSN - Data Source Name ), ou une série d'arguments paramètre=valeur
séparés par des points virgules.
En général, il est plus facile de créer un nom de source de données système avec
l''Administrateur ODBC. C'est la méthode que nous avons utilisée dans ce support.
Si l'on fournit une chaîne détaillée plutôt qu'un DSN système, ADO reconnaît cinq
paramètres standard:
Paramètres
Provider
File Name
Data Source
User
Password
Description
Nom du fournisseur à utiliser pour la connexion
Nom de fichier contenant des détails, spécifiques du fournisseur,
prédéfinis sur la connexion
Nom de la source ou du fichier de la source de données
c'est-à-dire un registre de bases de données SQL
compris par ODBC, ou le nom d'un fichier Access
Nom d'utilisateur à utiliser à l'ouverture de la connexion.
Mot de passe à utiliser à l'ouverture de la connexion.
Tout paramètre supplémentaire n'est pas interprété par ADO, mais passé au
fournisseur. De plus, notons qu'il est possible d'indiquer soit le paramètre Provider,
soit File Name, mais pas les deux simultanément.
Une fois la connexion ouverte, le chaîne de connexion est en lecture seule.
Pour plus de sécurité, on peut passer utilisateur (User) et MotDePasse(Password) en
paramètres,
dans
la
ChaîneDeConnexion
(ConnectionString).
Si
la
ChaîneDeConnexion est un DSN système, c'est la seule possibilité de les spécifier.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 9
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Exemple d'ouverture de Connection
Voici un exemple d'ouverture d'une connexion utilisant un DSN système appelé
Contacts :
Set objConn = Server.CreateObject("ADODB.Connection" )
objConn.Open "'Contacts"
On peut aussi utiliser une chaîne de connexion détaillée :
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "DATABASE=pubs; DSN = Publishers;UID=sa;Password=;"
L'exemple ci-dessus correspond à une base de données SQL-Server.
Par défaut, le délai d'attente d'ouverture de la connexion est de 30 secondes, mais on
le modifie avec la propriété ConnectionTimeout. Si sa valeur est 0, ADO attend
indéfiniment que l'opération ait réussi.
Exécuter des commandes sur la connexion
Nous pouvons maintenant utiliser notre connexion. Dans quelques pages, nous
verrons comment récupérer des informations dans un ensemble de résultats
(recordset). Pour le moment, restons-en à l'exécution de commandes qui modifient
les enregistrements, avec la méthode Execute.
Cette instruction admet une chaîne contenant une requête SQL, le nom d'une
procédure stockée ou le nom d'une table. Dans le cas d'une table, l'instruction renvoie
un jeu d'enregistrements contenant toutes les données de la table.
Une procédure stockée est une commande ou une procédure existant dans la base de
données, par exemple une requête d'Access. Elle est constituée d'une ou plusieurs
instructions SQL ; c'est un moyen rapide de mettre à jour des données, car seul le
nom de la procédure circule sur le réseau.
Les procédures stockées peuvent renvoyer des données, ou juste en mettre à jour.
Pour le moment, postulons qu'elles n'en renvoient pas.
Pour bien utiliser ADO, il faut connaître le langage SQL.
Voici un exemple utilisant directement une chaîne SQL ( sur la table Contact ) :
Set objConn = Server.CreateObject("ADODBConnection")
objConn.Open "Contacts"
objConn.Execute "DELETE * FROM Contact WHERE State = 'LA' "
La base de données a pour DSN Contacts et contient la table Contact.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 10
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Si l'on dispose d'une procédure stockée dans la base de données, comme une requête
Access, ici DeleteAllLA, on l'exécute ainsi:
Set objConn = CreateObject('"ADODB.Connection")
objConn.Open "Contacts"
objConn.Execute "DeleteAllLA"
Si l'on utilise SQL Server, ou toute autre base de données, la chaîne de l'instruction
Execute sera différente. En effet, elle doit satisfaire la syntaxe du fournisseur et non
d'ADO, car ce dernier la passe directement sans l'analyser. Par exemple, dans SQL
Server :
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "Contacts"
objConn.Execute "[call DeleteAllLA]"
L'utilisation de procédures stockées procure une certaine souplesse : il n'est pas
nécessaire de recréer les requêtes SQL depuis les scripts ASP.
Cette méthode est bien adaptée aux cas simples, mais on peut optimiser les opérations
de bases de données en fournissant des informations complémentaires.
Indiquer le type de commande
Nous avons jusqu'ici utilisé l'instruction Execute sous sa forme la plus simple. On
améliore l'opération à l'aide de paramètres optionnels:
Connection .Execute TexteCommande, nbEnregModifiés, Options
Le paramètre Options indique le type d'instruction à exécuter.Le paramètre
TexteCommande peut être de trois types. ADO doit interroger la source de données
pour savoir quoi faire, ce qui a pour conséquence de ralentir le processus global. Si
l'on donne au paramètre Options une des valeurs indiquées dans le tableau cidessous, ADO connaît le type d'instruction et accélère son exécution.
afpa ©
Constante
adCmdUnknown
Valeur
0
adCmdText
1
adCmdTable
2
adCmdStoredProc
4
auteur
JPP
centre
CAEN
formation
Description
Inconnu
Il s'agit de la valeur par défaut
La définition de la commande est de type
texte comme une instruction SOL
Nom de la table à partir de laquelle créer
un ensemble d' enregistrements.
Procédure stockée ou requête contenue
dans la source de données.
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 11
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Pour utiliser le nom des constantes dans le code, et non leur valeur , il faut inclure
un fichier de définition Server Side Include ( SSI ). Ce fichier est fourni avec ASP et
installé par défaut dans ASPSamp/Samples. Pour VBSCRIPT, utilisez Adovbs.inc,
pour Jscript Adojavas.inc. Par exemple:
<!-- #include virtual="/Aspsamp/samples/Adovbs.inc" -->
On peut copier le fichier dans le répertoire de l'application et simplifier l'instruction:
<!-- #include file="Adovbs.inc" -->
L'autre paramètre est nbEntregModifiés. Si l'on donne un nom de variable à ce
paramètre, ADO y placera le nombre de lignes modifiés par la requête ou la
procédure stockée.
Voici de nouveau les deux exemples précédents , cette fois ci optimisés:
'Exécution d'une requête SQL
objConn.Execute "DELETE * FROM Contacts WHERE State = 'LA' ",
lngRecs,adCmdText
' Exécution d'une procédure stockée
objConn.Execute "DeleteAllLA" , lngRecs, adCmdStoredProc
Le délai maximal d'exécution de la requête est par défaut de 30 secondes, mais peut
être modifié par la propriété CommandTimout. Si la valeur est 0, ADO attendra
indéfiniment la fin de la requête.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 12
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Fermer la connexion
En fin de traitement sur la base de données, on doit fermer la connexion. Cette
opération ne libère pas les ressources affectées à l'objet; pour ce faire, il faut encore
définir la variable objet à Nothing :
objConn.Close
Set objConn = Nothing
Si on ne le fait pas, ASP s'en charge automatiquement dès que la variable est hors de
portée: dès que la page est envoyée au navigateur ( comme ici ), en fin de session ou
en fin d'application si l'objet est créé dans Global.asa.
1.3 TRAVAIL A REALISER TP1.ASP
La série d'exercices de ce support va reposer sur une base de données destinées à
gérer des contacts. La base de données est la base Contacts.mdb ( Access 97 )
fournie avec les ressources pédagogiques.
Il faut au préalable créer une DSN Système "Contacts" pour pouvoir coder
l'application.
Créer un fichier Global.asa muni d'une procédure Session_OnStart. Dans cette
procédure Session_OnStart, instancier un objet Connection de niveau Session appelé
Session("Contact_conn"). Ouvrir la connexion sur la DSN Contacts.
Dans la procédure Session_OnEnd, fermez cette connexion et détruisez l'objet.
Créer une page TP1.ASP qui affichera les propriétés de l'objet Connection :
-
afpa ©
ConnectionString
CommandTimeout
Defaultdatabase
Provider
Version
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 13
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°2 L'OBJET COMMAND DU MODELE ADO
1.1 OBJECTIFS
 Etre capable de créer un objet Command.
1.2 CE QU’IL FAUT SAVOIR
L'objet Command
Jusqu'ici, pour interroger ou mettre à jour une source de données, nous nous sommes
servis de l'objet Connection qui exécutait une procédure stockée ou une requête SQL.
On peut également utiliser l'objet Command, à condition de lui attribuer une chaîne
de connexion grâce à la propriété ActiveConnection.
Dans ce cas, la connexion s'établit, mais sans variable de connexion, contrairement à
ce qui se passe avec l'objet Connection explicitement défini. Cette méthode n'est
intéressante que si l'on a besoin de toutes les données résultant des opérations en
même temps. Si l'on exécute séparément plusieurs opérations, il vaut mieux créer un
objet Connection..
Méthodes et propriétés de l'objet Command
On crée un objet Command et on définit sa portée avec la méthode
Server.CreateObject ou avec la balise <OBJECT>.
Ses méthodes et propriétés sont résumées dans les tableaux suivants
Méthodes
CreateParameter
Execute
Propriétés
ActiveConnection
CommandText
CommandTimeout
CommandType
Prepared
afpa ©
auteur
JPP
centre
CAEN
Description
Crée une nouvel objet Parameter dans la collection
Parameters
Exécute la requête SOL ou la procédure stockée
indiquée dans la propriété CommandText
Description
Objet Connection à utiliser avec Command
Texte de la commande à exécuter
Nombre de secondes à attendre avant de
déclencher une erreur suite à l'échec d'une
instruction
Type de la commande dans la propriété
CommandText
Indique s'il faut créer une instruction préparée
(prepared statement) avant exécution
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 14
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Créer une Connexion Active
Pour se servir de l'objet Command, il faut indiquer la connexion (ActiveConnection)
à utiliser.
Si l'on a créé un objet Connection, on peut le réutiliser, ou bien donner une chaîne de
connexion (ConnectionString), comme avec la méthode open de l'objet Connection:
Set objCmd = Server.CreateObject("ADODB.Command")
objCmd.ActiveConnection = "Contacts"
ou
Set objCmd = Server.CreateObject("ADODB.Command")
objCmd.ActiveConnection =
"DATABASE=pubs;DSN=Publishers;UID=sa;Password=;"
Exécuter une requête
Une fois la connexion établie, on se sert de l'objet Command de la même façon que
de l'objet Connection sans avoir à ouvrir explicitement la source de données.
Les différentes propriétés de l'objet Command invitent à spécifier des paramètres
externes à la méthode Execute, qui renforcent le contrôle des opérations. Par
exemple, il est possible de définir le texte de la commande (CommandText) et son
type (CommandType), avant d'appeler Execute.
On peut aussi demander au fournisseur de données de créer une représentation de la
requête temporairement stockée. Cela ralentit la première exécution, mais par la
suite, seule la requête compilée est utilisée, ce qui accélère sensiblement son
traitement.
Set objCmd = Server.CreateObject(" ADODB.Command")
objCmd.ActiveConnection = "Contacts"
' DSN système
objCmd.CommandText = "DELETE * FROM Contact WHERE State = 'LA' "
objCmd.CommandType = 1
' une requête SOL.
objCmd.Prepared = True
' compile l'instruction ...
objCmd.Execute
' ... puis l'exécute
Set objCmd.ActiveConnection = Nothing
' libère les ressources
Le temps d'attente d'exécution est de 30 secondes par défaut, modifiable avec le
paramètre CommandTimeout. Si ce paramètre vaut 0, ADO attend indéfiniment que
l'opération s'achève.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 15
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Utiliser des paramètres
Si la requête nécessite des paramètres, on peut les ajouter à la collection Parameters
de l'objet Command mais aussi au " coup par coup " lors de l'exécution de la requête.
La syntaxe de la méthode Execute de l'objet Command est légèrement différente de
celle de la méthode Connection car elle contient un argument pour les paramètres
utilisés.
Command.Execute nbenregModifiés, Paramètres,Options
Les paramètres NbEnregModifiés et Options sont identiques à ceux de l'objet Connection
Paramètres définit un tableau de paramètres à utiliser avec la requête. Les éléments
de ce tableau correspondent aux valeurs de la collection Parameters et donc aux
paramètres nécessaires à la requête.
Voici comment indiquer trois paramètres:
objCmd.Execute Array(Paramètre1, Paramètre2, Paramètre3)
Si l'on ne donne pas la valeur d'un paramètre, c'est celle de la collection Parameters qui sera
utilisée:
objCmd.Execute Array(Paramètre1, , Paramètre3)
La procédure stockée de l'exemple précédent pourrait, par exemple, être remplacée
par une requête paramétrée, dans laquelle les paramètres seraient le nom de la table
et celui de l'Etat.
Set objCmd = Server.Create0bject("ADODB.Command")
objCmd.ActiveConnection "Contacts"
objCmd.CommandText = "DeleteStateQuery"
objCmd.CommandType = 4
objCmd.Execute Array("Contact","NY")
set objCmd.ActiveConnection = Nothing
afpa ©
auteur
JPP
centre
CAEN
formation
module
'nom d'une procédure stockée
' une procédure stockée
' exécute la requête paramètrée
' libère les ressources
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 16
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
La collection Parameters
La collection Parameters contient les paramètres d'une requête exécutée via un objet
Command.
Plutôt que de les spécifier au " coup par coup " à la requête, nous pouvons les ajouter
à cette collection. Voici ses méthodes et propriétés
Méthode
Append
Delete
Refresh
Description
Ajoute un paramètre à la collection
Supprime un paramètre de la collection.
Met à jour la collection pour prendre en compte les modifications
des paramètres.
Créer et ajouter des paramètres à une collection
Chaque membre de la collection Parameters est un objet Parameter possédant un
ensemble de propriétés.
Propriété
Attributes
Direction
Description
Type de données accepté par le paramètre
Paramètre en entrée, sortie ou de retour
Name
NumericScale
Precision
Size
Type
Value
Nom du paramètre
Nombre de décimales si numérique
Nombre de chiffres si numérique
Taille maximale en octets
Type de données d'un paramètre
Valeur assignée à un paramètre
Pour ajouter un nouveau paramètre à la collection Parameters, il faut en créer une
instance, puis définir les valeurs de ses propriétés et enfin utiliser la rnéthode Append
de l'objet Commande
Pour créer un objet Parameter, on utilise la méthode CreateParameter de l'objet
Command:
Set objParam = Command.CreateParameter(Name,Type,Direction,Size,Value)
On peut, par exemple, créer un nouveau paramètre et l'ajouter à la collection de cette façon:
Set objParam = objCmd.CreateParameter("State",129,1,2,"NY")
objCmd.Parameters.Append objParam
Dans cet exenple, nous avons défini les argument Type, Direction et Size au
moment de la création du paramètre. . On peut aussi les définir séparémént et utiliser
des constantes prédéfinies dans adovbs.inc.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 17
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Dans l'exemple suivant nous récupérons la valeur du paramètre depuis une zone de
texte envoyée à notre page ASP dans la collection Form de l'objet Request
Set objCmd = Server.Create0bject("ADODB.Command")
objCmd.ActiveConnection = "Contacts"
objCmd.CommandText = "DeleteStateQuery"
objCmd.CommandType = adStoredProc
strValue =
Request.Form("txtState"')
' récupérer State depuis la
requête
Set objParam =
objCmd.CreateParameter("State") ' le nom du paramètre
objParam.Type =
adChar
' une chaîne
objParam.Direction = adParamInput
' un paramètre en entrée
objParam.Size = Len(strValue)
' la taille de la chaîne
objParam.Value = strValue
' la chaîne elle-même
objCmd.Parameters.Append objParam
objCmd.Execute
' ajout la collection
Set objCmd.ActiveConnection = Nothing
' libère les ressources
L'usage des paramètres n'est pas limité aux procédures stockées. On utilise aussi les
paramètres dans les requêtes d'Access, où ils sont mis entre crochets dans
l'instruction. Cela permet encore de créer dynamiquement des requêtes SQL, avec la
clause Where.
Référencer les objets de la collection
Quand les paramètres sont intégrés à la collection, on y fait référence soit avec la
propriété Item, soit directement, puisqu'Item est la propriété par défaut de cette
collection. On peut aussi utiliser l'index de l'élément ou le nom du paramètre:
objCmd.Parameters.Item(0)
objCmd.Parameters(0)
objCmd.Parameters.Item("State")
objCmd.Parameters("State")
' toutes ces lignes font référence au
' même élément de la collection
La collection Parameters est aussi la collection par défaut de l'objet Command, ce qui
nous permet de ne pas indiquer le nom de la collection. Mais le code devient moins
lisible et ceci devrait être évité
objCmd(0)
objCmd("State")
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 18
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
DEFINIR LA TAILLE ET LE TYPE DU PARAMETRE
Si le paramètre doit contenir une valeur de longueur variable, comme une chaîne, on
spécifie l'argument Size. Sinon, une erreur survient.
La même règle s'applique aux valeurs numériques. Seulement cette fois, il s'agit des
propriétés Precision ( nombre total de chiffres à stocker ) et NumericScale ( nombre
de décimales).
Lire, actualiser et supprimer des paramètres
Comme nous l'avons déjà vu, nous pouvons utiliser une boucle For...Each pour
parcourir une collection. On emploie la même méthode avec la collection
Parameters.
Voici un exemple illustrant ces concepts:
.....
For Each oParam In oCmd.Parameters
Response.Write "Nom du paramètre = " & oParam.Name & "<P>"
Response.Write " Valeur du paramètre = " & oParam.Value
Next
Si besoin est, on supprime un paramètre de la collection avec la méthode Delete.
Par exemple pour supprimer le paramètre State, on utilise son nom ou son index:
ocmd.Parameters.Delete " State"
oCmd.Parameters.Delete 0
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 19
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
2.3 TRAVAIL A REALISER TP2.ASP
Toujours sur la base Contacts:
Ce TP suppose d'avoir créé une requête paramétrée qui supprime un enregistrement
en fonction du contenu du champ Ville.
Créer une page TP2.HTM avec un formulaire qui contiendra une zone de saisie Ville
.
Cette page appellera par le méthode ACTION le programme TP2.ASP et passera le
nom de la ville à supprimer par la méthode POST.
Le programme TP2.ASP utilisera l'objet Connection créé au TP1 et instanciera un
objet Command. Cet objet Command utilisera un paramètre oParVille qui va passer à
la requête paramétrée le nom de la ville pour laquelle il faut supprimer les
enregistrements.
Variante TP2B:
Effectuer la même opération en utilisant un object Command avec un texte SQL qui
réalise l'ordre SQL DELETE.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 20
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°3 L'OBJET RECORDSET DU MODELE ADO
1.1 OBJECTIFS
 Etre capable de créer un objet Recordset et de l'utiliser.
1.2 CE QU’IL FAUT SAVOIR
L'objet Recordset
Jusqu'ici, nous avons vu les requêtes qui modifient, ajoutent ou suppriment des
enregistrements.
Bien sûr, le plus souvent, on cherche à renvoyer, via ADO, des données destinées à
renseigner des valeurs dans la page. Pour ce faire, il faut définir un objet Recordset
dans lequel mettre le résultat.
Les deux méthodes que nous avons étudiées pour exécuter une requête créent des
ensembles d'enregistrements contenant le résultat de la requête . On peut même créer
un recordset directement, sans ouvrir de connexion ou exécuter de commande au
préalable.
Méthodes et propriétés de l'objet Recordset
Pour commencer, voici une liste non exhaustive des méthodes et des propriétés de
l'objet Recordset (nous ne les utiliserons pas toutes dans ce chapitre, nous nous
sommes donc limités aux plus utiles).
Méthodes
Méthode
AddNew
CancelBatch
CancelUpdate
Close
Delete
Move
MoveFirst
MoveLast
MoveNext
MovePrevious
Open
Requery
Supports
Update
UpdateBatch
afpa ©
auteur
JPP
centre
CAEN
Description
Crée un nouvel enregistrement dans un recordset si c'est permis
Annule la mise à jour par lots (batch) en attente
Annule toute modification faite à l'enregistrement courant
Ferme un recordset et tous les objets qui en dépendent
Supprime l'enregistrement courant
Déplace la position de l'enregistrement courant.
Se déplace au premier, au dernier, au suivant ou au précédent
Ouvre un curseur sur un recordset
Met à jour les données en ré-exécutant la requête
Détermine les fonctions supportées par le recordset
Enregistre toutes les modifications apportées dans le recordset
Ecrit tous les mises à jour par lots en attente
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 21
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Propriétés de Recordset
Propriété
AbsolutePosition
BOF
Bookmark
CursorType
Editmode
EOF
LockType
RecordCount
Source
Description
Position absolue de l'enregistrement courant
Vrai si la position de l'enregistrement courant précède le
premier
Renvoie un signet identifiant de manière unique
l'enregistrement courant ou définit l'enregistrement courant
comme étant celui identifié par un signet valable
Type de curseur utilisé dans le recordset
Etat d'édition de l'enregistrement courant
Vrai si la position de l'enregistrement courant se situe juste
après le dernier enregistrement.
Type de verrou posé sur les enregistrements en cours d'édition
Nombre d'enregistrements dans le Recordset
Source des données de recordset, càd un objet Command, une
instruction SQL, un nom de table ou de procédure stockée.
Récupérer un recordset
Un jeu d'enregistrements résulte d'une instruction SQL, d'une procédure stockée ou
juste du nom d'une table, et ce depuis un objet Command ou Connection.
La différence, par rapport aux requêtes qui ne renvoient pas de résultats, est que l'on
précise que le résultat est stocké dans un objet Recordset et que l'on met les
paramètres entre crochets:
Set recordset = objConnection.Execute(TexteCommande, nbEnregModifiés,Options)
Set recordset = objCommand.Execute(NbEnregModifiés,Paramètres,Options)
Créer un recordset à partir d'une requête
A titre d'exemple, nous utilisons ici un objet Connection et indiquons seulement
l'argument TexteCommande. La requête SQL est cette fois un SELECT qui doit
renvoyer des enregistrements:
Set objConn = Server.CreateObject("ADODB.Connection")
ObjConn.Open "Contacts"
Set oRs = objConn.Execute("SELECT * FROM Contact WHERE State = 'LA' ")
Si l'on veut en savoir plus sur le résultat de la requête (nombre d'enregistrements
modifiés) et préciser la nature de la commande (requête SQL), on peut fournir un
nom de variable comme valeur du paramètre NbEnregModifiés et spécifier la valeur
de l'argument Options
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "Contacts"
StrSQL = " SELECT * FROM Contact WHERE State = 'LA' "
Set oRs = objConn.Execute(strSQL,lngRecs,adCmdText)
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 22
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
On peut aussi utiliser l'objet Command pour créer le recordset ....
Set oCmd = Server.CreateObject("ADODB.Command")
oCmd.ActiveConnection = "Contacts"
oCmd.CommandText = " SELECT * FROM Contact WHERE State = 'LA' "
oCmd.CommandType = adCmdText
Set oRs = oCmd.Execute
.... et, bien sûr, attribuer une variable à l'argument NbEnregModifiés, ainsi qu'une
liste de paramètres. Nous avons ici inclus le type de commande dans la méthode
Execute:
Set oCmd = Server.CreateObject("ADODB.Command")
oCmd.ActiveConnection = "Contacts"
oCmd.CommandText = " SELECT * FROM Contact WHERE State = 'LA' "
Set oRs = oCmd.Execute(lngRecs,Array("Contact","LA"),adCmdText)
Créer un recordset à partir d'une table
Une des façons d'utiliser la méthode Execute, que nous n'avons pas encore vue,
puisqu'elle ne permet pas de mise à jour directe, est d'indiquer un nom de table, que ce
soit avec l'objet Connection ou avec l'objet Command.
Avec l'objet Connection:
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open
"Contacts"
Set oRs = objConn.Execute("Contact")
' le nom de la table
On peut bien sûr définir le type de commande pour accélérer le processus:.
Set objConn = Server.Createobject("ADODB.Connection")
objConn.Open "Contacts"
Set oRs = objConn.Execute("Contact",, adCmdTable)
Enfin, on utilise l'objet Command de la même façon:
Set oCmd = Server.CreateObject("ADODB.Command")
oCmd.ActiveConnection = "Contacts"
oCmd.CommandText = " Contact"
oCmd.CommandType = adCmdtable
Set oRs = oCmd.Execute
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
' le nom de la table
type doc millésime
sup. form. 04/17 - v1.0
page 23
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Créer un recordset directement
Si l'on ne fait qu'un seul accès à la source de données, sans avoir à conserver la
connexion active, on peut faire l'impasse sur les objets Connection et Command, et
créer un recordset directement. La connexion se fait automatiquement en tâche de
fond, comme lorsque nous avons utilisé l'objet Command sans créer d'objet
Connection
Pour créer un recordset directement, il faut instancier un objet Recordset avec la
méthode Server.Create0bject ou la balise d'utilisation. <OBJECT> ; ensuite, utiliser
la méthode Open de l'objet Recordset pour remplir l'ensemble d'enregistrements avec
les données de la source. La syntaxe de la méthode Open est la suivante:
Recordset.Open Source,ActiveConnection,CursorType,LockType,Options
Argument
Source
Description
Une instruction SOL,
un nom de table ou de procédure stockée
ActiveConnection
Un objet Connection existant.
CursorType
Type de curseur utilisé à l'ouverture du recordset:
adOpenForwardOnly ( 0 valeur par défaut)
adOpenKeyset (1)
adOpenDynamic (2)
adOpenStatic(3)
LockType
Options
Type de verrou utilisé à l'ouverture du recordset.
Le type de requête ou la table représenté par source:
adCmdText, adCmdTable, adStoredProc
Souvenez vous que pour utiliser le nom des constantes dans votre code vous devez
inclure un fichier de définitionn Server-Side Include (SSI)
Par exemple, avec VBScript
<!-- #include virtual= /Aspsamp/samples/Adovbs.inc -->
L'argument Source indique la provenance des données. Si l'on a une chaîne de
connexion on peut l'utiliser dans la propriété ActiveConnection, et indiquer un nom
de table dans il argument Source:
Set oRs = Server.CreateObject("ADODB.Recordset")
ORs.Open "Contact","Contacts",,,adCmdTable
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 24
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
On peut aussi suivre le même principe qu'avec l'objet Command en définissant les
propriétés qui appellent la méthode Open
Set oRs = Server.CreateObject("ADODB.Recordset")
oRs.Source = "Contact"
' le nom de la table
oRs.ActiveConnection = "Contacts"
' la DSN utilisée
oRs.Open
' ouvrir le recordset
Les types de curseurs du recordset
Il y a quatre types de curseurs disponibles à l'ouverture d'un Recordset. Chacun
possède ses propres qualités et son champ d'utilisation. Dans nos exemples, nous
avons utilisé le type de curseurs par défaut adOpenForwardOnly, mais voici un
résumé des différents types:
 curseur dynamique : propose un recordset en mise à jour, et à travers lequel les
ajouts, modifications et suppressions exécutés par d'autres utilisateurs sont
visibles. Permet tout type de déplacement. Ce type est créé avec un argument
CursorType valant adOpenDynamic;
 curseur à jeu de clés : presque identique au curseur dynamique, mais les
enregistrements ajoutés par les autres utilisateurs après la création du recordset ne
sont pas accessibles. Permet tout type de déplacement. Ce type est créé avec un
argument CurSorType valant adOpenKeyset;
 curseur statique : propose une copie statique d'un ensemble d'enregistrements
en lecture seule. Les modifications apportées par les autres utilisateurs ne sont
pas visibles. Permet tout type de déplacement. Ce type est créé avec un
argument CursorType valant adOpenStatic;
 curseur à défilement vers l'avant: (type par défaut) ensemble d'enregistrements
en lecture seule dans lequel seuls les déplacements vers l'avant sont possibles.
Ce recordset améliore les performances dans les situations ne nécessitant qu'un
seul parcours de l'ensemble d'enregistrements. Ce type est créé avec un argument
CursorType valant adOpenForwardOnly, ou sans argument.'
Dans les exemples précédents, nous obtenons un curseur à défilement vers l'avant,
car nous n'avons pas spécifié de valeur dans l'argument CursorType. Pour éditer les
enregistrements ou se déplacer dans tous les sens, il faut indiquer le type approprié.
La raison d'être de ces types de curseurs est de fournir un moyen d'accès efficace et
adapté à des situations différentes. ADO et le fournisseur de données ont beaucoup
de travail pour maintenir un recordset dynamique modifiable. Même les recordset
statiques permettant tout type de déplacement nécessitent plusieurs accès à la base de
données pour permettre à l'utilisateur de se déplacer en avant et en arrière. Il est plus
efficace d'indiquer à ADO le ou les enregistrements à renvoyer, de sorte qu'il puisse
les mettre en cache.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 25
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Fermer un recordset
En fin de traitement, on ferme le recordset par la méthode Close, et on libère ses
ressources en donnant à sa variable objet la valeur Nothing
ORS.Close
Set oRS = Nothing
Là encore, l'ADO opère cette fermeture automatiquement dès que la variable
référençant le recordset est hors de portée (page envoyée au navigateur, fin de
session ou de l'application).
Utiliser les recordset avec ADO
Quand on crée un objet recordset c'est pour s'en servir : se déplacer, éditer un
enregistrement, en ajouter. La principale utilisation au début, sera sans doute
d'afficher dans une page Web le résultat d'une requête.
La méthode MOVE
La méthode Move déplace le pointeur vers l'avant (nombre positif ) ou vers l'arrière (
nombre négatif ) relativement à l'enregistrement courant.
Gardez à l'esprit les limites imposées par ce type de curseur. Dans un recordset ayant
un type de curseur par défaut (adOpenForwardOnly) , .on ne se déplace que vers
l'avant. Si l'on veut se déplacer dans les deux directions, il faut ouvrir un curseur
adOpenStatic ( voire adOpenDynamic ou adOpenKeyset si l'on veut faire des
modifications.)
Le type adOpenStatic est très efficace car son contenu est un cliché instantané du
contenu de la source de données. ADO met en cache les enregistrements à la création
du recordset .
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 26
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Quelques exemples d'utilisation de la méthode Move:
oRs.Move 7
oRs.Move -4
' déplace en avant de 7 enregistrements
' déplace en arrière de 4 enregistrements
On connait aussi la position courante avec la propriété AbsolutePosition de l'objet
recordset.
Constante
Valeur
adPosUnknown
-1
adPosBOF
-2
AdPosEOF
-3
Description
Pas d'enregistrement
courant
Avant le premier
enregistrement
Après le dernier
enregistrement
Utiliser un signet
Un signet marque l'enregistrement de telle sorte que l'on peut y revenir.
On utilise l'argument StartBookmark pour indiquer à la méthode Move de se
déplacer relativement à ce signet
Exemple :
varMyBookmark = oRs.Bookmark
courant
oRs.Move 3
oRs.Move -7
oRs.move 1, varMyBookmark
le signet
' enregistre le signet de l'enreg
' se déplace sur l'enreg suivant
Autres méthodes de déplacement
MoveFirst, MoveLast, MovePrevious, MoveNext.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 27
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Le début et la fin d'un recordset
Cela va vous sembler étrange, mais le pointeur d'enregistrement n'a pas besoin de
pointer sur un vrai enregistrement. Il peut indiquer un point avant le premier
enregistrement ou après le dernier. Dans certain cas, il peut même pointer un
enregistrement qui n'existe pas en plein milieu du recordset. Cela arrive avec les
recordset dynamiques, quand un utilisateur supprime notre enregistrement courant.
Notre pointeur indique alors un enregistrement supprimé. C'est la raison pour
laquelle il existe une valeur inconnue adPosUnknown, renvoyée par la propriété
AbsolutePosition.
Cependant, la situation rencontrée le plus souvent est d'atteindre une des extrémités
du recordset. Ce dernier a deux propriétés, BOF et EOF, qui représentent,
respectivement, le début du fichier (Beginning Of File) et sa fin (End Of File). Ceci
nous renvoie au temps où un recordset équivalait à un fichier physique (certaines
bases de données fonctionnent encore ainsi).
Les propriétés BOF et EOF
La propriété BOF est vraie quand le pointeur d'enregistrement se trouve juste avant
le premier enregistrement. EOF est vraie quand il se trouve juste après le dernier
enregistrement. S'il n'y a aucun enregistrement dans l'ensemble des enregistrements,
BOF et EOF sont tous les deux vraies.
Quand BOF est vraie, toute tentative de se déplacer en arrière provoque une erreur.
De la même façon, si EOF est vraie, toute tentative de se déplacer en avant provoque
une erreur. Avant d'ouvrir un recordset, il est donc bon de vérifier les propriétés
EOF et BOF pour s'assurer qu'il y a bien au moins un enregistrement.
Détecter les recordset vides
Quand on ouvre pour la première fois un recordset à défilement vers l'avant,
l'enregistrement courant est toujours le premier enregistrement (s'il existe). Pour
tous les autres types de recordset, il faut utiliser explicitement la méthode MoveFirst.
En fait, ce n'est pas gênant de systématiquement l'utiliser à l'ouverture d'un recordset.
Tout autre déplacement provoque une erreur si le recordset est vide. Il est donc
nécessaire de vérifier que les propriétés BOF et EOF sont fausses.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 28
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Vérifier le nombre d'enregistrements
On connait le nombre d'enregistrements d'un ensemble d'enregistrements avec la
propriété RecordCount. Cependant, il faut au préalable utiliser 1a méthode MoveLast
pour initialiser une valeur précise. Ceci est du au fait que le fournisseur ne connaît
pas le nombre d'enregistrements du recordset avant d'en avoir atteint la fin.
On peut utiliser cette propriété pour parcourir le recordset dans une boucle
For
... Next. Mais ce n'est pas une riche idée: si le recordset est dynamique le nombre
d'enregistrements peut changer alors que l'on parcourt les enregistrements,
provoquant une erreur. Il est préférable
d'utiliser les propriétés EOF et BOF.
Parcourir un recordset
La méthode MoveNext est généralement utilisée pour parcourir un recordset. Avec
une boucle Do while et la propriété EOF, on accède à tous les enregistrements, l'un
après l'autre.
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "Contacts"
Set oRs = objConn.Execute("Contact", adCmdtable)
oRs.MoveFirst
' pas nécessaire, mais bonne habitude
Do While Not oRs.EOF
.......
oRs.MoveNext
Loop
Quand il n'y a plus d'enregistrements, la propriété EOF est vraie. Dans ce cas, le
pointeur est au-delà du dernier enregistrement, et tenter de lire des données provoque
une erreur. Nous avons utilisé une boucle Do while parce qu'il se peut qu'il n'y ait
aucun enregistrement à l'ouverture du recordset.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 29
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Travailler avec la collection Fields
La collection Fields va maintenant nous permettre d'accéder aux données proprement
dites.
Tout objet Recordset est doté d'une collection Fields contenant les données, ainsi que
d'autres informations sur les champs de l'enregistrement courant.
Méthode
Refresh
Description
Met à jour la collection pour prendre en compte les modifications
apportées à la valeur des champs
Propriété
Count
Item
Description
Nombre de champs de la collection
Utilisé pour récupérer le contenu des champs dans la collection
Cette collection est relativement simple, puisqu'elle n'a qu'une et deux propriétés.
Nous avons déjà rencontré la propriété Item, lors de notre étude de la collection
Parameter
oRs.Fields.Item("State")
oRs.Fields.Item(0)
oRs.Fields.("State")
oRs.Fields(0)
' Toutes ces commandes
' font référence -au même
' champ
La collection Fields est aussi par défaut celle de l'objet Recordset. Il est donc de
nouveau possible d'omettre le nom de la collection. Dans ce cas (contrairement à
l'objet Command et à la collection Parameters), cela a un sens. En fait, il existe même
une notation qui rend le code encore plus lisible
oRs("State")
oRs(0)
oRs!State
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 30
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
L'objet Field
Chaque membre de la collection Fields est lui-même un objet Field
un ensemble de propriétés:
Propriété
Actualsize
Attributes
DefinedSize
Name
NumericScale
OriginalValue
Precision
Type
UnderlyingValue
Value
afpa ©
auteur
JPP
centre
CAEN
possédant
Description
Longueur de la valeur du champ.
Type de données que peut contenir le champ.
Taille ou longueur du champ telle queue est définie dans
la source de données
Nom du champ.
Nombre de décimales pour les champs numériques.
Valeur du champ avant une modification non encore
validée.
Nombre total de chiffres d'un champ numérique.
Type de données du champ
Valeur courante du champ dans la base de données
Valeur attribuée au champ, même avant validation
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 31
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Explorer la collection Field
Chercher le nom des champs du Recordset pour les mettre dans un en-tête de
tableau
<TABLE BORDER=1 COLS=<% = oRS.Fields.Count%>>
<TR>
<% For Each oField In oRS.Fields %>
<TH> <% = oField.Name %> </TH>
<% Next %>
</TR>
Chercher les valeurs des champs du Recordset pour les mettre dans les lignes
d'un tableau
<% Do While Not oRS.EOF %>
<TR>
<% For Each oField In oRS.Fields %>
<TD ALIGN=RIGHT>
<% If IsNull(oField) Then
Response.Write " "
Else
Response.Write oField.Value
End If %>
</TD>
<% Next
oRS.MoveNext %>
</TR>
<% Loop %>
</TABLE>
Ce code vient immédiatement à la suite du précédent
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 32
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
3.3 TRAVAIL A REALISER TP3.ASP
Toujours sur la base Contacts:
Créer une page TP3.HTM qui instancie et remplit un RecordSet à partir de la table
Contact de la base Contacts . Ce programme renvoie au navigateur un tableau avec
en en-tête de colonne les noms des champs et en lignes les enregistrements de la
table Contact.
On pourra tester plusieurs variantes :
- ouverture par la table Contact
- ouverture par du SQL direct
- appel d'une requête stockée dans la base de données
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 33
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°4 METTRE A JOUR UNE BASE DE DONNEES
4.1. OBJECTIFS
 Etre capable de mettre à jour une base de données à l'aide de plusieurs techniques
ADO et ASP.
4.2 CE QU’IL FAUT SAVOIR
Utiliser SQL pour mettre à jour des enregistrements
Nous avons déjà vu comment on se sert de la méthode Execute des objets Command
ou Connection pour supprimer des enregistrements. Le procédé est identique pour
des requêtes INSERT OU UPDATE.
Exemple d'insertion : stocker un ordre INSERT dans une variable
<% Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "Contacts"
sqlStatement = " INSERT INTO <nom de table > .(col1, col2, ...)." _
& " .VALUES ( val1, val2, ....) ;"
objConn.Execute(strSQLStatement)
objConn.Close
Set objConn = Nothing
Le caractère _ ( underscore ou souligné ) est utilisé pour indiquer une continuation de
ligne.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 34
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Utiliser les méthodes du recordset pour mettre à jour et supprimer des
enregistrements
Utiliser des instructions SQL pour mettre à jour la base de donnée très pratique, mais
ce n'est pas nécessairement le meilleur moyen de mettre à jour plusieurs
enregistrements
Avec les méthodes AddNew et Update du recordset, on modifie les données d'un
enregistrement, champ par champ.
Il faut que le recordset ait été ouvert avec un type de curseur adOpenDynamic ou
adOpenKeyset pour que les modifications puissent être envoyées à la source de
données. N'oublions pas que les records type statique ou à défilement vers l'avant ne
sont pas modifiables.
Exemple :
Set oRs = Server.CreateObject("ADODB.Recordset").
oRs.Open "Contact", "Contacts", adOpenKeyset,adLockPessimistic,adCmdTable
...traitement de prise en compte de la saisie..................................
oRs.Fields("Name") = strName
oRs.Fields("Address") = strAddress
etc etc
oRs.Update
oRs.Close
set oRs = Nothing.
Ajouter des enregistrements
Utiliser la méthode AddNew
Set oRs = Server.CreateObject("ADODB.Recordset").
oRs.Open "Contact", "Contacts", adOpenKeyset,adLockPessimistic,adCmdTable
oRs.AddNew
...traitement de prise en compte de la saisie..................................
oRs.Fields("Name") = strName
oRs.Fields("Address") = strAddress
etc etc
oRs.Update
oRs.Close
set oRs = Nothing.
Après AddNew, la propriété EditMode vaut adEditAdd. On peut alors décider
d'annuler les modifications avec CancelUpdate et l'enregistrement courant d'avant
AddNew redevient courant. Un fois l'enregistrement validé par Update EditMode
vaut EditNone.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 35
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
4.3 TRAVAIL A REALISER TP4.ASP
Toujours sur la base Contacts:
Modifier la page TP3.ASP pour rajouter un lien :
"Pour vous enregistrer , cliquer ici."
Ce lien est réalisé avec une page TP4.HTM qui contiendra un formulaire de saisie
des champs concernant un contact. Le clic sur le bouton envoi entraine l'exécution du
programme TP4.ASP qui réalise l'insertion du contact dans la table contact.
On pourra tester plusieurs variantes :
-
afpa ©
Insertion en SQLdirect
Insertion par une requête paramétrée stockée dans la base Access
Insertion par un addnew dans le recordset puis appel de la méthode Update de
l'objet RecordSet.
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 36
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°5 LES TRANSACTIONS
5.1. OBJECTIFS
 Etre capable d'utiliser les méthodes de l'objet Connection BeginTrans,
CommitTrans et RollBackTrans
5.2 CE QU’IL FAUT SAVOIR
Utiliser des transactions
Il nous reste à étudier les transactions. Le principe en est simple : si l'on doit faire
plusieurs mises à jour simultanées, on améliore l'efficacité de l'ensemble en
demandant au système de faire les modifications, puis en les validant en une
opération, plutôt que de les écrire les unes après les autres.
Ce système a encore un autre avantage : puisque les modifications ne sont validées
que lorsqu'elles sont toutes terminées, et qu'on l'a indiqué à ADO, on peut toujours
changer d'avis avant de valider les mises à jour.
Cela s'appelle l'annulation des modifications (Rollback), surtout utilisée en cas
d'erreur intempestive : plutôt qu'avoir un nombre indéterminé de modifications, on
préfère toutes les annuler. Ce n'est que lorsque toutes les opérations sont réussies
que l'on valide les modifications.
Voici une portion de code qui montre comment tout cela s'organise
Set objConn= Server.CreateObject("ADODB.Connection")
objConn.Open "Contacts"
objConn.BeginTrans
'démarre la transaction
' Table Contact
objConn.Execute "DELETE * FROM Contact WHERE State = 'LA' "
sngErrorFound = objConn.Errors.Count 'nombre d'erreurs de cette requête
' table Names
objConn.Execute "DELETE * FROM Names WHERE State = 'LA' "
sngErrorFound = sngErrorFound + objConn.Errors.Count
If sngErrorsFound = 0 Then
objConn.CommitTrans
Else
objConn.RollbackTrans
End If
' tout a fonctionné, validation
' annulation des modifications
objConn.Close
Set objConn = Nothing
Nous validons les modifications avec CommitTrans, à condition qu'aucune des
requêtes ne renvoie d'erreur. Si l'une échoue, nous abandonnons les mises à jour
avec RollbackTrans.On remarquera l'utilisation de la collection Errors de l'objet
Connection .
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 37
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
Transaction sur plusieurs pages
Dans ce cas, il faut impérativement utiliser un objet Connection de niveau Session.
Ouverture de l'objet Connection dans Sub Session_OnStart de global.asa
Set Session("Session_contacts") = CreateObject("ADODB.Connexion")
Session("Session_contacts").Open "Contacts"
' ouverture par DSN Contacts
Démarrage de la transaction dans une page P1.ASP:
' on crée une référence qui pointe sur l'objet connection de la session
Set objConnection = Session("Session_contacts")
ObjConnection.BeginTrans
Etc etc etc
Fin de transaction dans P2.ASP
Set objConnection = Session("Session_contacts")
objConnection.CommitTrans ou objConnection.RollBackTrans
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 38
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
5.3 TRAVAIL A REALISER TP5.ASP
Toujours sur la base Contacts:
Modifier le programme TP4.asp pour initialiser une transaction en début de
programme et faire le commit après l'insertion dans la table contacts.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 39
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
T.P. N°6 GESTION DES ERREURS
6.1 OBJECTIFS
 Etre capable de gérer les erreurs VBScript par l'objet ERR et les erreurs ADO par
la collection Errors.
6.2 CE QU’IL FAUT SAVOIR
Gestion des erreurs par l'objet ERR et par la collection Errors
L'objet ERR ( cf Visual Basic ) de VBScript fournit des propriétés Number, Source,
description qui permettrent de trapper certaines erreurs d'accès aux données.
La collection Errors de l'objet Connection du modèle ADO fournit des informations
complémentaires. Voici un exemple de code utilisant les deux objets :
<%
On Error Resume Next
Set oConn = Server.CreateObject("ADODB.Connection")
oConn.Open "Contacts"
Set oRs = oConn.Execute("Contact")
oRs.MoveFirst
oRs.Fields("Nom") = "Valerie Gonzales"
response.write oConn.Errors.Count
If oConn.Errors.Count > 0 Then 'Une erreur est survenue.
Response.Write "<B> Impossible de mettre à jour le champ 'Nom' </B><P>"
For intLoop = 0 To oConn.Errors.Count - 1
Response.Write "Erreur ADO numéro : " & oConn.Errors(intLoop).Number
Response.Write " - " & oConn.Errors(intLoop).Description & "<P>"
Next
Else
oRS.Update
End If
If Err.Number <> 0 then 'Une erreur est survenue.
Response.Write "<B> Impossible de mettre à jour le champ 'Nom' </B><P>"
Response.Write "Erreur VBScript numéro : " & Err.Number
Response.Write " - Source : " & Err.Source
Response.Write " - Description : " & Err.Description
Else
oRS.Update
End If
oRs.Close
Set oRs = Nothing
%>
Il est possible de mettre le code de gestion des erreurs dans un fichier .asp et de
l'inclure dans le script par une directive Include.
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 40
769800389
Programmation d'un site Web côté Serveur avec ASP et ADO : le modèle ADO
Support de formation
6.3 TRAVAIL A REALISER TP6.ASP
Toujours sur la base Contacts:
Tester le code ci-dessus qui cherche à modifier un enregistrement dans un recordSet
non modifiable ( qui est l'option d'ouverture par défaut ).
afpa ©
auteur
JPP
centre
CAEN
formation
module
séq/item
type doc millésime
sup. form. 04/17 - v1.0
page 41
769800389